repo_id stringlengths 4 98 | size int64 611 5.02M | file_path stringlengths 1 276 | content stringlengths 611 5.02M | shard_id int64 0 109 | quality_score float32 0.5 1 | quality_prediction int8 1 1 | quality_confidence float32 0.5 1 | topic_primary stringclasses 1 value | topic_group stringclasses 1 value | topic_score float32 0.05 1 | topic_all stringclasses 96 values | quality2_score float32 0.5 1 | quality2_prediction int8 1 1 | quality2_confidence float32 0.5 1 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
ouxianghui/janus-client | 3,229 | 3rd/webrtc/include/third_party/blink/renderer/modules/battery/battery_manager.h | // Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef THIRD_PARTY_BLINK_RENDERER_MODULES_BATTERY_BATTERY_MANAGER_H_
#define THIRD_PARTY_BLINK_RENDERER_MODULES_BATTERY_BATTERY_MANAGER_H_
#include "third_party/blink/renderer/bindings/core/v8/active_script_wrappable.h"
#include "third_party/blink/renderer/bindings/core/v8/script_promise.h"
#include "third_party/blink/renderer/bindings/core/v8/script_promise_property.h"
#include "third_party/blink/renderer/core/execution_context/execution_context_lifecycle_state_observer.h"
#include "third_party/blink/renderer/core/frame/platform_event_controller.h"
#include "third_party/blink/renderer/modules/battery/battery_dispatcher.h"
#include "third_party/blink/renderer/modules/battery/battery_status.h"
#include "third_party/blink/renderer/modules/event_target_modules.h"
#include "third_party/blink/renderer/platform/heap/handle.h"
#include "third_party/blink/renderer/platform/supplementable.h"
namespace blink {
class Navigator;
class BatteryManager final : public EventTargetWithInlineData,
public ActiveScriptWrappable<BatteryManager>,
public Supplement<Navigator>,
public ExecutionContextLifecycleStateObserver,
public PlatformEventController {
DEFINE_WRAPPERTYPEINFO();
public:
static const char kSupplementName[];
static ScriptPromise getBattery(ScriptState*, Navigator&);
explicit BatteryManager(Navigator&);
~BatteryManager() override;
// Returns a promise object that will be resolved with this BatteryManager.
ScriptPromise StartRequest(ScriptState*);
// EventTarget implementation.
const WTF::AtomicString& InterfaceName() const override {
return event_target_names::kBatteryManager;
}
ExecutionContext* GetExecutionContext() const override {
return ExecutionContextLifecycleObserver::GetExecutionContext();
}
bool charging();
double chargingTime();
double dischargingTime();
double level();
DEFINE_ATTRIBUTE_EVENT_LISTENER(chargingchange, kChargingchange)
DEFINE_ATTRIBUTE_EVENT_LISTENER(chargingtimechange, kChargingtimechange)
DEFINE_ATTRIBUTE_EVENT_LISTENER(dischargingtimechange, kDischargingtimechange)
DEFINE_ATTRIBUTE_EVENT_LISTENER(levelchange, kLevelchange)
// Inherited from PlatformEventController.
void DidUpdateData() override;
void RegisterWithDispatcher() override;
void UnregisterWithDispatcher() override;
bool HasLastData() override;
// ContextLifecycleState implementation.
void ContextLifecycleStateChanged(mojom::FrameLifecycleState) override;
void ContextDestroyed() override;
// ScriptWrappable implementation.
bool HasPendingActivity() const final;
void Trace(Visitor*) const override;
private:
using BatteryProperty =
ScriptPromiseProperty<Member<BatteryManager>, Member<DOMException>>;
Member<BatteryProperty> battery_property_;
BatteryStatus battery_status_;
Member<BatteryDispatcher> battery_dispatcher_;
};
} // namespace blink
#endif // THIRD_PARTY_BLINK_RENDERER_MODULES_BATTERY_BATTERY_MANAGER_H_
| 1 | 0.918858 | 1 | 0.918858 | game-dev | MEDIA | 0.534616 | game-dev | 0.87706 | 1 | 0.87706 |
PaddiM8/elk | 31,540 | src/Std/Iteration.cs | #region
using System;
using System.Collections.Generic;
using System.Linq;
using Elk.Exceptions;
using Elk.Parsing;
using Elk.Std.Attributes;
using Elk.Std.DataTypes;
using Elk.Std.Table;
#endregion
// ReSharper disable UnusedType.Global
// ReSharper disable UnusedMember.Global
namespace Elk.Std;
[ElkModule("iter")]
static class Iteration
{
/// <returns>Whether or not all the values in the list evaluate to true.</returns>
[ElkFunction("all")]
public static RuntimeBoolean All(IEnumerable<RuntimeObject> items)
=> RuntimeBoolean.From(items.All(x => x.As<RuntimeBoolean>().IsTrue));
/// <returns>Whether or not the closure evaluates to true for all of the items.</returns>
[ElkFunction("allOf")]
public static RuntimeBoolean AllOf(IEnumerable<RuntimeObject> items, Func<RuntimeObject, RuntimeObject> closure)
=> RuntimeBoolean.From(items.All(x => closure(x).As<RuntimeBoolean>().IsTrue));
/// <returns>Whether or not all the values in the list evaluate to true and the list is non-empty.</returns>
[ElkFunction("allAndAny")]
public static RuntimeBoolean AllANdAny(IEnumerable<RuntimeObject> items)
=> RuntimeBoolean.From(items.Any() && items.All(x => x.As<RuntimeBoolean>().IsTrue));
/// <returns>Whether or not one of the values evaluates to true.</returns>
[ElkFunction("any")]
public static RuntimeBoolean Any(IEnumerable<RuntimeObject> items)
=> RuntimeBoolean.From(items.Any(x => x.As<RuntimeBoolean>().IsTrue));
/// <returns>Whether or not the closure evaluates to true for any of the items.</returns>
[ElkFunction("anyOf")]
public static RuntimeBoolean AnyOf(IEnumerable<RuntimeObject> items, Func<RuntimeObject, RuntimeObject> closure)
=> RuntimeBoolean.From(items.Any(x => closure(x).As<RuntimeBoolean>().IsTrue));
/// <returns>A generator for the given item append to the given Iterable.</returns>
[ElkFunction("append")]
public static RuntimeGenerator Append(IEnumerable<RuntimeObject> items, RuntimeObject item)
=> new(items.Append(item));
/// <summary>
/// Equivalent to x[y] but returns nil if the item does not exist.
/// </summary>
/// <returns>The item at the given index.</returns>
[ElkFunction("at")]
public static RuntimeObject At(IEnumerable<RuntimeObject> items, RuntimeObject index, RuntimeObject? fallback = null)
{
if (items is not IIndexable<RuntimeObject> indexable)
return items.ElementAtOrDefault((int)index.As<RuntimeInteger>().Value) ?? RuntimeNil.Value;
try
{
return indexable[index];
}
catch (RuntimeItemNotFoundException)
{
return fallback ?? RuntimeNil.Value;
}
}
/// <param name="items">The items to split into chunks</param>
/// <param name="size">The maximum size of each chunk</param>
/// <returns>A list of chunks where each chunk is a list of items of the given size.</returns>
[ElkFunction("chunks")]
public static RuntimeGenerator Chunks(IEnumerable<RuntimeObject> items, RuntimeInteger size)
=> new(items.Chunk((int)size.Value).Select(x => new RuntimeTuple(x)));
/// <param name="items">The Iterable to clone</param>
[ElkFunction("clone")]
public static RuntimeObject Clone(IEnumerable<RuntimeObject> items)
{
return items switch
{
RuntimeSet set => new RuntimeSet([..set.Entries]),
RuntimeDictionary dict => new RuntimeDictionary(dict.Entries.ToDictionary(x => x.Key, x=> x.Value)),
RuntimeList list => new RuntimeList([..list.Values]),
_ => throw new RuntimeException($"Clone currently does not support {ExceptionFormatting.Type(items.GetType())}"),
};
}
/// <summary>
/// Some standard library functions return lazily evaluated Iterables. This function
/// forces an Iterable's items to be evaluated right away.
/// </summary>
/// <param name="items">The Iterable to collect.</param>
[ElkFunction("collect")]
public static RuntimeList Collect(IEnumerable<RuntimeObject> items)
=> new(items.ToList());
/// <param name="first">The first Iterable.</param>
/// <param name="second">The second Iterable.</param>
/// <returns>A generator for the items of both the the given Iterables.</returns>
[ElkFunction("concat")]
public static RuntimeGenerator Concat(IEnumerable<RuntimeObject> first, IEnumerable<RuntimeObject> second)
=> new(first.Concat(second));
/// <param name="items">The items to count</param>
/// <param name="closure">A condition for which items should be counted</param>
/// <returns>The amount of items that meet the condition.</returns>
[ElkFunction("count")]
public static RuntimeInteger Count(IEnumerable<RuntimeObject> items, Func<RuntimeObject, RuntimeObject> closure)
=> new(items.Count(x => closure(x).As<RuntimeBoolean>().IsTrue));
/// <returns>Whether or not x contains y</returns>
[ElkFunction("contains")]
public static RuntimeBoolean Contains(RuntimeObject container, RuntimeObject value)
{
var contains = container switch
{
RuntimeList list => list.Values
.Find(x => x.Operation(OperationKind.EqualsEquals, value).As<RuntimeBoolean>().IsTrue) != null,
RuntimeRange range => range.Contains(value.As<RuntimeInteger>().Value),
RuntimeSet set => set.Entries.Contains(value),
RuntimeDictionary dict => dict.Entries.ContainsKey(value),
RuntimeString str => str.Value.Contains(value.As<RuntimeString>().Value),
_ => throw new RuntimeInvalidOperationException("in", container.GetType()),
};
return RuntimeBoolean.From(contains);
}
/// <returns>A list of the distinct items in the given Iterable.</returns>
[ElkFunction("distinct")]
public static RuntimeGenerator Distinct(IEnumerable<RuntimeObject> items)
=> new(items.Distinct());
/// <returns>A list of the distinct items in the given Iterable where the closure determines the keys.</returns>
[ElkFunction("distinctBy")]
public static RuntimeGenerator DistinctBy(IEnumerable<RuntimeObject> items, Func<RuntimeObject, RuntimeObject> closure)
=> new(items.DistinctBy(closure));
/// <summary>
/// Invokes the given closure on each item in the given container.
/// </summary>
/// <param name="items">Container to iterate over.</param>
/// <param name="closure">Closure to invoke on every individual item.</param>
[ElkFunction("each", Reachability.Everywhere)]
public static void Each(IEnumerable<RuntimeObject> items, Action<RuntimeObject> closure)
{
foreach (var item in items)
closure(item);
}
/// <returns>
/// The set difference of the given Iterables,
/// i.e. the items in the first Iterable that don't appear in the second one.
/// </returns>
[ElkFunction("except")]
public static RuntimeGenerator Except(IEnumerable<RuntimeObject> first, IEnumerable<RuntimeObject> second)
=> new(first.Except(second));
/// <returns>
/// The set difference of the given Iterables,
/// i.e. the items in the first Iterable that don't appear in the second one.
/// The closure is used to determine the keys.
/// </returns>
[ElkFunction("exceptBy")]
public static RuntimeGenerator ExceptBy(
IEnumerable<RuntimeObject> first,
IEnumerable<RuntimeObject> second,
Func<RuntimeObject, RuntimeObject> closure)
=> new(first.ExceptBy(second, closure));
/// <param name="items"></param>
/// <param name="closure"></param>
/// <returns>The first item for which the closure evaluates to true.</returns>
[ElkFunction("find")]
public static RuntimeObject Find(IEnumerable<RuntimeObject> items, Func<RuntimeObject, RuntimeObject> closure)
=> items.FirstOrDefault(x => closure(x).As<RuntimeBoolean>().IsTrue) ?? RuntimeNil.Value;
/// <param name="items"></param>
/// <param name="closure"></param>
/// <returns>The index of the first item for which the closure evaluates to true. Returns -1 if no item was found.</returns>
[ElkFunction("findIndex")]
public static RuntimeObject FindIndex(IEnumerable<RuntimeObject> items, Func<RuntimeObject, RuntimeObject> closure)
{
var index = items
.Select((x, i) => (closure(x).As<RuntimeBoolean>().IsTrue, i))
.FirstOrDefault(x => x.Item1, (true, -1))
.Item2;
return new RuntimeInteger(index);
}
/// <summary>
/// Throws an error if the Iterable is empty.
/// </summary>
/// <param name="items"></param>
/// <returns>The first element of the given iterable object.</returns>
[ElkFunction("first")]
public static RuntimeObject First(IEnumerable<RuntimeObject> items)
=> items.FirstOrDefault()
?? throw new RuntimeStdException("Can not get the first item of an empty Iterable.");
/// <param name="items"></param>
/// <returns>The first element of the given iterable object, or nil if the Iterable is empty</returns>
[ElkFunction("firstOrNil")]
public static RuntimeObject FirstOrNil(IEnumerable<RuntimeObject> items)
=> items.FirstOrDefault() ?? RuntimeNil.Value;
/// <summary>
/// Throws an error if the Iterable is empty.
/// </summary>
/// <returns>The first element of the given iterable object where the closure returns true.</returns>
[ElkFunction("firstOf")]
public static RuntimeObject FirstOf(IEnumerable<RuntimeObject> items, Func<RuntimeObject, RuntimeObject> closure)
=> items.FirstOrDefault(x => closure(x).As<RuntimeBoolean>().IsTrue)
?? throw new RuntimeStdException("An item matching the condition was not found");
/// <returns>
/// The first element of the given iterable object where the closure returns true,
/// or nil if the Iterable is empty
/// </returns>
[ElkFunction("firstOfOrNil")]
public static RuntimeObject FirstOfOrNil(IEnumerable<RuntimeObject> items,
Func<RuntimeObject, RuntimeObject> closure)
=> items.FirstOrDefault(x => closure(x).As<RuntimeBoolean>().IsTrue)
?? RuntimeNil.Value;
/// <param name="items"></param>
/// <param name="closure"></param>
/// <returns>A list of flattened values where the closure has been called on each value.</returns>
/// <example>["abc", "def"] | flatMap => x: x #=> ["a", "b", "c", "d", "e", "f"]</example>
[ElkFunction("flatMap", Reachability.Everywhere)]
public static RuntimeGenerator FlatMap(
IEnumerable<RuntimeObject> items,
Func<RuntimeObject, RuntimeObject> closure)
{
return new(
items
.Select(x =>
x as IEnumerable<RuntimeObject>
?? throw new RuntimeCastException(x.GetType(), "Iterable")
)
.Select(x => x.Select(closure))
.SelectMany(x => x)
);
}
[ElkFunction("flatten")]
public static RuntimeGenerator Flatten(IEnumerable<RuntimeObject> items)
=> new(
items
.Select(x =>
x as IEnumerable<RuntimeObject>
?? throw new RuntimeCastException(x.GetType(), "Iterable")
)
.SelectMany(x => x)
);
/// <param name="items">The Iterable to look in</param>
/// <param name="target">The value to search for</param>
/// <param name="startIndex">Which index to start at</param>
/// <returns>The index of the first item with the given value, or -1 if no match was found.</returns>
[ElkFunction("indexOf")]
public static RuntimeInteger IndexOf(
IEnumerable<RuntimeObject> items,
RuntimeObject target,
RuntimeInteger? startIndex = null)
{
var i = (int?)startIndex?.Value ?? 0;
foreach (var item in items.Skip(i))
{
if (item.Equals(target))
return new RuntimeInteger(i);
i++;
}
return new RuntimeInteger(-1);
}
/// <param name="items">The Iterable to look in</param>
/// <param name="targets">The values to search for</param>
/// <param name="startIndex">Which index to start at</param>
/// <returns>
/// The index of the first item that is equal to one of the given values, or -1 if no match was found.
/// </returns>
[ElkFunction("indexOfAny")]
public static RuntimeInteger IndexOfAny(
IEnumerable<RuntimeObject> items,
IEnumerable<RuntimeObject> targets,
RuntimeInteger? startIndex = null)
{
var i = (int?)startIndex?.Value ?? 0;
foreach (var item in items.Skip(i))
{
if (targets.Any(x => item.Equals(x)))
return new RuntimeInteger(i);
i++;
}
return new RuntimeInteger(-1);
}
/// <returns>The intersect of the given Iterables.</returns>
[ElkFunction("intersect")]
public static RuntimeGenerator Intersect(IEnumerable<RuntimeObject> first, IEnumerable<RuntimeObject> second)
=> new(first.Intersect(second));
/// <returns>The intersect of the given Iterables where the closure determines the keys.</returns>
[ElkFunction("intersectBy")]
public static RuntimeGenerator IntersectBy(
IEnumerable<RuntimeObject> first,
IEnumerable<RuntimeObject> second,
Func<RuntimeObject, RuntimeObject> closure)
=> new(first.IntersectBy(second, closure));
/// <param name="input"></param>
/// <returns>The last element of the given indexable object.</returns>
[ElkFunction("last")]
public static RuntimeObject Last(RuntimeObject input)
{
if (input is not IIndexable<RuntimeObject> indexable)
throw new RuntimeCastException(input.GetType(), "Indexable");
return indexable[new RuntimeInteger(indexable.Count - 1)];
}
/// <param name="items">The Iterable to look in</param>
/// <param name="target">The value to search for</param>
/// <param name="startIndex">Which index to start at</param>
/// <returns>The index of the last item with the given value, or -1 if no match was found.</returns>
[ElkFunction("lastIndexOf")]
public static RuntimeInteger LastIndexOf(
IEnumerable<RuntimeObject> items,
RuntimeObject target,
RuntimeInteger? startIndex = null)
{
var maxIndex = items.Count() - 1;
var i = (int?)startIndex?.Value ?? maxIndex;
if (i > maxIndex)
return new RuntimeInteger(-1);
foreach (var item in items.Reverse().Skip(maxIndex - i))
{
if (item.Equals(target))
return new RuntimeInteger(i);
i--;
}
return new RuntimeInteger(-1);
}
/// <param name="items">The Iterable to look in</param>
/// <param name="targets">The values to search for</param>
/// <param name="startIndex">Which index to start at</param>
/// <returns>
/// The index of the last item that is equal to one of the values, or -1 if no match was found.
/// </returns>
[ElkFunction("lastIndexOfAny")]
public static RuntimeInteger LastIndexOfAny(
IEnumerable<RuntimeObject> items,
IEnumerable<RuntimeObject> targets,
RuntimeInteger? startIndex = null)
{
var maxIndex = items.Count() - 1;
var i = (int?)startIndex?.Value ?? maxIndex;
if (i > maxIndex)
return new RuntimeInteger(-1);
foreach (var item in items.Reverse().Skip(maxIndex - i))
{
if (targets.Any(x => item.Equals(x)))
return new RuntimeInteger(i);
i--;
}
return new RuntimeInteger(-1);
}
/// <param name="container" types="Tuple, List, Dictionary"></param>
/// <returns>The amount of items in the container.</returns>
[ElkFunction("len", Reachability.Everywhere)]
public static RuntimeInteger Length(RuntimeObject container)
=> container switch
{
RuntimeTuple tuple => new(tuple.Values.Count),
RuntimeList list => new(list.Values.Count),
RuntimeSet set => new(set.Entries.Count),
RuntimeDictionary dict => new(dict.Entries.Count),
RuntimeTable table => new(table.Rows.Count),
RuntimePipe pipe => new(pipe.Count),
RuntimeNil nil => throw new RuntimeCastException(nil.GetType(), "Iterable"),
IEnumerable<RuntimeObject> enumerable => new(enumerable.Count()),
_ => new(container.As<RuntimeString>().Value.Length),
};
/// <param name="items"></param>
/// <param name="closure"></param>
/// <returns>A list of values where the closure has been called on each value.</returns>
/// <example>[1, 2, 3] | map => x: x + 1 #=> [2, 3, 4]</example>
[ElkFunction("map", Reachability.Everywhere)]
public static RuntimeGenerator Map(IEnumerable<RuntimeObject> items, Func<RuntimeObject, RuntimeObject> closure)
=> new(items.Select(closure));
/// <returns>The lowest value in the Iterable.</returns>
/// <example>[1, 2, 3] | max #=> [2, 3, 4]</example>
[ElkFunction("max")]
public static RuntimeObject Max(IEnumerable<RuntimeObject> items)
=> items.Max() ?? RuntimeNil.Value;
/// <returns>The lowest value in the Iterable with the closure applied.</returns>
[ElkFunction("maxOf")]
public static RuntimeObject MaxOf(IEnumerable<RuntimeObject> items, Func<RuntimeObject, RuntimeObject> closure)
=> items.Max(closure) ?? RuntimeNil.Value;
/// <returns>The lowest value in the Iterable.</returns>
[ElkFunction("min")]
public static RuntimeObject Min(IEnumerable<RuntimeObject> items)
=> items.Min() ?? RuntimeNil.Value;
/// <returns>The lowest value in the Iterable with the closure applied.</returns>
[ElkFunction("minOf")]
public static RuntimeObject MinOf(IEnumerable<RuntimeObject> items, Func<RuntimeObject, RuntimeObject> closure)
=> items.Min(closure) ?? RuntimeNil.Value;
/// <param name="items">A list of values that will be stringified</param>
/// <param name="separator">Character sequence that should be put between each value</param>
/// <returns>A new string of all the list values separated by the specified separator string.</returns>
[ElkFunction("join", Reachability.Everywhere)]
public static RuntimeString Join(IEnumerable<RuntimeObject> items, RuntimeString? separator = null)
=> new(string.Join(separator?.Value ?? "", items.Select(x => x.As<RuntimeString>())));
/// <returns>The cartesian product of an Iterable.</returns>
[ElkFunction("product")]
public static RuntimeGenerator Product(IEnumerable<RuntimeObject> items, RuntimeInteger? repeat = null)
{
if (repeat == null)
{
var iterableItems = items.Select(x =>
x as IEnumerable<RuntimeObject>
?? throw new RuntimeCastException(x.GetType(), "Iterable")
);
return new(GetCartesianProduct(iterableItems));
}
var repeatedItems = Enumerable.Repeat(items, (int)repeat.Value);
return new(GetCartesianProduct(repeatedItems));
}
private static IEnumerable<RuntimeObject> GetCartesianProduct(IEnumerable<IEnumerable<RuntimeObject>> iterables)
{
var result1 = new List<IEnumerable<RuntimeObject>> { new List<RuntimeObject>() };
var result2 = new List<IEnumerable<RuntimeObject>>();
foreach (var iterable in iterables)
{
foreach (var x in result1)
result2.AddRange(iterable.Select(y => x.Append(y)));
result1 = [..result2];
result2 = [];
}
foreach (var r in result1)
yield return new RuntimeGenerator(r);
}
/// <returns>A generator for the given item prepended to the given Iterable.</returns>
[ElkFunction("prepend")]
public static RuntimeGenerator Prepend(IEnumerable<RuntimeObject> items, RuntimeObject item)
=> new(items.Prepend(item));
/// <summary>
/// Pushes the given value to the container.
/// </summary>
/// <param name="container" types="List, Dictionary"></param>
/// <param name="value1">List: Value to push<br />Set: Element<br />Dictionary: Key</param>
/// <param name="value2">Dictionary: Value to push</param>
/// <returns>The same container.</returns>
/// <example>
/// list | push(x)
/// dict | push("name", "John")
/// </example>
[ElkFunction("push", Reachability.Everywhere)]
public static RuntimeObject Push(
RuntimeObject container,
RuntimeObject value1,
RuntimeObject? value2 = null)
{
if (container is RuntimeList list)
{
list.Values.Add(value1);
}
else if (container is RuntimeSet set)
{
set.Entries.Add(value1);
}
else if (container is RuntimeDictionary dict)
{
if (value2 == null)
throw new RuntimeWrongNumberOfArgumentsException("push", 3, 2);
dict.Entries.Add(value1, value2);
}
else if (container is RuntimeTable table)
{
var row = value1 as RuntimeTableRow
?? new RuntimeTableRow(table, value1.As<RuntimeList>());
table.Rows.Add(row);
}
else
{
throw new RuntimeException("Can only use function 'push' on mutable containers");
}
return container;
}
/// <summary>
/// Adds all the given items to the container (list or set), one by one.
/// </summary>
/// <returns></returns>
[ElkFunction("pushAll", Reachability.Everywhere)]
public static RuntimeObject PushAll(
RuntimeObject container,
IEnumerable<RuntimeObject> values)
{
if (container is RuntimeList list)
{
foreach (var value in values)
list.Values.Add(value);
}
else if (container is RuntimeSet set)
{
foreach (var value in values)
set.Entries.Add(value);
}
return container;
}
/// <param name="input">An indexable object.</param>
/// <param name="startIndex"></param>
/// <param name="endIndex"></param>
/// <returns>
/// The elements between the specified indices.
/// </returns>
[ElkFunction("range")]
public static RuntimeObject Range(IIndexable<RuntimeObject> input, RuntimeInteger startIndex, RuntimeInteger endIndex)
=> input[new RuntimeRange((int)startIndex.Value, (int)endIndex.Value)];
[ElkFunction("reduce")]
public static RuntimeObject Reduce(IEnumerable<RuntimeObject> items, Func<RuntimeObject, RuntimeObject, RuntimeObject> closure)
=> items.Aggregate(closure);
/// <summary>
/// Removes the item at the given index.
/// </summary>
/// <param name="container" types="List, Dictionary"></param>
/// <param name="index">Index of the item to remove</param>
/// <returns>The same container.</returns>
[ElkFunction("remove", Reachability.Everywhere)]
public static RuntimeObject Remove(RuntimeObject container, RuntimeObject index)
{
if (container is RuntimeList list)
{
if (index is RuntimeRange range)
{
list.Values.RemoveRange(range);
return container;
}
list.Values.RemoveAt(index.As<RuntimeInteger>());
}
else if (container is RuntimeSet set)
{
set.Entries.Remove(index);
}
else if (container is RuntimeDictionary dict)
{
dict.Entries.Remove(index);
}
else if (container is RuntimeTable table)
{
if (index is RuntimeRange range)
{
table.Rows.RemoveRange(range);
return container;
}
table.Rows.RemoveAt(index.As<RuntimeInteger>());
}
else
{
throw new RuntimeException("Can only use function 'remove' on mutable containers");
}
return container;
}
/// <param name="item">The object to repeat</param>
/// <param name="n">The amount of times it should be repeated</param>
/// <returns>A list containing n instances of the given item.</returns>
[ElkFunction("repeat")]
public static RuntimeGenerator Repeat(RuntimeObject item, RuntimeInteger? n = null)
=> new(
n == null
? DataTypes.Extensions.RepeatIndefinitely(item)
: Enumerable.Repeat(item, (int)n.Value)
);
[ElkFunction("reverse")]
public static RuntimeGenerator Reverse(IEnumerable<RuntimeObject> items)
=> new(items.Reverse());
[ElkFunction("reverseMut")]
public static void Reverse(RuntimeList items)
{
items.Values.Reverse();
}
/// <param name="items">All items</param>
/// <param name="count">The amount of items to skip from the left</param>
/// <returns>A generator for the first n items.</returns>
[ElkFunction("skip")]
public static RuntimeGenerator Skip(IEnumerable<RuntimeObject> items, RuntimeInteger count)
=> new(items.Skip((int)count.Value).ToList());
/// <param name="items">All items</param>
/// <param name="closure"></param>
/// <returns></returns>
[ElkFunction("skipWhile")]
public static RuntimeGenerator SkipWhile(IEnumerable<RuntimeObject> items, Func<RuntimeObject, RuntimeObject> closure)
=> new(items.SkipWhile(x => closure(x).As<RuntimeBoolean>().IsTrue).ToList());
/// <summary>Changes the step size of the given range. The step size determines how much the range value should increase by after each iteration.</summary>
/// <param name="range">Range to modify</param>
/// <param name="step">Step size</param>
/// <returns>The same range.</returns>
/// <example>
/// # 0, 2, 4, 6, 8, 10
/// for i in 0..10 | stepBy(2): echo(i)
/// </example>
[ElkFunction("stepBy", Reachability.Everywhere)]
public static RuntimeRange StepBy(RuntimeRange range, RuntimeInteger step)
{
range.Increment = (int)step.Value;
return range;
}
/// <param name="items">All items</param>
/// <param name="count">The amount of items to take from the left</param>
/// <returns>A generator for the specified amount of items.</returns>
[ElkFunction("take")]
public static RuntimeGenerator Take(IEnumerable<RuntimeObject> items, RuntimeInteger count)
=> new(items.Take((int)count.Value).ToList());
/// <param name="items">All items</param>
/// <param name="closure"></param>
[ElkFunction("takeWhile")]
public static RuntimeGenerator TakeWhile(IEnumerable<RuntimeObject> items, Func<RuntimeObject, RuntimeObject> closure)
=> new(items.TakeWhile(x => closure(x).As<RuntimeBoolean>().IsTrue).ToList());
/// <param name="first">The first Iterable</param>
/// <param name="second">The second Iterable</param>
/// <returns>A generator for the items from the given Iterables combined, excluding duplicates.</returns>
[ElkFunction("union")]
public static RuntimeGenerator Union(IEnumerable<RuntimeObject> first, IEnumerable<RuntimeObject> second)
=> new(first.Union(second));
/// <param name="first">The first Iterable</param>
/// <param name="second">The second Iterable</param>
/// <param name="closure"></param>
/// <returns>
/// A generator for the items from the given Iterables combined, excluding duplicates.
/// The closure selects the key of each item.
/// </returns>
[ElkFunction("unionBy")]
public static RuntimeGenerator UnionBy(IEnumerable<RuntimeObject> first, IEnumerable<RuntimeObject> second, Func<RuntimeObject, RuntimeObject> closure)
=> new(first.UnionBy(second, closure));
/// <param name="values">The values to slide over</param>
/// <param name="size">The size of the window</param>
/// <returns>A generator for a sliding window over the given values.</returns>
/// <example>
/// [1, 2, 3, 4, 5] | iter::window(2) #=> [[1, 2], [2, 3], [3, 4], [4, 5], [5, nil]]
/// </example>
[ElkFunction("window")]
public static RuntimeGenerator Window(IEnumerable<RuntimeObject> values, RuntimeInteger size)
=> new(Window(values, size.Value));
private static IEnumerable<RuntimeObject> Window(IEnumerable<RuntimeObject> values, long size)
{
var buffer = new Queue<RuntimeObject>();
foreach (var value in values)
{
buffer.Enqueue(value);
if (buffer.Count == size)
{
yield return new RuntimeList(buffer.ToList());
buffer.Dequeue();
}
}
if (buffer.Count == size)
{
yield return new RuntimeList(buffer.ToList());
buffer.Clear();
}
}
/// <param name="values" types="Iterable"></param>
/// <returns>
/// A list containing a tuple for each item in the original container.
/// The first item of the tuple is the item from the original container,
/// while the second item is the index of that item.
/// </returns>
/// <example>for item, i in values: echo("{i}: {item}")</example>
[ElkFunction("withIndex", Reachability.Everywhere)]
public static RuntimeGenerator WithIndex(RuntimeObject values)
{
var items = values as IEnumerable<RuntimeObject> ?? values.As<RuntimeList>().Values;
return new(items.Select((x, i) => new RuntimeTuple([x, new RuntimeInteger(i)])));
}
/// <param name="items"></param>
/// <param name="closure"></param>
/// <returns>A list of values containing only those who evaluated to true in the closure.</returns>
/// <example>[1, 2, 3] | select => x: x + 1 #=> [2, 3, 4]</example>
[ElkFunction("where", Reachability.Everywhere)]
public static RuntimeGenerator Where(IEnumerable<RuntimeObject> items, Func<RuntimeObject, RuntimeObject> closure)
=> new(items.Where(x => closure(x).As<RuntimeBoolean>().IsTrue));
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns>A list containing pairs of values.</returns>
/// <example>[1, 2, 3] | iter::zip([4, 5, 6]) #=> [(1, 4), (2, 5), (3, 6)]</example>
[ElkFunction("zip")]
public static RuntimeGenerator Zip(IEnumerable<RuntimeObject> a, IEnumerable<RuntimeObject> b)
=> new(a.Zip(b).Select(x => new RuntimeTuple([x.First, x.Second])));
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns>A list containing pairs of values.</returns>
/// <example>[1, 2, 3, 4] | iter::zipLongest([4, 5, 6]) #=> [(1, 4), (2, 5), (3, 6), (4, 0)]</example>
[ElkFunction("zipLongest")]
public static RuntimeGenerator ZipLongest(IEnumerable<RuntimeObject> a, IEnumerable<RuntimeObject> b)
{
var result = a
.ZipLongest(b)
.Select(x =>
new RuntimeTuple([
x.Item1 ?? RuntimeNil.Value,
x.Item2 ?? RuntimeNil.Value
])
);
return new RuntimeGenerator(result);
}
}
| 1 | 0.82847 | 1 | 0.82847 | game-dev | MEDIA | 0.332457 | game-dev | 0.828918 | 1 | 0.828918 |
EKA2L1/EKA2L1 | 4,281 | src/external/sdl2/Windows/include/SDL_touch.h | /*
Simple DirectMedia Layer
Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
/**
* \file SDL_touch.h
*
* Include file for SDL touch event handling.
*/
#ifndef SDL_touch_h_
#define SDL_touch_h_
#include "SDL_stdinc.h"
#include "SDL_error.h"
#include "SDL_video.h"
#include "begin_code.h"
/* Set up for C function definitions, even when using C++ */
#ifdef __cplusplus
extern "C" {
#endif
typedef Sint64 SDL_TouchID;
typedef Sint64 SDL_FingerID;
typedef enum
{
SDL_TOUCH_DEVICE_INVALID = -1,
SDL_TOUCH_DEVICE_DIRECT, /* touch screen with window-relative coordinates */
SDL_TOUCH_DEVICE_INDIRECT_ABSOLUTE, /* trackpad with absolute device coordinates */
SDL_TOUCH_DEVICE_INDIRECT_RELATIVE /* trackpad with screen cursor-relative coordinates */
} SDL_TouchDeviceType;
typedef struct SDL_Finger
{
SDL_FingerID id;
float x;
float y;
float pressure;
} SDL_Finger;
/* Used as the device ID for mouse events simulated with touch input */
#define SDL_TOUCH_MOUSEID ((Uint32)-1)
/* Used as the SDL_TouchID for touch events simulated with mouse input */
#define SDL_MOUSE_TOUCHID ((Sint64)-1)
/**
* Get the number of registered touch devices.
*
* On some platforms SDL first sees the touch device if it was actually used.
* Therefore SDL_GetNumTouchDevices() may return 0 although devices are
* available. After using all devices at least once the number will be
* correct.
*
* This was fixed for Android in SDL 2.0.1.
*
* \returns the number of registered touch devices.
*
* \since This function is available since SDL 2.0.0.
*
* \sa SDL_GetTouchDevice
*/
extern DECLSPEC int SDLCALL SDL_GetNumTouchDevices(void);
/**
* Get the touch ID with the given index.
*
* \param index the touch device index
* \returns the touch ID with the given index on success or 0 if the index is
* invalid; call SDL_GetError() for more information.
*
* \since This function is available since SDL 2.0.0.
*
* \sa SDL_GetNumTouchDevices
*/
extern DECLSPEC SDL_TouchID SDLCALL SDL_GetTouchDevice(int index);
/**
* Get the type of the given touch device.
*
* \since This function is available since SDL 2.0.10.
*/
extern DECLSPEC SDL_TouchDeviceType SDLCALL SDL_GetTouchDeviceType(SDL_TouchID touchID);
/**
* Get the number of active fingers for a given touch device.
*
* \param touchID the ID of a touch device
* \returns the number of active fingers for a given touch device on success
* or 0 on failure; call SDL_GetError() for more information.
*
* \since This function is available since SDL 2.0.0.
*
* \sa SDL_GetTouchFinger
*/
extern DECLSPEC int SDLCALL SDL_GetNumTouchFingers(SDL_TouchID touchID);
/**
* Get the finger object for specified touch device ID and finger index.
*
* The returned resource is owned by SDL and should not be deallocated.
*
* \param touchID the ID of the requested touch device
* \param index the index of the requested finger
* \returns a pointer to the SDL_Finger object or NULL if no object at the
* given ID and index could be found.
*
* \since This function is available since SDL 2.0.0.
*
* \sa SDL_RecordGesture
*/
extern DECLSPEC SDL_Finger * SDLCALL SDL_GetTouchFinger(SDL_TouchID touchID, int index);
/* Ends C function definitions when using C++ */
#ifdef __cplusplus
}
#endif
#include "close_code.h"
#endif /* SDL_touch_h_ */
/* vi: set ts=4 sw=4 expandtab: */
| 1 | 0.857523 | 1 | 0.857523 | game-dev | MEDIA | 0.548846 | game-dev | 0.592442 | 1 | 0.592442 |
D-Programming-GDC/gcc | 1,325 | gcc/testsuite/gnat.dg/debug10.adb | -- PR debug/80321
-- { dg-do compile }
-- { dg-options "-O2 -g" }
with Debug10_Pkg; use Debug10_Pkg;
procedure Debug10 (T : Entity_Id) is
procedure Inner (E : Entity_Id);
pragma Inline (Inner);
procedure Inner (E : Entity_Id) is
begin
if E /= Empty
and then not Nodes (E + 3).Flag16
then
Debug10 (E);
end if;
end Inner;
function Ekind (E : Entity_Id) return Entity_Kind is
begin
return N_To_E (Nodes (E + 1).Nkind);
end Ekind;
begin
if T = Empty then
return;
end if;
Nodes (T + 3).Flag16 := True;
if Ekind (T) in Object_Kind then
Inner (T);
elsif Ekind (T) in Type_Kind then
Inner (T);
if Ekind (T) in Record_Kind then
if Ekind (T) = E_Class_Wide_Subtype then
Inner (T);
end if;
elsif Ekind (T) in Array_Kind then
Inner (T);
elsif Ekind (T) in Access_Kind then
Inner (T);
elsif Ekind (T) in Scalar_Kind then
if My_Scalar_Range (T) /= Empty
and then My_Test (My_Scalar_Range (T))
then
if My_Is_Entity_Name (T) then
Inner (T);
end if;
if My_Is_Entity_Name (T) then
Inner (T);
end if;
end if;
end if;
end if;
end;
| 1 | 0.736854 | 1 | 0.736854 | game-dev | MEDIA | 0.455647 | game-dev | 0.624964 | 1 | 0.624964 |
pdaodao/fiflow | 932 | fiflow-core/src/main/java/com/github/lessonone/fiflow/core/flink/BuildLevel.java | package com.github.lessonone.fiflow.core.flink;
/**
* 构建级别
* 1. help list tables 之类的无需执行
* 2. select 需要特别处理 后 execute
* 3. insert 可以直接提交执行
*/
public enum BuildLevel {
None(0), // 啥也没干
Show(1), // help, show tables 之类的无需执行 只要给出信息
Set(2), // 设置 jar 并发 等
Create(3), // create table
Select(4), // select
Insert(5), // insert
Error(11); // 错误
public final Integer level;
BuildLevel(Integer level) {
this.level = level;
}
public static BuildLevel parse(String name) {
for (BuildLevel v : values()) {
if (v.name().equalsIgnoreCase(name)) return v;
}
return null;
}
public boolean isNeedExecute() {
if (this == BuildLevel.Select || this == BuildLevel.Insert) {
return true;
}
return false;
}
@Override
public String toString() {
return name();
}
}
| 1 | 0.741485 | 1 | 0.741485 | game-dev | MEDIA | 0.830245 | game-dev | 0.835409 | 1 | 0.835409 |
henrikstengaard/hstwb-installer | 7,237 | src/HstWbInstaller.Core/IO/RigidDiskBlocks/PartitionBlockReader.cs | namespace HstWbInstaller.Core.IO.RigidDiskBlocks
{
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Extensions;
public static class PartitionBlockReader
{
public static async Task<IEnumerable<PartitionBlock>> Read(RigidDiskBlock rigidDiskBlock, Stream stream)
{
if (rigidDiskBlock.PartitionList == BlockIdentifiers.EndOfBlock)
{
return Enumerable.Empty<PartitionBlock>();
}
// get partition list block and set partition number to 1
var partitionList = rigidDiskBlock.PartitionList;
var partitionBlocks = new List<PartitionBlock>();
do
{
// calculate partition block offset
var partitionBlockOffset = rigidDiskBlock.BlockSize * partitionList;
// seek partition block offset
stream.Seek(partitionBlockOffset, SeekOrigin.Begin);
// read block
var blockBytes = await BlockHelper.ReadBlock(stream);
// read partition block
var partitionBlock = await Parse(rigidDiskBlock, blockBytes);
// fail, if partition block is null
if (partitionBlock == null)
{
throw new IOException("Invalid partition block");
}
partitionBlocks.Add(partitionBlock);
// get next partition list block and increase partition number
partitionList = partitionBlock.NextPartitionBlock;
} while (partitionList > 0 && partitionList != BlockIdentifiers.EndOfBlock);
rigidDiskBlock.PartitionBlocks = partitionBlocks;
rigidDiskBlock.FileSystemHeaderBlocks =
await FileSystemHeaderBlockReader.Read(rigidDiskBlock, stream);
return partitionBlocks;
}
public static async Task<PartitionBlock> Parse(RigidDiskBlock rigidDiskBlock, byte[] blockBytes)
{
var blockStream = new MemoryStream(blockBytes);
var magic = await blockStream.ReadAsciiString(); // Identifier 32 bit word : 'PART'
if (!magic.Equals(BlockIdentifiers.PartitionBlock))
{
return null;
}
await blockStream.ReadUInt32(); // Size of the structure for checksums
var checksum = await blockStream.ReadInt32(); // Checksum of the structure
var hostId = await blockStream.ReadUInt32(); // SCSI Target ID of host, not really used
var nextPartitionBlock = await blockStream.ReadUInt32(); // Block number of the next PartitionBlock
var flags = await blockStream.ReadUInt32(); // Part Flags (NOMOUNT and BOOTABLE)
// skip reserved
blockStream.Seek(4 * 2, SeekOrigin.Current);
var devFlags = await blockStream.ReadUInt32(); // Preferred flags for OpenDevice
var driveNameLength =
(await blockStream.ReadBytes(1)).FirstOrDefault(); // Preferred DOS device name: BSTR form
var driveName = await blockStream.ReadString(driveNameLength); // # Preferred DOS device name: BSTR form
if (driveNameLength < 31)
{
await blockStream.ReadBytes(31 - driveNameLength);
}
// skip reserved
blockStream.Seek(4 * 15, SeekOrigin.Current);
var sizeOfVector = await blockStream.ReadUInt32(); // Size of Environment vector
var sizeBlock = await blockStream.ReadUInt32(); // Size of the blocks in 32 bit words, usually 128
var secOrg = await blockStream.ReadUInt32(); // Not used; must be 0
var surfaces = await blockStream.ReadUInt32(); // Number of heads (surfaces)
var sectors = await blockStream.ReadUInt32(); // Disk sectors per block, used with SizeBlock, usually 1
var blocksPerTrack = await blockStream.ReadUInt32(); // Blocks per track. drive specific
var reserved = await blockStream.ReadUInt32(); // DOS reserved blocks at start of partition.
var preAlloc = await blockStream.ReadUInt32(); // DOS reserved blocks at end of partition
var interleave = await blockStream.ReadUInt32(); // Not used, usually 0
var lowCyl = await blockStream.ReadUInt32(); // First cylinder of the partition
var highCyl = await blockStream.ReadUInt32(); // Last cylinder of the partition
var numBuffer = await blockStream.ReadUInt32(); // Initial # DOS of buffers.
var bufMemType = await blockStream.ReadUInt32(); // Type of mem to allocate for buffers
var maxTransfer = await blockStream.ReadUInt32(); // Max number of bytes to transfer at a time
var mask = await blockStream.ReadUInt32(); // Address Mask to block out certain memory
var bootPriority = await blockStream.ReadUInt32(); // Boot priority for autoboot
var dosType = await blockStream.ReadBytes(4); // # Dostype of the file system
var baud = await blockStream.ReadUInt32(); // Baud rate for serial handler
var control = await blockStream.ReadUInt32(); // Control word for handler/filesystem
var bootBlocks = await blockStream.ReadUInt32(); // Number of blocks containing boot code
// skip reserved
blockStream.Seek(4 * 12, SeekOrigin.Current);
// calculate size of partition in bytes
var partitionSize = (long)(highCyl - lowCyl + 1) * surfaces * blocksPerTrack * rigidDiskBlock.BlockSize;
var calculatedChecksum = await BlockHelper.CalculateChecksum(blockBytes, 8);
if (checksum != calculatedChecksum)
{
throw new Exception("Invalid partition block checksum");
}
var fileSystemBlockSize = sizeBlock * 4;
return new PartitionBlock
{
BlockBytes = blockBytes,
Checksum = checksum,
HostId = hostId,
NextPartitionBlock = nextPartitionBlock,
Flags = flags,
DevFlags = devFlags,
DriveName = driveName,
SizeOfVector = sizeOfVector,
SizeBlock = sizeBlock,
SecOrg = secOrg,
Surfaces = surfaces,
Sectors = sectors,
BlocksPerTrack = blocksPerTrack,
Reserved = reserved,
PreAlloc = preAlloc,
Interleave = interleave,
LowCyl = lowCyl,
HighCyl = highCyl,
NumBuffer = numBuffer,
BufMemType = bufMemType,
MaxTransfer = maxTransfer,
Mask = mask,
BootPriority = bootPriority,
DosType = dosType,
Baud = baud,
Control = control,
BootBlocks = bootBlocks,
PartitionSize = partitionSize,
FileSystemBlockSize = fileSystemBlockSize,
};
}
}
} | 1 | 0.921815 | 1 | 0.921815 | game-dev | MEDIA | 0.271919 | game-dev | 0.78956 | 1 | 0.78956 |
Ezzz-dev/Nostalrius | 2,880 | data/npc/ferryman2.npc | # GIMUD - Graphical Interface Multi User Dungeon
# ferryman2.npc: Fhrmann Anderson auf Senja (Ice)
Name = "Anderson"
Outfit = (129,79-113-68-67)
Home = [32127,31660,7]
Radius = 1
Behaviour = {
ADDRESS,"hello$",male,! -> "Ahoi, young man %N and welcome to the Nordic Tibia Ferries."
ADDRESS,"hi$",male,! -> *
ADDRESS,"hello$",female,! -> "Ahoi, young lady %N and welcome to the Nordic Tibia Ferries."
ADDRESS,"hi$",female,! -> *
ADDRESS,! -> Idle
BUSY,"hello$",! -> "One moment please, %N.", Queue
BUSY,"hi$",! -> *
BUSY,! -> NOP
VANISH,! -> "Good bye. You are welcome."
"bye" -> "Good bye. You are welcome.", Idle
"farewell" -> *
"name" -> "My name is Anderson from the Nordic Tibia Ferries."
"anderson" -> "The four of us are the captains of the Nordic Tibia Ferries."
"svenson" -> *
"carlson" -> *
"nielson" -> *
"job" -> "We are ferrymen. We transport goods and passengers to the Ice Islands."
"captain" -> *
"ship" -> "Our ferries are strong enough to stand the high waves of the Nordic Ocean."
"ferry" -> *
"ferries" -> *
"water" -> *
"good" -> "We can transport everything you want."
"passenger" -> "We would like to welcome you on board our ferries."
"trip" -> "Where do you want to go today? We serve the routes to Senja, Folda, and Vega, and back to Tibia."
"passage" -> *
"round","trip" -> "The fee for the trip back to Tibia is included."
"island" -> "We serve the routes to Senja, Folda, and Vega, and back to Tibia."
"route" -> *
"senja" -> "This island is Senja."
"folda" -> Price=10, "Do you want a passage to Folda for %P gold?", Topic=1
"vega" -> Price=10, "Do you want a passage to Vega for %P gold?", Topic=2
"tibia" -> Price=0, "Do you want a free passage back to Tibia?", Topic=3
Topic=1,"yes",PZBlock,! -> "First get rid of those blood stains! You are not going to ruin my vehicle!"
Topic=2,"yes",PZBlock,! -> *
Topic=3,"yes",PZBlock,! -> *
Topic=1,"yes",CountMoney>=Price -> "Have a nice trip!", DeleteMoney, Idle, EffectOpp(11), Teleport(32048,31582,7), EffectOpp(11)
Topic=1,"yes" -> "You don't have enough money."
Topic=1 -> "You shouldn't miss the experience."
Topic=2,"yes",CountMoney>=Price -> "Have a nice trip!", DeleteMoney, Idle, EffectOpp(11), Teleport(32025,31692,7), EffectOpp(11)
Topic=2,"yes" -> "You don't have enough money."
Topic=2 -> "You shouldn't miss the experience."
Topic=3,"yes",CountMoney>=Price -> "Have a nice trip!", DeleteMoney, Idle, EffectOpp(11), Teleport(32236,31677,7), EffectOpp(11)
Topic=3,"yes" -> "You don't have enough money."
Topic=3 -> "You shouldn't miss the experience."
}
| 1 | 0.609293 | 1 | 0.609293 | game-dev | MEDIA | 0.785183 | game-dev | 0.673845 | 1 | 0.673845 |
davejlin/trading | 23,803 | My EAs/2ndSkiesB.mq4 | //+----------------------------------------------------------------------+
//| 2ndSkiesB.mq4 |
//| David J. Lin |
//|Based on an MA/MACD strategy |
//|by Chris Capre, 2ndSkies.com (Info@2ndSkies.com) |
//|Coded by David J. Lin (dave.j.lin@sbcglobal.net) |
//|Evanston, IL, December 14, 2008 |
//+----------------------------------------------------------------------+
#property copyright "Copyright 2008, Chris Capre & David J. Lin"
#property link "2ndSkies.com"
// Internal usage parameters:
extern double LotsPerPosition=1.0; // fixed-lots per position
extern int starthour=7; // platform hour to start (inclusive)
extern int startmin=30; // platform minute to start
extern int endhour=16; // platform hour to end (inclusive)
int StopLoss=24; // pips beyond cloud SL
int TakeProfit=15; // pips TP
int FixedStop=0; // move SL 2nd order
int MAPeriod1=3;
int MAPeriod2=24;
int MAPeriod3=30;
int MAShift=0;
int MAMethod=MODE_EMA;
int MAPrice=PRICE_CLOSE;
int MACDPeriodFast=12;
int MACDPeriodSlow=33;
int MACDPeriodSignal=9;
double lotsmin,lotsmax;
int lotsprecision;
bool orderlong,ordershort;
int Slippage=2;
int Magic1,Magic2;
datetime ots,otl,lasttime,lastM1,starttime,lastLong,lastShort;
string comment1,comment2;
//+------------------------------------------------------------------+
//| expert initialization function |
//+------------------------------------------------------------------+
int init()
{
//----
starttime=TimeCurrent();
lotsmin=MarketInfo(Symbol(),MODE_MINLOT);
lotsmax=MarketInfo(Symbol(),MODE_MAXLOT);
comment1=StringConcatenate("2SB1 ",DoubleToStr(Period(),0)," ",Symbol());
comment2=StringConcatenate("2SB2 ",DoubleToStr(Period(),0)," ",Symbol());
Magic1=81+Period();
Magic2=82+Period();
if(lotsmin==1) lotsprecision=0;
else if(lotsmin==0.50) lotsprecision=1; // for PFG ECN
else if(lotsmin==0.10) lotsprecision=1;
else if(lotsmin==0.01) lotsprecision=2;
else lotsprecision=1;
// First check closed trades
int trade;
int trades=OrdersHistoryTotal();
for(trade=0;trade<trades;trade++) // The most recent closed order has the largest position number, so this works forward
// to allow the values of the most recent closed orders to be the ones which are recorded
{
OrderSelect(trade,SELECT_BY_POS,MODE_HISTORY);
if(OrderSymbol()!=Symbol()) continue;
if(OrderMagicNumber()==Magic1||OrderMagicNumber()==Magic2)
{
// int D1bars=iBarShift(NULL,PERIOD_D1,OrderCloseTime(),false); // time difference in days
// if(D1bars>60) // = only interested in recently closed trades
// continue;
Status(OrderMagicNumber());
DrawCross(false);
}
}
// Now check open orders
orderlong=false; ordershort=false; //reset flags
trades=OrdersTotal();
for(trade=0;trade<trades;trade++)// The most recent closed order has the largest position number, so this works forward
// to allow the values of the most recent closed orders to be the ones which are recorded
{
OrderSelect(trade,SELECT_BY_POS,MODE_TRADES);
if(OrderSymbol()!=Symbol()) continue;
if(OrderMagicNumber()==Magic1||OrderMagicNumber()==Magic2)
{
Status(OrderMagicNumber());
DrawCross(true);
}
}
// HideTestIndicators(true);
//----
return(0);
}
//+------------------------------------------------------------------+
//| expert deinitialization function |
//+------------------------------------------------------------------+
int deinit()
{
//----
//----
return(0);
}
//+------------------------------------------------------------------+
//| expert start function |
//+------------------------------------------------------------------+
int start()
{
//----
Main();
ManageOrders();
lasttime=iTime(NULL,0,0);
lastM1=iTime(NULL,PERIOD_M1,0);
//----
return(0);
}
//+------------------------------------------------------------------+
//| expert utility functions |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
void Main()
{
if(orderlong||ordershort) return;
// if(lastM1==iTime(NULL,PERIOD_M1,0)) return;
int timehour=TimeHour(iTime(NULL,0,0));
if(starthour<endhour)
{
if(timehour<starthour || timehour>endhour) return;
}
else
{
if(timehour<starthour && timehour>endhour) return;
}
int timeminute=TimeMinute(iTime(NULL,0,0));
if(timehour==starthour && timeminute<startmin) return;
double Lots,SL,TP,MA1a,MA2a,MA3a,MA1b,MA2b,MA3b;
string td;
MA1a=iMA(NULL,0,MAPeriod1,MAShift,MAMethod,MAPrice,0);
MA2a=iMA(NULL,0,MAPeriod2,MAShift,MAMethod,MAPrice,0);
MA3a=iMA(NULL,0,MAPeriod3,MAShift,MAMethod,MAPrice,0);
MA1b=iMA(NULL,0,MAPeriod1,MAShift,MAMethod,MAPrice,1);
MA2b=iMA(NULL,0,MAPeriod2,MAShift,MAMethod,MAPrice,1);
MA3b=iMA(NULL,0,MAPeriod3,MAShift,MAMethod,MAPrice,1);
if(((MA1a>MA2a && MA1b<MA2b)||(MA1a>MA3a && MA1b<MA3b)) && MA1a>MA3a && MA1a>MA2a && Bid>MA2a && Bid>MA3a)
{
if(iBarShift(NULL,0,otl,false)>0)
{
if(filter(true))
{
SL=StopLong(Ask,StopLoss);
TP=TakeLong(Ask,TakeProfit);
Lots=LotsPerPosition;
SendOrderLong(Symbol(),Lots,Slippage,0,0,comment1,Magic1);
SendOrderLong(Symbol(),Lots,Slippage,0,0,comment2,Magic2);
otl=TimeCurrent();
td=TimeToStr(otl,TIME_DATE|TIME_MINUTES);
Alert("2ndSkiesB enter long: ",Symbol()," M",Period()," at",td);
AddSLTP(SL,TP);
}
}
}
else if(((MA1a<MA2a && MA1b>MA2b)||(MA1a<MA3a && MA1b>MA3b)) && MA1a<MA3a && MA1a<MA2a && Bid<MA2a && Bid<MA3a)
{
if(iBarShift(NULL,0,ots,false)>0)
{
if(filter(false))
{
SL=StopShort(Bid,StopLoss);
TP=TakeShort(Bid,TakeProfit);
Lots=LotsPerPosition;
SendOrderShort(Symbol(),Lots,Slippage,0,0,comment1,Magic1);
SendOrderShort(Symbol(),Lots,Slippage,0,0,comment2,Magic2);
ots=TimeCurrent();
td=TimeToStr(ots,TIME_DATE|TIME_MINUTES);
Alert("2ndSkiesB enter short: ",Symbol()," M",Period()," at",td);
AddSLTP(SL,TP);
}
}
}
return;
}
//+------------------------------------------------------------------+
bool filter(bool long)
{
int Trigger[3], totN=3,i,j,k,trig;
double MA1a,MA2a,MA3a,MA1b,MA2b,MA3b,MACDmain,MACDsig;
for(i=0;i<totN;i++) Trigger[i]=-1;
if(long) // long filters
{
for(i=0;i<totN;i++)
{
switch(i)
{
case 0:
for(j=0;j<=5000;j++)
{
MA1a=iMA(NULL,0,MAPeriod1,MAShift,MAMethod,MAPrice,j);
MA2a=iMA(NULL,0,MAPeriod2,MAShift,MAMethod,MAPrice,j);
MA3a=iMA(NULL,0,MAPeriod3,MAShift,MAMethod,MAPrice,j);
MA1b=iMA(NULL,0,MAPeriod1,MAShift,MAMethod,MAPrice,j+1);
MA2b=iMA(NULL,0,MAPeriod2,MAShift,MAMethod,MAPrice,j+1);
MA3b=iMA(NULL,0,MAPeriod3,MAShift,MAMethod,MAPrice,j+1);
if(MA1a<MA2a && MA1b>MA2b) return(false); // negate upon contrary cross since
if(MA1a<MA3a && MA1b>MA3b) return(false); // negate upon contrary cross since
if(((MA1a>MA2a && MA1b<MA2b) || (MA1a>MA3a && MA1b<MA3b)) && MA1a>MA3a && MA1a>MA2a)
{
if(iTime(NULL,0,j)>otl && iTime(NULL,0,j)>starttime ) // take trigger upon new cross only & after start
{
Trigger[i]=1;
trig=j;
break;
}
else return(false);
}
}
break;
case 1: // MACD filter
MACDmain=iMACD(NULL,0,MACDPeriodFast,MACDPeriodSlow,MACDPeriodSignal,PRICE_CLOSE,MODE_MAIN,0);
MACDsig= iMACD(NULL,0,MACDPeriodFast,MACDPeriodSlow,MACDPeriodSignal,PRICE_CLOSE,MODE_SIGNAL,0);
if(MACDmain>MACDsig) Trigger[i]=1;
break;
case 2:
CheckClosedOrders();
if(iTime(NULL,0,trig)>lastLong) Trigger[i]=1;
break;
}
if(Trigger[i]<0) return(false);
}
}
else // short filters
{
for(i=0;i<totN;i++)
{
switch(i)
{
case 0:
for(j=0;j<=5000;j++)
{
MA1a=iMA(NULL,0,MAPeriod1,MAShift,MAMethod,MAPrice,j);
MA2a=iMA(NULL,0,MAPeriod2,MAShift,MAMethod,MAPrice,j);
MA3a=iMA(NULL,0,MAPeriod3,MAShift,MAMethod,MAPrice,j);
MA1b=iMA(NULL,0,MAPeriod1,MAShift,MAMethod,MAPrice,j+1);
MA2b=iMA(NULL,0,MAPeriod2,MAShift,MAMethod,MAPrice,j+1);
MA3b=iMA(NULL,0,MAPeriod3,MAShift,MAMethod,MAPrice,j+1);
if(MA1a>MA2a && MA1b<MA2b) return(false); // negate upon contrary cross since
if(MA1a>MA3a && MA1b<MA3b) return(false); // negate upon contrary cross since
if(((MA1a<MA2a && MA1b>MA2b) || (MA1a<MA3a && MA1b>MA3b)) && MA1a<MA3a && MA1a<MA2a)
{
if(iTime(NULL,0,j)>ots && iTime(NULL,0,j)>starttime ) // take trigger upon new cross only & after start
{
Trigger[i]=1;
trig=j;
break;
}
else return(false);
}
}
break;
case 1: // MACD filter
MACDmain=iMACD(NULL,0,MACDPeriodFast,MACDPeriodSlow,MACDPeriodSignal,PRICE_CLOSE,MODE_MAIN,0);
MACDsig= iMACD(NULL,0,MACDPeriodFast,MACDPeriodSlow,MACDPeriodSignal,PRICE_CLOSE,MODE_SIGNAL,0);
if(MACDmain<MACDsig) Trigger[i]=1;
break;
case 2:
CheckClosedOrders();
if(iTime(NULL,0,trig)>lastShort) Trigger[i]=1;
break;
}
if(Trigger[i]<0) return(false);
}
}
return(true); // no anti-trigger: so, return true (to order)
}
//+------------------------------------------------------------------+
void ManageOrders()
{
orderlong=false;ordershort=false;
int magic,trade,trades=OrdersTotal();
for(trade=trades-1;trade>=0;trade--)
{
OrderSelect(trade,SELECT_BY_POS,MODE_TRADES);
if(OrderSymbol()!=Symbol()) continue;
magic=OrderMagicNumber();
if(magic==Magic1)
{
if(OrderType()==OP_BUY) orderlong=true;
else if(OrderType()==OP_SELL) ordershort=true;
// if(iBarShift(NULL,0,OrderOpenTime(),false)<1) continue;
// if(lastM1==iTime(NULL,PERIOD_M1,0)) continue;
}
else if(magic==Magic2)
{
if(OrderType()==OP_BUY) orderlong=true;
else if(OrderType()==OP_SELL) ordershort=true;
if(CheckSL()<0) FixedStopsB(TakeProfit,FixedStop);
if(iBarShift(NULL,0,OrderOpenTime(),false)<1) continue;
// if(lastM1==iTime(NULL,PERIOD_M1,0)) continue;
MACDExit();
}
}
return;
}
//+------------------------------------------------------------------+
bool ModifyOrder(int ticket, double price, double sl, double tp, datetime exp, color cl=CLR_NONE)
{
GetSemaphore();
if(OrderModify(ticket,price,sl,tp,exp,cl)==false)
{
Print("OrderModify failed, Error: ",GetLastError(), " Ticket Number: ", ticket);
Print("Old price: ", OrderOpenPrice(), " Old S/L ", OrderStopLoss(), " Old T/P ", OrderTakeProfit(), " Ask/Bid ",Ask,", ",Bid);
Print(" New Price: ", price, " New S/L ", sl, " New T/P ", tp, " New Expiration ", exp);
}
ReleaseSemaphore();
}
//+------------------------------------------------------------------+
int SendOrderLong(string sym, double vol, int slip, double sl, double tp, string comment="", int magic=0, datetime exp=0, color cl=Blue)
{
int err;
GetSemaphore();
for(int z=0;z<5;z++)
{
if(OrderSend(sym,OP_BUY,NormLots(vol),Ask,slip,NormDigits(sl),NormDigits(tp),comment,magic,exp,cl)<0)
{
err = GetLastError();
Print("OrderSend Long failed, Error: ", err, " Magic Number: ", magic);
Print("Ask: ", Ask, " S/L ", sl, " T/P ", tp);
if(err>4000) break;
RefreshRates();
}
else
break;
}
ReleaseSemaphore();
}
//+------------------------------------------------------------------+
int SendOrderShort(string sym, double vol, int slip, double sl, double tp, string comment="", int magic=0, datetime exp=0, color cl=Red)
{
int err;
GetSemaphore();
for(int z=0;z<5;z++)
{
if(OrderSend(sym,OP_SELL,NormLots(vol),Bid,slip,NormDigits(sl),NormDigits(tp),comment,magic,exp,cl)<0)
{
err = GetLastError();
Print("OrderSend Short failed, Error: ", err, " Magic Number: ", magic);
Print("Bid: ", Bid, " S/L ", sl, " T/P ", tp);
if(err>4000) break;
RefreshRates();
}
else
break;
}
ReleaseSemaphore();
}
//+------------------------------------------------------------------+
bool CloseOrderLong(int ticket, double lots, int slip, color cl=CLR_NONE)
{
GetSemaphore();
for(int z=0;z<10;z++)
{
if(!OrderClose(ticket,NormLots(lots),Bid,slip,cl))
{
int err = GetLastError();
Print("OrderClose Long failed, Error: ", err, " Ticket #: ", ticket);
Print("Bid: ", Bid);
if(err>4000) break;
RefreshRates();
}
else break;
}
ReleaseSemaphore();
}
//+------------------------------------------------------------------+
bool CloseOrderShort(int ticket, double lots, int slip, color cl=CLR_NONE)
{
GetSemaphore();
for(int z=0;z<10;z++)
{
if(!OrderClose(ticket,NormLots(lots),Ask,slip,cl))
{
int err = GetLastError();
Print("OrderClose Short failed, Error: ", err, " Ticket #: ", ticket);
Print("Ask: ", Ask);
if(err>4000) break;
RefreshRates();
}
else break;
}
ReleaseSemaphore();
}
//+------------------------------------------------------------------+
bool GetSemaphore()
{
if(!GlobalVariableCheck("SEMAPHORE")) GlobalVariableSet("SEMAPHORE",0);
while(!IsStopped())
{
if(GlobalVariableSetOnCondition("SEMAPHORE",1,0)==true) break;
Sleep(500);
}
return(true);
}
//+------------------------------------------------------------------+
bool ReleaseSemaphore()
{
GlobalVariableSet("SEMAPHORE",0);
return(true);
}
//+------------------------------------------------------------------+
double NormPoints(int pips)
{
return(NormDigits(pips*Point));
}
//+------------------------------------------------------------------+
double NormDigits(double price)
{
return(NormalizeDouble(price,Digits));
}
//+------------------------------------------------------------------+
double NormLots(double lots)
{
if(lotsmin==0.50) // for PFG ECN
{
int lotmod=lots/lotsmin;
lots=lotmod*lotsmin; // increments of 0.50 lots
}
return(MathMax(NormalizeDouble(lotsmin,lotsprecision),NormalizeDouble(lots,lotsprecision)));
}
//+------------------------------------------------------------------+
void ExitOrder(bool flag_Long,bool flag_Short,int cancelpending=1)
{
switch(cancelpending)
{
case 1:
if(OrderType()==OP_BUY&&flag_Long)
CloseOrderLong(OrderTicket(),OrderLots(),Slippage,Lime);
else if(OrderType()==OP_SELL&&flag_Short)
CloseOrderShort(OrderTicket(),OrderLots(),Slippage,Lime);
break;
case 2:
if((OrderType()==OP_BUYSTOP)&&flag_Long)
OrderDelete(OrderTicket());
else if((OrderType()==OP_SELLSTOP)&&flag_Short)
OrderDelete(OrderTicket());
break;
}
return;
}
//+------------------------------------------------------------------+
void FixedStopsB(int PP,int PFS)
{
if(PFS<0) return;
double stopcal;
double stopcrnt=OrderStopLoss();
double profitpoint=NormPoints(PP);
double profit=DetermineProfit();
//Long
if(OrderType()==OP_BUY)
{
if(profit>=profitpoint)
{
stopcal=TakeLong(OrderOpenPrice(),PFS);
ModifyCompLong(stopcal,stopcrnt);
}
}
//Short
if(OrderType()==OP_SELL)
{
if(profit>=profitpoint)
{
stopcal=TakeShort(OrderOpenPrice(),PFS);
ModifyCompShort(stopcal,stopcrnt);
}
}
return(0);
}
//+------------------------------------------------------------------+
double DetermineProfit()
{
if(OrderType()==OP_BUY)
return(NormDigits(Bid-OrderOpenPrice()));
else if(OrderType()==OP_SELL)
return(NormDigits(OrderOpenPrice()-Ask));
return(0);
}
//+------------------------------------------------------------------+
double TakeLong(double price,int take) // function to calculate takeprofit if long
{
return(NormDigits(price+NormPoints(take)));
// plus, since the take profit is above us for long positions
}
//+------------------------------------------------------------------+
double TakeShort(double price,int take) // function to calculate takeprofit if short
{
return(NormDigits(price-NormPoints(take)));
// minus, since the take profit is below us for short positions
}
//+------------------------------------------------------------------+
double StopShort(double price,int stop) // function to calculate normal stoploss if short
{
return(NormDigits(price+NormPoints(stop)));
// plus, since the stop loss is above us for short positions
}
//+------------------------------------------------------------------+
double StopLong(double price,int stop) // function to calculate normal stoploss if long
{
return(NormDigits(price-NormPoints(stop)));
// minus, since the stop loss is below us for long positions
// Point is 0.01 or 0.001 depending on currency, so stop*POINT is a way to convert pips into price with multiplication
}
//+------------------------------------------------------------------+
double CheckSL()
{
int type=OrderType();
if(type==OP_BUY) return( NormDigits(OrderStopLoss()-OrderOpenPrice()) );
else if(type==OP_SELL) return( NormDigits(OrderOpenPrice()-OrderStopLoss()) );
return(0.0);
}
//+------------------------------------------------------------------+
void ModifyCompLong(double stopcal, double stopcrnt)
{
stopcal=NormDigits(stopcal);
stopcrnt=NormDigits(stopcrnt);
if (stopcal==stopcrnt) return;
if(stopcal>stopcrnt)
{
if(stopcal>=Bid) // check whether s/l is too close to market
return;
ModifyOrder(OrderTicket(),OrderOpenPrice(),stopcal,OrderTakeProfit(),0,Blue);
}
return;
}
//+------------------------------------------------------------------+
void ModifyCompShort(double stopcal, double stopcrnt)
{
stopcal=NormDigits(stopcal);
stopcrnt=NormDigits(stopcrnt);
if (stopcal==stopcrnt) return;
if(stopcrnt==0)
{
if(stopcal<=Ask) // check whether s/l is too close to market
return;
ModifyOrder(OrderTicket(),OrderOpenPrice(),stopcal,OrderTakeProfit(),0,Red);
}
else if(stopcal<stopcrnt&&stopcal!=0)
{
if(stopcal<=Ask) // check whether s/l is too close to market
return;
ModifyOrder(OrderTicket(),OrderOpenPrice(),stopcal,OrderTakeProfit(),0,Red);
}
return;
}
//+------------------------------------------------------------------+
void Status(int magic)
{
if(magic==Magic1)
{
if(OrderType()==OP_BUY)
{
otl=OrderOpenTime();
orderlong=true;
}
else if(OrderType()==OP_SELL)
{
ots=OrderOpenTime();
ordershort=true;
}
}
else if(magic==Magic2)
{
if(OrderType()==OP_BUY)
{
otl=OrderOpenTime();
orderlong=true;
}
else if(OrderType()==OP_SELL)
{
ots=OrderOpenTime();
ordershort=true;
}
}
return(0);
}
//+------------------------------------------------------------------+
void CheckClosedOrders() // check most recently closed for time ... don't enter until new cross occurs after a close
{
lastLong=0;lastShort=0;
int trade;
int trades=OrdersHistoryTotal();
for(trade=trades-1;trade>=0;trade--) // The most recent closed order has the largest position number, so this works backward
// to find the most recently closed order
{
OrderSelect(trade,SELECT_BY_POS,MODE_HISTORY);
if(OrderSymbol()!=Symbol()) continue;
if(OrderType()==OP_BUY)
{
if(OrderMagicNumber()==Magic1||OrderMagicNumber()==Magic2)
{
lastLong=OrderCloseTime();
break;
}
}
}
for(trade=trades-1;trade>=0;trade--) // The most recent closed order has the largest position number, so this works backward
// to find the most recently closed order
{
OrderSelect(trade,SELECT_BY_POS,MODE_HISTORY);
if(OrderSymbol()!=Symbol()) continue;
if(OrderType()==OP_SELL)
{
if(OrderMagicNumber()==Magic1||OrderMagicNumber()==Magic2)
{
lastShort=OrderCloseTime();
break;
}
}
}
return;
}
//+------------------------------------------------------------------+
void DrawCross(bool flag)
{
color clr;
string name;
double price=OrderOpenPrice();
datetime time=OrderOpenTime();
string comment=OrderComment();
int ticket=OrderTicket();
int type=OrderType();
if(type==OP_BUY||type==OP_BUYLIMIT||type==OP_BUYSTOP) clr=Blue;
else if(type==OP_SELL||type==OP_SELLLIMIT||type==OP_SELLSTOP) clr=Red;
if(flag)
{
name=StringConcatenate(comment," #",ticket," ",TimeToStr(time)," ",price);
ObjectDelete(name);
ObjectCreate(name,OBJ_ARROW,0,time,price);
ObjectSet(name,OBJPROP_COLOR,clr);
ObjectSet(name,OBJPROP_ARROWCODE,1);
ObjectSet(name,OBJPROP_WIDTH,1);
}
else
{
// if(type!=OP_BUY||type!=OP_SELL) comment=FindComment(OrderMagicNumber()); // expired pendings don't have method name for comment, must match up w/ list
name=StringConcatenate(comment," #",ticket," ",TimeToStr(time)," ",price);
ObjectDelete(name);
ObjectCreate(name,OBJ_ARROW,0,time,price);
ObjectSet(name,OBJPROP_COLOR,clr);
ObjectSet(name,OBJPROP_ARROWCODE,1);
ObjectSet(name,OBJPROP_WIDTH,1);
double closeprice;
if(type==OP_BUY||type==OP_SELL) closeprice=OrderClosePrice();
else closeprice=OrderOpenPrice();
datetime closetime=OrderCloseTime();
name=StringConcatenate(comment,": ",price,"-->",closeprice);
if(type==OP_BUYLIMIT||type==OP_BUYSTOP||type==OP_SELLLIMIT||type==OP_SELLSTOP) clr=Black;
ObjectDelete(name);
ObjectCreate(name,OBJ_TREND,0,time,price,closetime,closeprice);
ObjectSet(name,OBJPROP_STYLE,STYLE_DOT);
ObjectSet(name,OBJPROP_COLOR,clr);
ObjectSet(name,OBJPROP_RAY,false);
if(type==OP_BUY||type==OP_SELL)
{
if(OrderStopLoss()!=OrderClosePrice()) clr=LimeGreen;
}
name=StringConcatenate(comment," #",ticket," ",TimeToStr(closetime)," ",closeprice);
ObjectDelete(name);
ObjectCreate(name,OBJ_ARROW,0,closetime,closeprice);
ObjectSet(name,OBJPROP_ARROWCODE,3);
ObjectSet(name,OBJPROP_COLOR,clr);
}
return;
}
//+------------------------------------------------------------------+
void MACDExit()
{
double MACDmain1=iMACD(NULL,0,MACDPeriodFast,MACDPeriodSlow,MACDPeriodSignal,PRICE_CLOSE,MODE_MAIN,0);
double MACDsig1= iMACD(NULL,0,MACDPeriodFast,MACDPeriodSlow,MACDPeriodSignal,PRICE_CLOSE,MODE_SIGNAL,0);
double MACDmain2=iMACD(NULL,0,MACDPeriodFast,MACDPeriodSlow,MACDPeriodSignal,PRICE_CLOSE,MODE_MAIN,1);
double MACDsig2= iMACD(NULL,0,MACDPeriodFast,MACDPeriodSlow,MACDPeriodSignal,PRICE_CLOSE,MODE_SIGNAL,1);
if(OrderType()==OP_BUY)
{
if(MACDmain1<MACDsig1 && MACDmain2>MACDsig2)
{
ExitOrder(true,false);
Alert("2ndSkiesB2 cross-exit long: ",Symbol()," M",Period()," at",TimeToStr(TimeCurrent(),TIME_DATE|TIME_MINUTES));
}
}
else if(OrderType()==OP_SELL)
{
if(MACDmain1>MACDsig1 && MACDmain2<MACDsig2)
{
ExitOrder(false,true);
Alert("2ndSkiesB2 cross-exit short: ",Symbol()," M",Period()," at",TimeToStr(TimeCurrent(),TIME_DATE|TIME_MINUTES));
}
}
return;
}
//+------------------------------------------------------------------+
void AddSLTP(double sl, double tp)
{
int magic,trade,trades=OrdersTotal();
for(trade=trades-1;trade>=0;trade--)
{
OrderSelect(trade,SELECT_BY_POS,MODE_TRADES);
if(OrderSymbol()!=Symbol()) continue;
if(OrderStopLoss()==0)
{
magic=OrderMagicNumber();
if(magic==Magic1) ModifyOrder(OrderTicket(),OrderOpenPrice(),sl,tp,0,CLR_NONE);
else if(magic==Magic2) ModifyOrder(OrderTicket(),OrderOpenPrice(),sl,0, 0,CLR_NONE);
}
}
return;
} | 1 | 0.775528 | 1 | 0.775528 | game-dev | MEDIA | 0.353818 | game-dev | 0.984801 | 1 | 0.984801 |
KDE/krita | 1,137 | libs/image/commands_new/KisUpdateCommandEx.cpp | /*
* SPDX-FileCopyrightText: 2021 Dmitry Kazakov <dimula73@gmail.com>
*
* SPDX-License-Identifier: GPL-2.0-or-later
*/
#include "KisUpdateCommandEx.h"
#include "kis_image_interfaces.h"
#include "kis_node.h"
KisUpdateCommandEx::KisUpdateCommandEx(KisBatchNodeUpdateSP updateData,
KisUpdatesFacade *updatesFacade,
State state,
QWeakPointer<boost::none_t> blockUpdatesCookie)
: FlipFlopCommand(state),
m_updateData(updateData),
m_blockUpdatesCookie(blockUpdatesCookie),
m_updatesFacade(updatesFacade)
{
}
KisUpdateCommandEx::~KisUpdateCommandEx()
{
}
KisUpdateCommandEx::KisUpdateCommandEx(KisBatchNodeUpdateSP updateData, KisUpdatesFacade *updatesFacade, State state)
: KisUpdateCommandEx(updateData, updatesFacade, state, QWeakPointer<boost::none_t>())
{
}
void KisUpdateCommandEx::partB() {
if (m_blockUpdatesCookie) return;
for (auto it = m_updateData->begin(); it != m_updateData->end(); ++it) {
m_updatesFacade->refreshGraphAsync(it->first, it->second);
}
}
| 1 | 0.835447 | 1 | 0.835447 | game-dev | MEDIA | 0.593213 | game-dev | 0.530008 | 1 | 0.530008 |
AntiCope/meteor-rejects | 8,748 | src/main/java/anticope/rejects/modules/FullFlight.java | package anticope.rejects.modules;
import anticope.rejects.MeteorRejectsAddon;
import anticope.rejects.utils.RejectsUtils;
import com.google.common.collect.Streams;
import meteordevelopment.meteorclient.events.entity.player.PlayerMoveEvent;
import meteordevelopment.meteorclient.events.packets.PacketEvent;
import meteordevelopment.meteorclient.mixin.ClientPlayerEntityAccessor;
import meteordevelopment.meteorclient.mixin.PlayerMoveC2SPacketAccessor;
import meteordevelopment.meteorclient.settings.*;
import meteordevelopment.meteorclient.systems.modules.Module;
import meteordevelopment.orbit.EventHandler;
import net.minecraft.block.AbstractBlock;
import net.minecraft.entity.Entity;
import net.minecraft.network.packet.c2s.play.PlayerMoveC2SPacket;
import net.minecraft.util.math.Box;
import net.minecraft.util.shape.VoxelShape;
import java.util.stream.Stream;
public class FullFlight extends Module {
private final SettingGroup sgGeneral = settings.getDefaultGroup();
private final SettingGroup sgAntiKick = settings.createGroup("Anti Kick");
private final Setting<Double> speed = sgGeneral.add(new DoubleSetting.Builder()
.name("speed")
.description("Your speed when flying.")
.defaultValue(0.3)
.min(0.0)
.sliderMax(10)
.build()
);
private final Setting<Boolean> verticalSpeedMatch = sgGeneral.add(new BoolSetting.Builder()
.name("vertical-speed-match")
.description("Matches your vertical speed to your horizontal speed, otherwise uses vanilla ratio.")
.defaultValue(false)
.build()
);
private final Setting<AntiKickMode> antiKickMode = sgAntiKick.add(new EnumSetting.Builder<AntiKickMode>()
.name("mode")
.description("The mode for anti kick.")
.defaultValue(AntiKickMode.PaperNew)
.build()
);
public FullFlight() {
super(MeteorRejectsAddon.CATEGORY, "fullflight", "FullFlight.");
}
private double calculateGround() {
for (double ground = mc.player.getY(); ground > 0D; ground -= 0.05) {
Box box = mc.player.getBoundingBox();
Box adjustedBox = box.offset(0, ground - mc.player.getY(), 0);
Stream<VoxelShape> blockCollisions = Streams.stream(mc.world.getBlockCollisions(mc.player, adjustedBox));
if (blockCollisions.findAny().isPresent()) return ground + 0.05;
}
return 0F;
}
// Copied from ServerPlayNetworkHandler#isEntityOnAir
private boolean isEntityOnAir(Entity entity) {
return entity.getWorld().getStatesInBox(entity.getBoundingBox().expand(0.0625).stretch(0.0, -0.55, 0.0)).allMatch(AbstractBlock.AbstractBlockState::isAir);
}
private int delayLeft = 20;
private double lastPacketY = Double.MAX_VALUE;
private boolean shouldFlyDown(double currentY, double lastY) {
if (currentY >= lastY) {
return true;
} else return lastY - currentY < 0.03130D;
}
private void antiKickPacket(PlayerMoveC2SPacket packet, double currentY) {
// maximum time we can be "floating" is 80 ticks, so 4 seconds max
if (this.delayLeft <= 0 && this.lastPacketY != Double.MAX_VALUE &&
shouldFlyDown(currentY, this.lastPacketY) && isEntityOnAir(mc.player)) {
// actual check is for >= -0.03125D, but we have to do a bit more than that
// due to the fact that it's a bigger or *equal* to, and not just a bigger than
((PlayerMoveC2SPacketAccessor) packet).setY(lastPacketY - 0.03130D);
lastPacketY -= 0.03130D;
delayLeft = 20;
} else {
lastPacketY = currentY;
if (!isEntityOnAir(mc.player))
delayLeft = 20;
}
if (delayLeft > 0) delayLeft--;
}
@EventHandler
private void onSendPacket(PacketEvent.Send event) {
if (mc.player.getVehicle() == null || !(event.packet instanceof PlayerMoveC2SPacket packet) || antiKickMode.get() != AntiKickMode.PaperNew)
return;
double currentY = packet.getY(Double.MAX_VALUE);
if (currentY != Double.MAX_VALUE) {
antiKickPacket(packet, currentY);
} else {
// if the packet is a LookAndOnGround packet or an OnGroundOnly packet then we need to
// make it a Full packet or a PositionAndOnGround packet respectively, so it has a Y value
PlayerMoveC2SPacket fullPacket;
if (packet.changesLook()) {
fullPacket = new PlayerMoveC2SPacket.Full(
mc.player.getX(),
mc.player.getY(),
mc.player.getZ(),
packet.getYaw(0),
packet.getPitch(0),
packet.isOnGround(),
packet.horizontalCollision()
);
} else {
fullPacket = new PlayerMoveC2SPacket.PositionAndOnGround(
mc.player.getX(),
mc.player.getY(),
mc.player.getZ(),
packet.isOnGround(),
packet.horizontalCollision()
);
}
event.cancel();
antiKickPacket(fullPacket, mc.player.getY());
mc.getNetworkHandler().sendPacket(fullPacket);
}
}
private int floatingTicks = 0;
@EventHandler
private void onPlayerMove(PlayerMoveEvent event) {
if (antiKickMode.get() == AntiKickMode.PaperNew) {
// Resend movement packets
((ClientPlayerEntityAccessor) mc.player).setTicksSinceLastPositionPacketSent(20);
}
if (floatingTicks >= 20) {
switch (antiKickMode.get()) {
case New -> {
Box box = mc.player.getBoundingBox();
Box adjustedBox = box.offset(0, -0.4, 0);
Stream<VoxelShape> blockCollisions = Streams.stream(mc.world.getBlockCollisions(mc.player, adjustedBox));
if (blockCollisions.findAny().isPresent()) break;
mc.getNetworkHandler().sendPacket(new PlayerMoveC2SPacket.PositionAndOnGround(mc.player.getX(), mc.player.getY() - 0.4, mc.player.getZ(), mc.player.isOnGround(), mc.player.horizontalCollision));
mc.getNetworkHandler().sendPacket(new PlayerMoveC2SPacket.PositionAndOnGround(mc.player.getX(), mc.player.getY(), mc.player.getZ(), mc.player.isOnGround(), mc.player.horizontalCollision));
}
case Old -> {
Box box = mc.player.getBoundingBox();
Box adjustedBox = box.offset(0, -0.4, 0);
Stream<VoxelShape> blockCollisions = Streams.stream(mc.world.getBlockCollisions(mc.player, adjustedBox));
if (blockCollisions.findAny().isPresent()) break;
double ground = calculateGround();
double groundExtra = ground + 0.1D;
for (double posY = mc.player.getY(); posY > groundExtra; posY -= 4D) {
mc.getNetworkHandler().sendPacket(new PlayerMoveC2SPacket.PositionAndOnGround(mc.player.getX(), posY, mc.player.getZ(), true, mc.player.horizontalCollision));
if (posY - 4D < groundExtra) break; // Prevent next step
}
mc.getNetworkHandler().sendPacket(new PlayerMoveC2SPacket.PositionAndOnGround(mc.player.getX(), groundExtra, mc.player.getZ(), true, mc.player.horizontalCollision));
for (double posY = groundExtra; posY < mc.player.getY(); posY += 4D) {
mc.getNetworkHandler().sendPacket(new PlayerMoveC2SPacket.PositionAndOnGround(mc.player.getX(), posY, mc.player.getZ(), mc.player.isOnGround(), mc.player.horizontalCollision));
if (posY + 4D > mc.player.getY()) break; // Prevent next step
}
mc.getNetworkHandler().sendPacket(new PlayerMoveC2SPacket.PositionAndOnGround(mc.player.getX(), mc.player.getY(), mc.player.getZ(), mc.player.isOnGround(), mc.player.horizontalCollision));
}
}
floatingTicks = 0;
}
float ySpeed = RejectsUtils.fullFlightMove(event, speed.get(), verticalSpeedMatch.get());
if (floatingTicks < 20)
if (ySpeed >= -0.1)
floatingTicks++;
else if (antiKickMode.get() == AntiKickMode.New)
floatingTicks = 0;
}
public enum AntiKickMode {
Old,
New,
PaperNew,
None
}
} | 1 | 0.867983 | 1 | 0.867983 | game-dev | MEDIA | 0.922754 | game-dev | 0.897635 | 1 | 0.897635 |
MigaMiDev/OLD-Just-Enough-Guns | 2,208 | src/main/java/ttv/migami/jeg/init/ModTileEntities.java | package ttv.migami.jeg.init;
import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.entity.BlockEntity;
import net.minecraft.world.level.block.entity.BlockEntityType;
import net.minecraftforge.registries.DeferredRegister;
import net.minecraftforge.registries.ForgeRegistries;
import net.minecraftforge.registries.RegistryObject;
import ttv.migami.jeg.Reference;
import ttv.migami.jeg.blockentity.*;
import java.util.function.Supplier;
/**
* Author: MrCrayfish
*/
public class ModTileEntities
{
public static final DeferredRegister<BlockEntityType<?>> REGISTER = DeferredRegister.create(ForgeRegistries.BLOCK_ENTITIES, Reference.MOD_ID);
public static final RegistryObject<BlockEntityType<ScrapWorkbenchBlockEntity>> SCRAP_WORKBENCH = register("scrap_workbench", ScrapWorkbenchBlockEntity::new,
() -> new Block[]{ModBlocks.SCRAP_WORKBENCH.get()});
public static final RegistryObject<BlockEntityType<GunmetalWorkbenchBlockEntity>> GUNMETAL_WORKBENCH = register("gunmetal_workbench", GunmetalWorkbenchBlockEntity::new,
() -> new Block[]{ModBlocks.GUNMETAL_WORKBENCH.get()});
public static final RegistryObject<BlockEntityType<GunniteWorkbenchBlockEntity>> GUNNITE_WORKBENCH = register("gunnite_workbench", GunniteWorkbenchBlockEntity::new,
() -> new Block[]{ModBlocks.GUNNITE_WORKBENCH.get()});
public static final RegistryObject<BlockEntityType<RecyclerBlockEntity>> RECYCLER = register("recycler", RecyclerBlockEntity::new,
() -> new Block[]{ModBlocks.RECYCLER.get()});
public static final RegistryObject<BlockEntityType<BooNestBlockEntity>> BOO_NEST = REGISTER.register("boo_nest", () ->
BlockEntityType.Builder.of(BooNestBlockEntity::new,
ModBlocks.BOO_NEST.get(),
ModBlocks.BOOHIVE.get()
).build(null)
);
private static <T extends BlockEntity> RegistryObject<BlockEntityType<T>> register(String id, BlockEntityType.BlockEntitySupplier<T> factoryIn, Supplier<Block[]> validBlocksSupplier)
{
return REGISTER.register(id, () -> BlockEntityType.Builder.of(factoryIn, validBlocksSupplier.get()).build(null));
}
}
| 1 | 0.84837 | 1 | 0.84837 | game-dev | MEDIA | 0.982469 | game-dev | 0.719619 | 1 | 0.719619 |
asc-community/AngouriMath | 3,200 | Sources/Wrappers/AngouriMath.CPP.Exporting/A.Exports.Hyperbolic.Functions.cs | //
// Copyright (c) 2019-2022 Angouri.
// AngouriMath is licensed under MIT.
// Details: https://github.com/asc-community/AngouriMath/blob/master/LICENSE.md.
// Website: https://am.angouri.org.
//
// This file is auto-generated. Use generate_exports.bat to re-generate it, do not edit the file itself.
using System.Runtime.InteropServices;
namespace AngouriMath.CPP.Exporting
{
unsafe partial class Exports
{
[UnmanagedCallersOnly(EntryPoint = "hyperbolic_sinh")]
public static NErrorCode ESinh(ObjRef arg0, ObjRef* res)
=> ExceptionEncode(res, (arg0), e => AngouriMath.MathS.Hyperbolic.Sinh(e.AsEntity));
[UnmanagedCallersOnly(EntryPoint = "hyperbolic_cosh")]
public static NErrorCode ECosh(ObjRef arg0, ObjRef* res)
=> ExceptionEncode(res, (arg0), e => AngouriMath.MathS.Hyperbolic.Cosh(e.AsEntity));
[UnmanagedCallersOnly(EntryPoint = "hyperbolic_tanh")]
public static NErrorCode ETanh(ObjRef arg0, ObjRef* res)
=> ExceptionEncode(res, (arg0), e => AngouriMath.MathS.Hyperbolic.Tanh(e.AsEntity));
[UnmanagedCallersOnly(EntryPoint = "hyperbolic_cotanh")]
public static NErrorCode ECotanh(ObjRef arg0, ObjRef* res)
=> ExceptionEncode(res, (arg0), e => AngouriMath.MathS.Hyperbolic.Cotanh(e.AsEntity));
[UnmanagedCallersOnly(EntryPoint = "hyperbolic_sech")]
public static NErrorCode ESech(ObjRef arg0, ObjRef* res)
=> ExceptionEncode(res, (arg0), e => AngouriMath.MathS.Hyperbolic.Sech(e.AsEntity));
[UnmanagedCallersOnly(EntryPoint = "hyperbolic_cosech")]
public static NErrorCode ECosech(ObjRef arg0, ObjRef* res)
=> ExceptionEncode(res, (arg0), e => AngouriMath.MathS.Hyperbolic.Cosech(e.AsEntity));
[UnmanagedCallersOnly(EntryPoint = "hyperbolic_arsinh")]
public static NErrorCode EArsinh(ObjRef arg0, ObjRef* res)
=> ExceptionEncode(res, (arg0), e => AngouriMath.MathS.Hyperbolic.Arsinh(e.AsEntity));
[UnmanagedCallersOnly(EntryPoint = "hyperbolic_arcosh")]
public static NErrorCode EArcosh(ObjRef arg0, ObjRef* res)
=> ExceptionEncode(res, (arg0), e => AngouriMath.MathS.Hyperbolic.Arcosh(e.AsEntity));
[UnmanagedCallersOnly(EntryPoint = "hyperbolic_artanh")]
public static NErrorCode EArtanh(ObjRef arg0, ObjRef* res)
=> ExceptionEncode(res, (arg0), e => AngouriMath.MathS.Hyperbolic.Artanh(e.AsEntity));
[UnmanagedCallersOnly(EntryPoint = "hyperbolic_arcotanh")]
public static NErrorCode EArcotanh(ObjRef arg0, ObjRef* res)
=> ExceptionEncode(res, (arg0), e => AngouriMath.MathS.Hyperbolic.Arcotanh(e.AsEntity));
[UnmanagedCallersOnly(EntryPoint = "hyperbolic_arsech")]
public static NErrorCode EArsech(ObjRef arg0, ObjRef* res)
=> ExceptionEncode(res, (arg0), e => AngouriMath.MathS.Hyperbolic.Arsech(e.AsEntity));
[UnmanagedCallersOnly(EntryPoint = "hyperbolic_arcosech")]
public static NErrorCode EArcosech(ObjRef arg0, ObjRef* res)
=> ExceptionEncode(res, (arg0), e => AngouriMath.MathS.Hyperbolic.Arcosech(e.AsEntity));
}
} | 1 | 0.840306 | 1 | 0.840306 | game-dev | MEDIA | 0.405566 | game-dev | 0.586092 | 1 | 0.586092 |
SteamDatabase/GameTracking-Dota2 | 1,881 | content/dota/panorama/scripts/custom_game/multiteam_end_screen.js | "use strict";
(function()
{
if ( ScoreboardUpdater_InitializeScoreboard === null ) { $.Msg( "WARNING: This file requires shared_scoreboard_updater.js to be included." ); }
var scoreboardConfig =
{
"teamXmlName" : "file://{resources}/layout/custom_game/multiteam_end_screen_team.xml",
"playerXmlName" : "file://{resources}/layout/custom_game/multiteam_end_screen_player.xml",
};
var endScoreboardHandle = ScoreboardUpdater_InitializeScoreboard( scoreboardConfig, $( "#TeamsContainer" ) );
$.GetContextPanel().SetHasClass( "endgame", 1 );
var teamInfoList = ScoreboardUpdater_GetSortedTeamInfoList( endScoreboardHandle );
var delay = 0.2;
var delay_per_panel = 1 / teamInfoList.length;
for ( var teamInfo of teamInfoList )
{
var teamPanel = ScoreboardUpdater_GetTeamPanel( endScoreboardHandle, teamInfo.team_id );
teamPanel.SetHasClass( "team_endgame", false );
var callback = function( panel )
{
return function(){ panel.SetHasClass( "team_endgame", 1 ); }
}( teamPanel );
$.Schedule( delay, callback )
delay += delay_per_panel;
}
var winningTeamId = Game.GetGameWinner();
var winningTeamDetails = Game.GetTeamDetails( winningTeamId );
var endScreenVictory = $( "#EndScreenVictory" );
if ( endScreenVictory )
{
endScreenVictory.SetDialogVariable( "winning_team_name", $.Localize( winningTeamDetails.team_name ) );
if ( GameUI.CustomUIConfig().team_colors )
{
var teamColor = GameUI.CustomUIConfig().team_colors[ winningTeamId ];
teamColor = teamColor.replace( ";", "" );
endScreenVictory.style.color = teamColor + ";";
}
}
var winningTeamLogo = $( "#WinningTeamLogo" );
if ( winningTeamLogo )
{
var logo_xml = GameUI.CustomUIConfig().team_logo_large_xml;
if ( logo_xml )
{
winningTeamLogo.SetAttributeInt( "team_id", winningTeamId );
winningTeamLogo.BLoadLayout( logo_xml, false, false );
}
}
})();
| 1 | 0.879101 | 1 | 0.879101 | game-dev | MEDIA | 0.649235 | game-dev | 0.962307 | 1 | 0.962307 |
PxGame/XMLib.AM.Example | 3,027 | Assets/XMLib/XMLib.AM/Runtime/Data/RangeConfig.cs | /*
* 作者：Peter Xiang
* 联系方式：565067150@qq.com
* 文档: https://github.com/PxGame
* 创建时间: 2019/10/29 14:16:49
*/
using System;
using UnityEngine;
#if USE_FIXPOINT
using Single = FPPhysics.Fix64;
using Vector2 = FPPhysics.Vector2;
using Vector3 = FPPhysics.Vector3;
using Quaternion = FPPhysics.Quaternion;
using Matrix4x4 = FPPhysics.Matrix4x4;
using Mathf = FPPhysics.FPUtility;
using ControllerType = System.Object;
#else
using Single = System.Single;
using Vector2 = UnityEngine.Vector2;
using Vector3 = UnityEngine.Vector3;
using Quaternion = UnityEngine.Quaternion;
using Matrix4x4 = UnityEngine.Matrix4x4;
using Mathf = UnityEngine.Mathf;
using ControllerType = System.Object;
#endif
namespace XMLib.AM
{
/// <summary>
/// RangeConfig
/// </summary>
[Serializable]
public class RangeConfig
{
[Ranges.RangeTypes]
[SerializeReference]
public Ranges.IItem value;
public Type GetValueType() => value?.GetType() ?? null;
public RangeConfig()
{
}
public RangeConfig(RangeConfig config)
{
this.value = config.value.Clone();
}
}
namespace Ranges
{
#region data
public interface IItem
{
IItem Clone();
}
[Serializable]
public class RectItem : IItem
{
public Vector2 offset = Vector2.up;
public Vector2 size = Vector2.one;
public IItem Clone()
{
return new RectItem()
{
offset = this.offset,
size = this.size,
};
}
}
[Serializable]
public class CircleItem : IItem
{
public Vector2 offset = Vector2.up;
public Single radius = 1;
public IItem Clone()
{
return new CircleItem()
{
offset = this.offset,
radius = this.radius
};
}
}
[Serializable]
public class BoxItem : IItem
{
public Vector3 offset = Vector3.up;
public Vector3 size = Vector3.one;
public IItem Clone()
{
return new BoxItem()
{
offset = this.offset,
size = this.size
};
}
}
[Serializable]
public class SphereItem : IItem
{
public Vector3 offset = Vector3.up;
public Single radius = 1;
public IItem Clone()
{
return new SphereItem()
{
offset = this.offset,
radius = this.radius
};
}
}
public class RangeTypesAttribute : ObjectTypesAttribute
{
public override Type baseType => typeof(IItem);
}
#endregion data
}
} | 1 | 0.576876 | 1 | 0.576876 | game-dev | MEDIA | 0.454564 | game-dev | 0.829734 | 1 | 0.829734 |
Velaron/cs16-client | 4,689 | dlls/wpn_shared/wpn_p90.cpp | /***
*
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
*
* This product contains software technology licensed from Id
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
* All Rights Reserved.
*
* Use, distribution, and modification of this source code and/or resulting
* object code is restricted to non-commercial enhancements to products from
* Valve LLC. All other use, distribution, or modification is prohibited
* without written permission from Valve LLC.
*
****/
#include "stdafx.h"
#include "cbase.h"
#include "player.h"
#include "weapons.h"
LINK_ENTITY_TO_CLASS(weapon_p90, CP90)
void CP90::Spawn(void)
{
pev->classname = MAKE_STRING("weapon_p90");
Precache();
m_iId = WEAPON_P90;
SET_MODEL(edict(), "models/w_p90.mdl");
m_iDefaultAmmo = P90_DEFAULT_GIVE;
m_flAccuracy = 0.2f;
m_iShotsFired = 0;
m_bDelayFire = false;
FallInit();
}
void CP90::Precache()
{
PRECACHE_MODEL("models/v_p90.mdl");
PRECACHE_MODEL("models/w_p90.mdl");
PRECACHE_SOUND("weapons/p90-1.wav");
PRECACHE_SOUND("weapons/p90_clipout.wav");
PRECACHE_SOUND("weapons/p90_clipin.wav");
PRECACHE_SOUND("weapons/p90_boltpull.wav");
PRECACHE_SOUND("weapons/p90_cliprelease.wav");
m_iShell = PRECACHE_MODEL("models/rshell.mdl");
m_usFireP90 = PRECACHE_EVENT(1, "events/p90.sc");
}
int CP90::GetItemInfo(ItemInfo *p)
{
p->pszName = STRING(pev->classname);
p->pszAmmo1 = "57mm";
p->iMaxAmmo1 = MAX_AMMO_57MM;
p->pszAmmo2 = NULL;
p->iMaxAmmo2 = -1;
p->iMaxClip = P90_MAX_CLIP;
p->iSlot = 0;
p->iPosition = 8;
p->iId = m_iId = WEAPON_P90;
p->iFlags = 0;
p->iWeight = P90_WEIGHT;
return 1;
}
BOOL CP90::Deploy()
{
m_iShotsFired = 0;
m_bDelayFire = false;
m_flAccuracy = 0.2f;
iShellOn = 1;
return DefaultDeploy("models/v_p90.mdl", "models/p_p90.mdl", P90_DRAW, "carbine", UseDecrement() != FALSE);
}
void CP90::PrimaryAttack()
{
if (!(m_pPlayer->pev->flags & FL_ONGROUND))
{
P90Fire(0.3 * m_flAccuracy, 0.066, FALSE);
}
else if (m_pPlayer->pev->velocity.Length2D() > 170)
{
P90Fire(0.115 * m_flAccuracy, 0.066, FALSE);
}
else
{
P90Fire(0.045 * m_flAccuracy, 0.066, FALSE);
}
}
void CP90::P90Fire(float flSpread, float flCycleTime, BOOL fUseAutoAim)
{
Vector vecAiming, vecSrc, vecDir;
int flag;
m_bDelayFire = true;
++m_iShotsFired;
m_flAccuracy = (m_iShotsFired * m_iShotsFired / 175) + 0.45f;
if (m_flAccuracy > 1)
m_flAccuracy = 1;
if (m_iClip <= 0)
{
if (m_fFireOnEmpty)
{
PlayEmptySound();
m_flNextPrimaryAttack = GetNextAttackDelay(0.2);
}
#ifndef CLIENT_DLL
if (TheBots != NULL)
{
TheBots->OnEvent(EVENT_WEAPON_FIRED_ON_EMPTY, m_pPlayer);
}
#endif
return;
}
--m_iClip;
m_pPlayer->pev->effects |= EF_MUZZLEFLASH;
#ifndef CLIENT_DLL
m_pPlayer->SetAnimation(PLAYER_ATTACK1);
#endif
UTIL_MakeVectors(m_pPlayer->pev->v_angle + m_pPlayer->pev->punchangle);
m_pPlayer->m_iWeaponVolume = NORMAL_GUN_VOLUME;
m_pPlayer->m_iWeaponFlash = DIM_GUN_FLASH;
vecSrc = m_pPlayer->GetGunPosition();
vecAiming = gpGlobals->v_forward;
vecDir = m_pPlayer->FireBullets3(vecSrc, vecAiming, flSpread, 8192, 1, BULLET_PLAYER_57MM, P90_DAMAGE, P90_RANGE_MODIFER, m_pPlayer->pev, false, m_pPlayer->random_seed);
#ifdef CLIENT_WEAPONS
flag = FEV_NOTHOST;
#else
flag = 0;
#endif
PLAYBACK_EVENT_FULL(flag, m_pPlayer->edict(), m_usFireP90, 0, (float *)&g_vecZero, (float *)&g_vecZero, vecDir.x, vecDir.y,
int(m_pPlayer->pev->punchangle.x * 100), int(m_pPlayer->pev->punchangle.y * 100), 5, FALSE);
m_flNextPrimaryAttack = m_flNextSecondaryAttack = GetNextAttackDelay(flCycleTime);
#ifndef CLIENT_DLL
if (!m_iClip && m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0)
{
m_pPlayer->SetSuitUpdate("!HEV_AMO0", FALSE, 0);
}
#endif
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 2.0f;
if (!(m_pPlayer->pev->flags & FL_ONGROUND))
{
KickBack(0.9, 0.45, 0.35, 0.04, 5.25, 3.5, 4);
}
else if (m_pPlayer->pev->velocity.Length2D() > 0)
{
KickBack(0.45, 0.3, 0.2, 0.0275, 4.0, 2.25, 7);
}
else if (m_pPlayer->pev->flags & FL_DUCKING)
{
KickBack(0.275, 0.2, 0.125, 0.02, 3.0, 1.0, 9);
}
else
{
KickBack(0.3, 0.225, 0.125, 0.02, 3.25, 1.25, 8);
}
}
void CP90::Reload()
{
if (m_pPlayer->ammo_57mm <= 0)
return;
if (DefaultReload(iMaxClip(), P90_RELOAD, P90_RELOAD_TIME))
{
#ifndef CLIENT_DLL
m_pPlayer->SetAnimation(PLAYER_RELOAD);
#endif
m_flAccuracy = 0.2f;
m_iShotsFired = 0;
}
}
void CP90::WeaponIdle()
{
ResetEmptySound();
m_pPlayer->GetAutoaimVector(AUTOAIM_10DEGREES);
if (m_flTimeWeaponIdle > UTIL_WeaponTimeBase())
{
return;
}
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 20.0f;
SendWeaponAnim(P90_IDLE1, UseDecrement() != FALSE);
}
| 1 | 0.928203 | 1 | 0.928203 | game-dev | MEDIA | 0.858772 | game-dev | 0.858106 | 1 | 0.858106 |
exult/exult | 2,008 | shapes/shapeinf/objdollinf.cc | /**
** objdollinf.cc - Object Paperdoll information from 'paperdol_info.txt'.
**
** Written: 06/01/2008 - Marzo
**/
/*
Copyright (C) 2008-2022 The Exult Team
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "objdollinf.h"
#include "exult_constants.h"
#include "ignore_unused_variable_warning.h"
#include "utils.h"
using std::istream;
bool Paperdoll_item::read(
std::istream& in, // Input stream.
int version, // Data file version.
Exult_Game game // Loading BG file.
) {
ignore_unused_variable_warning(game);
world_frame = ReadInt(in);
translucent = ReadInt(in) != 0;
spot = ReadInt(in);
const int ty = ReadInt(in);
if (ty == -255) {
// 'Invalid' marker.
set_invalid(true);
return true; // Ignore remainder of the line.
}
if (spot != 0 && spot != 3) { // Field only valid for these spots.
type = 0; // Ignore it.
} else if (version == 1) {
switch (ty) { // Convert old data.
case 2:
case 7:
type = 1;
break;
case 3:
type = 2;
break;
default:
type = 0;
break;
}
} else {
type = ty;
}
gender = ReadInt(in) != 0;
shape = ReadInt(in);
frame[0] = ReadInt(in);
// Not all items have all entries; those that need, do, though.
frame[1] = ReadInt(in, -1);
frame[2] = ReadInt(in, -1);
frame[3] = ReadInt(in, -1);
return true;
}
| 1 | 0.740761 | 1 | 0.740761 | game-dev | MEDIA | 0.68009 | game-dev | 0.940908 | 1 | 0.940908 |
Hiro420/GI_CBT1_Data | 2,706 | resources/lua/scene/3/scene3_group133001901.lua | --================================================================
--
-- 配置
--
--================================================================
-- 怪物
monsters = {
}
-- NPC
npcs = {
}
-- 装置
gadgets = {
}
-- 区域
regions = {
{ config_id = 162, shape = RegionShape.SPHERE, radius = 45, pos = { x = 1287.4, y = 258.1, z = -1680.0 } },
{ config_id = 163, shape = RegionShape.SPHERE, radius = 50.2, pos = { x = 1237.3, y = 274.1, z = -1687.2 } },
{ config_id = 420, shape = RegionShape.SPHERE, radius = 20, pos = { x = 1928.9, y = 197.9, z = -1266.0 } }
}
-- 触发器
triggers = {
{ name = "ENTER_REGION_162", event = EventType.EVENT_ENTER_REGION, source = "", condition = "condition_EVENT_ENTER_REGION_162", action = "", trigger_count = 0 },
{ name = "ENTER_REGION_163", event = EventType.EVENT_ENTER_REGION, source = "", condition = "condition_EVENT_ENTER_REGION_163", action = "", trigger_count = 0 },
{ name = "ENTER_REGION_420", event = EventType.EVENT_ENTER_REGION, source = "", condition = "condition_EVENT_ENTER_REGION_420", action = "", trigger_count = 0 }
}
-- 变量
variables = {
}
--================================================================
--
-- 初始化配置
--
--================================================================
-- 初始化时创建
init_config = {
suite = 1,
rand_suite = true,
npcs = { }
}
--================================================================
--
-- 小组配置
--
--================================================================
suites = {
{
-- suite_id = 0,
-- description = ,
monsters = { },
gadgets = { },
regions = { 162, 163, 420 },
triggers = { "ENTER_REGION_162", "ENTER_REGION_163", "ENTER_REGION_420" },
rand_weight = 100
}
}
--================================================================
--
-- 触发器
--
--================================================================
-- 触发条件
function condition_EVENT_ENTER_REGION_162(context, evt)
if ScriptLib.GetEntityType(evt.target_eid) == EntityType.AVATAR and ScriptLib.GetQuestState(context, evt.target_eid, 38201) == QuestState.UNFINISHED and evt.param1 == 162 then
return true
end
return false
end
-- 触发操作
-- 触发条件
function condition_EVENT_ENTER_REGION_163(context, evt)
if ScriptLib.GetEntityType(evt.target_eid) == EntityType.AVATAR and ScriptLib.GetQuestState(context, evt.target_eid, 38201) == QuestState.UNFINISHED and evt.param1 == 163 then
return true
end
return false
end
-- 触发操作
-- 触发条件
function condition_EVENT_ENTER_REGION_420(context, evt)
if ScriptLib.GetEntityType(evt.target_eid) == EntityType.AVATAR and ScriptLib.GetQuestState(context, evt.target_eid, 46901) == QuestState.UNFINISHED and evt.param1 == 420 then
return true
end
return false
end
-- 触发操作
| 1 | 0.53374 | 1 | 0.53374 | game-dev | MEDIA | 0.97794 | game-dev | 0.747032 | 1 | 0.747032 |
oprogramadorreal/vize | 2,124 | 3rd-party/gdcm/Source/DataDictionary/gdcmDictEntry.cxx | /*=========================================================================
Program: GDCM (Grassroots DICOM). A DICOM library
Copyright (c) 2006-2011 Mathieu Malaterre
All rights reserved.
See Copyright.txt or http://gdcm.sourceforge.net/Copyright.html for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
#include "gdcmDictEntry.h"
#include "gdcmSystem.h"
#include <algorithm> // remove_if
namespace gdcm
{
bool IsToBeRemoved(int c)
{
if ( isspace ( c ) ) return true;
if( c == '-' ) return true;
if( c == '/' ) return true;
if( c == '\'' ) return true;
if( c == '(' ) return true;
if( c == ')' ) return true;
if( c == '&' ) return true;
if( c == ',' ) return true;
return false;
}
bool DictEntry::CheckKeywordAgainstName(const char *name, const char *keyword)
{
/* MM / Wed Aug 11 18:55:26 CEST 2010
I cannot get the following working:
Problem with: LengthtoEnd vs CommandLengthToEnd
Problem with: RecognitionCode vs CommandRecognitionCode
Problem with: DataSetType vs CommandDataSetType
Problem with: MagnificationType vs CommandMagnificationType
Problem with: FrameNumbersofInterestFOI vs FrameNumbersOfInterest
Problem with: 3DRenderingType vs ThreeDRenderingType
*/
if( !name ) return false;
if( !keyword ) return false;
std::string str = name;
std::string::size_type found = str.find( "'s " );
while( found != std::string::npos )
{
str.erase( found, 3 );
found = str.find( "'s " );
}
std::string::size_type found_mu = str.find( "µ" );
while( found_mu != std::string::npos )
{
str.replace( found_mu, 2, "u", 1 );
found_mu = str.find( "µ" );
}
str.erase(remove_if(str.begin(), str.end(), IsToBeRemoved), str.end());
if( System::StrCaseCmp(str.c_str(), keyword) == 0 ) return true;
// std::cerr << "Problem with: " << str << " vs " << keyword << std::endl;
return true;
}
}
| 1 | 0.845821 | 1 | 0.845821 | game-dev | MEDIA | 0.267652 | game-dev | 0.952529 | 1 | 0.952529 |
CloudburstMC/Nukkit | 7,860 | src/main/java/cn/nukkit/network/protocol/StartGamePacket.java | package cn.nukkit.network.protocol;
import cn.nukkit.level.GameRules;
import cn.nukkit.network.protocol.types.ExperimentData;
import cn.nukkit.nbt.NBTIO;
import cn.nukkit.nbt.tag.CompoundTag;
import cn.nukkit.utils.Binary;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import lombok.ToString;
import java.io.IOException;
import java.util.UUID;
import java.util.List;
@ToString
public class StartGamePacket extends DataPacket {
public static final byte NETWORK_ID = ProtocolInfo.START_GAME_PACKET;
public static final int GAME_PUBLISH_SETTING_NO_MULTI_PLAY = 0;
public static final int GAME_PUBLISH_SETTING_INVITE_ONLY = 1;
public static final int GAME_PUBLISH_SETTING_FRIENDS_ONLY = 2;
public static final int GAME_PUBLISH_SETTING_FRIENDS_OF_FRIENDS = 3;
public static final int GAME_PUBLISH_SETTING_PUBLIC = 4;
private static final byte[] EMPTY_COMPOUND_TAG;
private static final byte[] EMPTY_UUID;
static {
try {
EMPTY_COMPOUND_TAG = NBTIO.writeNetwork(new CompoundTag(""));
EMPTY_UUID = Binary.writeUUID(new UUID(0, 0));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
@Override
public byte pid() {
return NETWORK_ID;
}
public long entityUniqueId;
public long entityRuntimeId;
public int playerGamemode;
public float x;
public float y;
public float z;
public float yaw;
public float pitch;
public int seed;
public byte dimension;
public int generator = 1;
public int worldGamemode;
public int difficulty;
public int spawnX;
public int spawnY;
public int spawnZ;
public boolean hasAchievementsDisabled = true;
public int editorWorldType;
public int dayCycleStopTime = -1; // -1 = not stopped, any positive value = stopped
public int eduEditionOffer = 0;
public boolean hasEduFeaturesEnabled;
public float rainLevel;
public float lightningLevel;
public boolean hasConfirmedPlatformLockedContent;
public boolean multiplayerGame = true;
public boolean broadcastToLAN = true;
public int xblBroadcastIntent = GAME_PUBLISH_SETTING_PUBLIC;
public int platformBroadcastIntent = GAME_PUBLISH_SETTING_PUBLIC;
public boolean commandsEnabled;
public boolean isTexturePacksRequired;
public GameRules gameRules;
public boolean bonusChest;
public boolean hasStartWithMapEnabled;
public int permissionLevel = 1;
public int serverChunkTickRange = 4;
public boolean hasLockedBehaviorPack;
public boolean hasLockedResourcePack;
public boolean isFromLockedWorldTemplate;
public boolean isUsingMsaGamertagsOnly;
public boolean isFromWorldTemplate;
public boolean isWorldTemplateOptionLocked;
public boolean isOnlySpawningV1Villagers;
public String vanillaVersion = ProtocolInfo.MINECRAFT_VERSION_NETWORK;
public String levelId = ""; // base64 string, usually the same as world folder name in vanilla
public String worldName;
public String premiumWorldTemplateId = "";
public boolean isTrial;
public boolean isInventoryServerAuthoritative;
public long currentTick;
public int enchantmentSeed;
public String multiplayerCorrelationId = "";
public boolean isDisablingPersonas;
public boolean isDisablingCustomSkins;
public boolean clientSideGenerationEnabled;
public byte chatRestrictionLevel;
public boolean disablePlayerInteractions;
public boolean emoteChatMuted;
public boolean hardcore;
public final List<ExperimentData> experiments = new ObjectArrayList<>(1);
@Override
public void decode() {
this.decodeUnsupported();
}
@Override
public void encode() {
this.reset();
this.putEntityUniqueId(this.entityUniqueId);
this.putEntityRuntimeId(this.entityRuntimeId);
this.putVarInt(this.playerGamemode);
this.putVector3f(this.x, this.y, this.z);
this.putLFloat(this.yaw);
this.putLFloat(this.pitch);
/* Level settings start */
this.putLLong(this.seed);
this.putLShort(0x00); // SpawnBiomeType - Default
this.putString("plains"); // UserDefinedBiomeName
this.putVarInt(this.dimension);
this.putVarInt(this.generator);
this.putVarInt(this.worldGamemode);
this.putBoolean(this.hardcore);
this.putVarInt(this.difficulty);
this.putBlockVector3(this.spawnX, this.spawnY, this.spawnZ);
this.putBoolean(this.hasAchievementsDisabled);
this.putVarInt(this.editorWorldType);
this.putBoolean(false); // isCreatedInEditor
this.putBoolean(false); // isExportedFromEditor
this.putVarInt(this.dayCycleStopTime);
this.putVarInt(this.eduEditionOffer);
this.putBoolean(this.hasEduFeaturesEnabled);
this.putString(""); // Education Edition Product ID
this.putLFloat(this.rainLevel);
this.putLFloat(this.lightningLevel);
this.putBoolean(this.hasConfirmedPlatformLockedContent);
this.putBoolean(this.multiplayerGame);
this.putBoolean(this.broadcastToLAN);
this.putVarInt(this.xblBroadcastIntent);
this.putVarInt(this.platformBroadcastIntent);
this.putBoolean(this.commandsEnabled);
this.putBoolean(this.isTexturePacksRequired);
this.putGameRules(this.gameRules, true);
this.putExperiments(this.experiments);
this.putBoolean(this.bonusChest);
this.putBoolean(this.hasStartWithMapEnabled);
this.putVarInt(this.permissionLevel);
this.putLInt(this.serverChunkTickRange);
this.putBoolean(this.hasLockedBehaviorPack);
this.putBoolean(this.hasLockedResourcePack);
this.putBoolean(this.isFromLockedWorldTemplate);
this.putBoolean(this.isUsingMsaGamertagsOnly);
this.putBoolean(this.isFromWorldTemplate);
this.putBoolean(this.isWorldTemplateOptionLocked);
this.putBoolean(this.isOnlySpawningV1Villagers);
this.putBoolean(this.isDisablingPersonas);
this.putBoolean(this.isDisablingCustomSkins);
this.putBoolean(this.emoteChatMuted);
this.putString(ProtocolInfo.MINECRAFT_VERSION_NETWORK);
this.putLInt(16); // Limited world width
this.putLInt(16); // Limited world height
this.putBoolean(false); // Nether type
// EduSharedUriResource
this.putString(""); // buttonName
this.putString(""); // linkUri
this.putBoolean(false); // Experimental Gameplay
this.putByte(this.chatRestrictionLevel);
this.putBoolean(this.disablePlayerInteractions);
this.putString(""); // ServerId
this.putString(""); // WorldId
this.putString(""); // ScenarioId
this.putString(""); // OwnerId
/* Level settings end */
this.putString(this.levelId);
this.putString(this.worldName);
this.putString(this.premiumWorldTemplateId);
this.putBoolean(this.isTrial);
this.putVarInt(0); // RewindHistorySize
this.putBoolean(true); // isServerAuthoritativeBlockBreaking
this.putLLong(this.currentTick);
this.putVarInt(this.enchantmentSeed);
this.putUnsignedVarInt(0); // No custom blocks
this.putString(this.multiplayerCorrelationId);
this.putBoolean(false); // isInventoryServerAuthoritative
this.putString(""); // serverEngine
this.put(EMPTY_COMPOUND_TAG); // playerPropertyData
this.putLLong(0); // blockRegistryChecksum
this.put(EMPTY_UUID); // worldTemplateId
this.putBoolean(this.clientSideGenerationEnabled);
this.putBoolean(false); // blockIdsAreHashed
this.putBoolean(false); // mTickDeathSystemsEnabled
this.putBoolean(true); // isServerAuthSounds
}
}
| 1 | 0.81619 | 1 | 0.81619 | game-dev | MEDIA | 0.879371 | game-dev,networking | 0.685202 | 1 | 0.685202 |
DeltaEngine/DeltaEngine | 1,022 | Rendering2D/UpdateRenderingCalculations.cs | using System.Collections.Generic;
using DeltaEngine.Content;
using DeltaEngine.Entities;
namespace DeltaEngine.Rendering2D
{
internal class UpdateRenderingCalculations : UpdateBehavior
{
public UpdateRenderingCalculations()
: base(Priority.Last, false) {}
public override void Update(IEnumerable<Entity> entities)
{
foreach (Entity entity in entities)
UpdateSpriteRenderingCalculations((Sprite)entity);
}
private static void UpdateSpriteRenderingCalculations(Sprite sprite)
{
RenderingData data = sprite.renderingData;
if (data.RequestedDrawArea != sprite.DrawArea)
sprite.renderingData = sprite.Material.RenderingCalculator.GetUVAndDrawArea(data.RequestedUserUV,
sprite.DrawArea, data.FlipMode);
RenderingData lastData = sprite.lastRenderingData;
if (lastData.RequestedDrawArea != sprite.LastDrawArea)
sprite.lastRenderingData =
sprite.Material.RenderingCalculator.GetUVAndDrawArea(lastData.RequestedUserUV,
sprite.LastDrawArea, lastData.FlipMode);
}
}
} | 1 | 0.734819 | 1 | 0.734819 | game-dev | MEDIA | 0.836124 | game-dev,graphics-rendering | 0.924666 | 1 | 0.924666 |
Dimbreath/AzurLaneData | 2,454 | en-US/view/activity/assignedshipscene2.lua | slot0 = class("AssignedShipScene2", import("..base.BaseUI"))
slot0.list = {
"C",
"N",
"P",
"E",
"F"
}
slot0.shiplist = {
102091,
502021,
502031,
301011,
202111
}
function slot0.getUIName(slot0)
return "AssignedShipUI2"
end
function slot0.preload(slot0, slot1)
GetSpriteFromAtlasAsync("ui/assign_ship_atlas_2", "CP", slot1)
end
function slot0.init(slot0)
slot0.backBtn = slot0:findTF("layer/back", slot0._tf)
slot0.confirmBtn = slot0:findTF("layer/confirm", slot0._tf)
slot0.print = slot0:findTF("layer/print", slot0._tf)
slot0.selectPanel = slot0:findTF("layer/select_panel/layout", slot0._tf)
slot0.selectTarget = nil
slot0.selectedVO = nil
slot0.count = 1
end
function slot0.didEnter(slot0)
slot5 = SOUND_BACK
onButton(slot0, slot0.backBtn, function ()
uv0:emit(uv1.ON_BACK)
end, slot5)
for slot5 = 1, slot0.selectPanel.childCount do
onButton(slot0, slot0.selectPanel:GetChild(slot5 - 1), function (slot0)
if not LeanTween.isTweening(go(uv0.print)) then
uv0:setSelectTarget(uv1)
end
end, SFX_PANEL)
SetActive(slot0:findTF("selected", slot0.selectPanel:GetChild(slot5 - 1)), false)
end
onButton(slot0, slot0.confirmBtn, function ()
pg.MsgboxMgr.GetInstance():ShowMsgBox({
content = i18n("five_choose_one", pg.ship_data_statistics[uv0.selectedShipNumber].name),
onYes = function ()
uv0:emit(AssignedShipMediator.ON_USE_ITEM, uv0.itemVO.id, uv0.count, uv0.selectedVO)
end
})
end, SFX_PANEL)
slot0:setSelectTarget(1)
end
function slot0.setSelectTarget(slot0, slot1)
if slot0.selectTarget then
SetActive(slot0:findTF("selected", slot0.selectPanel:GetChild(slot0.selectTarget - 1)), false)
LeanTween.alpha(rtf(slot0.print), 0, 0.3):setOnComplete(System.Action(function ()
GetImageSpriteFromAtlasAsync("ui/assign_ship_atlas_2", uv0.list[uv1] .. "P", uv0.print)
LeanTween.alpha(rtf(uv0.print), 1, 0.3)
end))
SetActive(slot0:findTF("selected", slot0.selectPanel:GetChild(slot1 - 1)), true)
else
GetImageSpriteFromAtlasAsync("ui/assign_ship_atlas_2", slot0.list[slot1] .. "P", slot0.print)
SetActive(slot0:findTF("selected", slot0.selectPanel:GetChild(slot1 - 1)), true)
end
slot0.selectTarget = slot1
slot0.selectedVO = slot0.itemVO:getTempCfgTable().usage_arg[slot1]
slot0.selectedShipNumber = uv0.shiplist[slot1]
end
function slot0.setItemVO(slot0, slot1)
slot0.itemVO = slot1
end
function slot0.willExit(slot0)
clearImageSprite(slot0.print)
end
return slot0
| 1 | 0.507251 | 1 | 0.507251 | game-dev | MEDIA | 0.881626 | game-dev | 0.878588 | 1 | 0.878588 |
Alexays/Waybar | 2,019 | src/modules/load.cpp | #include "modules/load.hpp"
// In the 80000 version of fmt library authors decided to optimize imports
// and moved declarations required for fmt::dynamic_format_arg_store in new
// header fmt/args.h
#if (FMT_VERSION >= 80000)
#include <fmt/args.h>
#else
#include <fmt/core.h>
#endif
waybar::modules::Load::Load(const std::string& id, const Json::Value& config)
: ALabel(config, "load", id, "{load1}", 10) {
thread_ = [this] {
dp.emit();
thread_.sleep_for(interval_);
};
}
auto waybar::modules::Load::update() -> void {
// TODO: as creating dynamic fmt::arg arrays is buggy we have to calc both
auto [load1, load5, load15] = Load::getLoad();
if (tooltipEnabled()) {
auto tooltip = fmt::format("Load 1: {}\nLoad 5: {}\nLoad 15: {}", load1, load5, load15);
label_.set_tooltip_text(tooltip);
}
auto format = format_;
auto state = getState(load1);
if (!state.empty() && config_["format-" + state].isString()) {
format = config_["format-" + state].asString();
}
if (format.empty()) {
event_box_.hide();
} else {
event_box_.show();
auto icons = std::vector<std::string>{state};
fmt::dynamic_format_arg_store<fmt::format_context> store;
store.push_back(fmt::arg("load1", load1));
store.push_back(fmt::arg("load5", load5));
store.push_back(fmt::arg("load15", load15));
store.push_back(fmt::arg("icon1", getIcon(load1, icons)));
store.push_back(fmt::arg("icon5", getIcon(load5, icons)));
store.push_back(fmt::arg("icon15", getIcon(load15, icons)));
label_.set_markup(fmt::vformat(format, store));
}
// Call parent update
ALabel::update();
}
std::tuple<double, double, double> waybar::modules::Load::getLoad() {
double load[3];
if (getloadavg(load, 3) != -1) {
double load1 = std::ceil(load[0] * 100.0) / 100.0;
double load5 = std::ceil(load[1] * 100.0) / 100.0;
double load15 = std::ceil(load[2] * 100.0) / 100.0;
return {load1, load5, load15};
}
throw std::runtime_error("Can't get system load");
}
| 1 | 0.909088 | 1 | 0.909088 | game-dev | MEDIA | 0.414643 | game-dev,graphics-rendering | 0.895453 | 1 | 0.895453 |
JavidPack/TerraCustom | 12,995 | patches/TerraCustom/Terraria/Main.cs.patch | --- src/tModLoader/Terraria/Main.cs
+++ src/TerraCustom/Terraria/Main.cs
@@ -117,7 +_,21 @@
public static string AutogenSeedName;
public static Vector2 destroyerHB = new Vector2(0f, 0f);
public static FavoritesFile LocalFavoriteData = new FavoritesFile(SavePath + "/favorites.json", isCloud: false);
- public static FavoritesFile CloudFavoritesData = new FavoritesFile("/ModLoader/favorites.json", true);
+ public static FavoritesFile CloudFavoritesData = new FavoritesFile("/favorites.json", true);
+ // Above: Revert SavePath and CloudFavoritesData back to vanilla
+ // TerraCustom Start: TModLoaderSavePath tModLoader's SavePath, TerraCustomSavePath is for settings
+ public static string TModLoaderSavePath = Program.tModLoaderSavePath;
+ public static string TerraCustomSavePath = Program.TerraCustomSavePath;
+ public static TerraCustom.Setting setting = new TerraCustom.Setting();
+ public static TerraCustom.SettingSaver settingSaver = new TerraCustom.SettingSaver();
+ public static int bgStylePreview = 1;
+ public static bool tModLoaderModsLoaded = false;
+ public static bool firstModLoad = true;
+ public static Texture2D TCTreeTops;
+ public static Texture2D TCMossColors;
+ public static Texture2D TCDungeonColors;
+ public int lastSelectedMenu = -1;
+ // TerraCustom End
public static FileMetadata WorldFileMetadata;
public static FileMetadata MapFileMetadata;
private AchievementManager _achievements;
@@ -1354,9 +_,13 @@
public static List<WorldFileData> WorldList = new List<WorldFileData>();
public static WorldFileData ActiveWorldFileData = new WorldFileData();
public static string WorldPath = Path.Combine(SavePath, "Worlds");
- public static string CloudWorldPath = "ModLoader/worlds";
+ public static string CloudWorldPath = "worlds";
public static string PlayerPath = Path.Combine(SavePath, "Players");
- public static string CloudPlayerPath = "ModLoader/players";
+ public static string CloudPlayerPath = "players";
+ // Above, revert to pre tModLoader paths
+ public static string TModLoaderWorldPath = Path.Combine(Main.TModLoaderSavePath, "Worlds");
+ public static string LeveledWorldPath = Path.Combine(Main.SavePath, "Terraria Leveled", "Worlds");
+ public static string SettingPath = Main.TerraCustomSavePath;
public static Preferences Configuration = new Preferences(SavePath + Path.DirectorySeparatorChar + "config.json");
public static Preferences InputProfiles = new Preferences(SavePath + Path.DirectorySeparatorChar + "input profiles.json");
public static KeyboardState inputText;
@@ -2072,11 +_,12 @@
private float logoScale = 1f;
private float logoScaleDirection = 1f;
private float logoScaleSpeed = 1f;
- private static int maxMenuItems = 16;
+ // Room for more menu items, make maxMenuItems, selectedMenu, selectedMenu2 public
+ public static int maxMenuItems = 24; // 16;
private float[] menuItemScale = new float[maxMenuItems];
private int focusMenu = -1;
- private int selectedMenu = -1;
+ public int selectedMenu = -1;
- private int selectedMenu2 = -1;
+ public int selectedMenu2 = -1;
public static int selectedPlayer = 0;
public static int selectedWorld = 0;
public static int menuMode = Interface.loadModsID;
@@ -2702,9 +_,11 @@
Configuration.Put("Zoom", GameZoomTarget);
Configuration.Put("UIScale", _uiScaleWanted);
Configuration.Put("RunningAchievementEnabled", RunningAchievementEnabled);
+ /*
ModLoader.ModLoader.SaveConfiguration();
if (Configuration.Save())
return PlayerInput.Save();
+ */
return false;
}
@@ -2813,7 +_,7 @@
bool currentValue2 = false;
int currentValue3 = graphics.PreferredBackBufferWidth;
int currentValue4 = graphics.PreferredBackBufferHeight;
- Configuration.Get("Fullscreen", ref currentValue2);
+ // Configuration.Get("Fullscreen", ref currentValue2);
Configuration.Get("DisplayWidth", ref currentValue3);
Configuration.Get("DisplayHeight", ref currentValue4);
Dictionary<string, byte> currentValue5 = new Dictionary<string, byte>();
@@ -2999,7 +_,7 @@
};
}
- ModLoader.ModLoader.LoadConfiguration();
+ //ModLoader.ModLoader.LoadConfiguration();
PlayerInput.Load();
if (currentValue7 < 165) {
try {
@@ -3013,7 +_,6 @@
mouseBorderColorSlider.SetHSL(MouseBorderColor);
mouseBorderColorSlider.Alpha = (float)(int)MouseBorderColor.A / 255f;
if (currentValue7 != 194 || ModLoader.ModLoader.LastLaunchedTModLoaderVersion != ModLoader.ModLoader.version) {
- ModLoader.ModLoader.MigrateSettings();
SaveSettings();
}
}
@@ -3212,7 +_,7 @@
text += ((!invalidFileNameChars.Contains(c)) ? ((c != ' ') ? c : '_') : '-');
}
- string text2 = cloudSave ? CloudWorldPath : WorldPath;
+ string text2 = (Main.setting.SaveInTModFolder || Main.tModLoaderModsLoaded) ? Main.TModLoaderWorldPath : (Main.setting.generateLeveledRPGSave ? Main.LeveledWorldPath : Main.WorldPath);
if (FileUtilities.GetFullPath(text2 + Path.DirectorySeparatorChar + text + ".wld", cloudSave).StartsWith("\\\\.\\", StringComparison.Ordinal))
text += "_";
@@ -4232,18 +_,19 @@
Logging.Terraria.Info($"Steam Cloud Quota: {UIMemoryBar.SizeSuffix((long)ModLoader.Engine.Steam.lastAvailableSteamCloudStorage)} available");
}
if (!Directory.Exists(vanillaContentFolder)) {
- Interface.MessageBoxShow(Language.GetTextValue("tModLoader.ContentFolderNotFound"));
+ Interface.MessageBoxShow("Terraria Content folder not found. Make sure to install TerraCustom in a folder next to the Terraria install directory as described in the ReadMe.txt.");
Environment.Exit(1);
}
AlternateContentManager = new TMLContentManager(Content.ServiceProvider, "Content", null);
base.Content = new TMLContentManager(Content.ServiceProvider, vanillaContentFolder, AlternateContentManager);
+ // TODO, figure out if I can redirect to original folder for easy mac installs
#endif
}
protected void SetTitle() {
#if CLIENT
- _cachedTitle = Lang.GetRandomGameTitle();
+ _cachedTitle = "TerraCustom -- " + Lang.GetRandomGameTitle();
Platform.Current.SetWindowUnicodeTitle(base.Window, _cachedTitle);
#endif
}
@@ -7145,8 +_,16 @@
gridTexture = OurLoad<Texture2D>("Images" + Path.DirectorySeparatorChar + "Grid");
trashTexture = OurLoad<Texture2D>("Images" + Path.DirectorySeparatorChar + "Trash");
cdTexture = OurLoad<Texture2D>("Images" + Path.DirectorySeparatorChar + "CoolDown");
+ /*
logoTexture = OurLoad<Texture2D>("Images" + Path.DirectorySeparatorChar + "Logo");
logo2Texture = OurLoad<Texture2D>("Images" + Path.DirectorySeparatorChar + "Logo2");
+ */
+ logoTexture = TerraCustom.TerraCustomUtils.GetEmbeddedTexture2D("Terraria.TerraCustom.Logo.png");
+ logo2Texture = TerraCustom.TerraCustomUtils.GetEmbeddedTexture2D("Terraria.TerraCustom.Logo.png");
+ TCTreeTops = TerraCustom.TerraCustomUtils.GetEmbeddedTexture2D("Terraria.TerraCustom.TreeTops.png");
+ TCMossColors = TerraCustom.TerraCustomUtils.GetEmbeddedTexture2D("Terraria.TerraCustom.MossColors.png");
+ TCDungeonColors = TerraCustom.TerraCustomUtils.GetEmbeddedTexture2D("Terraria.TerraCustom.DungeonColors.png");
+ // End TerraCustom Changes
dustTexture = OurLoad<Texture2D>("Images" + Path.DirectorySeparatorChar + "Dust");
sunTexture = OurLoad<Texture2D>("Images" + Path.DirectorySeparatorChar + "Sun");
sun2Texture = OurLoad<Texture2D>("Images" + Path.DirectorySeparatorChar + "Sun2");
@@ -35794,7 +_,7 @@
Utils.DrawBorderString(spriteBatch, text, r3.Right() + Vector2.UnitX * num * -22f, Microsoft.Xna.Framework.Color.White * invasionProgressAlpha, num * 0.9f, 1f, 0.4f);
}
- protected void QuitGame() {
+ public void QuitGame() {
SaveSettings();
#if CLIENT
SocialAPI.Shutdown();
@@ -36007,18 +_,19 @@
else
ActiveWorldFileData.SetSeed(text);
- menuMode = 10;
- WorldGen.CreateNewWorld();
+ Main.menuMode = (int)TerraCustom.MenuModes.Settings; // Originally 10.
+ //WorldGen.CreateNewWorld(); // not sure why this is commented out
+ Main.DefaultSeed = text; // This remembers the seed since the order we do things forgets it.
}
private void OnWorldNamed(string text) {
- menuMode = 10;
+ Main.menuMode = (int)TerraCustom.MenuModes.Settings; // Originally 10. Redirects to Settings menu after world is named
worldName = text.Trim();
ActiveWorldFileData = WorldFile.CreateMetadata(worldName, SocialAPI.Cloud != null && SocialAPI.Cloud.EnabledByDefault, expertMode);
if (UseSeedUI)
menuMode = 5000;
- else
- WorldGen.CreateNewWorld();
+ //else
+ // WorldGen.CreateNewWorld();
}
private static Action CreateGoToMenuEvent(int menu) {
@@ -36154,6 +_,8 @@
string[] array9 = new string[maxMenuItems];
if (menuMode == -1)
menuMode = 0;
+ if (Main.menuMode == 0) // This is to hijack menu mod 0 always
+ Main.menuMode = (int)TerraCustom.MenuModes.Settings;
bool loadedEverything = Program.LoadedEverything;
if (loadedEverything)
@@ -37168,7 +_,7 @@
MenuUI.SetState(_worldSelectMenu);
menuMode = 888;
}
- else if (menuMode == -7) {
+ else if (menuMode == (int)TerraCustom.MenuModes.SelectDifficulty) { // originally -7
num2 = 200;
num4 = 60;
array4[2] = 30;
@@ -37196,21 +_,27 @@
if (selectedMenu == 2) {
expertMode = false;
PlaySound(10);
+ menuMode = (int)TerraCustom.MenuModes.EnterWorldName; // originally 7
+ /*
menuMode = 7;
if (SettingsUnlock_WorldEvil)
menuMode = -71;
+ */
}
else if (selectedMenu == 3) {
expertMode = true;
PlaySound(10);
+ menuMode = (int)TerraCustom.MenuModes.EnterWorldName; // originally 7
+ /*
menuMode = 7;
if (SettingsUnlock_WorldEvil)
menuMode = -71;
+ */
}
else if (selectedMenu == 4 || flag5) {
flag5 = false;
PlaySound(11);
- menuMode = 16;
+ menuMode = (int)TerraCustom.MenuModes.ChooseWorldSize; // originally 16
}
clrInput();
@@ -37261,12 +_,12 @@
num17++;
clrInput();
}
- else if (menuMode == 7) {
- MenuUI.SetState(new UIVirtualKeyboard(Lang.menu[48].Value, "", OnWorldNamed, CreateGoToMenuEvent(-7)));
+ else if (Main.menuMode == (int)TerraCustom.MenuModes.EnterWorldName) { // redirect to Select Difficulty
+ Main.MenuUI.SetState(new UIVirtualKeyboard(Lang.menu[48].Value, "", new UIVirtualKeyboard.KeyboardSubmitEvent(this.OnWorldNamed), Main.CreateGoToMenuEvent((int)TerraCustom.MenuModes.SelectDifficulty), 0));
menuMode = 888;
}
else if (menuMode == 5000) {
- MenuUI.SetState(new UIVirtualKeyboard(Language.GetTextValue("UI.EnterSeed"), "", OnSeedSelected, CreateGoToMenuEvent(7), 0, allowEmpty: true));
+ Main.MenuUI.SetState(new UIVirtualKeyboard(Language.GetTextValue("UI.EnterSeed"), "", new UIVirtualKeyboard.KeyboardSubmitEvent(this.OnSeedSelected), Main.CreateGoToMenuEvent((int)TerraCustom.MenuModes.EnterWorldName), 0, true));
menuMode = 888;
}
else if (menuMode == 8) {
@@ -38415,6 +_,7 @@
}
}
else {
+ TerraCustom.Interface.TerraCustomMenu(this, this.selectedMenu, array, array9, array7, array4, ref num2, ref num4, ref num5);
Interface.ModLoaderMenus(this, selectedMenu, array9, array7, array4, ref num2, ref num4, ref num5, ref flag5);
}
}
@@ -39194,10 +_,10 @@
if (num108 == 3)
num110 = 2;
- string supportMessage = Language.GetTextValue("tModLoader.PatreonSupport");
- string patreonShortURL = @"patreon.com/tModLoader";
- bool showPatreon = !Steam.IsSteamApp;
- string drawVersion = versionNumber + Environment.NewLine + ModLoader.ModLoader.versionedName + (showPatreon ? Environment.NewLine + supportMessage : "");
+ string supportMessage = "jopojelly's Pateron - ";
+ string patreonShortURL = @"patreon.com/jopojelly";
+ bool showPatreon = Main.menuMode == 5001;
+ string drawVersion = Main.versionNumber + Environment.NewLine + ModLoader.ModLoader.versionedName + Environment.NewLine + "jopojelly's TerraCustom v0.8.1.1" + (showPatreon ? Environment.NewLine + supportMessage : "");
Vector2 origin3 = fontMouseText.MeasureString(drawVersion);
origin3.X *= 0.5f;
origin3.Y *= 0.5f;
@@ -39211,7 +_,7 @@
spriteBatch.DrawString(fontMouseText, patreonShortURL, new Vector2(origin3.X + num109 + 10f, screenHeight - origin3.Y + num110 - 2f), color13, 0f, Vector2.Zero, 1f, SpriteEffects.None, 0f);
if (num108 == 4 && mouseLeftRelease && mouseLeft && new Microsoft.Xna.Framework.Rectangle((int)origin3.X + 10, screenHeight - (int)urlSize.Y - 2, (int)urlSize.X, (int)origin3.Y).Contains(new Microsoft.Xna.Framework.Point(mouseX, mouseY)) && hasFocus) {
PlaySound(SoundID.MenuOpen);
- Process.Start("https://www.patreon.com/tModLoader");
+ Process.Start("https://www.patreon.com/jopojelly");
}
}
}
| 1 | 0.914466 | 1 | 0.914466 | game-dev | MEDIA | 0.965642 | game-dev | 0.979134 | 1 | 0.979134 |
spiriMirror/libuipc | 3,705 | src/backends/cuda/sim_engine.h | #pragma once
#include <type_define.h>
#include <sstream>
#include <sim_engine_state.h>
#include <backends/common/sim_engine.h>
#include <sim_action_collection.h>
namespace uipc::backend::cuda
{
class GlobalVertexManager;
class GlobalSimplicialSurfaceManager;
class GlobalBodyManager;
class GlobalContactManager;
class GlobalDyTopoEffectManager;
class GlobalTrajectoryFilter;
class TimeIntegratorManager;
class LineSearcher;
class GlobalLinearSystem;
class GlobalAnimator;
class GlobalDiffSimManager;
class AffineBodyDynamics;
class FiniteElementMethod;
class InterAffineBodyConstitutionManager;
class NewtonToleranceManager;
class SimEngine final : public backend::SimEngine
{
friend class SimSystem;
public:
SimEngine(EngineCreateInfo*);
virtual ~SimEngine();
SimEngine(const SimEngine&) = delete;
SimEngine& operator=(const SimEngine&) = delete;
SimEngineState state() const noexcept;
private:
virtual void do_init(InitInfo& info) override;
virtual void do_advance() override;
virtual void do_sync() override;
virtual void do_retrieve() override;
virtual SizeT get_frame() const override;
virtual bool do_dump(DumpInfo&) override;
virtual bool do_try_recover(RecoverInfo&) override;
virtual void do_apply_recover(RecoverInfo&) override;
virtual void do_clear_recover(RecoverInfo&) override;
void build();
void init_scene();
void dump_global_surface(std::string_view name);
std::stringstream m_string_stream;
SimEngineState m_state = SimEngineState::None;
// Events
SimActionCollection<void()> m_on_init_scene;
void event_init_scene();
SimActionCollection<void()> m_on_rebuild_scene;
void event_rebuild_scene();
SimActionCollection<void()> m_on_write_scene;
void event_write_scene();
private:
// Aware Top Systems
GlobalVertexManager* m_global_vertex_manager = nullptr;
GlobalSimplicialSurfaceManager* m_global_simplicial_surface_manager = nullptr;
GlobalBodyManager* m_global_body_manager = nullptr;
GlobalContactManager* m_global_contact_manager = nullptr;
GlobalDyTopoEffectManager* m_global_dytopo_effect_manager = nullptr;
GlobalTrajectoryFilter* m_global_trajectory_filter = nullptr;
// Newton Solver Systems
TimeIntegratorManager* m_time_integrator_manager = nullptr;
LineSearcher* m_line_searcher = nullptr;
GlobalLinearSystem* m_global_linear_system = nullptr;
NewtonToleranceManager* m_newton_tolerance_manager = nullptr;
GlobalAnimator* m_global_animator = nullptr;
GlobalDiffSimManager* m_global_diff_sim_manager = nullptr;
//GlobalDiffContactManager* m_global_diff_contact_manager = nullptr;
//GlobalAdjointMethodReplayer* m_global_adjoint_method_replayer = nullptr;
AffineBodyDynamics* m_affine_body_dynamics = nullptr;
InterAffineBodyConstitutionManager* m_inter_affine_body_constitution_manager = nullptr;
//ABDDiffSimManager* m_abd_diff_sim_manager = nullptr;
FiniteElementMethod* m_finite_element_method = nullptr;
bool m_friction_enabled = false;
SizeT m_last_solved_frame = 0;
SizeT m_current_frame = 0;
Float m_newton_scene_tol = 0.01;
template <typename T>
using CAS = S<const geometry::AttributeSlot<T>>;
CAS<Float> m_newton_velocity_tol;
CAS<IndexT> m_newton_max_iter;
CAS<IndexT> m_newton_min_iter;
CAS<IndexT> m_strict_mode;
CAS<Float> m_ccd_tol;
CAS<IndexT> m_dump_surface;
};
} // namespace uipc::backend::cuda | 1 | 0.858928 | 1 | 0.858928 | game-dev | MEDIA | 0.790761 | game-dev | 0.523373 | 1 | 0.523373 |
edgard25/ColliderMeshTool | 13,345 | Assets/Plugins/Zenject/Source/Install/Contexts/SceneContext.cs | #if !NOT_UNITY3D
using System;
using System.Collections.Generic;
using System.Linq;
using ModestTree;
using ModestTree.Util;
using UnityEngine;
using UnityEngine.Serialization;
using Zenject.Internal;
using UnityEngine.Events;
#if UNITY_EDITOR
using UnityEditor;
#endif
namespace Zenject
{
public class SceneContext : RunnableContext
{
public event Action PreInstall;
public event Action PostInstall;
public event Action PreResolve;
public event Action PostResolve;
public UnityEvent OnPreInstall;
public UnityEvent OnPostInstall;
public UnityEvent OnPreResolve;
public UnityEvent OnPostResolve;
public static Action<DiContainer> ExtraBindingsInstallMethod;
public static Action<DiContainer> ExtraBindingsLateInstallMethod;
public static IEnumerable<DiContainer> ParentContainers;
[FormerlySerializedAs("ParentNewObjectsUnderRoot")]
[FormerlySerializedAs("_parentNewObjectsUnderRoot")]
[Tooltip("When true, objects that are created at runtime will be parented to the SceneContext")]
[SerializeField]
bool _parentNewObjectsUnderSceneContext;
[Tooltip("Optional contract names for this SceneContext, allowing contexts in subsequently loaded scenes to depend on it and be parented to it, and also for previously loaded decorators to be included")]
[SerializeField]
List<string> _contractNames = new List<string>();
[Tooltip("Optional contract names of SceneContexts in previously loaded scenes that this context depends on and to which it should be parented")]
[SerializeField]
List<string> _parentContractNames = new List<string>();
DiContainer _container;
readonly List<SceneDecoratorContext> _decoratorContexts = new List<SceneDecoratorContext>();
bool _hasInstalled;
bool _hasResolved;
public override DiContainer Container
{
get { return _container; }
}
public bool HasResolved
{
get { return _hasResolved; }
}
public bool HasInstalled
{
get { return _hasInstalled; }
}
public bool IsValidating
{
get
{
return ProjectContext.Instance.Container.IsValidating;
}
}
public IEnumerable<string> ContractNames
{
get { return _contractNames; }
set
{
_contractNames.Clear();
_contractNames.AddRange(value);
}
}
public IEnumerable<string> ParentContractNames
{
get
{
var result = new List<string>();
result.AddRange(_parentContractNames);
return result;
}
set
{
_parentContractNames = value.ToList();
}
}
public bool ParentNewObjectsUnderSceneContext
{
get { return _parentNewObjectsUnderSceneContext; }
set { _parentNewObjectsUnderSceneContext = value; }
}
#if UNITY_EDITOR
// Required for disabling domain reload in enter the play mode feature. See: https://docs.unity3d.com/Manual/DomainReloading.html
[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
static void ResetStaticValues()
{
if (!EditorSettings.enterPlayModeOptionsEnabled)
{
return;
}
ExtraBindingsInstallMethod = null;
ParentContainers = null;
ExtraBindingsLateInstallMethod = null;
}
#endif
protected override void Awake()
{
base.Awake();
#if ZEN_INTERNAL_PROFILING
ProfileTimers.ResetAll();
using (ProfileTimers.CreateTimedBlock("Other"))
#endif
{
Initialize();
}
}
#if UNITY_EDITOR
protected override void ResetInstanceFields()
{
base.ResetInstanceFields();
_container = null;
_decoratorContexts.Clear();
_hasInstalled = false;
_hasResolved = false;
PreInstall = null;
PostInstall = null;
PreResolve = null;
PostResolve = null;
}
#endif
public void Validate()
{
Assert.That(IsValidating);
Install();
Resolve();
}
protected override void RunInternal()
{
// We always want to initialize ProjectContext as early as possible
ProjectContext.Instance.EnsureIsInitialized();
#if UNITY_EDITOR
using (ProfileBlock.Start("Zenject.SceneContext.Install"))
#endif
{
Install();
}
#if UNITY_EDITOR
using (ProfileBlock.Start("Zenject.SceneContext.Resolve"))
#endif
{
Resolve();
}
}
public override IEnumerable<GameObject> GetRootGameObjects()
{
return ZenUtilInternal.GetRootGameObjects(gameObject.scene);
}
IEnumerable<DiContainer> GetParentContainers()
{
var parentContractNames = ParentContractNames;
if (parentContractNames.IsEmpty())
{
if (ParentContainers != null)
{
var tempParentContainer = ParentContainers;
// Always reset after using it - it is only used to pass the reference
// between scenes via ZenjectSceneLoader
ParentContainers = null;
return tempParentContainer;
}
return new[] { ProjectContext.Instance.Container };
}
Assert.IsNull(ParentContainers,
"Scene cannot have both a parent scene context name set and also an explicit parent container given");
var parentContainers = UnityUtil.AllLoadedScenes
.Except(gameObject.scene)
.SelectMany(scene => scene.GetRootGameObjects())
.SelectMany(root => root.GetComponentsInChildren<SceneContext>())
.Where(sceneContext => sceneContext.ContractNames.Where(x => parentContractNames.Contains(x)).Any())
.Select(x => x.Container)
.ToList();
if (!parentContainers.Any())
{
throw Assert.CreateException(
"SceneContext on object {0} of scene {1} requires at least one of contracts '{2}', but none of the loaded SceneContexts implements that contract.",
gameObject.name,
gameObject.scene.name,
parentContractNames.Join(", "));
}
return parentContainers;
}
List<SceneDecoratorContext> LookupDecoratorContexts()
{
if (_contractNames.IsEmpty())
{
return new List<SceneDecoratorContext>();
}
return UnityUtil.AllLoadedScenes
.Except(gameObject.scene)
.SelectMany(scene => scene.GetRootGameObjects())
.SelectMany(root => root.GetComponentsInChildren<SceneDecoratorContext>())
.Where(decoratorContext => _contractNames.Contains(decoratorContext.DecoratedContractName))
.ToList();
}
public void Install()
{
Assert.That(!_hasInstalled);
_hasInstalled = true;
Assert.IsNull(_container);
var parents = GetParentContainers();
Assert.That(!parents.IsEmpty());
Assert.That(parents.All(x => x.IsValidating == parents.First().IsValidating));
_container = new DiContainer(parents, parents.First().IsValidating);
// Do this after creating DiContainer in case it's needed by the pre install logic
if (PreInstall != null)
{
PreInstall();
}
if (OnPreInstall != null)
{
OnPreInstall.Invoke();
}
Assert.That(_decoratorContexts.IsEmpty());
_decoratorContexts.AddRange(LookupDecoratorContexts());
if (_parentNewObjectsUnderSceneContext)
{
_container.DefaultParent = transform;
}
else
{
_container.DefaultParent = null;
}
// Record all the injectable components in the scene BEFORE installing the installers
// This is nice for cases where the user calls InstantiatePrefab<>, etc. in their installer
// so that it doesn't inject on the game object twice
// InitialComponentsInjecter will also guarantee that any component that is injected into
// another component has itself been injected
var injectableMonoBehaviours = new List<MonoBehaviour>();
GetInjectableMonoBehaviours(injectableMonoBehaviours);
foreach (var instance in injectableMonoBehaviours)
{
_container.QueueForInject(instance);
}
foreach (var decoratorContext in _decoratorContexts)
{
decoratorContext.Initialize(_container);
}
_container.IsInstalling = true;
try
{
InstallBindings(injectableMonoBehaviours);
}
finally
{
_container.IsInstalling = false;
}
if (PostInstall != null)
{
PostInstall();
}
if (OnPostInstall != null)
{
OnPostInstall.Invoke();
}
}
public void Resolve()
{
if (PreResolve != null)
{
PreResolve();
}
if (OnPreResolve != null)
{
OnPreResolve.Invoke();
}
Assert.That(_hasInstalled);
Assert.That(!_hasResolved);
_hasResolved = true;
_container.ResolveRoots();
if (PostResolve != null)
{
PostResolve();
}
if (OnPostResolve != null)
{
OnPostResolve.Invoke();
}
}
void InstallBindings(List<MonoBehaviour> injectableMonoBehaviours)
{
_container.Bind(typeof(Context), typeof(SceneContext)).To<SceneContext>().FromInstance(this);
_container.BindInterfacesTo<SceneContextRegistryAdderAndRemover>().AsSingle();
// Add to registry first and remove from registry last
_container.BindExecutionOrder<SceneContextRegistryAdderAndRemover>(-1);
foreach (var decoratorContext in _decoratorContexts)
{
decoratorContext.InstallDecoratorSceneBindings();
}
InstallSceneBindings(injectableMonoBehaviours);
_container.Bind(typeof(SceneKernel), typeof(MonoKernel))
.To<SceneKernel>().FromNewComponentOn(gameObject).AsSingle().NonLazy();
_container.Bind<ZenjectSceneLoader>().AsSingle();
if (ExtraBindingsInstallMethod != null)
{
ExtraBindingsInstallMethod(_container);
// Reset extra bindings for next time we change scenes
ExtraBindingsInstallMethod = null;
}
// Always install the installers last so they can be injected with
// everything above
foreach (var decoratorContext in _decoratorContexts)
{
decoratorContext.InstallDecoratorInstallers();
}
InstallInstallers();
foreach (var decoratorContext in _decoratorContexts)
{
decoratorContext.InstallLateDecoratorInstallers();
}
if (ExtraBindingsLateInstallMethod != null)
{
ExtraBindingsLateInstallMethod(_container);
// Reset extra bindings for next time we change scenes
ExtraBindingsLateInstallMethod = null;
}
}
protected override void GetInjectableMonoBehaviours(List<MonoBehaviour> monoBehaviours)
{
var scene = gameObject.scene;
ZenUtilInternal.AddStateMachineBehaviourAutoInjectersInScene(scene);
ZenUtilInternal.GetInjectableMonoBehavioursInScene(scene, monoBehaviours);
}
// These methods can be used for cases where you need to create the SceneContext entirely in code
// Note that if you use these methods that you have to call Run() yourself
// This is useful because it allows you to create a SceneContext and configure it how you want
// and add what installers you want before kicking off the Install/Resolve
public static SceneContext Create()
{
return CreateComponent<SceneContext>(
new GameObject("SceneContext"));
}
}
}
#endif
| 1 | 0.913463 | 1 | 0.913463 | game-dev | MEDIA | 0.426871 | game-dev | 0.918734 | 1 | 0.918734 |
MindPort-GmbH/VR-Builder | 1,561 | Source/XRInteraction/Source/Editor/UI/Inspector/TeleportationAreaVRBuilderEditor.cs | using UnityEditor;
using UnityEditor.XR.Interaction.Toolkit.Locomotion.Teleportation;
using UnityEngine;
using UnityEngine.XR.Interaction.Toolkit.Locomotion.Teleportation;
using VRBuilder.XRInteraction.Interactables;
namespace VRBuilder.XRInteraction.Editor.UI.Inspector
{
[CustomEditor(typeof(TeleportationAreaVRBuilder)), CanEditMultipleObjects]
public class TeleportationAreaVRBuilderEditor : TeleportationAreaEditor
{
private const string teleportLayerName = "Teleport";
private const string reticlePrefab = "TeleportReticle";
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
if (GUILayout.Button("Configure VR Builder Defaults"))
{
foreach (UnityEngine.Object targetObject in serializedObject.targetObjects)
{
if (targetObject is TeleportationAreaVRBuilder teleportationArea)
{
ConfigureVRBuilderDefaults(teleportationArea);
}
}
}
}
protected virtual void ConfigureVRBuilderDefaults(TeleportationAreaVRBuilder teleportationArea)
{
teleportationArea.teleportTrigger = BaseTeleportationInteractable.TeleportTrigger.OnSelectExited;
teleportationArea.ConfigureLayers(teleportLayerName, teleportLayerName);
teleportationArea.customReticle = Resources.Load<GameObject>(reticlePrefab);
EditorUtility.SetDirty(teleportationArea);
}
}
} | 1 | 0.791582 | 1 | 0.791582 | game-dev | MEDIA | 0.968614 | game-dev | 0.913069 | 1 | 0.913069 |
EpicSentry/P2ASW | 8,416 | src/game/client/hl2/clientmode_hlnormal.cpp | //========= Copyright 1996-2005, Valve Corporation, All rights reserved. ====
//
// Purpose:
//
//=============================================================================
#include "cbase.h"
#include "clientmode_hlnormal.h"
#include "vgui_int.h"
#include "hud.h"
#include <vgui/IInput.h>
#include <vgui/IPanel.h>
#include <vgui/ISurface.h>
#include <vgui_controls/AnimationController.h>
#include "iinput.h"
#include "vgui_int.h"
#include "ienginevgui.h"
#include "cdll_client_int.h"
#include "engine/IEngineSound.h"
#include "ivmodemanager.h"
#include "panelmetaclassmgr.h"
//#include "nb_header_footer.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
extern bool g_bRollingCredits;
ConVar default_fov( "default_fov", "75", FCVAR_CHEAT );
ConVar fov_desired( "fov_desired", "75", FCVAR_ARCHIVE | FCVAR_USERINFO, "Sets the base field-of-view.", true, 75.0, true, 90.0 );
vgui::HScheme g_hVGuiCombineScheme = 0;
static IClientMode *g_pClientMode[ MAX_SPLITSCREEN_PLAYERS ];
IClientMode *GetClientMode()
{
ASSERT_LOCAL_PLAYER_RESOLVABLE();
return g_pClientMode[ GET_ACTIVE_SPLITSCREEN_SLOT() ];
}
// --------------------------------------------------------------------------------- //
// CASWModeManager.
// --------------------------------------------------------------------------------- //
class CSDKModeManager : public IVModeManager
{
public:
virtual void Init();
virtual void SwitchMode( bool commander, bool force ) {}
virtual void LevelInit( const char *newmap );
virtual void LevelShutdown( void );
virtual void ActivateMouse( bool isactive ) {}
};
static CSDKModeManager g_ModeManager;
IVModeManager *modemanager = ( IVModeManager * )&g_ModeManager;
// --------------------------------------------------------------------------------- //
// CASWModeManager implementation.
// --------------------------------------------------------------------------------- //
#define SCREEN_FILE "scripts/vgui_screens.txt"
void CSDKModeManager::Init()
{
for( int i = 0; i < MAX_SPLITSCREEN_PLAYERS; ++i )
{
ACTIVE_SPLITSCREEN_PLAYER_GUARD( i );
g_pClientMode[ i ] = GetClientModeNormal();
}
PanelMetaClassMgr()->LoadMetaClassDefinitionFile( SCREEN_FILE );
}
void CSDKModeManager::LevelInit( const char *newmap )
{
for( int i = 0; i < MAX_SPLITSCREEN_PLAYERS; ++i )
{
ACTIVE_SPLITSCREEN_PLAYER_GUARD( i );
GetClientMode()->LevelInit( newmap );
}
}
void CSDKModeManager::LevelShutdown( void )
{
for( int i = 0; i < MAX_SPLITSCREEN_PLAYERS; ++i )
{
ACTIVE_SPLITSCREEN_PLAYER_GUARD( i );
GetClientMode()->LevelShutdown();
}
}
ClientModeHLNormal g_ClientModeNormal[ MAX_SPLITSCREEN_PLAYERS ];
IClientMode *GetClientModeNormal()
{
Assert( engine->IsLocalPlayerResolvable() );
return &g_ClientModeNormal[ engine->GetActiveSplitScreenPlayerSlot() ];
}
ClientModeHLNormal* GetClientModeSDK()
{
Assert( engine->IsLocalPlayerResolvable() );
return &g_ClientModeNormal[ engine->GetActiveSplitScreenPlayerSlot() ];
}
static char const *s_CloseWindowNames[]={
"InfoMessageWindow",
"SkipIntro",
};
//-----------------------------------------------------------------------------
// Purpose: this is the viewport that contains all the hud elements
//-----------------------------------------------------------------------------
class CHudViewport : public CBaseViewport
{
private:
DECLARE_CLASS_SIMPLE( CHudViewport, CBaseViewport );
protected:
virtual void ApplySchemeSettings( vgui::IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
GetHud().InitColors( pScheme );
SetPaintBackgroundEnabled( false );
}
virtual void CreateDefaultPanels( void ) { /* don't create any panels yet*/ };
};
bool ClientModeHLNormal::ShouldDrawCrosshair( void )
{
return ( g_bRollingCredits == false );
}
//--------------------------------------------------------------------------------------------------------
// See interface.h/.cpp for specifics: basically this ensures that we actually Sys_UnloadModule the dll and that we don't call Sys_LoadModule
// over and over again.
static CDllDemandLoader g_GameUI( "gameui" );
class FullscreenSDKViewport : public CHudViewport
{
private:
DECLARE_CLASS_SIMPLE( FullscreenSDKViewport, CHudViewport );
private:
virtual void InitViewportSingletons( void )
{
SetAsFullscreenViewportInterface();
}
};
class ClientModeHLNormalFullscreen : public ClientModeHLNormal
{
DECLARE_CLASS_SIMPLE( ClientModeHLNormalFullscreen, ClientModeHLNormal );
public:
virtual void InitViewport()
{
// Skip over BaseClass!!!
BaseClass::BaseClass::InitViewport();
m_pViewport = new FullscreenSDKViewport();
m_pViewport->Start( gameuifuncs, gameeventmanager );
}
virtual void Init()
{
//
//CASW_VGUI_Debug_Panel *pDebugPanel = new CASW_VGUI_Debug_Panel( GetViewport(), "ASW Debug Panel" );
//g_hDebugPanel = pDebugPanel;
// Skip over BaseClass!!!
BaseClass::BaseClass::Init();
// Load up the combine control panel scheme
if ( !g_hVGuiCombineScheme )
{
g_hVGuiCombineScheme = vgui::scheme()->LoadSchemeFromFileEx( enginevgui->GetPanel( PANEL_CLIENTDLL ), IsXbox() ? "resource/ClientScheme.res" : "resource/CombinePanelScheme.res", "CombineScheme" );
if (!g_hVGuiCombineScheme)
{
Warning( "Couldn't load combine panel scheme!\n" );
}
}
}
void Shutdown()
{
}
};
//--------------------------------------------------------------------------------------------------------
static ClientModeHLNormalFullscreen g_FullscreenClientMode;
IClientMode *GetFullscreenClientMode( void )
{
return &g_FullscreenClientMode;
}
void ClientModeHLNormal::Init()
{
BaseClass::Init();
gameeventmanager->AddListener( this, "game_newmap", false );
// Load up the combine control panel scheme
g_hVGuiCombineScheme = vgui::scheme()->LoadSchemeFromFileEx( enginevgui->GetPanel( PANEL_CLIENTDLL ), IsXbox() ? "resource/ClientScheme.res" : "resource/CombinePanelScheme.res", "CombineScheme" );
if (!g_hVGuiCombineScheme)
{
Warning( "Couldn't load combine panel scheme!\n" );
}
}
void ClientModeHLNormal::Shutdown()
{
}
void ClientModeHLNormal::InitViewport()
{
m_pViewport = new CHudViewport();
m_pViewport->Start( gameuifuncs, gameeventmanager );
}
void ClientModeHLNormal::LevelInit( const char *newmap )
{
// reset ambient light
static ConVarRef mat_ambient_light_r( "mat_ambient_light_r" );
static ConVarRef mat_ambient_light_g( "mat_ambient_light_g" );
static ConVarRef mat_ambient_light_b( "mat_ambient_light_b" );
if ( mat_ambient_light_r.IsValid() )
{
mat_ambient_light_r.SetValue( "0" );
}
if ( mat_ambient_light_g.IsValid() )
{
mat_ambient_light_g.SetValue( "0" );
}
if ( mat_ambient_light_b.IsValid() )
{
mat_ambient_light_b.SetValue( "0" );
}
BaseClass::LevelInit(newmap);
// sdk: make sure no windows are left open from before
SDK_CloseAllWindows();
// clear any DSP effects
CLocalPlayerFilter filter;
enginesound->SetRoomType( filter, 0 );
enginesound->SetPlayerDSP( filter, 0, true );
}
void ClientModeHLNormal::LevelShutdown( void )
{
BaseClass::LevelShutdown();
// sdk:shutdown all vgui windows
SDK_CloseAllWindows();
}
void ClientModeHLNormal::FireGameEvent( IGameEvent *event )
{
const char *eventname = event->GetName();
if ( Q_strcmp( "asw_mission_restart", eventname ) == 0 )
{
SDK_CloseAllWindows();
}
else if ( Q_strcmp( "game_newmap", eventname ) == 0 )
{
engine->ClientCmd("exec newmapsettings\n");
}
else
{
BaseClass::FireGameEvent(event);
}
}
// Close all ASW specific VGUI windows that the player might have open
void ClientModeHLNormal::SDK_CloseAllWindows()
{
SDK_CloseAllWindowsFrom(GetViewport());
}
// recursive search for matching window names
void ClientModeHLNormal::SDK_CloseAllWindowsFrom(vgui::Panel* pPanel)
{
if (!pPanel)
return;
int num_names = NELEMS(s_CloseWindowNames);
for (int k=0;k<pPanel->GetChildCount();k++)
{
Panel *pChild = pPanel->GetChild(k);
if (pChild)
{
SDK_CloseAllWindowsFrom(pChild);
}
}
// When VGUI is shutting down (i.e. if the player closes the window), GetName() can return NULL
const char *pPanelName = pPanel->GetName();
if ( pPanelName != NULL )
{
for (int i=0;i<num_names;i++)
{
if ( !strcmp( pPanelName, s_CloseWindowNames[i] ) )
{
pPanel->SetVisible(false);
pPanel->MarkForDeletion();
}
}
}
}
void ClientModeHLNormal::DoPostScreenSpaceEffects( const CViewSetup *pSetup )
{
} | 1 | 0.985069 | 1 | 0.985069 | game-dev | MEDIA | 0.703673 | game-dev,graphics-rendering | 0.931035 | 1 | 0.931035 |
11011010/BFA-Frankenstein-Core | 31,225 | src/server/scripts/BrokenIsles/NeltharionsLair/boss_ularogg_cragshaper.cpp | /*
* Copyright (C) 2020 BfaCore
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "AreaTriggerAI.h"
#include "AreaTrigger.h"
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "neltharions_lair.h"
#include "CreatureTextMgr.h"
#include "Log.h"
#include "Spell.h"
#include "GameObject.h"
class at_mountain_strike : public AreaTriggerEntityScript
{
public:
at_mountain_strike() : AreaTriggerEntityScript("at_mountain_strike") { }
struct at_mountain_strikeAI : AreaTriggerAI
{
at_mountain_strikeAI(AreaTrigger* areatrigger) : AreaTriggerAI(areatrigger) { }
void OnUnitEnter(Unit* unit) override
{
if (unit && unit->ToPlayer())
playerGuid = unit->GetGUID();
}
void OnUnitExit(Unit* unit) override
{
if (unit && unit->ToPlayer())
playerGuid = ObjectGuid::Empty;
}
void OnUpdate(uint32 /*diff*/) override
{
if (!playerGuid.Empty)
{
if (Player* player = ObjectAccessor::GetPlayer(*at, playerGuid))
{
if (at->GetDuration() <= 1000)
{
player->CastSpell(player, 198475, false);
playerGuid = ObjectGuid::Empty;
}
}
}
}
private:
ObjectGuid playerGuid;
};
AreaTriggerAI* GetAI(AreaTrigger* areatrigger) const override
{
return new at_mountain_strikeAI(areatrigger);
}
};
// 216292 , 210164 (Naraxas toxic retch too) , 200722, 200338 (Dargrul lanslide and Crystal spike too)
class spell_mountain_strike_dest : public SpellScriptLoader
{
public:
spell_mountain_strike_dest() : SpellScriptLoader("spell_mountain_strike_dest") { }
class spell_mountain_strike_dest_SpellScript : public SpellScript
{
PrepareSpellScript(spell_mountain_strike_dest_SpellScript);
void ModDestHeight(SpellDestination& dest)
{
if (Unit* caster = GetCaster())
{
if (InstanceScript* instance = caster->GetInstanceScript())
{
Map::PlayerList const &PlayerList = instance->instance->GetPlayers();
std::list<Player*> validPlayers;
if (!PlayerList.isEmpty())
{
for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
{
Player* _player = i->GetSource();
if (_player && _player->IsAlive() && caster->IsWithinDistInMap(_player, 85.0f))
validPlayers.push_back(_player);
}
}
if (validPlayers.size() == 0)
return;
uint8 selectPlr = urand(1, validPlayers.size());
uint8 i = 0;
for (auto validPlr : validPlayers)
{
++i;
if (i == selectPlr)
{
Position pos = validPlr->GetPosition();
dest.Relocate(pos);
break;
}
}
}
}
}
void Register()
{
OnDestinationTargetSelect += SpellDestinationTargetSelectFn(spell_mountain_strike_dest_SpellScript::ModDestHeight, EFFECT_0, TARGET_DEST_DEST_RANDOM);
}
};
SpellScript* GetSpellScript() const override
{
return new spell_mountain_strike_dest_SpellScript();
}
};
class boss_ularogg_cragshaper : public CreatureScript
{
public:
boss_ularogg_cragshaper() : CreatureScript("boss_ularogg_cragshaper") { }
CreatureAI* GetAI(Creature* creature) const override
{
return new boss_ularogg_cragshaper_AI(creature);
}
enum eTexts
{
TALK_AGGRO = 0,
TALK_STRIKE_OF_THE_MOUNTAIN = 1,
TALK_STRIKE_OF_THE_MOUNTAIN_2 = 2,
TALK_MOUNTAIN_STANCE = 3,
TALK_DEATH = 4,
TALK_MOUNTAIN_STANCE_PHRASE = 5,
TALK_KILL = 6,
};
enum eEvents
{
EVENT_MANAREGEN_TICK = 1,
EVENT_BELLOW_OF_THE_DEEPS = 2,
EVENT_STRIKE_OF_THE_MOUNTAIN = 3,
EVENT_SUNDER = 4,
EVENT_PHASE_2 = 5,
EVENT_START_ATTACK = 6,
EVENT_PHASE_2_INVISIBLE = 7,
EVENT_IDOLS_MOTION = 8
};
enum eSpells
{
SPELL_BELLOW_OF_THE_DEEPS = 193375,
SPELL_STRIKE_OF_THE_MOUNTAIN = 216290,
SPELL_SUNDER = 198496,
SPELL_STANCE_OF_THE_MOUNTAIN = 198565
};
struct boss_ularogg_cragshaper_AI : public BossAI
{
boss_ularogg_cragshaper_AI(Creature* creature) : BossAI(creature, DATA_ULAROGG_CRAGSHAPER)
{
me->SetReactState(REACT_PASSIVE);
me->AddUnitFlag(UNIT_FLAG_IMMUNE_TO_PC);
}
EventMap events;
InstanceScript* instance;
bool manaRegenerated = false;
bool inSecondPhase = false;
bool isJumpedToCenter = false;
bool allowUpdateVictim = false;
uint8 idolsPoint = 0;
std::list<Position> idolsPositions;
void InitializeAI() override
{
instance = me->GetInstanceScript();
me->SetPower(POWER_MANA, 0);
}
void MoveInLineOfSight(Unit* who) override
{
if (!isJumpedToCenter && who->GetTypeId() == TYPEID_PLAYER && !who->ToPlayer()->IsGameMaster() && me->IsWithinDistInMap(who, 35.0f))
{
me->GetMotionMaster()->MoveJump(ularoggJumpPos, 15.0f, 15.0f, EVENT_JUMP, true);
if (me->GetPositionX() < 2858)
{
isJumpedToCenter = true;
events.ScheduleEvent(EVENT_START_ATTACK, 5 * IN_MILLISECONDS);
}
}
}
void Reset() override
{
_Reset();
events.Reset();
me->SetPower(POWER_MANA, 0);
manaRegenerated = false;
inSecondPhase = false;
isJumpedToCenter = false;
allowUpdateVictim = false;
idolsPoint = 0;
me->SetVisible(true);
if (instance)
{
instance->SetData(DATA_ULAROGG_CRAGSHAPER, NOT_STARTED);
instance->SetData(DATA_CENTER_IDOL_KILLED, NOT_STARTED);
}
}
void EnterCombat(Unit* /*who*/) override
{
Talk(TALK_AGGRO);
me->SetInCombatWithZone();
me->SetPower(POWER_MANA, 0);
events.ScheduleEvent(EVENT_MANAREGEN_TICK, 1s);
events.ScheduleEvent(EVENT_BELLOW_OF_THE_DEEPS, 4s, 6s);
events.ScheduleEvent(EVENT_SUNDER, 2s);
events.ScheduleEvent(EVENT_STRIKE_OF_THE_MOUNTAIN, 10s);
if (instance)
{
instance->SendEncounterUnit(ENCOUNTER_FRAME_ENGAGE, me);
instance->SetData(DATA_ULAROGG_CRAGSHAPER, IN_PROGRESS);
}
}
void JustDied(Unit* /*unit*/) override
{
Talk(TALK_DEATH);
if (GameObject* barrier = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(DATA_BARRIER_ULAROGG)))
barrier->SetGoState(GO_STATE_ACTIVE);
instance->SetData(DATA_ULAROGG_CRAGSHAPER, DONE);
}
void KilledUnit(Unit* victim) override
{
if (victim->GetTypeId() == TYPEID_PLAYER)
Talk(TALK_KILL);
}
void EnterEvadeMode(EvadeReason) override
{
me->SetPower(POWER_MANA, 0);
manaRegenerated = false;
inSecondPhase = false;
allowUpdateVictim = false;
BossAI::EnterEvadeMode();
if (instance)
{
instance->SetData(DATA_ULAROGG_CRAGSHAPER, FAIL);
instance->SetData(DATA_CENTER_IDOL_KILLED, FAIL);
instance->SendEncounterUnit(ENCOUNTER_FRAME_DISENGAGE, me);
}
isJumpedToCenter = false;
me->SetVisible(true);
}
int32 round(float v)
{
return floor(v + 0.5f);
}
void FillIdolsPositions(Creature* leftIdol, Creature* centerIdol, Creature* rightIdol, Creature* backIdol, Creature* frontIdol)
{
idolsPositions.clear();
for (uint8 i = 0; i < 18; ++i)
{
if (round(leftIdol->GetPositionX()) == round(ularoggIdolsPositions[i][0]) &&
round(leftIdol->GetPositionY()) == round(ularoggIdolsPositions[i][1]) &&
round(leftIdol->GetPositionZ()) == round(ularoggIdolsPositions[i][2]))
continue;
if (round(centerIdol->GetPositionX()) == round(ularoggIdolsPositions[i][0]) &&
round(centerIdol->GetPositionY()) == round(ularoggIdolsPositions[i][1]) &&
round(centerIdol->GetPositionZ()) == round(ularoggIdolsPositions[i][2]))
continue;
if (round(rightIdol->GetPositionX()) == round(ularoggIdolsPositions[i][0]) &&
round(rightIdol->GetPositionY()) == round(ularoggIdolsPositions[i][1]) &&
round(rightIdol->GetPositionZ()) == round(ularoggIdolsPositions[i][2]))
continue;
if (instance && instance->instance->GetDifficultyID() >= 2 && backIdol && frontIdol)
{
if (round(backIdol->GetPositionX()) == round(ularoggIdolsPositions[i][0]) &&
round(backIdol->GetPositionY()) == round(ularoggIdolsPositions[i][1]) &&
round(backIdol->GetPositionZ()) == round(ularoggIdolsPositions[i][2]))
continue;
if (round(frontIdol->GetPositionX()) == round(ularoggIdolsPositions[i][0]) &&
round(frontIdol->GetPositionY()) == round(ularoggIdolsPositions[i][1]) &&
round(frontIdol->GetPositionZ()) == round(ularoggIdolsPositions[i][2]))
continue;
}
idolsPositions.push_back(Position(ularoggIdolsPositions[i][0], ularoggIdolsPositions[i][1], ularoggIdolsPositions[i][2], 0.0f));
}
}
Position SelectRandomIdolPos(uint8 randomIndex)
{
uint8 i = 0;
for (auto idolsPoss : idolsPositions)
{
if (i == randomIndex)
return idolsPoss;
++i;
}
return Position(0.0f, 0.0f, 0.0f, 0.0f);
}
void UpdateAI(uint32 diff) override
{
if (instance && instance->GetData(DATA_CENTER_IDOL_KILLED) == DONE && inSecondPhase)
{
me->GetMotionMaster()->MoveJump(me->GetPositionX(), me->GetPositionY(), me->GetPositionX(), me->GetOrientation(), 55.0f, 55.0f, EVENT_JUMP, true);
me->SetVisible(true);
me->RemoveUnitFlag(UNIT_FLAG_IMMUNE_TO_PC);
me->SetReactState(REACT_AGGRESSIVE);
me->RemoveAllAuras();
allowUpdateVictim = true;
inSecondPhase = false;
manaRegenerated = false;
me->SetPower(POWER_MANA, 0);
events.ScheduleEvent(EVENT_MANAREGEN_TICK, 1s);
events.ScheduleEvent(EVENT_BELLOW_OF_THE_DEEPS, 4s, 6s);
events.ScheduleEvent(EVENT_SUNDER, 2s);
events.ScheduleEvent(EVENT_STRIKE_OF_THE_MOUNTAIN, 10s);
}
if (!UpdateVictim() && allowUpdateVictim)
return;
events.Update(diff);
switch (events.ExecuteEvent())
{
case EVENT_MANAREGEN_TICK:
if (!manaRegenerated && !inSecondPhase && me->GetPower(POWER_MANA) < me->GetMaxPower(POWER_MANA))
{
if (instance)
{
float manaRegenMod = 2.857f;
if (instance->instance->GetDifficultyID() == DIFFICULTY_MYTHIC)
manaRegenMod = 4;
me->SetPower(POWER_MANA, me->GetPower(POWER_MANA)+(me->GetMaxPower(POWER_MANA)*manaRegenMod/100));
if (me->GetPower(POWER_MANA) == me->GetMaxPower(POWER_MANA))
{
manaRegenerated = true;
events.ScheduleEvent(EVENT_PHASE_2, 3s);
me->AddUnitFlag(UNIT_FLAG_IMMUNE_TO_PC);
me->SetReactState(REACT_PASSIVE);
me->RemoveAllAuras();
me->RemoveAllAttackers();
allowUpdateVictim = false;
me->AttackStop();
me->GetMotionMaster()->MoveJump(ularoggJumpPos, 15.0f, 15.0f, EVENT_JUMP, true);
}
else
events.ScheduleEvent(EVENT_MANAREGEN_TICK, 2s);
}
}
break;
case EVENT_SUNDER:
if (!inSecondPhase)
{
me->CastSpell(me->GetVictim(), SPELL_SUNDER, false);
events.ScheduleEvent(EVENT_SUNDER, 6s, 10s);
}
break;
case EVENT_BELLOW_OF_THE_DEEPS:
if (!inSecondPhase)
{
me->CastSpell(me->GetVictim(), SPELL_BELLOW_OF_THE_DEEPS, false);
events.ScheduleEvent(EVENT_BELLOW_OF_THE_DEEPS, 6s, 10s);
}
break;
case EVENT_STRIKE_OF_THE_MOUNTAIN:
if (!inSecondPhase)
{
uint8 randomTalk = urand(TALK_STRIKE_OF_THE_MOUNTAIN, TALK_STRIKE_OF_THE_MOUNTAIN_2);
Talk(randomTalk);
me->CastSpell(me->GetVictim(), SPELL_STRIKE_OF_THE_MOUNTAIN, false);
events.ScheduleEvent(EVENT_STRIKE_OF_THE_MOUNTAIN, 12s, 15s);
}
break;
case EVENT_PHASE_2:
if (!inSecondPhase)
{
Talk(TALK_MOUNTAIN_STANCE);
Talk(TALK_MOUNTAIN_STANCE_PHRASE);
instance->SetData(DATA_CENTER_IDOL_KILLED, NOT_STARTED);
me->CastSpell(me, SPELL_STANCE_OF_THE_MOUNTAIN, false);
events.ScheduleEvent(EVENT_PHASE_2_INVISIBLE, 700);
inSecondPhase = true;
}
break;
case EVENT_START_ATTACK:
if (!inSecondPhase)
{
me->SetReactState(REACT_DEFENSIVE);
me->RemoveUnitFlag(UNIT_FLAG_IMMUNE_TO_PC);
allowUpdateVictim = true;
}
break;
case EVENT_PHASE_2_INVISIBLE:
if (!ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_CENTER_IDOL)))
{
TC_LOG_ERROR("misc", "!centerIdol");
instance->SetData(DATA_CENTER_IDOL_KILLED, NOT_STARTED);
me->CastSpell(me, SPELL_STANCE_OF_THE_MOUNTAIN, false);
events.ScheduleEvent(EVENT_PHASE_2_INVISIBLE, 500);
}
else
{
me->SetVisible(false);
events.ScheduleEvent(EVENT_IDOLS_MOTION, 3s);
}
break;
case EVENT_IDOLS_MOTION:
Creature* centerIdol = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_CENTER_IDOL));
Creature* leftIdol = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_LEFT_IDOL));
Creature* rightIdol = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_RIGHT_IDOL));
Creature* backIdol = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_BACK_IDOL));
Creature* frontIdol = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_FRONT_IDOL));
if (centerIdol && leftIdol && rightIdol)
{
FillIdolsPositions(leftIdol, centerIdol, rightIdol, backIdol, frontIdol);
Position leftIdolPos = SelectRandomIdolPos(urand(0, idolsPositions.size()-1));
FillIdolsPositions(leftIdol, centerIdol, rightIdol, backIdol, frontIdol);
for (std::list<Position>::iterator idPoss = idolsPositions.begin(); idPoss != idolsPositions.end(); ++idPoss)
if (*idPoss == leftIdolPos)
idPoss = idolsPositions.erase(idPoss);
Position centerIdolPos = SelectRandomIdolPos(urand(0, idolsPositions.size()-1));
FillIdolsPositions(leftIdol, centerIdol, rightIdol, backIdol, frontIdol);
for (std::list<Position>::iterator idPoss = idolsPositions.begin(); idPoss != idolsPositions.end(); ++idPoss)
{
if (*idPoss == leftIdolPos)
idPoss = idolsPositions.erase(idPoss);
if (*idPoss == centerIdolPos)
idPoss = idolsPositions.erase(idPoss);
}
Position rightIdolPos = SelectRandomIdolPos(urand(0, idolsPositions.size()-1));
if (instance && instance->instance->GetDifficultyID() >= 2 && backIdol && frontIdol)
{
FillIdolsPositions(leftIdol, centerIdol, rightIdol, backIdol, frontIdol);
for (std::list<Position>::iterator idPoss = idolsPositions.begin(); idPoss != idolsPositions.end(); ++idPoss)
{
if (*idPoss == leftIdolPos)
idPoss = idolsPositions.erase(idPoss);
if (*idPoss == centerIdolPos)
idPoss = idolsPositions.erase(idPoss);
if (*idPoss == rightIdolPos)
idPoss = idolsPositions.erase(idPoss);
}
Position backIdolPos = SelectRandomIdolPos(urand(0, idolsPositions.size()-1));
FillIdolsPositions(leftIdol, centerIdol, rightIdol, backIdol, frontIdol);
for (std::list<Position>::iterator idPoss = idolsPositions.begin(); idPoss != idolsPositions.end(); ++idPoss)
{
if (*idPoss == leftIdolPos)
idPoss = idolsPositions.erase(idPoss);
if (*idPoss == centerIdolPos)
idPoss = idolsPositions.erase(idPoss);
if (*idPoss == rightIdolPos)
idPoss = idolsPositions.erase(idPoss);
if (*idPoss == backIdolPos)
idPoss = idolsPositions.erase(idPoss);
}
Position frontIdolPos = SelectRandomIdolPos(urand(0, idolsPositions.size()-1));
frontIdol->GetMotionMaster()->MovePoint(idolsPoint, frontIdolPos);
backIdol->GetMotionMaster()->MovePoint(idolsPoint, backIdolPos);
}
leftIdol->GetMotionMaster()->MovePoint(idolsPoint, leftIdolPos);
centerIdol->GetMotionMaster()->MovePoint(idolsPoint, centerIdolPos);
rightIdol->GetMotionMaster()->MovePoint(idolsPoint, rightIdolPos);
}
++idolsPoint;
if (idolsPoint <= 8)
events.ScheduleEvent(EVENT_IDOLS_MOTION, 500);
else
{
std::list<Creature*> idolsList;
idolsList.push_back(centerIdol);
idolsList.push_back(leftIdol);
idolsList.push_back(rightIdol);
idolsList.push_back(backIdol);
idolsList.push_back(frontIdol);
for (auto Idol : idolsList)
{
if (Idol)
{
Idol->RemoveUnitFlag(UNIT_FLAG_NOT_SELECTABLE);
Idol->RemoveUnitFlag(UNIT_FLAG_IMMUNE_TO_PC);
Idol->AddAura(193267, Idol);
}
}
idolsPoint = 0;
}
break;
}
DoMeleeAttackIfReady();
}
};
};
// 100818
class mob_bellowing_idol_mountain_stance : public CreatureScript
{
public:
mob_bellowing_idol_mountain_stance() : CreatureScript("mob_bellowing_idol_mountain_stance") { }
CreatureAI* GetAI(Creature* creature) const override
{
return new mob_bellowing_idol_mountain_stance_AI(creature);
}
enum eSpells
{
SPELL_FALLING_DERBIS = 193271,
SPELL_DERBIS_AURA = 193267,
};
struct mob_bellowing_idol_mountain_stance_AI : public ScriptedAI
{
InstanceScript* instance;
mob_bellowing_idol_mountain_stance_AI(Creature* creature) : ScriptedAI(creature)
{
me->SetReactState(REACT_PASSIVE);
me->AddUnitFlag(UNIT_FLAG_NOT_SELECTABLE);
me->AddUnitFlag(UNIT_FLAG_IMMUNE_TO_PC);
float allSpeed = 3.0f;
me->SetSpeedRate(MOVE_WALK, allSpeed);
me->SetSpeedRate(MOVE_RUN, allSpeed);
me->SetSpeedRate(MOVE_SWIM, allSpeed);
me->SetSpeedRate(MOVE_FLIGHT, allSpeed);
instance = me->GetInstanceScript();
}
void JustDied(Unit* /*unit*/) override
{
if (instance)
if (me->GetGUID() == instance->GetGuidData(DATA_CENTER_IDOL))
instance->SetData(DATA_CENTER_IDOL_KILLED, DONE);
}
uint32 derbisTime = 3000;
void UpdateAI(uint32 diff) override
{
if (instance && instance->GetData(DATA_CENTER_IDOL_KILLED) == DONE)
me->DespawnOrUnsummon();
if (me->HasAura(SPELL_DERBIS_AURA))
{
if (derbisTime <= diff)
{
if (InstanceScript* instance = me->GetInstanceScript())
{
Map::PlayerList const &PlayerList = instance->instance->GetPlayers();
std::list<Player*> validPlayers;
if (!PlayerList.isEmpty())
{
for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
{
Player* _player = i->GetSource();
if (_player && _player->IsAlive() && me->IsWithinDistInMap(_player, 85.0f))
validPlayers.push_back(_player);
}
}
if (validPlayers.size() == 0)
return;
uint8 selectPlr = urand(1, validPlayers.size());
uint8 i = 0;
for (auto validPlr : validPlayers)
{
++i;
if (i == selectPlr)
{
me->CastSpell(validPlr, SPELL_FALLING_DERBIS, false);
break;
}
}
}
derbisTime = 3000;
}
else
derbisTime -= diff;
}
}
};
};
// 98081
class mob_bellowing_idol : public CreatureScript
{
public:
mob_bellowing_idol() : CreatureScript("mob_bellowing_idol") { }
CreatureAI* GetAI(Creature* creature) const override
{
return new mob_bellowing_idol_AI(creature);
}
enum eSpells
{
SPELL_FALLING_DERBIS = 193271,
SPELL_DERBIS_AURA = 193267,
};
struct mob_bellowing_idol_AI : public ScriptedAI
{
mob_bellowing_idol_AI(Creature* creature) : ScriptedAI(creature)
{
me->SetReactState(REACT_PASSIVE);
me->AddAura(SPELL_DERBIS_AURA, me);
}
uint32 derbisTime = 3000;
void UpdateAI(uint32 diff) override
{
if (derbisTime <= diff)
{
if (InstanceScript* instance = me->GetInstanceScript())
{
Map::PlayerList const &PlayerList = instance->instance->GetPlayers();
std::list<Player*> validPlayers;
if (!PlayerList.isEmpty())
{
for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
{
Player* _player = i->GetSource();
if (_player && _player->IsAlive() && me->IsWithinDistInMap(_player, 85.0f))
validPlayers.push_back(_player);
}
}
if (validPlayers.size() == 0)
return;
uint8 selectPlr = urand(1, validPlayers.size());
uint8 i = 0;
for (auto validPlr : validPlayers)
{
++i;
if (i == selectPlr)
{
me->CastSpell(validPlr, SPELL_FALLING_DERBIS, false);
break;
}
}
}
derbisTime = 3000;
}
else
derbisTime -= diff;
}
};
};
// 198565
class spell_ularogg_mountain_stance : public SpellScriptLoader
{
public:
spell_ularogg_mountain_stance() : SpellScriptLoader("spell_ularogg_mountain_stance") { }
class spell_ularogg_mountain_stance_SpellScript : public SpellScript
{
PrepareSpellScript(spell_ularogg_mountain_stance_SpellScript);
void SpawnOtherIdols()
{
if (Unit* caster = GetCaster())
{
if (InstanceScript* instance = caster->GetInstanceScript())
{
caster->SummonCreature(100818, ularoggRightIdolStartPos, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, -1);
caster->SummonCreature(100818, ularoggLeftIdolStartPos, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, -1);
if (instance->instance->GetDifficultyID() >= 2)
{
caster->SummonCreature(100818, ularoggBackIdolStartPos, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, -1);
caster->SummonCreature(100818, ularoggFrontIdolStartPos, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, -1);
}
}
}
}
void Register()
{
AfterCast += SpellCastFn(spell_ularogg_mountain_stance_SpellScript::SpawnOtherIdols);
}
};
SpellScript* GetSpellScript() const override
{
return new spell_ularogg_mountain_stance_SpellScript();
}
};
// 193270
class spell_idol_falling_debris : public SpellScriptLoader
{
public:
spell_idol_falling_debris() : SpellScriptLoader("spell_idol_falling_debris") { }
class spell_idol_falling_debris_SpellScript : public SpellScript
{
PrepareSpellScript(spell_idol_falling_debris_SpellScript);
void CastTriggerSpell()
{
if (Unit* caster = GetCaster())
caster->CastSpell(caster, 193271, false);
}
void Register()
{
AfterCast += SpellCastFn(spell_idol_falling_debris_SpellScript::CastTriggerSpell);
}
};
SpellScript* GetSpellScript() const override
{
return new spell_idol_falling_debris_SpellScript();
}
};
// 216290
class spell_mountain_strike_trigger : public SpellScriptLoader
{
public:
spell_mountain_strike_trigger() : SpellScriptLoader("spell_mountain_strike_trigger") { }
class spell_mountain_strike_trigger_SpellScript : public SpellScript
{
PrepareSpellScript(spell_mountain_strike_trigger_SpellScript);
void CastTriggerSpell()
{
if (Unit* caster = GetCaster())
caster->CastSpell(caster, 216292, false);
}
void Register()
{
AfterCast += SpellCastFn(spell_mountain_strike_trigger_SpellScript::CastTriggerSpell);
}
};
SpellScript* GetSpellScript() const override
{
return new spell_mountain_strike_trigger_SpellScript();
}
};
void AddSC_boss_ularogg_cragshaper()
{
new boss_ularogg_cragshaper();
new mob_bellowing_idol();
new mob_bellowing_idol_mountain_stance();
new spell_ularogg_mountain_stance();
new spell_idol_falling_debris();
new at_mountain_strike();
new spell_mountain_strike_trigger();
new spell_mountain_strike_dest();
}
| 1 | 0.937246 | 1 | 0.937246 | game-dev | MEDIA | 0.989663 | game-dev | 0.985995 | 1 | 0.985995 |
DanceManiac/Advanced-X-Ray-Public | 7,459 | SourcesAXR/xrGame/Level_load.cpp | #include "stdafx.h"
#include "LevelGameDef.h"
#include "ai_space.h"
#include "ParticlesObject.h"
#include "script_process.h"
#include "script_engine.h"
#include "script_engine_space.h"
#include "level.h"
#include "game_cl_base.h"
#include "../xrEngine/x_ray.h"
#include "../xrEngine/gamemtllib.h"
#include "../xrphysics/PhysicsCommon.h"
#include "level_sounds.h"
#include "GamePersistent.h"
ENGINE_API bool g_dedicated_server;
BOOL CLevel::Load_GameSpecific_Before()
{
// AI space
g_pGamePersistent->SetLoadStageTitle("st_loading_ai_objects");
g_pGamePersistent->LoadTitle ();
string_path fn_game;
if (GamePersistent().GameType() == eGameIDSingle && !ai().get_alife() && FS.exist(fn_game,"$level$","level.ai") && !net_Hosts.empty())
ai().load (net_SessionName());
if (!g_dedicated_server && !ai().get_alife() && ai().get_game_graph() && FS.exist(fn_game, "$level$", "level.game")) {
IReader *stream = FS.r_open (fn_game);
ai().patrol_path_storage_raw (*stream);
FS.r_close (stream);
}
return (TRUE);
}
BOOL CLevel::Load_GameSpecific_After()
{
R_ASSERT(m_StaticParticles.empty());
// loading static particles
string_path fn_game;
if (FS.exist(fn_game, "$level$", "level.ps_static"))
{
IReader *F = FS.r_open (fn_game);
CParticlesObject* pStaticParticles;
u32 chunk = 0;
string256 ref_name;
Fmatrix transform;
Fvector zero_vel={0.f,0.f,0.f};
u32 ver = 0;
for (IReader *OBJ = F->open_chunk_iterator(chunk); OBJ; OBJ = F->open_chunk_iterator(chunk,OBJ))
{
if(chunk==0)
{
if(OBJ->length()==sizeof(u32))
{
ver = OBJ->r_u32();
#ifndef MASTER_GOLD
Msg ("PS new version, %d", ver);
#endif // #ifndef MASTER_GOLD
continue;
}
}
u16 gametype_usage = 0;
if(ver>0)
{
gametype_usage = OBJ->r_u16();
}
OBJ->r_stringZ (ref_name,sizeof(ref_name));
OBJ->r (&transform,sizeof(Fmatrix));transform.c.y+=0.01f;
if ((g_pGamePersistent->m_game_params.m_e_game_type & EGameIDs(gametype_usage)) || (ver == 0))
{
pStaticParticles = CParticlesObject::Create(ref_name,FALSE,false);
pStaticParticles->UpdateParent (transform,zero_vel);
pStaticParticles->Play (false);
m_StaticParticles.push_back (pStaticParticles);
}
}
FS.r_close (F);
}
if (!g_dedicated_server)
{
// loading static sounds
VERIFY (m_level_sound_manager);
m_level_sound_manager->Load ();
// loading sound environment
if ( FS.exist(fn_game, "$level$", "level.snd_env")) {
IReader *F = FS.r_open (fn_game);
::Sound->set_geometry_env(F);
FS.r_close (F);
}
// loading SOM
if (FS.exist(fn_game, "$level$", "level.som")) {
IReader *F = FS.r_open (fn_game);
::Sound->set_geometry_som(F);
FS.r_close (F);
}
// loading random (around player) sounds
if (pSettings->section_exist("sounds_random")){
CInifile::Sect& S = pSettings->r_section("sounds_random");
Sounds_Random.reserve (S.Data.size());
for (CInifile::SectCIt I=S.Data.begin(); S.Data.end()!=I; ++I)
{
Sounds_Random.push_back (ref_sound());
Sound->create (Sounds_Random.back(),*I->first,st_Effect,sg_SourceType);
}
Sounds_Random_dwNextTime= Device.TimerAsync () + 50000;
Sounds_Random_Enabled = FALSE;
}
if ( FS.exist(fn_game, "$level$", "level.fog_vol"))
{
IReader *F = FS.r_open (fn_game);
u16 version = F->r_u16();
if(version == 2)
{
u32 cnt = F->r_u32();
Fmatrix volume_matrix;
for(u32 i=0; i<cnt; ++i)
{
F->r (&volume_matrix, sizeof(volume_matrix));
u32 sub_cnt = F->r_u32();
for(u32 is=0; is<sub_cnt; ++is)
{
F->r (&volume_matrix, sizeof(volume_matrix));
}
}
}
FS.r_close (F);
}
}
if (!g_dedicated_server) {
// loading scripts
ai().script_engine().remove_script_process(ScriptEngine::eScriptProcessorLevel);
if (pLevel->section_exist("level_scripts") && pLevel->line_exist("level_scripts","script"))
ai().script_engine().add_script_process(ScriptEngine::eScriptProcessorLevel,xr_new<CScriptProcess>("level",pLevel->r_string("level_scripts","script")));
else
ai().script_engine().add_script_process(ScriptEngine::eScriptProcessorLevel,xr_new<CScriptProcess>("level",""));
}
BlockCheatLoad();
g_pGamePersistent->Environment().SetGameTime (GetEnvironmentGameDayTimeSec(),game->GetEnvironmentGameTimeFactor());
return TRUE;
}
struct translation_pair {
u32 m_id;
u16 m_index;
IC translation_pair (u32 id, u16 index)
{
m_id = id;
m_index = index;
}
IC bool operator== (const u16 &id) const
{
return (m_id == id);
}
IC bool operator< (const translation_pair &pair) const
{
return (m_id < pair.m_id);
}
IC bool operator< (const u16 &id) const
{
return (m_id < id);
}
};
void CLevel::Load_GameSpecific_CFORM_Serialize(IWriter& writer)
{
writer.w_u32(GMLib.GetFileAge());
}
bool CLevel::Load_GameSpecific_CFORM_Deserialize(IReader& reader)
{
const auto materials_file_age = GMLib.GetFileAge();
const auto cached_materials_file_age = reader.r_u32();
return materials_file_age == cached_materials_file_age;
}
void CLevel::Load_GameSpecific_CFORM ( CDB::TRI* tris, u32 count )
{
typedef xr_vector<translation_pair> ID_INDEX_PAIRS;
ID_INDEX_PAIRS translator;
translator.reserve (GMLib.CountMaterial());
u16 default_id = (u16)GMLib.GetMaterialIdx("default");
translator.push_back (translation_pair(u32(-1),default_id));
u16 index = 0, static_mtl_count = 1;
int max_ID = 0;
int max_static_ID = 0;
for (GameMtlIt I=GMLib.FirstMaterial(); GMLib.LastMaterial()!=I; ++I, ++index) {
if (!(*I)->Flags.test(SGameMtl::flDynamic)) {
++static_mtl_count;
translator.push_back (translation_pair((*I)->GetID(),index));
if ((*I)->GetID()>max_static_ID) max_static_ID = (*I)->GetID();
}
if ((*I)->GetID()>max_ID) max_ID = (*I)->GetID();
}
// Msg("* Material remapping ID: [Max:%d, StaticMax:%d]",max_ID,max_static_ID);
VERIFY(max_static_ID<0xFFFF);
if (static_mtl_count < 128) {
CDB::TRI *I = tris;
CDB::TRI *E = tris + count;
for ( ; I != E; ++I) {
ID_INDEX_PAIRS::iterator i = std::find(translator.begin(),translator.end(),(u16)(*I).material);
if (i != translator.end()) {
(*I).material = (*i).m_index;
SGameMtl* mtl = GMLib.GetMaterialByIdx ((*i).m_index);
(*I).suppress_shadows = mtl->Flags.is(SGameMtl::flSuppressShadows);
(*I).suppress_wm = mtl->Flags.is(SGameMtl::flSuppressWallmarks);
continue;
}
Debug.fatal (DEBUG_INFO,"Game material '%d' not found",(*I).material);
}
return;
}
std::sort (translator.begin(),translator.end());
{
CDB::TRI *I = tris;
CDB::TRI *E = tris + count;
for ( ; I != E; ++I) {
ID_INDEX_PAIRS::iterator i = std::lower_bound(translator.begin(),translator.end(),(u16)(*I).material);
if ((i != translator.end()) && ((*i).m_id == (*I).material)) {
(*I).material = (*i).m_index;
SGameMtl* mtl = GMLib.GetMaterialByIdx ((*i).m_index);
(*I).suppress_shadows = mtl->Flags.is(SGameMtl::flSuppressShadows);
(*I).suppress_wm = mtl->Flags.is(SGameMtl::flSuppressWallmarks);
continue;
}
Debug.fatal (DEBUG_INFO,"Game material '%d' not found",(*I).material);
}
}
}
void CLevel::BlockCheatLoad()
{
#ifndef DEBUG
if( game && (GameID() != eGameIDSingle) ) phTimefactor=1.f;
#endif
}
| 1 | 0.807648 | 1 | 0.807648 | game-dev | MEDIA | 0.921396 | game-dev | 0.880496 | 1 | 0.880496 |
Dreamtowards/Ethertia | 2,799 | lib/jolt-3.0.1/Jolt/Physics/Collision/CollideSphereVsTriangles.h | // Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
#pragma once
#include <Jolt/Physics/Collision/Shape/Shape.h>
#include <Jolt/Physics/Collision/Shape/SubShapeID.h>
#include <Jolt/Physics/Collision/Shape/SphereShape.h>
JPH_NAMESPACE_BEGIN
class CollideShapeSettings;
/// Collision detection helper that collides a sphere vs one or more triangles
class CollideSphereVsTriangles
{
public:
/// Constructor
/// @param inShape1 The sphere to collide against triangles
/// @param inScale1 Local space scale for the sphere
/// @param inScale2 Local space scale for the triangles
/// @param inCenterOfMassTransform1 Transform that takes the center of mass of 1 into world space
/// @param inCenterOfMassTransform2 Transform that takes the center of mass of 2 into world space
/// @param inSubShapeID1 Sub shape ID of the convex object
/// @param inCollideShapeSettings Settings for the collide shape query
/// @param ioCollector The collector that will receive the results
CollideSphereVsTriangles(const SphereShape *inShape1, Vec3Arg inScale1, Vec3Arg inScale2, Mat44Arg inCenterOfMassTransform1, Mat44Arg inCenterOfMassTransform2, const SubShapeID &inSubShapeID1, const CollideShapeSettings &inCollideShapeSettings, CollideShapeCollector &ioCollector);
/// Collide sphere with a single triangle
/// @param inV0 , inV1 , inV2: CCW triangle vertices
/// @param inActiveEdges bit 0 = edge v0..v1 is active, bit 1 = edge v1..v2 is active, bit 2 = edge v2..v0 is active
/// An active edge is an edge that is not connected to another triangle in such a way that it is impossible to collide with the edge
/// @param inSubShapeID2 The sub shape ID for the triangle
void Collide(Vec3Arg inV0, Vec3Arg inV1, Vec3Arg inV2, uint8 inActiveEdges, const SubShapeID &inSubShapeID2);
protected:
const CollideShapeSettings & mCollideShapeSettings; ///< Settings for this collision operation
CollideShapeCollector & mCollector; ///< The collector that will receive the results
const SphereShape * mShape1; ///< The shape that we're colliding with
Vec3 mScale2; ///< The scale of the shape (in shape local space) of the shape we're colliding against
Mat44 mTransform2; ///< Transform of the shape we're colliding against
Vec3 mSphereCenterIn2; ///< The center of the sphere in the space of 2
SubShapeID mSubShapeID1; ///< Sub shape ID of colliding shape
float mScaleSign2; ///< Sign of the scale of object 2, -1 if object is inside out, 1 if not
float mRadius; ///< Radius of the sphere
float mRadiusPlusMaxSeparationSq; ///< (Radius + Max SeparationDistance)^2
};
JPH_NAMESPACE_END
| 1 | 0.927111 | 1 | 0.927111 | game-dev | MEDIA | 0.959689 | game-dev | 0.917092 | 1 | 0.917092 |
Open-RSC/Core-Framework | 4,020 | server/plugins/com/openrsc/server/plugins/authentic/npcs/Man.java | package com.openrsc.server.plugins.authentic.npcs;
import com.openrsc.server.constants.ItemId;
import com.openrsc.server.constants.NpcId;
import com.openrsc.server.model.entity.npc.Npc;
import com.openrsc.server.model.entity.player.Player;
import com.openrsc.server.plugins.triggers.TalkNpcTrigger;
import com.openrsc.server.util.rsc.DataConversions;
import static com.openrsc.server.plugins.Functions.*;
public class Man implements TalkNpcTrigger {
@Override
public boolean blockTalkNpc(Player player, Npc n) {
// Dialogue same between all Man, Farmer, Thief, Rogue, Alkharid Warrior
return inArray(n.getID(), NpcId.MAN.id(), NpcId.MAN_ALKHARID.id(), NpcId.MAN_ARDOUGNE.id(),
NpcId.FARMER.id(), NpcId.FARMER_ARDOUGNE.id(),
NpcId.THIEF.id(), NpcId.THIEF_BLANKET.id(), NpcId.HEAD_THIEF.id(),
NpcId.ROGUE.id(), NpcId.ALKHARID_WARRIOR.id());
}
@Override
public void onTalkNpc(Player player, Npc n) {
int selected = DataConversions.getRandom().nextInt(20);
boolean autoChoose = DataConversions.getRandom().nextBoolean();
String[] menuOptions;
say(player, n, "Hello", "How's it going?");
if (selected == 0)
npcsay(player, n, "Get out of my way", "I'm in a hurry");
else if (selected == 1)
player.message("The man ignores you");
else if (selected == 2)
npcsay(player, n, "Not too bad");
else if (selected == 3)
npcsay(player, n, "Very well, thank you");
else if (selected == 4) {
npcsay(player, n, "Have this flier");
give(player, ItemId.FLIER.id(), 1);
} else if (selected == 5)
npcsay(player, n, "I'm a little worried",
"I've heard there's lots of people going about,",
"killing citizens at random");
else if (selected == 6) {
npcsay(player, n, "I'm fine", "How are you?");
say(player, n, "Very well, thank you");
} else if (selected == 7)
npcsay(player, n, "Hello");
else if (selected == 8) {
npcsay(player, n, "Who are you?");
say(player, n, "I am a bold adventurer");
npcsay(player, n, "A very noble profession");
} else if (selected == 9) {
npcsay(player, n, "Not too bad",
"I'm a little worried about the increase in Goblins these days");
say(player, n, "Don't worry. I'll kill them");
} else if (selected == 10)
npcsay(player, n, "Hello", "Nice weather we've been having");
else if (selected == 11)
npcsay(player, n, "No, I don't want to buy anything");
else if (selected == 12) {
npcsay(player, n, "Do I know you?");
say(player, n,
"No, I was just wondering if you had anything interesting to say");
} else if (selected == 13) {
npcsay(player, n, "How can I help you?");
menuOptions = new String[]{"Do you wish to trade?",
"I'm in search of a quest",
"I'm in search of enemies to kill"};
int option;
if (autoChoose) {
option = DataConversions.getRandom().nextInt(menuOptions.length);
} else {
option = multi(player, n, false, menuOptions);
}
if (option == 0) {
say(player, n, "Do you wish to trade?");
npcsay(player, n, "No, I have nothing I wish to get rid of",
"If you want to do some trading,",
"there are plenty of shops and market stalls around though");
}
else if (option == 1) {
say(player, n, "I'm in search of a quest");
npcsay(player, n, "I'm sorry I can't help you there");
}
else if (option == 2) {
say(player, n, "I'm in search of enemies to kill");
npcsay(player, n,
"I've heard there are many fearsome creatures under the ground");
}
} else if (selected == 14) {
npcsay(player, n, "Are you asking for a fight?");
n.startCombat(player);
} else if (selected == 15)
npcsay(player, n, "That is classified information");
else if (selected == 16)
npcsay(player, n, "No, I don't have any spare change");
else if (selected == 17)
npcsay(player, n, "None of your business");
else if (selected == 18)
npcsay(player, n, "I think we need a new king",
"The one we've got isn't very good");
else if (selected == 19)
npcsay(player, n, "Yo wassup!");
}
}
| 1 | 0.838744 | 1 | 0.838744 | game-dev | MEDIA | 0.977406 | game-dev | 0.908426 | 1 | 0.908426 |
NetCodersX/Unity-Script | 8,824 | 简易任务系统场景建造/Assets/Sprites/Astar/Astar.cs | using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.Tilemaps;
public class Astar : MonoBehaviour
{
#region 单例
private static Astar instance;
public static Astar Instance
{
get
{
if (instance == null)
{
instance = FindObjectOfType<Astar>();
}
return instance;
}
}
#endregion
public Tilemap tilemap;
/// <summary>
/// 开始位置、目标位置
/// </summary>
[HideInInspector]
public Vector3Int startPos, goalPos;
[HideInInspector]
public bool start, goal;
//水Tile
[HideInInspector]
public List<Vector3Int> waterTiles = new List<Vector3Int>();
[HideInInspector]
public HashSet<Vector3Int> changedTiles = new HashSet<Vector3Int>();
private HashSet<Node> openList = new HashSet<Node>();
private Dictionary<Vector3Int, Node> allNodes = new Dictionary<Vector3Int, Node>();
private Node current;
private HashSet<Node> closeList = new HashSet<Node>();
private Stack<Vector3Int> path;
void Update()
{
//if (Input.GetKeyDown(KeyCode.Space))
//{
// Algotithm();
//}
}
private void Init()
{
current = GetNode(startPos);
openList.Add(current);
}
/// <summary>
/// 测试
/// </summary>
public void Algotithm(Vector3Int startPos, Vector3Int goalPos, bool step)
{
this.startPos = startPos;
this.goalPos = goalPos;
if (current == null)
{
Init();
}
while (openList.Count > 0 && path == null)
{
List<Node> neighbors = FindNeighbors(current.Position);
ExamineNeighbors(neighbors, current);
UpdateCurrentTile(ref current);
path = GeneratePath(current);
if (step)
{
break;
}
}
//if (path != null)
//{
// foreach (var postion in path)
// {
// tilemap.SetTile(postion, TileController.Instance.tileDic[TileType.sand_tile]);
// }
//}
AstarDebug.Instance.CreateTiles(openList, closeList, allNodes, startPos, goalPos, path);
}
public Stack<Vector3Int> Algotithm(Vector3 start,Vector3 goal)
{
startPos = tilemap.WorldToCell(start);
goalPos = tilemap.WorldToCell(goal);
openList = new HashSet<Node>();
closeList = new HashSet<Node>();
path = null;
Reset();
current = GetNode(startPos);
openList.Add(current);
while (openList.Count > 0 && path == null)
{
List<Node> neighbors = FindNeighbors(current.Position);
ExamineNeighbors(neighbors, current);
UpdateCurrentTile(ref current);
path = GeneratePath(current);
}
AstarDebug.Instance.CreateTiles(openList, closeList, allNodes, startPos, goalPos, path);
if (path != null)
{
return path;
}
return null;
}
/// <summary>
/// 查找邻居
/// </summary>
/// <param name="parentPosition"></param>
/// <returns></returns>
private List<Node> FindNeighbors(Vector3Int parentPosition)
{
List<Node> neighbors = new List<Node>();
for (int x = -1; x <= 1; x++)
{
for (int y = -1; y <= 1; y++)
{
Vector3Int neighborPos = new Vector3Int(parentPosition.x - x, parentPosition.y - y, parentPosition.z);
if (y != 0 || x != 0)
{
//排除开始位置、障碍位置
if (neighborPos != startPos && !waterTiles.Contains(neighborPos) && tilemap.GetTile(neighborPos))
{
Node neighbor = GetNode(neighborPos);
neighbors.Add(neighbor);
}
}
}
}
return neighbors;
}
/// <summary>
/// 检查邻居
/// </summary>
/// <param name="neighbors"></param>
/// <param name="current"></param>
private void ExamineNeighbors(List<Node> neighbors, Node current)
{
for (int i = 0; i < neighbors.Count; i++)
{
Node neighbor = neighbors[i];
if (!ConntedDiagonally(current, neighbor))
{
continue;
}
int gScore = DetermineGScore(neighbors[i].Position, current.Position);
if (openList.Contains(neighbor))
{
if (current.G + gScore < neighbor.G)
{
CalcValues(current, neighbor, gScore);
}
}
else if (!closeList.Contains(neighbor))
{
CalcValues(current, neighbor, gScore);
openList.Add(neighbor);
}
}
}
/// <summary>
/// 计算选择路径消耗值
/// </summary>
/// <param name="parent"></param>
/// <param name="neighbor"></param>
/// <param name="cost"></param>
private void CalcValues(Node parent, Node neighbor, int cost)
{
neighbor.Parent = parent;
neighbor.G = parent.G + cost;
neighbor.H = ((Math.Abs(neighbor.Position.x - goalPos.x) + Math.Abs((neighbor.Position.y - goalPos.y))) * 10);
neighbor.F = neighbor.G + neighbor.H;
}
/// <summary>
/// 确定分数
/// </summary>
/// <param name="neighbor"></param>
/// <param name="current"></param>
/// <returns></returns>
private int DetermineGScore(Vector3Int neighbor, Vector3Int current)
{
int gScore = 0;
int x = current.x - neighbor.x;
int y = current.y - neighbor.y;
if (Math.Abs(x - y) % 2 == 1)
{
gScore = 10;
}
else
{
gScore = 14;
}
return gScore;
}
/// <summary>
/// 更新当前Tile
/// </summary>
/// <param name="current"></param>
private void UpdateCurrentTile(ref Node current)
{
openList.Remove(current);
closeList.Add(current);
//获取最小的消耗
if (openList.Count > 0)
{
current = openList.OrderBy(x => x.F).First();
}
}
/// <summary>
/// 获取节点
/// </summary>
/// <param name="position">坐标.</param>
/// <returns></returns>
private Node GetNode(Vector3Int position)
{
if (allNodes.ContainsKey(position))
{
return allNodes[position];
}
else
{
Node node = new Node(position);
allNodes.Add(position, node);
return node;
}
}
/// <summary>
/// 对角连接
/// </summary>
/// <param name="currentNode"></param>
/// <param name="neighbor"></param>
/// <returns></returns>
private bool ConntedDiagonally(Node currentNode, Node neighbor)
{
Vector3Int direct = currentNode.Position - neighbor.Position;
//第一
Vector3Int first = new Vector3Int(current.Position.x + (direct.x * -1), current.Position.y, current.Position.z);
//第二
Vector3Int second = new Vector3Int(current.Position.x, current.Position.y + (direct.y * -1), current.Position.z);
if (waterTiles.Contains(first) || waterTiles.Contains(second))
{
return false;
}
return true;
}
/// <summary>
/// 生成路径。
/// </summary>
/// <param name="current"></param>
/// <returns></returns>
private Stack<Vector3Int> GeneratePath(Node current)
{
if (current.Position == goalPos)
{
Stack<Vector3Int> finalPath = new Stack<Vector3Int>();
while (current.Position != startPos)
{
finalPath.Push(current.Position);
current = current.Parent;
}
return finalPath;
}
return null;
}
public void Reset()
{
AstarDebug.Instance.Reset(allNodes);
//foreach (var position in changedTiles)
//{
// tilemap.SetTile(position, TileController.Instance.tileDic[TileType.grass]);
//}
//if (path!=null)
//{
// foreach (var position in path)
// {
// tilemap.SetTile(position, TileController.Instance.tileDic[TileType.grass]);
// }
//}
//tilemap.SetTile(startPos, TileController.Instance.tileDic[TileType.grass]);
//tilemap.SetTile(goalPos, TileController.Instance.tileDic[TileType.grass]);
waterTiles.Clear();
openList.Clear();
closeList.Clear();
allNodes.Clear();
start = false;
goal = false;
current = null;
path = null;
}
} | 1 | 0.904143 | 1 | 0.904143 | game-dev | MEDIA | 0.820318 | game-dev | 0.960719 | 1 | 0.960719 |
Breakthrough-Energy/PowerSimData | 2,295 | powersimdata/network/constants/carrier/label.py | class USALabel:
"""Label for each resource in USA grid models."""
def __init__(self):
self.type2label = {
"nuclear": "Nuclear",
"geothermal": "Geothermal",
"coal": "Coal",
"dfo": "Diesel Fuel Oil",
"hydro": "Hydro",
"ng": "Natural Gas",
"solar": "Solar",
"wind": "Onshore Wind",
"wind_offshore": "Offshore Wind",
"biomass": "Biomass",
"other": "Other",
"storage": "Storage",
}
self.curtailable2label = {
"solar": "Solar Curtailment",
"wind": "Onshore Wind Curtailment",
"wind_offshore": "Offshore Wind Curtailment",
}
self.label2type = {v: k for k, v in self.type2label.items()}
self.label2curtailable = {v: k for k, v in self.curtailable2label.items()}
class EULabel:
"""Label for each resource in EU grid model."""
def __init__(self):
self.type2label = {
"onwind": "Onshore Wind",
"offwind-ac": "Offshore Wind (AC)",
"offwind-dc": "Offshore Wind (DC)",
"inflow": "Hydroelectricity with Inflow",
"ror": "Run of River",
"solar": "Solar",
"biomass": "Biomass",
"geothermal": "Geothermal",
"OCGT": "Open-Cycle Gas",
"CCGT": "Combined-Cycle Gas",
"nuclear": "Nuclear",
"coal": "Coal",
"lignite": "Lignite",
"oil": "Oil",
"H2": "Hydrogen Storage",
"battery": "Battery Storage",
}
self.curtailable2label = {
"solar": "Solar Curtailment",
"onwind": "Onshore Wind Curtailment",
"offwind-ac": "Offshore Wind Curtailment (AC)",
"offwind-dc": "Offshore Wind Curtailment (DC)",
}
self.label2type = {v: k for k, v in self.type2label.items()}
self.label2curtailable = {v: k for k, v in self.curtailable2label.items()}
def get_label(model):
"""Return label for generator types.
:param str model: grid model
"""
_lookup = {
"usa_tamu": USALabel,
"hifld": USALabel,
"europe_tub": EULabel,
}
return _lookup[model]().__dict__
| 1 | 0.668658 | 1 | 0.668658 | game-dev | MEDIA | 0.280403 | game-dev | 0.640214 | 1 | 0.640214 |
natbro/kaon | 23,435 | lsteamclient/lsteamclient/steamworks_sdk_123/isteamuserstats.h | //====== Copyright � 1996-2009, Valve Corporation, All rights reserved. =======
//
// Purpose: interface to stats, achievements, and leaderboards
//
//=============================================================================
#ifndef ISTEAMUSERSTATS_H
#define ISTEAMUSERSTATS_H
#ifdef _WIN32
#pragma once
#endif
#include "isteamclient.h"
#include "isteamremotestorage.h"
// size limit on stat or achievement name (UTF-8 encoded)
enum { k_cchStatNameMax = 128 };
// maximum number of bytes for a leaderboard name (UTF-8 encoded)
enum { k_cchLeaderboardNameMax = 128 };
// maximum number of details int32's storable for a single leaderboard entry
enum { k_cLeaderboardDetailsMax = 64 };
// handle to a single leaderboard
typedef uint64 SteamLeaderboard_t;
// handle to a set of downloaded entries in a leaderboard
typedef uint64 SteamLeaderboardEntries_t;
// type of data request, when downloading leaderboard entries
enum ELeaderboardDataRequest
{
k_ELeaderboardDataRequestGlobal = 0,
k_ELeaderboardDataRequestGlobalAroundUser = 1,
k_ELeaderboardDataRequestFriends = 2,
k_ELeaderboardDataRequestUsers = 3
};
// the sort order of a leaderboard
enum ELeaderboardSortMethod
{
k_ELeaderboardSortMethodNone = 0,
k_ELeaderboardSortMethodAscending = 1, // top-score is lowest number
k_ELeaderboardSortMethodDescending = 2, // top-score is highest number
};
// the display type (used by the Steam Community web site) for a leaderboard
enum ELeaderboardDisplayType
{
k_ELeaderboardDisplayTypeNone = 0,
k_ELeaderboardDisplayTypeNumeric = 1, // simple numerical score
k_ELeaderboardDisplayTypeTimeSeconds = 2, // the score represents a time, in seconds
k_ELeaderboardDisplayTypeTimeMilliSeconds = 3, // the score represents a time, in milliseconds
};
enum ELeaderboardUploadScoreMethod
{
k_ELeaderboardUploadScoreMethodNone = 0,
k_ELeaderboardUploadScoreMethodKeepBest = 1, // Leaderboard will keep user's best score
k_ELeaderboardUploadScoreMethodForceUpdate = 2, // Leaderboard will always replace score with specified
};
// a single entry in a leaderboard, as returned by GetDownloadedLeaderboardEntry()
#if defined( VALVE_CALLBACK_PACK_SMALL )
#pragma pack( push, 4 )
#elif defined( VALVE_CALLBACK_PACK_LARGE )
#pragma pack( push, 8 )
#else
#error isteamclient.h must be included
#endif
struct LeaderboardEntry_t
{
CSteamID m_steamIDUser; // user with the entry - use SteamFriends()->GetFriendPersonaName() & SteamFriends()->GetFriendAvatar() to get more info
int32 m_nGlobalRank; // [1..N], where N is the number of users with an entry in the leaderboard
int32 m_nScore; // score as set in the leaderboard
int32 m_cDetails; // number of int32 details available for this entry
UGCHandle_t m_hUGC; // handle for UGC attached to the entry
};
#pragma pack( pop )
//-----------------------------------------------------------------------------
// Purpose: Functions for accessing stats, achievements, and leaderboard information
//-----------------------------------------------------------------------------
class ISteamUserStats
{
public:
// Ask the server to send down this user's data and achievements for this game
virtual bool RequestCurrentStats() = 0;
// Data accessors
virtual bool GetStat( const char *pchName, int32 *pData ) = 0;
virtual bool GetStat( const char *pchName, float *pData ) = 0;
// Set / update data
virtual bool SetStat( const char *pchName, int32 nData ) = 0;
virtual bool SetStat( const char *pchName, float fData ) = 0;
virtual bool UpdateAvgRateStat( const char *pchName, float flCountThisSession, double dSessionLength ) = 0;
// Achievement flag accessors
virtual bool GetAchievement( const char *pchName, bool *pbAchieved ) = 0;
virtual bool SetAchievement( const char *pchName ) = 0;
virtual bool ClearAchievement( const char *pchName ) = 0;
// Get the achievement status, and the time it was unlocked if unlocked.
// If the return value is true, but the unlock time is zero, that means it was unlocked before Steam
// began tracking achievement unlock times (December 2009). Time is seconds since January 1, 1970.
virtual bool GetAchievementAndUnlockTime( const char *pchName, bool *pbAchieved, uint32 *punUnlockTime ) = 0;
// Store the current data on the server, will get a callback when set
// And one callback for every new achievement
//
// If the callback has a result of k_EResultInvalidParam, one or more stats
// uploaded has been rejected, either because they broke constraints
// or were out of date. In this case the server sends back updated values.
// The stats should be re-iterated to keep in sync.
virtual bool StoreStats() = 0;
// Achievement / GroupAchievement metadata
// Gets the icon of the achievement, which is a handle to be used in ISteamUtils::GetImageRGBA(), or 0 if none set.
// A return value of 0 may indicate we are still fetching data, and you can wait for the UserAchievementIconFetched_t callback
// which will notify you when the bits are ready. If the callback still returns zero, then there is no image set for the
// specified achievement.
virtual int GetAchievementIcon( const char *pchName ) = 0;
// Get general attributes for an achievement. Accepts the following keys:
// - "name" and "desc" for retrieving the localized achievement name and description (returned in UTF8)
// - "hidden" for retrieving if an achievement is hidden (returns "0" when not hidden, "1" when hidden)
virtual const char *GetAchievementDisplayAttribute( const char *pchName, const char *pchKey ) = 0;
// Achievement progress - triggers an AchievementProgress callback, that is all.
// Calling this w/ N out of N progress will NOT set the achievement, the game must still do that.
virtual bool IndicateAchievementProgress( const char *pchName, uint32 nCurProgress, uint32 nMaxProgress ) = 0;
// Used for iterating achievements. In general games should not need these functions because they should have a
// list of existing achievements compiled into them
virtual uint32 GetNumAchievements() = 0;
// Get achievement name iAchievement in [0,GetNumAchievements)
virtual const char *GetAchievementName( uint32 iAchievement ) = 0;
// Friends stats & achievements
// downloads stats for the user
// returns a UserStatsReceived_t received when completed
// if the other user has no stats, UserStatsReceived_t.m_eResult will be set to k_EResultFail
// these stats won't be auto-updated; you'll need to call RequestUserStats() again to refresh any data
virtual SteamAPICall_t RequestUserStats( CSteamID steamIDUser ) = 0;
// requests stat information for a user, usable after a successful call to RequestUserStats()
virtual bool GetUserStat( CSteamID steamIDUser, const char *pchName, int32 *pData ) = 0;
virtual bool GetUserStat( CSteamID steamIDUser, const char *pchName, float *pData ) = 0;
virtual bool GetUserAchievement( CSteamID steamIDUser, const char *pchName, bool *pbAchieved ) = 0;
// See notes for GetAchievementAndUnlockTime above
virtual bool GetUserAchievementAndUnlockTime( CSteamID steamIDUser, const char *pchName, bool *pbAchieved, uint32 *punUnlockTime ) = 0;
// Reset stats
virtual bool ResetAllStats( bool bAchievementsToo ) = 0;
// Leaderboard functions
// asks the Steam back-end for a leaderboard by name, and will create it if it's not yet
// This call is asynchronous, with the result returned in LeaderboardFindResult_t
virtual SteamAPICall_t FindOrCreateLeaderboard( const char *pchLeaderboardName, ELeaderboardSortMethod eLeaderboardSortMethod, ELeaderboardDisplayType eLeaderboardDisplayType ) = 0;
// as above, but won't create the leaderboard if it's not found
// This call is asynchronous, with the result returned in LeaderboardFindResult_t
virtual SteamAPICall_t FindLeaderboard( const char *pchLeaderboardName ) = 0;
// returns the name of a leaderboard
virtual const char *GetLeaderboardName( SteamLeaderboard_t hSteamLeaderboard ) = 0;
// returns the total number of entries in a leaderboard, as of the last request
virtual int GetLeaderboardEntryCount( SteamLeaderboard_t hSteamLeaderboard ) = 0;
// returns the sort method of the leaderboard
virtual ELeaderboardSortMethod GetLeaderboardSortMethod( SteamLeaderboard_t hSteamLeaderboard ) = 0;
// returns the display type of the leaderboard
virtual ELeaderboardDisplayType GetLeaderboardDisplayType( SteamLeaderboard_t hSteamLeaderboard ) = 0;
// Asks the Steam back-end for a set of rows in the leaderboard.
// This call is asynchronous, with the result returned in LeaderboardScoresDownloaded_t
// LeaderboardScoresDownloaded_t will contain a handle to pull the results from GetDownloadedLeaderboardEntries() (below)
// You can ask for more entries than exist, and it will return as many as do exist.
// k_ELeaderboardDataRequestGlobal requests rows in the leaderboard from the full table, with nRangeStart & nRangeEnd in the range [1, TotalEntries]
// k_ELeaderboardDataRequestGlobalAroundUser requests rows around the current user, nRangeStart being negate
// e.g. DownloadLeaderboardEntries( hLeaderboard, k_ELeaderboardDataRequestGlobalAroundUser, -3, 3 ) will return 7 rows, 3 before the user, 3 after
// k_ELeaderboardDataRequestFriends requests all the rows for friends of the current user
virtual SteamAPICall_t DownloadLeaderboardEntries( SteamLeaderboard_t hSteamLeaderboard, ELeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd ) = 0;
// as above, but downloads leaderboard entries for an arbitrary set of users - ELeaderboardDataRequest is k_ELeaderboardDataRequestUsers
// if a user doesn't have a leaderboard entry, they won't be included in the result
// a max of 100 users can be downloaded at a time, with only one outstanding call at a time
virtual SteamAPICall_t DownloadLeaderboardEntriesForUsers( SteamLeaderboard_t hSteamLeaderboard, CSteamID *prgUsers, int cUsers ) = 0;
// Returns data about a single leaderboard entry
// use a for loop from 0 to LeaderboardScoresDownloaded_t::m_cEntryCount to get all the downloaded entries
// e.g.
// void OnLeaderboardScoresDownloaded( LeaderboardScoresDownloaded_t *pLeaderboardScoresDownloaded )
// {
// for ( int index = 0; index < pLeaderboardScoresDownloaded->m_cEntryCount; index++ )
// {
// LeaderboardEntry_t leaderboardEntry;
// int32 details[3]; // we know this is how many we've stored previously
// GetDownloadedLeaderboardEntry( pLeaderboardScoresDownloaded->m_hSteamLeaderboardEntries, index, &leaderboardEntry, details, 3 );
// assert( leaderboardEntry.m_cDetails == 3 );
// ...
// }
// once you've accessed all the entries, the data will be free'd, and the SteamLeaderboardEntries_t handle will become invalid
virtual bool GetDownloadedLeaderboardEntry( SteamLeaderboardEntries_t hSteamLeaderboardEntries, int index, LeaderboardEntry_t *pLeaderboardEntry, int32 *pDetails, int cDetailsMax ) = 0;
// Uploads a user score to the Steam back-end.
// This call is asynchronous, with the result returned in LeaderboardScoreUploaded_t
// Details are extra game-defined information regarding how the user got that score
// pScoreDetails points to an array of int32's, cScoreDetailsCount is the number of int32's in the list
virtual SteamAPICall_t UploadLeaderboardScore( SteamLeaderboard_t hSteamLeaderboard, ELeaderboardUploadScoreMethod eLeaderboardUploadScoreMethod, int32 nScore, const int32 *pScoreDetails, int cScoreDetailsCount ) = 0;
// Attaches a piece of user generated content the user's entry on a leaderboard.
// hContent is a handle to a piece of user generated content that was shared using ISteamUserRemoteStorage::FileShare().
// This call is asynchronous, with the result returned in LeaderboardUGCSet_t.
virtual SteamAPICall_t AttachLeaderboardUGC( SteamLeaderboard_t hSteamLeaderboard, UGCHandle_t hUGC ) = 0;
// Retrieves the number of players currently playing your game (online + offline)
// This call is asynchronous, with the result returned in NumberOfCurrentPlayers_t
virtual SteamAPICall_t GetNumberOfCurrentPlayers() = 0;
// Requests that Steam fetch data on the percentage of players who have received each achievement
// for the game globally.
// This call is asynchronous, with the result returned in GlobalAchievementPercentagesReady_t.
virtual SteamAPICall_t RequestGlobalAchievementPercentages() = 0;
// Get the info on the most achieved achievement for the game, returns an iterator index you can use to fetch
// the next most achieved afterwards. Will return -1 if there is no data on achievement
// percentages (ie, you haven't called RequestGlobalAchievementPercentages and waited on the callback).
virtual int GetMostAchievedAchievementInfo( char *pchName, uint32 unNameBufLen, float *pflPercent, bool *pbAchieved ) = 0;
// Get the info on the next most achieved achievement for the game. Call this after GetMostAchievedAchievementInfo or another
// GetNextMostAchievedAchievementInfo call passing the iterator from the previous call. Returns -1 after the last
// achievement has been iterated.
virtual int GetNextMostAchievedAchievementInfo( int iIteratorPrevious, char *pchName, uint32 unNameBufLen, float *pflPercent, bool *pbAchieved ) = 0;
// Returns the percentage of users who have achieved the specified achievement.
virtual bool GetAchievementAchievedPercent( const char *pchName, float *pflPercent ) = 0;
// Requests global stats data, which is available for stats marked as "aggregated".
// This call is asynchronous, with the results returned in GlobalStatsReceived_t.
// nHistoryDays specifies how many days of day-by-day history to retrieve in addition
// to the overall totals. The limit is 60.
virtual SteamAPICall_t RequestGlobalStats( int nHistoryDays ) = 0;
// Gets the lifetime totals for an aggregated stat
virtual bool GetGlobalStat( const char *pchStatName, int64 *pData ) = 0;
virtual bool GetGlobalStat( const char *pchStatName, double *pData ) = 0;
// Gets history for an aggregated stat. pData will be filled with daily values, starting with today.
// So when called, pData[0] will be today, pData[1] will be yesterday, and pData[2] will be two days ago,
// etc. cubData is the size in bytes of the pubData buffer. Returns the number of
// elements actually set.
virtual int32 GetGlobalStatHistory( const char *pchStatName, int64 *pData, uint32 cubData ) = 0;
virtual int32 GetGlobalStatHistory( const char *pchStatName, double *pData, uint32 cubData ) = 0;
#ifdef _PS3
// Call to kick off installation of the PS3 trophies. This call is asynchronous, and the results will be returned in a PS3TrophiesInstalled_t
// callback.
virtual bool InstallPS3Trophies() = 0;
// Returns the amount of space required at boot to install trophies. This value can be used when comparing the amount of space needed
// by the game to the available space value passed to the game at boot. The value is set during InstallPS3Trophies().
virtual uint64 GetTrophySpaceRequiredBeforeInstall() = 0;
// On PS3, user stats & achievement progress through Steam must be stored with the user's saved game data.
// At startup, before calling RequestCurrentStats(), you must pass the user's stats data to Steam via this method.
// If you do not have any user data, call this function with pvData = NULL and cubData = 0
virtual bool SetUserStatsData( const void *pvData, uint32 cubData ) = 0;
// Call to get the user's current stats data. You should retrieve this data after receiving successful UserStatsReceived_t & UserStatsStored_t
// callbacks, and store the data with the user's save game data. You can call this method with pvData = NULL and cubData = 0 to get the required
// buffer size.
virtual bool GetUserStatsData( void *pvData, uint32 cubData, uint32 *pcubWritten ) = 0;
#endif
};
#define STEAMUSERSTATS_INTERFACE_VERSION "STEAMUSERSTATS_INTERFACE_VERSION011"
// callbacks
#if defined( VALVE_CALLBACK_PACK_SMALL )
#pragma pack( push, 4 )
#elif defined( VALVE_CALLBACK_PACK_LARGE )
#pragma pack( push, 8 )
#else
#error isteamclient.h must be included
#endif
//-----------------------------------------------------------------------------
// Purpose: called when the latests stats and achievements have been received
// from the server
//-----------------------------------------------------------------------------
struct UserStatsReceived_t
{
enum { k_iCallback = k_iSteamUserStatsCallbacks + 1 };
uint64 m_nGameID; // Game these stats are for
EResult m_eResult; // Success / error fetching the stats
CSteamID m_steamIDUser; // The user for whom the stats are retrieved for
};
//-----------------------------------------------------------------------------
// Purpose: result of a request to store the user stats for a game
//-----------------------------------------------------------------------------
struct UserStatsStored_t
{
enum { k_iCallback = k_iSteamUserStatsCallbacks + 2 };
uint64 m_nGameID; // Game these stats are for
EResult m_eResult; // success / error
};
//-----------------------------------------------------------------------------
// Purpose: result of a request to store the achievements for a game, or an
// "indicate progress" call. If both m_nCurProgress and m_nMaxProgress
// are zero, that means the achievement has been fully unlocked.
//-----------------------------------------------------------------------------
struct UserAchievementStored_t
{
enum { k_iCallback = k_iSteamUserStatsCallbacks + 3 };
uint64 m_nGameID; // Game this is for
bool m_bGroupAchievement; // if this is a "group" achievement
char m_rgchAchievementName[k_cchStatNameMax]; // name of the achievement
uint32 m_nCurProgress; // current progress towards the achievement
uint32 m_nMaxProgress; // "out of" this many
};
//-----------------------------------------------------------------------------
// Purpose: call result for finding a leaderboard, returned as a result of FindOrCreateLeaderboard() or FindLeaderboard()
// use CCallResult<> to map this async result to a member function
//-----------------------------------------------------------------------------
struct LeaderboardFindResult_t
{
enum { k_iCallback = k_iSteamUserStatsCallbacks + 4 };
SteamLeaderboard_t m_hSteamLeaderboard; // handle to the leaderboard serarched for, 0 if no leaderboard found
uint8 m_bLeaderboardFound; // 0 if no leaderboard found
};
//-----------------------------------------------------------------------------
// Purpose: call result indicating scores for a leaderboard have been downloaded and are ready to be retrieved, returned as a result of DownloadLeaderboardEntries()
// use CCallResult<> to map this async result to a member function
//-----------------------------------------------------------------------------
struct LeaderboardScoresDownloaded_t
{
enum { k_iCallback = k_iSteamUserStatsCallbacks + 5 };
SteamLeaderboard_t m_hSteamLeaderboard;
SteamLeaderboardEntries_t m_hSteamLeaderboardEntries; // the handle to pass into GetDownloadedLeaderboardEntries()
int m_cEntryCount; // the number of entries downloaded
};
//-----------------------------------------------------------------------------
// Purpose: call result indicating scores has been uploaded, returned as a result of UploadLeaderboardScore()
// use CCallResult<> to map this async result to a member function
//-----------------------------------------------------------------------------
struct LeaderboardScoreUploaded_t
{
enum { k_iCallback = k_iSteamUserStatsCallbacks + 6 };
uint8 m_bSuccess; // 1 if the call was successful
SteamLeaderboard_t m_hSteamLeaderboard; // the leaderboard handle that was
int32 m_nScore; // the score that was attempted to set
uint8 m_bScoreChanged; // true if the score in the leaderboard change, false if the existing score was better
int m_nGlobalRankNew; // the new global rank of the user in this leaderboard
int m_nGlobalRankPrevious; // the previous global rank of the user in this leaderboard; 0 if the user had no existing entry in the leaderboard
};
struct NumberOfCurrentPlayers_t
{
enum { k_iCallback = k_iSteamUserStatsCallbacks + 7 };
uint8 m_bSuccess; // 1 if the call was successful
int32 m_cPlayers; // Number of players currently playing
};
//-----------------------------------------------------------------------------
// Purpose: Callback indicating that a user's stats have been unloaded.
// Call RequestUserStats again to access stats for this user
//-----------------------------------------------------------------------------
struct UserStatsUnloaded_t
{
enum { k_iCallback = k_iSteamUserStatsCallbacks + 8 };
CSteamID m_steamIDUser; // User whose stats have been unloaded
};
//-----------------------------------------------------------------------------
// Purpose: Callback indicating that an achievement icon has been fetched
//-----------------------------------------------------------------------------
struct UserAchievementIconFetched_t
{
enum { k_iCallback = k_iSteamUserStatsCallbacks + 9 };
CGameID m_nGameID; // Game this is for
char m_rgchAchievementName[k_cchStatNameMax]; // name of the achievement
bool m_bAchieved; // Is the icon for the achieved or not achieved version?
int m_nIconHandle; // Handle to the image, which can be used in SteamUtils()->GetImageRGBA(), 0 means no image is set for the achievement
};
//-----------------------------------------------------------------------------
// Purpose: Callback indicating that global achievement percentages are fetched
//-----------------------------------------------------------------------------
struct GlobalAchievementPercentagesReady_t
{
enum { k_iCallback = k_iSteamUserStatsCallbacks + 10 };
uint64 m_nGameID; // Game this is for
EResult m_eResult; // Result of the operation
};
//-----------------------------------------------------------------------------
// Purpose: call result indicating UGC has been uploaded, returned as a result of SetLeaderboardUGC()
//-----------------------------------------------------------------------------
struct LeaderboardUGCSet_t
{
enum { k_iCallback = k_iSteamUserStatsCallbacks + 11 };
EResult m_eResult; // The result of the operation
SteamLeaderboard_t m_hSteamLeaderboard; // the leaderboard handle that was
};
//-----------------------------------------------------------------------------
// Purpose: callback indicating that PS3 trophies have been installed
//-----------------------------------------------------------------------------
struct PS3TrophiesInstalled_t
{
enum { k_iCallback = k_iSteamUserStatsCallbacks + 12 };
uint64 m_nGameID; // Game these stats are for
EResult m_eResult; // The result of the operation
uint64 m_ulRequiredDiskSpace; // If m_eResult is k_EResultDiskFull, will contain the amount of space needed to install trophies
};
//-----------------------------------------------------------------------------
// Purpose: callback indicating global stats have been received.
// Returned as a result of RequestGlobalStats()
//-----------------------------------------------------------------------------
struct GlobalStatsReceived_t
{
enum { k_iCallback = k_iSteamUserStatsCallbacks + 12 };
uint64 m_nGameID; // Game global stats were requested for
EResult m_eResult; // The result of the request
};
#pragma pack( pop )
#endif // ISTEAMUSER_H
| 1 | 0.872355 | 1 | 0.872355 | game-dev | MEDIA | 0.357824 | game-dev | 0.837471 | 1 | 0.837471 |
qcad/qcad | 3,720 | src/3rdparty/legacy/spatialindexnavel/src/rtree/PointerPoolNode.h | /******************************************************************************
* Project: libspatialindex - A C++ library for spatial indexing
* Author: Marios Hadjieleftheriou, mhadji@gmail.com
******************************************************************************
* Copyright (c) 2002, Marios Hadjieleftheriou
*
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
******************************************************************************/
#ifndef __spatialindex_rtree_pointer_pool_node_h
#define __spatialindex_rtree_pointer_pool_node_h
#include "Node.h"
namespace Tools
{
using namespace SpatialIndex;
template<> class PointerPool<RTree::Node>
{
public:
explicit PointerPool(uint32_t capacity) : m_capacity(capacity)
{
#ifndef NDEBUG
m_hits = 0;
m_misses = 0;
m_pointerCount = 0;
#endif
}
~PointerPool()
{
assert(m_pool.size() <= m_capacity);
while (! m_pool.empty())
{
RTree::Node* x = m_pool.top(); m_pool.pop();
#ifndef NDEBUG
--m_pointerCount;
#endif
delete x;
}
#ifndef NDEBUG
std::cerr << "Lost pointers: " << m_pointerCount << std::endl;
#endif
}
PoolPointer<RTree::Node> acquire()
{
if (! m_pool.empty())
{
RTree::Node* p = m_pool.top(); m_pool.pop();
#ifndef NDEBUG
++m_hits;
#endif
return PoolPointer<RTree::Node>(p, this);
}
#ifndef NDEBUG
else
{
// fixme: well sort of...
++m_pointerCount;
++m_misses;
}
#endif
return PoolPointer<RTree::Node>();
}
void release(RTree::Node* p)
{
if (p != 0)
{
if (m_pool.size() < m_capacity)
{
if (p->m_pData != 0)
{
for (uint32_t cChild = 0; cChild < p->m_children; ++cChild)
{
// there is no need to set the pointer to zero, after deleting it,
// since it will be redeleted only if it is actually initialized again,
// a fact that will be depicted by variable m_children.
if (p->m_pData[cChild] != 0) delete[] p->m_pData[cChild];
}
}
p->m_level = 0;
p->m_identifier = -1;
p->m_children = 0;
p->m_totalDataLength = 0;
m_pool.push(p);
}
else
{
#ifndef NDEBUG
--m_pointerCount;
#endif
delete p;
}
assert(m_pool.size() <= m_capacity);
}
}
uint32_t getCapacity() const { return m_capacity; }
void setCapacity(uint32_t c)
{
assert (c >= 0);
m_capacity = c;
}
protected:
uint32_t m_capacity;
std::stack<RTree::Node*> m_pool;
#ifndef NDEBUG
public:
uint64_t m_hits;
uint64_t m_misses;
uint64_t m_pointerCount;
#endif
};
}
#endif /* __spatialindex_rtree_pointer_pool_node_h */
| 1 | 0.970028 | 1 | 0.970028 | game-dev | MEDIA | 0.292195 | game-dev | 0.91627 | 1 | 0.91627 |
HbmMods/Hbm-s-Nuclear-Tech-GIT | 2,229 | src/main/java/com/hbm/blocks/machine/albion/BlockPADetector.java | package com.hbm.blocks.machine.albion;
import java.util.List;
import com.hbm.blocks.BlockDummyable;
import com.hbm.blocks.ITooltipProvider;
import com.hbm.lib.RefStrings;
import com.hbm.main.MainRegistry;
import com.hbm.tileentity.TileEntityProxyCombo;
import com.hbm.tileentity.machine.albion.TileEntityPADetector;
import net.minecraft.block.material.Material;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import net.minecraftforge.common.util.ForgeDirection;
public class BlockPADetector extends BlockDummyable implements ITooltipProvider {
public BlockPADetector() {
super(Material.iron);
this.setCreativeTab(MainRegistry.machineTab);
this.setBlockTextureName(RefStrings.MODID + ":block_steel");
}
@Override
public TileEntity createNewTileEntity(World world, int meta) {
if(meta >= 12) return new TileEntityPADetector();
if(meta >= 6) return new TileEntityProxyCombo().inventory().power().fluid();
return null;
}
@Override
public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float hitX, float hitY, float hitZ) {
return standardOpenBehavior(world, x, y, z, player, side);
}
@Override public int[] getDimensions() { return new int[] {2, 2, 2, 2, 4, 4}; }
@Override public int getOffset() { return 0; }
@Override public int getHeightOffset() { return 2; }
@Override
public void fillSpace(World world, int x, int y, int z, ForgeDirection dir, int o) {
super.fillSpace(world, x, y, z, dir, o);
ForgeDirection rot = dir.getRotation(ForgeDirection.UP);
this.makeExtra(world, x - rot.offsetX * 4, y, z - rot.offsetZ * 4);
this.makeExtra(world, x - rot.offsetX * 4, y + 1, z - rot.offsetZ * 4);
this.makeExtra(world, x - rot.offsetX * 4, y - 1, z - rot.offsetZ * 4);
this.makeExtra(world, x - rot.offsetX * 4 + dir.offsetX, y, z - rot.offsetZ * 4 + dir.offsetZ);
this.makeExtra(world, x - rot.offsetX * 4 - dir.offsetX, y, z - rot.offsetZ * 4 - dir.offsetZ);
}
@Override
public void addInformation(ItemStack stack, EntityPlayer player, List list, boolean ext) {
addStandardInfo(stack, player, list, ext);
}
}
| 1 | 0.893191 | 1 | 0.893191 | game-dev | MEDIA | 0.989101 | game-dev | 0.815636 | 1 | 0.815636 |
DeltaV-Station/Delta-v | 1,534 | Content.Server/Movement/Systems/MobCollisionSystem.cs | using System.Numerics;
using Content.Shared.CCVar;
using Content.Shared.Movement.Components;
using Content.Shared.Movement.Systems;
using Robust.Shared.Player;
namespace Content.Server.Movement.Systems;
public sealed class MobCollisionSystem : SharedMobCollisionSystem
{
private EntityQuery<ActorComponent> _actorQuery;
public override void Initialize()
{
base.Initialize();
_actorQuery = GetEntityQuery<ActorComponent>();
SubscribeLocalEvent<MobCollisionComponent, MobCollisionMessage>(OnServerMobCollision);
}
private void OnServerMobCollision(Entity<MobCollisionComponent> ent, ref MobCollisionMessage args)
{
MoveMob((ent.Owner, ent.Comp, Transform(ent.Owner)), args.Direction, args.SpeedModifier);
}
public override void Update(float frameTime)
{
if (!CfgManager.GetCVar(CCVars.MovementMobPushing))
return;
var query = EntityQueryEnumerator<MobCollisionComponent>();
while (query.MoveNext(out var uid, out var comp))
{
if (_actorQuery.HasComp(uid) || !PhysicsQuery.TryComp(uid, out var physics))
continue;
HandleCollisions((uid, comp, physics), frameTime);
}
base.Update(frameTime);
}
protected override void RaiseCollisionEvent(EntityUid uid, Vector2 direction, float speedMod)
{
RaiseLocalEvent(uid, new MobCollisionMessage()
{
Direction = direction,
SpeedModifier = speedMod,
});
}
}
| 1 | 0.862895 | 1 | 0.862895 | game-dev | MEDIA | 0.972562 | game-dev | 0.955 | 1 | 0.955 |
Jplamo13/Wurst | 4,377 | src/main/java/io/github/betterclient/snaptap/SnapTap.java | package io.github.betterclient.snaptap;
import net.fabricmc.api.ModInitializer;
import net.fabricmc.fabric.api.client.networking.v1.ClientPlayConnectionEvents;
import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking;
import net.minecraft.client.MinecraftClient;
import net.minecraft.client.gui.DrawContext;
import net.minecraft.client.option.KeyBinding;
import net.minecraft.client.util.InputUtil;
import net.minecraft.network.packet.CustomPayload;
import net.minecraft.text.Style;
import net.minecraft.text.Text;
import net.minecraft.util.Formatting;
import net.minecraft.util.Identifier;
public class SnapTap implements ModInitializer {
public static long LEFT_STRAFE_LAST_PRESS_TIME = 0;
public static long RIGHT_STRAFE_LAST_PRESS_TIME = 0;
public static KeyBinding TOGGLE_BIND;
public static boolean TOGGLED = true;
public static KeyBinding KEYSTROKES_TOGGLE_BIND;
public static boolean KEYSTROKES_TOGGLED = true;
private static boolean SERVER_ALLOWS = true;
private static boolean PRE_SERVER_ALLOWS = true;
@Override
public void onInitialize() {
LEFT_STRAFE_LAST_PRESS_TIME = 0;
RIGHT_STRAFE_LAST_PRESS_TIME = 0;
TOGGLE_BIND = new KeyBinding("text.snaptap.toggle", InputUtil.GLFW_KEY_F8, "key.categories.misc") {
@Override
public void setPressed(boolean pressed) {
if(pressed) {
TOGGLED = !TOGGLED;
MinecraftClient.getInstance().inGameHud.getChatHud().addMessage(
Text.translatable("text.snaptap.toggled",
Text.translatable(TOGGLED ? "text.snaptap.enabled" : "options.ao.off")
.fillStyle(Style.EMPTY
.withColor(TOGGLED ? Formatting.GREEN : Formatting.RED))));
}
super.setPressed(pressed);
}
};
KEYSTROKES_TOGGLE_BIND = new KeyBinding("text.snaptap.keystrokestoggle", InputUtil.GLFW_KEY_F7, "key.categories.misc") {
@Override
public void setPressed(boolean pressed) {
if (!SERVER_ALLOWS) {
TOGGLED = false;
super.setPressed(pressed);
return;
}
if(pressed) {
KEYSTROKES_TOGGLED = !KEYSTROKES_TOGGLED;
MinecraftClient.getInstance().inGameHud.getChatHud().addMessage(
Text.translatable("text.snaptap.toggledkeystokes",
Text.translatable(KEYSTROKES_TOGGLED ? "text.snaptap.enabled" : "options.ao.off")
.fillStyle(Style.EMPTY
.withColor(KEYSTROKES_TOGGLED ? Formatting.GREEN : Formatting.RED))));
}
super.setPressed(pressed);
}
};
ClientPlayNetworking.registerGlobalReceiver(new CustomPayload.Id<>(Identifier.of("snaptap", "update_status")), (payload, context) -> {
PRE_SERVER_ALLOWS = TOGGLED;
TOGGLED = false;
SERVER_ALLOWS = false;
});
ClientPlayConnectionEvents.DISCONNECT.register((handler, client) -> {
TOGGLED = PRE_SERVER_ALLOWS;
SERVER_ALLOWS = true;
});
}
public static void render(DrawContext context) {
MinecraftClient client = MinecraftClient.getInstance();
KeyBinding leftKey = client.options.leftKey;
KeyBinding rightKey = client.options.rightKey;
KeybindingAccess left = (KeybindingAccess) leftKey;
KeybindingAccess right = (KeybindingAccess) rightKey;
if (left.snapTap$isPressedReal()) {
context.fill(5, 5, 25, 25, 0xFF444444);
} else {
context.fill(5, 5, 25, 25, 0xFF000000);
}
if (right.snapTap$isPressedReal()) {
context.fill(30, 5, 50, 25, 0xFF444444);
} else {
context.fill(30, 5, 50, 25, 0xFF000000);
}
context.drawCenteredTextWithShadow(client.textRenderer, leftKey.getBoundKeyLocalizedText(), 15, 11, -1);
context.drawCenteredTextWithShadow(client.textRenderer, rightKey.getBoundKeyLocalizedText(), 40, 11, -1);
}
}
| 1 | 0.918041 | 1 | 0.918041 | game-dev | MEDIA | 0.753825 | game-dev | 0.969662 | 1 | 0.969662 |
AngryAnt/UnityHacks | 3,405 | Assets/Logic/Examples/Bundles/Tools/Editor/PrefabBundle.cs | using UnityEngine;
using UnityEditor;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
namespace CrossPlatformTools
{
public class PrefabBundle
{
[MenuItem ("Assets/PrefabBundle")]
public static void BuildBundles ()
{
foreach (string bundlePath in GetPrefabBundles ())
{
BuildBundle (bundlePath);
}
}
public static bool BuildBundle (string path)
// TODO: Hold prefab paths in its own list so you only load the prefabs once
{
string manifestPath = path + "/" + "Manifest.asset";
if (AssetDatabase.LoadMainAssetAtPath (manifestPath) != null)
// Bail if manifest is found. Don't want to build a bundle twice.
{
Debug.LogError (string.Format (
"Bundle at {0} already built. Found manifest.",
path
));
return false;
}
// TODO: Bail if a non-prefab asset from this bundle is referenced from outside of it
List<string> prefabs = new List<string> (ListPrefabs (path));
// TODO: Remove all prefabs not referenced outside of the bundle
List<BundledPrefab> bundledPrefabs = new List<BundledPrefab> ();
PrefabBundleManifest manifest = PrefabBundleManifest.Create ();
foreach (string prefab in prefabs)
{
bundledPrefabs.Add (manifest.Add (AssetDatabase.LoadMainAssetAtPath (prefab)));
}
AssetDatabase.CreateAsset (manifest, manifestPath);
AssetDatabase.Refresh ();
List<string> allAssetPaths = ListAllAssets (path);
BuildPipeline.BuildAssetBundle (
AssetDatabase.LoadMainAssetAtPath (manifestPath),
allAssetPaths.ConvertAll (
assetPath => AssetDatabase.LoadMainAssetAtPath (assetPath)
).ToArray (),
Application.dataPath + "/../" + manifest.ID + ".unity3d",
BuildAssetBundleOptions.CompleteAssets | BuildAssetBundleOptions.CollectDependencies,
EditorUserBuildSettings.activeBuildTarget
);
foreach (string prefab in prefabs)
{
AssetDatabase.CopyAsset (
prefab,
prefab.Substring (0, prefab.Length - "prefab".Length) + "original.prefab"
);
}
AssetDatabase.Refresh ();
for (int i = 0; i < prefabs.Count; i++)
{
PrefabUtility.ReplacePrefab (
bundledPrefabs[i].gameObject,
AssetDatabase.LoadMainAssetAtPath (prefabs[i]),
ReplacePrefabOptions.ReplaceNameBased
);
Object.DestroyImmediate (bundledPrefabs[i].gameObject);
}
return true;
}
static string[] ListPrefabs (string path)
{
string pathPrefix = Application.dataPath + "/../";
path = pathPrefix + path;
return System.Array.ConvertAll (
Directory.GetFiles (
path,
"*.prefab",
SearchOption.AllDirectories
),
fullPath => fullPath.Substring (pathPrefix.Length)
);
}
static List<string> ListAllAssets (string path, List<string> excluded = null)
{
string pathPrefix = Application.dataPath + "/../";
path = pathPrefix + path;
List<string> assets = new List<string> ();
foreach (string filePath in Directory.GetFiles (path, "*", SearchOption.AllDirectories))
{
string assetPath = filePath.Substring (pathPrefix.Length);
if (Path.GetExtension (assetPath) == ".meta" || (excluded != null && excluded.Contains (assetPath)))
{
continue;
}
assets.Add (assetPath);
}
return assets;
}
static string[] GetPrefabBundles ()
{
return new string[] { "Assets/Prefabs/Example.prefabBundle" };
}
}
}
| 1 | 0.854356 | 1 | 0.854356 | game-dev | MEDIA | 0.898323 | game-dev | 0.895217 | 1 | 0.895217 |
magefree/mage | 1,900 | Mage.Sets/src/mage/cards/s/SurtlandFrostpyre.java | package mage.cards.s;
import mage.abilities.Ability;
import mage.abilities.common.ActivateAsSorceryActivatedAbility;
import mage.abilities.common.EntersBattlefieldTappedAbility;
import mage.abilities.costs.common.SacrificeSourceCost;
import mage.abilities.costs.common.TapSourceCost;
import mage.abilities.costs.mana.ManaCostsImpl;
import mage.abilities.effects.common.DamageAllEffect;
import mage.abilities.effects.keyword.ScryEffect;
import mage.abilities.mana.RedManaAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Zone;
import mage.filter.StaticFilters;
import java.util.UUID;
/**
* @author TheElk801
*/
public final class SurtlandFrostpyre extends CardImpl {
public SurtlandFrostpyre(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.LAND}, "");
// Surtland Frostpyre enters the battlefield tapped.
this.addAbility(new EntersBattlefieldTappedAbility());
// {T}: Add {R}.
this.addAbility(new RedManaAbility());
// {2}{U}{U}{R}, {T}, Sacrifice Surtland Frostpyre: Scry 2. Surtland Frostpyre deals 2 damage to each creature. Activate this ability only any time you could cast a sorcery.
Ability ability = new ActivateAsSorceryActivatedAbility(
Zone.BATTLEFIELD,
new ScryEffect(2).setText("Scry 2."),
new ManaCostsImpl<>("{2}{U}{U}{R}")
);
ability.addCost(new TapSourceCost());
ability.addCost(new SacrificeSourceCost());
ability.addEffect(new DamageAllEffect(2, StaticFilters.FILTER_PERMANENT_CREATURE));
this.addAbility(ability);
}
private SurtlandFrostpyre(final SurtlandFrostpyre card) {
super(card);
}
@Override
public SurtlandFrostpyre copy() {
return new SurtlandFrostpyre(this);
}
}
| 1 | 0.882202 | 1 | 0.882202 | game-dev | MEDIA | 0.95572 | game-dev | 0.994726 | 1 | 0.994726 |
magefree/mage | 3,338 | Mage.Sets/src/mage/cards/b/BreathstealersCrypt.java | package mage.cards.b;
import java.util.UUID;
import mage.abilities.Ability;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.costs.common.PayLifeCost;
import mage.abilities.effects.ReplacementEffectImpl;
import mage.cards.*;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.constants.Outcome;
import mage.game.Game;
import mage.game.events.GameEvent;
import mage.players.Player;
/**
* @author jeffwadsworth
*/
public final class BreathstealersCrypt extends CardImpl {
public BreathstealersCrypt(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.ENCHANTMENT}, "{2}{U}{B}");
// If a player would draw a card, instead they draw a card and reveals it. If it's a creature card, that player discards it unless they pay 3 life.
this.addAbility(new SimpleStaticAbility(new BreathstealersCryptEffect()));
}
private BreathstealersCrypt(final BreathstealersCrypt card) {
super(card);
}
@Override
public BreathstealersCrypt copy() {
return new BreathstealersCrypt(this);
}
}
class BreathstealersCryptEffect extends ReplacementEffectImpl {
BreathstealersCryptEffect() {
super(Duration.WhileOnBattlefield, Outcome.LoseLife);
staticText = "If a player would draw a card, instead they draw a card and reveal it. " +
"If it's a creature card, that player discards it unless they pay 3 life";
}
private BreathstealersCryptEffect(final BreathstealersCryptEffect effect) {
super(effect);
}
@Override
public BreathstealersCryptEffect copy() {
return new BreathstealersCryptEffect(this);
}
@Override
public boolean replaceEvent(GameEvent event, Ability source, Game game) {
Player player = game.getPlayer(event.getPlayerId());
if (player == null) {
return false;
}
Card cardDrawn = player.getLibrary().getFromTop(game);
// Gatherer ruling (2007-02-01)
// If the draw is replaced by another effect, none of the rest of Fa’adiyah Seer’s ability applies,
// even if the draw is replaced by another draw (such as with Enduring Renewal).
if (cardDrawn == null || player.drawCards(1, source, game, event) != 1) {
return true;
}
player.revealCards(source, new CardsImpl(cardDrawn), game);
if (!cardDrawn.isCreature(game)) {
return true;
}
game.informPlayers("The card drawn by " + player.getName() + " is a creature card. They discard that card unless they pay 3 life.");
PayLifeCost cost = new PayLifeCost(3);
if (!cost.canPay(source, source, player.getId(), game)
|| !player.chooseUse(outcome, "Pay 3 life or discard " + cardDrawn.getIdName() + "?", null, "Pay 3 life", "Discard", source, game)
|| !cost.pay(source, game, source, player.getId(), true, cost)) {
player.discard(cardDrawn, false, source, game);
}
return true;
}
@Override
public boolean checksEventType(GameEvent event, Game game) {
return event.getType() == GameEvent.EventType.DRAW_CARD;
}
@Override
public boolean applies(GameEvent event, Ability source, Game game) {
return true;
}
}
| 1 | 0.981344 | 1 | 0.981344 | game-dev | MEDIA | 0.893234 | game-dev | 0.982475 | 1 | 0.982475 |
Albeoris/Memoria | 2,966 | UnityEngine.UI/UI/Core/Layout/LayoutElement.cs | using UnityEngine.EventSystems;
namespace UnityEngine.UI
{
[AddComponentMenu("Layout/Layout Element", 140)]
[RequireComponent(typeof(RectTransform))]
[ExecuteInEditMode]
public class LayoutElement : UIBehaviour, ILayoutElement, ILayoutIgnorer
{
[SerializeField] private bool m_IgnoreLayout = false;
[SerializeField] private float m_MinWidth = -1;
[SerializeField] private float m_MinHeight = -1;
[SerializeField] private float m_PreferredWidth = -1;
[SerializeField] private float m_PreferredHeight = -1;
[SerializeField] private float m_FlexibleWidth = -1;
[SerializeField] private float m_FlexibleHeight = -1;
public virtual bool ignoreLayout { get { return m_IgnoreLayout; } set { if (SetPropertyUtility.SetStruct(ref m_IgnoreLayout, value)) SetDirty(); } }
public virtual void CalculateLayoutInputHorizontal() { }
public virtual void CalculateLayoutInputVertical() { }
public virtual float minWidth { get { return m_MinWidth; } set { if (SetPropertyUtility.SetStruct(ref m_MinWidth, value)) SetDirty(); } }
public virtual float minHeight { get { return m_MinHeight; } set { if (SetPropertyUtility.SetStruct(ref m_MinHeight, value)) SetDirty(); } }
public virtual float preferredWidth { get { return m_PreferredWidth; } set { if (SetPropertyUtility.SetStruct(ref m_PreferredWidth, value)) SetDirty(); } }
public virtual float preferredHeight { get { return m_PreferredHeight; } set { if (SetPropertyUtility.SetStruct(ref m_PreferredHeight, value)) SetDirty(); } }
public virtual float flexibleWidth { get { return m_FlexibleWidth; } set { if (SetPropertyUtility.SetStruct(ref m_FlexibleWidth, value)) SetDirty(); } }
public virtual float flexibleHeight { get { return m_FlexibleHeight; } set { if (SetPropertyUtility.SetStruct(ref m_FlexibleHeight, value)) SetDirty(); } }
public virtual int layoutPriority { get { return 1; } }
protected LayoutElement()
{ }
#region Unity Lifetime calls
protected override void OnEnable()
{
base.OnEnable();
SetDirty();
}
protected override void OnTransformParentChanged()
{
SetDirty();
}
protected override void OnDisable()
{
SetDirty();
base.OnDisable();
}
protected override void OnDidApplyAnimationProperties()
{
SetDirty();
}
protected override void OnBeforeTransformParentChanged()
{
SetDirty();
}
#endregion
protected void SetDirty()
{
if (!IsActive())
return;
LayoutRebuilder.MarkLayoutForRebuild(transform as RectTransform);
}
#if UNITY_EDITOR
protected override void OnValidate()
{
SetDirty();
}
#endif
}
}
| 1 | 0.91794 | 1 | 0.91794 | game-dev | MEDIA | 0.504501 | game-dev | 0.957821 | 1 | 0.957821 |
mmalka/TheNoobBot | 1,154 | docs/updatebase_directory/Profiles/Quester/Scripts/26171.cs | WoWUnit unit = ObjectManager.GetNearestWoWUnit(ObjectManager.GetWoWUnitByEntry(questObjective.Entry, questObjective.IsDead), questObjective.IgnoreBlackList);
nManager.Wow.Helpers.Quest.GetSetIgnoreFight = true;
while(!unit.IsValid)
{
Thread.Sleep(5000);
unit = ObjectManager.GetNearestWoWUnit(ObjectManager.GetWoWUnitByEntry(questObjective.Entry, questObjective.IsDead), questObjective.IgnoreBlackList);
}
if(unit.IsValid)
{
System.Threading.Thread _worker;
MovementManager.FindTarget(unit, CombatClass.GetAggroRange);
Thread.Sleep(100);
if (MovementManager.InMovement)
{
return false;
}
_worker = new System.Threading.Thread(() => nManager.Wow.Helpers.Fight.StartFight(unit.Guid));
_worker.Start();
while(unit.HealthPercent >= 3)
{
Thread.Sleep(2000);
}
Logging.Write("Unit Below 2% HP");
Fight.StopFight();
MovementManager.Face(unit);
Thread.Sleep(2000);
Interact.InteractWith(unit.GetBaseAddress);
Thread.Sleep(1000);
ItemsManager.UseItem(ItemsManager.GetItemNameById(questObjective.UseItemId));
nManager.Wow.Helpers.Quest.GetSetIgnoreFight = false;
questObjective.IsObjectiveCompleted = true;
}
return false; | 1 | 0.884728 | 1 | 0.884728 | game-dev | MEDIA | 0.879777 | game-dev,testing-qa | 0.911844 | 1 | 0.911844 |
duckdb/duckdb-r | 4,655 | src/duckdb/src/storage/statistics/array_stats.cpp | #include "duckdb/storage/statistics/array_stats.hpp"
#include "duckdb/storage/statistics/base_statistics.hpp"
#include "duckdb/common/string_util.hpp"
#include "duckdb/common/types/vector.hpp"
#include "duckdb/common/serializer/serializer.hpp"
#include "duckdb/common/serializer/deserializer.hpp"
namespace duckdb {
void ArrayStats::Construct(BaseStatistics &stats) {
stats.child_stats = unsafe_unique_array<BaseStatistics>(new BaseStatistics[1]);
BaseStatistics::Construct(stats.child_stats[0], ArrayType::GetChildType(stats.GetType()));
}
BaseStatistics ArrayStats::CreateUnknown(LogicalType type) {
auto &child_type = ArrayType::GetChildType(type);
BaseStatistics result(std::move(type));
result.InitializeUnknown();
result.child_stats[0].Copy(BaseStatistics::CreateUnknown(child_type));
return result;
}
BaseStatistics ArrayStats::CreateEmpty(LogicalType type) {
auto &child_type = ArrayType::GetChildType(type);
BaseStatistics result(std::move(type));
result.InitializeEmpty();
result.child_stats[0].Copy(BaseStatistics::CreateEmpty(child_type));
return result;
}
void ArrayStats::Copy(BaseStatistics &stats, const BaseStatistics &other) {
D_ASSERT(stats.child_stats);
D_ASSERT(other.child_stats);
stats.child_stats[0].Copy(other.child_stats[0]);
}
const BaseStatistics &ArrayStats::GetChildStats(const BaseStatistics &stats) {
if (stats.GetStatsType() != StatisticsType::ARRAY_STATS) {
throw InternalException("ArrayStats::GetChildStats called on stats that is not a array");
}
D_ASSERT(stats.child_stats);
return stats.child_stats[0];
}
BaseStatistics &ArrayStats::GetChildStats(BaseStatistics &stats) {
if (stats.GetStatsType() != StatisticsType::ARRAY_STATS) {
throw InternalException("ArrayStats::GetChildStats called on stats that is not a array");
}
D_ASSERT(stats.child_stats);
return stats.child_stats[0];
}
void ArrayStats::SetChildStats(BaseStatistics &stats, unique_ptr<BaseStatistics> new_stats) {
if (!new_stats) {
stats.child_stats[0].Copy(BaseStatistics::CreateUnknown(ArrayType::GetChildType(stats.GetType())));
} else {
stats.child_stats[0].Copy(*new_stats);
}
}
void ArrayStats::Merge(BaseStatistics &stats, const BaseStatistics &other) {
if (other.GetType().id() == LogicalTypeId::VALIDITY) {
return;
}
auto &child_stats = ArrayStats::GetChildStats(stats);
auto &other_child_stats = ArrayStats::GetChildStats(other);
child_stats.Merge(other_child_stats);
}
void ArrayStats::Serialize(const BaseStatistics &stats, Serializer &serializer) {
auto &child_stats = ArrayStats::GetChildStats(stats);
serializer.WriteProperty(200, "child_stats", child_stats);
}
void ArrayStats::Deserialize(Deserializer &deserializer, BaseStatistics &base) {
auto &type = base.GetType();
D_ASSERT(type.id() == LogicalTypeId::ARRAY);
auto &child_type = ArrayType::GetChildType(type);
// Push the logical type of the child type to the deserialization context
deserializer.Set<const LogicalType &>(child_type);
base.child_stats[0].Copy(deserializer.ReadProperty<BaseStatistics>(200, "child_stats"));
deserializer.Unset<LogicalType>();
}
string ArrayStats::ToString(const BaseStatistics &stats) {
auto &child_stats = ArrayStats::GetChildStats(stats);
return StringUtil::Format("[%s]", child_stats.ToString());
}
void ArrayStats::Verify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count) {
auto &child_stats = ArrayStats::GetChildStats(stats);
auto &child_entry = ArrayVector::GetEntry(vector);
auto array_size = ArrayType::GetSize(vector.GetType());
UnifiedVectorFormat vdata;
vector.ToUnifiedFormat(count, vdata);
// Basically,
// 1. Count the number of valid arrays
// 2. Create a selection vector with the size of the number of valid arrays * array_size
// 3. Fill the selection vector with the offsets of all the elements in the child vector
// that exist in each valid array
// 4. Use that selection vector to verify the child stats
idx_t valid_count = 0;
for (idx_t i = 0; i < count; i++) {
auto idx = sel.get_index(i);
auto index = vdata.sel->get_index(idx);
if (vdata.validity.RowIsValid(index)) {
valid_count++;
}
}
SelectionVector element_sel(valid_count * array_size);
idx_t element_count = 0;
for (idx_t i = 0; i < count; i++) {
auto idx = sel.get_index(i);
auto index = vdata.sel->get_index(idx);
auto offset = index * array_size;
if (vdata.validity.RowIsValid(index)) {
for (idx_t elem_idx = 0; elem_idx < array_size; elem_idx++) {
element_sel.set_index(element_count++, offset + elem_idx);
}
}
}
child_stats.Verify(child_entry, element_sel, element_count);
}
} // namespace duckdb
| 1 | 0.549499 | 1 | 0.549499 | game-dev | MEDIA | 0.226046 | game-dev | 0.858362 | 1 | 0.858362 |
HongZhaoHua/jstarcraft-core | 2,089 | jstarcraft-core-cache/src/test/java/com/jstarcraft/core/cache/crud/mybatis/MyBatisRegionObject.java | package com.jstarcraft.core.cache.crud.mybatis;
import javax.persistence.Entity;
import javax.persistence.Id;
import org.apache.commons.lang3.builder.EqualsBuilder;
import org.apache.commons.lang3.builder.HashCodeBuilder;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.jstarcraft.core.cache.annotation.CacheChange;
import com.jstarcraft.core.cache.annotation.CacheConfiguration;
import com.jstarcraft.core.cache.annotation.CacheConfiguration.Unit;
import com.jstarcraft.core.common.identification.IdentityObject;
@Entity
//@TableName("MyBatisRegionObject")
@CacheConfiguration(unit = Unit.REGION, indexes = { "owner" }, transienceStrategy = "lruMemoryStrategy", persistenceStrategy = "promptPersistenceStrategy")
public class MyBatisRegionObject implements IdentityObject<Integer> {
@Id
@TableId
private Integer id;
private int owner;
MyBatisRegionObject() {
}
@Override
public Integer getId() {
return id;
}
public int getOwner() {
return owner;
}
@CacheChange(values = { "true" })
public boolean modify(int owner, boolean modify) {
this.owner = owner;
return modify;
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null)
return false;
if (!(object instanceof MyBatisRegionObject))
return false;
MyBatisRegionObject that = (MyBatisRegionObject) object;
EqualsBuilder equal = new EqualsBuilder();
equal.append(this.getId(), that.getId());
return equal.isEquals();
}
@Override
public int hashCode() {
HashCodeBuilder hash = new HashCodeBuilder();
hash.append(getId());
return hash.toHashCode();
}
public static MyBatisRegionObject instanceOf(Integer id, int owner) {
MyBatisRegionObject instance = new MyBatisRegionObject();
instance.id = id;
instance.owner = owner;
return instance;
}
}
| 1 | 0.864442 | 1 | 0.864442 | game-dev | MEDIA | 0.31015 | game-dev | 0.653326 | 1 | 0.653326 |
kolmafia/kolmafia | 2,430 | src/net/sourceforge/kolmafia/request/concoction/Crimbo07Request.java | package net.sourceforge.kolmafia.request.concoction;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import net.sourceforge.kolmafia.AdventureResult;
import net.sourceforge.kolmafia.KoLmafia;
import net.sourceforge.kolmafia.RequestLogger;
import net.sourceforge.kolmafia.objectpool.Concoction;
import net.sourceforge.kolmafia.persistence.ConcoctionDatabase;
import net.sourceforge.kolmafia.session.ResultProcessor;
import net.sourceforge.kolmafia.utilities.StringUtilities;
public class Crimbo07Request extends CreateItemRequest {
private static final Pattern CREATE_PATTERN =
Pattern.compile("crimbo07.php.*whichitem=(\\d+).*quantity=(\\d+)");
public Crimbo07Request(final Concoction conc) {
super("crimbo07.php", conc);
this.addFormField("place", "toys");
this.addFormField("action", "toys");
this.addFormField("whichitem", String.valueOf(this.getItemId()));
}
@Override
public void run() {
// Attempting to make the ingredients will pull the
// needed items from the closet if they are missing.
// In this case, it will also create the needed white
// pixels if they are not currently available.
if (!this.makeIngredients()) {
return;
}
KoLmafia.updateDisplay("Creating " + this.getQuantityNeeded() + " " + this.getName() + "...");
this.addFormField("quantity", String.valueOf(this.getQuantityNeeded()));
super.run();
}
public static final boolean registerRequest(final String urlString) {
Matcher createMatcher = Crimbo07Request.CREATE_PATTERN.matcher(urlString);
if (!createMatcher.find()) {
return false;
}
// Item ID of the base item
int itemId = StringUtilities.parseInt(createMatcher.group(1));
int quantity = StringUtilities.parseInt(createMatcher.group(2));
AdventureResult[] ingredients = ConcoctionDatabase.getIngredients(itemId);
StringBuffer text = new StringBuffer();
text.append("Combine ");
for (int i = 0; i < ingredients.length; ++i) {
if (i > 0) {
text.append(" + ");
}
text.append(ingredients[i].getCount() * quantity);
text.append(" ");
text.append(ingredients[i].getName());
ResultProcessor.processResult(
ingredients[i].getInstance(-1 * ingredients[i].getCount() * quantity));
}
RequestLogger.updateSessionLog();
RequestLogger.updateSessionLog(text.toString());
return true;
}
}
| 1 | 0.874773 | 1 | 0.874773 | game-dev | MEDIA | 0.665755 | game-dev | 0.972055 | 1 | 0.972055 |
lunduniversity/introprog | 3,901 | workspace/introprog/src/main/scala/introprog/examples/TestBlockGame.scala | package introprog.examples
/** Examples of a simple BlockGame app with overridden callbacks to handle events
* See the documentation of BlockGame and the source code of TestBlockGame
* for inspiration on how to inherit BlockGame to create your own block game.
*/
object TestBlockGame:
/** Create Game and start playing. */
def main(args: Array[String]): Unit =
println("Press Enter to toggle random blocks. Close window to continue.")
(new RandomBlocks).play()
println("Opening MovingBlock. Press Ctrl+C to exit.")
(new MovingBlock).start()
println("MovingBlock has ended.")
/** A class extending `introprog.BlockGame`, see source code. */
class RandomBlocks extends introprog.BlockGame:
sealed trait State
case object Starting extends State
case object Playing extends State
case object GameOver extends State
var state: State = Starting
var isDrawingRandomBlocks: Boolean = false
def showEnterMessage(): Unit =
drawTextInMessageArea("Press Enter to toggle random blocks.", 0,0)
def showEscapeMessage(): Unit =
drawTextInMessageArea("Press Esc to clear window.", 25, 0)
override def onKeyDown(key: String): Unit =
print(s" Key down: $key")
key match
case "Esc" =>
clearWindow()
drawCenteredText("ESCAPED TO BLACK SPACE!")
showEnterMessage()
case "Enter" =>
isDrawingRandomBlocks = !isDrawingRandomBlocks
showEnterMessage()
showEscapeMessage()
case _ =>
override def onKeyUp(key: String): Unit = print(s" Key up: $key")
override def onMouseDown(pos: (Int, Int)): Unit = print(s" Mouse down: $pos")
override def onMouseUp(pos: (Int, Int)): Unit = print(s" Mouse up: $pos")
override def onClose(): Unit =
print(" Window Closed.")
state = GameOver
override def gameLoopAction(): Unit =
import scala.util.Random.nextInt
def rndPos: (Int, Int) = (nextInt(dim._1), nextInt(dim._2))
def rndColor = new java.awt.Color(nextInt(256), nextInt(256), nextInt(256))
print(".")
if isDrawingRandomBlocks then
drawBlock(rndPos._1, rndPos._2, rndColor)
def play(): Unit =
state = Playing
println(s"framesPerSecond == $framesPerSecond")
showEnterMessage()
gameLoop(stopWhen = state == GameOver)
println("Goodbye!")
end RandomBlocks
class MovingBlock extends introprog.BlockGame(
title = "MovingBlock",
dim = (10,5),
blockSize = 40,
background = java.awt.Color.BLACK,
framesPerSecond = 50,
messageAreaHeight = 1,
messageAreaBackground = java.awt.Color.DARK_GRAY
):
var movesPerSecond: Double = 2
def millisBetweenMoves: Int = (1000 / movesPerSecond).round.toInt max 1
var _timestampLastMove: Long = System.currentTimeMillis
def timestampLastMove = _timestampLastMove
var x = 0
var y = 0
def move(): Unit =
if x == dim._1 - 1 then
x = -1
y += 1
end if
x = x+1
def erase(): Unit = drawBlock(x, y, java.awt.Color.BLACK)
def draw(): Unit = drawBlock(x, y, java.awt.Color.CYAN)
def update(): Unit =
if System.currentTimeMillis > _timestampLastMove + millisBetweenMoves then
move()
_timestampLastMove = System.currentTimeMillis()
var loopCounter: Int = 0
override def gameLoopAction(): Unit =
erase()
update()
draw()
clearMessageArea()
drawTextInMessageArea(s"Loop number: $loopCounter", 1, 0, java.awt.Color.PINK, size = 30)
loopCounter += 1
final def start(): Unit =
pixelWindow.show() // show window again if closed and start() is called again
gameLoop(stopWhen = x == dim._1 - 1 && y == dim._2 - 1)
end MovingBlock
| 1 | 0.773544 | 1 | 0.773544 | game-dev | MEDIA | 0.875474 | game-dev | 0.84269 | 1 | 0.84269 |
lian/ofx-dev | 5,576 | addons/ofxARTKPlus/gandalf/include/gandalf/vision/mask1D.h | /**
* File: $RCSfile: mask1D.h,v $
* Module: Constructing 1D Gaussian convolution masks
* Part of: Gandalf Library
*
* Revision: $Revision: 1.19 $
* Last edited: $Date: 2005/08/22 08:52:18 $
* Author: $Author: jps $
* Copyright: (c) 2000 Imagineer Software Limited
*/
/* This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef _GAN_MASK1D_H
#define _GAN_MASK1D_H
#include <gandalf/common/misc_defs.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* \addtogroup Vision
* \{
*/
/**
* \addtogroup Convolution
* \{
*/
/**
* \brief Format of convolution mask.
*/
typedef enum
{
GAN_MASK1D_SYMMETRIC, /**< Symmetric 1D convolution mask */
GAN_MASK1D_ANTISYMMETRIC, /**< Antisymmetric 1D convolution mask */
GAN_MASK1D_GENERIC /**< General 1D convolution mask */
} Gan_Mask1DFormat;
/**
* \brief Edge behaviour
*/
typedef enum
{
GAN_EDGE_BEHAVIOUR_CLIP, /**< Don't access data outside edge */
GAN_EDGE_BEHAVIOUR_REPEAT, /**< Repeat data outside edge */
GAN_EDGE_BEHAVIOUR_CIRCULAR, /**< Treat data as circular */
GAN_EDGE_BEHAVIOUR_EXPAND /**< Expand data by mask size */
} Gan_EdgeBehaviour;
/**
* \brief 1D convolution mask.
*/
typedef struct
{
/// format of convolution mask
Gan_Mask1DFormat format;
/// type of mask
Gan_Type type;
/// size of mask (must be odd)
unsigned int size;
/// allocated size of mask
unsigned int size_alloc;
/// mask data
union
{
float *f;
double *d;
int *i;
unsigned short *us;
unsigned char *uc;
} data;
/// whether the mask data was dynamically allocated
Gan_Bool data_alloc;
/// whether this structure was dynamically allocated
Gan_Bool alloc;
} Gan_Mask1D;
/* create new mask */
GANDALF_API Gan_Mask1D *gan_mask1D_form_gen ( Gan_Mask1D *mask,
Gan_Mask1DFormat format, Gan_Type type,
void *data, unsigned int size );
GANDALF_API Gan_Bool gan_mask1D_copy_q ( Gan_Mask1D *source, Gan_Mask1D *dest );
GANDALF_API Gan_Bool gan_mask1D_free ( Gan_Mask1D *mask );
GANDALF_API Gan_Mask1D *gan_gauss_mask_new ( Gan_Type type, double sigma,
unsigned mask_size, double scale,
void *mask_data );
/**
* \brief Macro: Allocate and return a new 1D convolution mask.
*
* Allocates and returns a new 1D convolution mask with the given \a format,
* \a type and \a size.
*
* Implemented as a macro call to gan_mask1D_form_gen().
* \sa gan_mask1D_form() and gan_mask1D_alloc_data().
*/
#ifdef GAN_GENERATE_DOCUMENTATION
GANDALF_API Gan_Mask1D *gan_mask1D_alloc ( Gan_Mask1DFormat format, Gan_Type type,
unsigned int size );
#else
#define gan_mask1D_alloc(f,t,s) gan_mask1D_form_gen(NULL,f,t,NULL,s)
#endif
/**
* \brief Macro: Allocate and return a new 1D convolution mask.
*
* Allocates and returns a new 1D convolution mask with the given \a format,
* \a type, \a data array and \a size.
*
* Implemented as a macro call to gan_mask1D_form_gen().
* \sa gan_mask1D_form() and gan_mask1D_alloc().
*/
#ifdef GAN_GENERATE_DOCUMENTATION
GANDALF_API Gan_Mask1D *gan_mask1D_alloc_data ( Gan_Mask1DFormat format, Gan_Type type,
void *data, unsigned int size );
#else
#define gan_mask1D_alloc_data(f,t,d,s) gan_mask1D_form_gen(NULL,f,t,d,s)
#endif
/**
* \brief Macro: Build a new 1D convolution mask.
*
* Builds and returns a new 1D convolution mask with the given \a format,
* \a type and \a size, writing it into the provided structure \a mask.
*
* Implemented as a macro call to gan_mask1D_form_gen().
* \sa gan_mask1D_alloc() and gan_mask1D_alloc_data().
*/
#ifdef GAN_GENERATE_DOCUMENTATION
GANDALF_API Gan_Mask1D *gan_mask1D_form ( Gan_Mask1D *mask,
Gan_Mask1DFormat format, Gan_Type type,
unsigned int size );
#else
#define gan_mask1D_form(m,f,t,s) gan_mask1D_form_gen(m,f,t,NULL,s)
#endif
/**
* \brief Macro: Build a new 1D convolution mask.
*
* Builds and returns a new 1D convolution mask with the given \a format,
* \a type, \a data and \a size, writing it into the provided structure
* \a mask.
*
* Implemented as a macro call to gan_mask1D_form_gen().
* \sa gan_mask1D_alloc() and gan_mask1D_alloc_data().
*/
#ifdef GAN_GENERATE_DOCUMENTATION
GANDALF_API Gan_Mask1D *gan_mask1D_form_data ( Gan_Mask1D *mask,
Gan_Mask1DFormat format, Gan_Type type,
void *data, unsigned int size );
#else
#define gan_mask1D_form_data(mask,format,type,data,size)\
gan_mask1D_form_gen(mask,format,type,data,size)
#endif
/**
* \}
*/
/**
* \}
*/
#ifdef __cplusplus
}
#endif
#endif /* #ifndef _GAN_MASK1D_H */
| 1 | 0.829471 | 1 | 0.829471 | game-dev | MEDIA | 0.495283 | game-dev,scientific-computing | 0.882486 | 1 | 0.882486 |
amethyst/grumpy_visitors | 4,556 | libs/game/src/ecs/systems/level.rs | use amethyst::ecs::{System, WriteExpect};
use std::time::Duration;
use gv_core::{
actions::monster_spawn::{SpawnAction, SpawnActions, SpawnType},
ecs::{
resources::{net::EntityNetMetadataStorage, world::FramedUpdates, GameLevelState},
system_data::time::GameTimeService,
},
math::Vector2,
};
use crate::{
ecs::system_data::GameStateHelper,
utils::world::{random_spawn_position, spawning_side},
};
const SECS_PER_LEVEL: u64 = 30;
const MIN_BORDERLINE_INTERVAL_SECS: f32 = 30.0;
const MAX_BORDERLINE_INTERVAL_SECS: f32 = 5.0;
#[derive(Default)]
pub struct LevelSystem;
impl<'s> System<'s> for LevelSystem {
type SystemData = (
GameStateHelper<'s>,
GameTimeService<'s>,
WriteExpect<'s, GameLevelState>,
WriteExpect<'s, FramedUpdates<SpawnActions>>,
WriteExpect<'s, EntityNetMetadataStorage>,
);
fn run(
&mut self,
(
game_state_helper,
game_time_service,
mut game_level_state,
mut spawn_actions,
mut entity_net_metadata_storage,
): Self::SystemData,
) {
if !game_state_helper.is_running() || !game_state_helper.is_authoritative() {
return;
}
spawn_actions.reserve_updates(game_time_service.game_frame_number());
let spawn_actions = spawn_actions
.update_frame(game_time_service.game_frame_number())
.unwrap_or_else(|| {
panic!(
"Expected SpawnActions for frame {}",
game_time_service.game_frame_number()
)
});
let now = game_time_service.level_duration();
if now - game_level_state.spawn_level_started > Duration::from_secs(SECS_PER_LEVEL) {
game_level_state.spawn_level += 1;
game_level_state.spawn_level_started = now;
}
if game_time_service.game_frame_number() == 10 {
spawn_actions.spawn_actions.push(SpawnAction {
spawn_type: SpawnType::Single {
entity_net_id: Some(entity_net_metadata_storage.reserve_ids(1).start),
position: Vector2::new(0.0, 300.0),
},
});
}
let borderline_spawn_interval = MIN_BORDERLINE_INTERVAL_SECS
- (game_level_state.spawn_level as f32 / 7.0).atan() / std::f32::consts::PI
* 2.0
* (MAX_BORDERLINE_INTERVAL_SECS - MIN_BORDERLINE_INTERVAL_SECS);
let borderline_spawn_interval =
Duration::from_millis((borderline_spawn_interval * 1000.0).round() as u64);
if now - game_level_state.last_borderline_spawn > borderline_spawn_interval {
game_level_state.last_borderline_spawn = now;
let side = rand::random();
let spawn_margin = 50.0;
let (side_start, side_end, _) = spawning_side(side, &game_level_state);
let d = (side_start - side_end) / spawn_margin;
let monsters_to_spawn = num::Float::max(d.x.abs(), d.y.abs()).round() as usize;
let entity_net_id_range = if game_state_helper.is_multiplayer() {
Some(entity_net_metadata_storage.reserve_ids(monsters_to_spawn))
} else {
None
};
log::trace!(
"Spawning {} monster(s) (SpawnType::Borderline)",
monsters_to_spawn
);
spawn_actions.spawn_actions.push(SpawnAction {
spawn_type: SpawnType::Borderline {
count: monsters_to_spawn as u8,
entity_net_id_range,
side,
},
});
}
let random_spawn_interval = Duration::from_secs(1);
let monsters_to_spawn = game_level_state.spawn_level.min(255) as u8;
if now - game_level_state.last_random_spawn > random_spawn_interval {
game_level_state.last_random_spawn = now;
log::trace!(
"Spawning {} monster(s) (SpawnType::Single)",
monsters_to_spawn
);
for _ in 0..monsters_to_spawn {
spawn_actions.spawn_actions.push(SpawnAction {
spawn_type: SpawnType::Single {
entity_net_id: Some(entity_net_metadata_storage.reserve_ids(1).start),
position: random_spawn_position(&game_level_state),
},
});
}
}
}
}
| 1 | 0.787706 | 1 | 0.787706 | game-dev | MEDIA | 0.995901 | game-dev | 0.708036 | 1 | 0.708036 |
GaijinEntertainment/DagorEngine | 1,990 | prog/3rdPartyLibs/phys/bullet-3/src/BulletDynamics/Character/btCharacterControllerInterface.h | /*
Bullet Continuous Collision Detection and Physics Library
Copyright (c) 2003-2008 Erwin Coumans http://bulletphysics.com
This software is provided 'as-is', without any express or implied warranty.
In no event will the authors be held liable for any damages arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it freely,
subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#ifndef BT_CHARACTER_CONTROLLER_INTERFACE_H
#define BT_CHARACTER_CONTROLLER_INTERFACE_H
#include "LinearMath/btVector3.h"
#include "BulletDynamics/Dynamics/btActionInterface.h"
class btCollisionShape;
class btRigidBody;
class btCollisionWorld;
class btCharacterControllerInterface : public btActionInterface
{
public:
btCharacterControllerInterface(){};
virtual ~btCharacterControllerInterface(){};
virtual void setWalkDirection(const btVector3& walkDirection) = 0;
virtual void setVelocityForTimeInterval(const btVector3& velocity, btScalar timeInterval) = 0;
virtual void reset(btCollisionWorld* collisionWorld) = 0;
virtual void warp(const btVector3& origin) = 0;
virtual void preStep(btCollisionWorld* collisionWorld) = 0;
virtual void playerStep(btCollisionWorld* collisionWorld, btScalar dt) = 0;
virtual bool canJump() const = 0;
virtual void jump(const btVector3& dir = btVector3(0, 0, 0)) = 0;
virtual bool onGround() const = 0;
virtual void setUpInterpolate(bool value) = 0;
};
#endif //BT_CHARACTER_CONTROLLER_INTERFACE_H
| 1 | 0.873917 | 1 | 0.873917 | game-dev | MEDIA | 0.978235 | game-dev | 0.652822 | 1 | 0.652822 |
oot-pc-port/oot-pc-port | 2,233 | asm/non_matchings/code/z_bgcheck/func_80039A3C.s | glabel func_80039A3C
/* AB0BDC 80039A3C C7A40024 */ lwc1 $f4, 0x24($sp)
/* AB0BE0 80039A40 C7A60020 */ lwc1 $f6, 0x20($sp)
/* AB0BE4 80039A44 C7AA001C */ lwc1 $f10, 0x1c($sp)
/* AB0BE8 80039A48 C7B20010 */ lwc1 $f18, 0x10($sp)
/* AB0BEC 80039A4C 46062201 */ sub.s $f8, $f4, $f6
/* AB0BF0 80039A50 C4D00000 */ lwc1 $f16, ($a2)
/* AB0BF4 80039A54 460A4002 */ mul.s $f0, $f8, $f10
/* AB0BF8 80039A58 00000000 */ nop
/* AB0BFC 80039A5C 46120102 */ mul.s $f4, $f0, $f18
/* AB0C00 80039A60 46048180 */ add.s $f6, $f16, $f4
/* AB0C04 80039A64 E4C60000 */ swc1 $f6, ($a2)
/* AB0C08 80039A68 C7AA0018 */ lwc1 $f10, 0x18($sp)
/* AB0C0C 80039A6C C4E80000 */ lwc1 $f8, ($a3)
/* AB0C10 80039A70 460A0482 */ mul.s $f18, $f0, $f10
/* AB0C14 80039A74 46124400 */ add.s $f16, $f8, $f18
/* AB0C18 80039A78 E4F00000 */ swc1 $f16, ($a3)
/* AB0C1C 80039A7C 8FAE0028 */ lw $t6, 0x28($sp)
/* AB0C20 80039A80 8DC20000 */ lw $v0, ($t6)
/* AB0C24 80039A84 14400004 */ bnez $v0, .L80039A98
/* AB0C28 80039A88 00000000 */ nop
/* AB0C2C 80039A8C ADC50000 */ sw $a1, ($t6)
/* AB0C30 80039A90 03E00008 */ jr $ra
/* AB0C34 80039A94 24020001 */ li $v0, 1
.L80039A98:
/* AB0C38 80039A98 8C8F0000 */ lw $t7, ($a0)
/* AB0C3C 80039A9C 94590000 */ lhu $t9, ($v0)
/* AB0C40 80039AA0 00001025 */ move $v0, $zero
/* AB0C44 80039AA4 8DF8001C */ lw $t8, 0x1c($t7)
/* AB0C48 80039AA8 001940C0 */ sll $t0, $t9, 3
/* AB0C4C 80039AAC 8FAB0028 */ lw $t3, 0x28($sp)
/* AB0C50 80039AB0 03084821 */ addu $t1, $t8, $t0
/* AB0C54 80039AB4 8D230004 */ lw $v1, 4($t1)
/* AB0C58 80039AB8 00035100 */ sll $t2, $v1, 4
/* AB0C5C 80039ABC 05410003 */ bgez $t2, .L80039ACC
/* AB0C60 80039AC0 00000000 */ nop
/* AB0C64 80039AC4 10000001 */ b .L80039ACC
/* AB0C68 80039AC8 24020001 */ li $v0, 1
.L80039ACC:
/* AB0C6C 80039ACC 54400005 */ bnezl $v0, .L80039AE4
/* AB0C70 80039AD0 00001025 */ move $v0, $zero
/* AB0C74 80039AD4 AD650000 */ sw $a1, ($t3)
/* AB0C78 80039AD8 03E00008 */ jr $ra
/* AB0C7C 80039ADC 24020001 */ li $v0, 1
/* AB0C80 80039AE0 00001025 */ move $v0, $zero
.L80039AE4:
/* AB0C84 80039AE4 03E00008 */ jr $ra
/* AB0C88 80039AE8 00000000 */ nop
| 1 | 0.657194 | 1 | 0.657194 | game-dev | MEDIA | 0.65619 | game-dev | 0.815715 | 1 | 0.815715 |
JetBoom/zombiesurvival | 1,528 | gamemodes/zombiesurvival/entities/entities/projectile_strengthdart/init.lua | INC_SERVER()
function ENT:Hit(vHitPos, vHitNormal, eHitEntity, vOldVelocity)
if self:GetHitTime() ~= 0 then return end
self:SetHitTime(CurTime())
self:Fire("kill", "", 10)
local owner = self:GetOwner()
if not owner:IsValid() then owner = self end
vHitPos = vHitPos or self:GetPos()
vHitNormal = (vHitNormal or Vector(0, 0, -1)) * -1
self:SetSolid(SOLID_NONE)
self:SetMoveType(MOVETYPE_NONE)
self:SetPos(vHitPos + vHitNormal)
local alt = self:GetDTBool(0)
if eHitEntity:IsValid() then
self:AttachToPlayer(vHitPos, eHitEntity)
if eHitEntity:IsPlayer() and eHitEntity:Team() ~= TEAM_UNDEAD then
local strstatus = eHitEntity:GiveStatus(alt and "medrifledefboost" or "strengthdartboost", (alt and 2 or 1) * (self.BuffDuration or 10))
strstatus.Applier = owner
local txt = alt and "Defence Shot Gun" or "Strength Shot Gun"
net.Start("zs_buffby")
net.WriteEntity(owner)
net.WriteString(txt)
net.Send(eHitEntity)
net.Start("zs_buffwith")
net.WriteEntity(eHitEntity)
net.WriteString(txt)
net.Send(owner)
eHitEntity:GiveStatus("healdartboost", (self.BuffDuration or 10)/2)
else
self:DoRefund(owner)
end
else
self:DoRefund(owner)
end
self:SetAngles(vOldVelocity:Angle())
local effectdata = EffectData()
effectdata:SetOrigin(vHitPos)
effectdata:SetNormal(vHitNormal)
if eHitEntity:IsValid() then
effectdata:SetEntity(eHitEntity)
else
effectdata:SetEntity(NULL)
end
util.Effect(alt and "hit_healdart2" or "hit_strengthdart", effectdata)
end
| 1 | 0.819649 | 1 | 0.819649 | game-dev | MEDIA | 0.905996 | game-dev | 0.955848 | 1 | 0.955848 |
dmccuskey/DMC-Corona-Library | 6,740 | examples/dmc_wamp/dmc-wamp-publish/dmc_corona/dmc_touchmanager.lua | --===================================================================--
-- dmc_touchmanager.lua
--
-- by David McCuskey
-- Documentation: http://docs.davidmccuskey.com/display/docs/dmc_touchmanager.lua
--===================================================================--
--[[
Copyright (C) 2012-2013 David McCuskey. All Rights Reserved.
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in the
Software without restriction, including without limitation the rights to use, copy,
modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
and to permit persons to whom the Software is furnished to do so, subject to the
following conditions:
The above copyright notice and this permission notice shall be included in all copies
or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
--]]
--====================================================================--
-- DMC Corona Library : DMC Touch Manager
--====================================================================--
-- Semantic Versioning Specification: http://semver.org/
local VERSION = "0.1.0"
--====================================================================--
-- DMC Corona Library Config
--====================================================================--
--====================================================================--
-- Support Functions
local Utils = {} -- make copying from dmc_utils easier
function Utils.extend( fromTable, toTable )
function _extend( fT, tT )
for k,v in pairs( fT ) do
if type( fT[ k ] ) == "table" and
type( tT[ k ] ) == "table" then
tT[ k ] = _extend( fT[ k ], tT[ k ] )
elseif type( fT[ k ] ) == "table" then
tT[ k ] = _extend( fT[ k ], {} )
else
tT[ k ] = v
end
end
return tT
end
return _extend( fromTable, toTable )
end
--====================================================================--
-- Configuration
local dmc_lib_data, dmc_lib_info
-- boot dmc_library with boot script or
-- setup basic defaults if it doesn't exist
--
if false == pcall( function() require( "dmc_corona_boot" ) end ) then
_G.__dmc_corona = {
dmc_corona={},
}
end
dmc_lib_data = _G.__dmc_corona
dmc_lib_info = dmc_lib_data.dmc_library
--====================================================================--
-- DMC Touch Manager
--====================================================================--
--===================================================================--
-- Setup, Constants
system.activate("multitouch")
--===================================================================--
-- Support Functions
-- createObjectTouchHandler()
--
-- creates special touch handler for objects
--
-- @param mgr reference to the Touch Manager object
-- @param obj reference to the object on which to apply the callback (optional)
-- @return return value of callback, or false if no callback available
--
local createObjectTouchHandler = function( mgr, obj )
return function( event )
local t = mgr:_getRegisteredTouch( event.id )
if t then
if not event.target then
event.target = t.obj
else
event.dispatcher = event.target
event.target = t.obj
end
event.isFocused = true
if t.handler then
return t.handler( event )
else
return t.obj:touch( event )
end
else
local o = mgr:_getRegisteredObject( obj )
if o then
if not event.target then
event.target = o.obj
else
event.dispatcher = event.target
event.target = o.obj
end
if o.handler then
return o.handler( event )
else
return o.obj:touch( event )
end
end
end
return false
end
end
--===================================================================--
-- Touch Manager Class
--===================================================================--
local TouchManager = {}
--== Constants ==--
TouchManager._objects = {} -- keyed on obj ; object keys: obj, handler
TouchManager._touches = {} -- keyed on event.id ; object keys: obj, handler
--====================================================================--
--== Private Methods ==--
function TouchManager:_getRegisteredObject( obj )
return self._objects[ obj ]
end
function TouchManager:_setRegisteredObject( obj, value )
self._objects[ obj ] = value
end
function TouchManager:_getRegisteredTouch( event_id )
return self._touches[ event_id ]
end
function TouchManager:_setRegisteredTouch( event_id, value )
self._touches[ event_id ] = value
end
--====================================================================--
--== Public Methods / API ==--
-- register()
--
-- puts touch manager in control of touch events for this object
--
-- @param obj a Corona-type object
-- @param handler the function handler for the touch event (optional)
--
function TouchManager:register( obj, handler )
local r = { obj=obj, handler=handler }
r.callback = createObjectTouchHandler( self, obj )
self:_setRegisteredObject( obj, r )
obj:addEventListener( "touch", r.callback )
end
-- unregister()
--
-- removes touch manager control for touch events for this object
--
-- @param obj a Corona-type object
-- @param handler the function handler for the touch event (optional)
--
function TouchManager:unregister( obj, handler )
local r = self:_getRegisteredObject( obj )
if r then
self:_setRegisteredObject( obj, nil )
obj:removeEventListener( "touch", r.callback )
end
end
-- setFocus()
--
-- sets focus on an object for a single touch event
--
-- @param obj a Corona-type object
-- @param event_id id of the touch event
--
function TouchManager:setFocus( obj, event_id )
local o = self:_getRegisteredObject( obj )
local r = { obj=obj, handler=o.handler }
self:_setRegisteredTouch( event_id, r )
end
-- unsetFocus()
--
-- removes focus on an object for a single touch event
--
-- @param obj a Corona-type object
-- @param event_id id of the touch event
--
function TouchManager:unsetFocus( obj, event_id )
self:_setRegisteredTouch( event_id, nil )
end
--== puts touch manager in control of global (runtime) touch events ==--
Runtime:addEventListener( "touch", createObjectTouchHandler( TouchManager ) )
return TouchManager
| 1 | 0.941142 | 1 | 0.941142 | game-dev | MEDIA | 0.559359 | game-dev,desktop-app | 0.836314 | 1 | 0.836314 |
bernie-g/Techarium | 2,567 | src/main/java/software/bernie/techarium/util/StaticHandler.java | package software.bernie.techarium.util;
import com.google.gson.JsonObject;
import com.google.gson.JsonSyntaxException;
import net.minecraft.entity.EntityType;
import net.minecraft.entity.item.ItemEntity;
import net.minecraft.fluid.Fluid;
import net.minecraft.item.ItemStack;
import net.minecraft.util.Direction;
import net.minecraft.util.JSONUtils;
import net.minecraft.util.ResourceLocation;
import net.minecraft.util.registry.Registry;
import net.minecraft.world.World;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.items.IItemHandler;
import software.bernie.techarium.machine.sideness.Side;
import javax.annotation.Nullable;
import java.util.Random;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class StaticHandler {
public static Side getSideFromDirection(@Nullable Direction face,Direction rotated){
if (face == null) {
return null;
} else if (face == Direction.UP) {
return Side.UP;
} else if (face == Direction.DOWN) {
return Side.DOWN;
} else if (rotated == face) {
return Side.FRONT;
} else if (rotated == face.getOpposite()) {
return Side.BACK;
} else if (rotated == face.getCounterClockWise()) {
return Side.LEFT;
} else {
return rotated == face.getClockWise() ? Side.RIGHT : Side.DOWN;
}
}
//Inventory Item Stream.
public static Stream<ItemStack> getItemStackStream(IItemHandler inventory) {
//Get slot indexes
return IntStream.range(0, inventory.getSlots())
//Map to each slot
.mapToObj(inventory::getStackInSlot);
}
//Spawn ItemStacks
public static void spawnItemStack(World worldIn, double x, double y, double z, ItemStack stack, Random rand) {
double d0 = (double) EntityType.ITEM.getWidth();
double d1 = 1.0D - d0;
double d2 = d0 / 2.0D;
double d3 = Math.floor(x) + rand.nextDouble() * d1 + d2;
double d4 = Math.floor(y) + rand.nextDouble() * d1;
double d5 = Math.floor(z) + rand.nextDouble() * d1 + d2;
while (!stack.isEmpty()) {
ItemEntity itementity = new ItemEntity(worldIn, d3, d4, d5, stack.split(rand.nextInt(21) + 10));
float f = 0.05F;
itementity.setDeltaMovement(rand.nextGaussian() * (double) 0.05F, rand.nextGaussian() * (double) 0.05F + (double) 0.2F, rand.nextGaussian() * (double) 0.05F);
worldIn.addFreshEntity(itementity);
}
}
}
| 1 | 0.799899 | 1 | 0.799899 | game-dev | MEDIA | 0.983552 | game-dev | 0.931874 | 1 | 0.931874 |
Hork-Engine/Hork-Source | 8,238 | ThirdParty/SDL3/src/video/wayland/SDL_waylandkeyboard.c | /*
Simple DirectMedia Layer
Copyright (C) 1997-2024 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#include "SDL_internal.h"
#if SDL_VIDEO_DRIVER_WAYLAND
#include "../SDL_sysvideo.h"
#include "SDL_waylandvideo.h"
#include "SDL_waylandevents_c.h"
#include "../../events/SDL_keyboard_c.h"
#include "text-input-unstable-v3-client-protocol.h"
bool Wayland_InitKeyboard(SDL_VideoDevice *_this)
{
#ifdef SDL_USE_IME
SDL_VideoData *internal = _this->internal;
if (!internal->text_input_manager) {
SDL_IME_Init();
}
#endif
SDL_SetScancodeName(SDL_SCANCODE_APPLICATION, "Menu");
return true;
}
void Wayland_QuitKeyboard(SDL_VideoDevice *_this)
{
#ifdef SDL_USE_IME
SDL_VideoData *internal = _this->internal;
if (!internal->text_input_manager) {
SDL_IME_Quit();
}
#endif
}
bool Wayland_StartTextInput(SDL_VideoDevice *_this, SDL_Window *window, SDL_PropertiesID props)
{
SDL_VideoData *internal = _this->internal;
struct SDL_WaylandInput *input = internal->input;
if (internal->text_input_manager) {
if (input && input->text_input) {
const SDL_Rect *rect = &input->text_input->cursor_rect;
enum zwp_text_input_v3_content_hint hint = ZWP_TEXT_INPUT_V3_CONTENT_HINT_NONE;
enum zwp_text_input_v3_content_purpose purpose;
switch (SDL_GetTextInputType(props)) {
default:
case SDL_TEXTINPUT_TYPE_TEXT:
purpose = ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_NORMAL;
break;
case SDL_TEXTINPUT_TYPE_TEXT_NAME:
purpose = ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_NAME;
break;
case SDL_TEXTINPUT_TYPE_TEXT_EMAIL:
purpose = ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_EMAIL;
break;
case SDL_TEXTINPUT_TYPE_TEXT_USERNAME:
purpose = ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_NORMAL;
hint |= ZWP_TEXT_INPUT_V3_CONTENT_HINT_SENSITIVE_DATA;
break;
case SDL_TEXTINPUT_TYPE_TEXT_PASSWORD_HIDDEN:
purpose = ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_PASSWORD;
hint |= (ZWP_TEXT_INPUT_V3_CONTENT_HINT_HIDDEN_TEXT | ZWP_TEXT_INPUT_V3_CONTENT_HINT_SENSITIVE_DATA);
break;
case SDL_TEXTINPUT_TYPE_TEXT_PASSWORD_VISIBLE:
purpose = ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_PASSWORD;
hint |= ZWP_TEXT_INPUT_V3_CONTENT_HINT_SENSITIVE_DATA;
break;
case SDL_TEXTINPUT_TYPE_NUMBER:
purpose = ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_NUMBER;
break;
case SDL_TEXTINPUT_TYPE_NUMBER_PASSWORD_HIDDEN:
purpose = ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_PIN;
hint |= (ZWP_TEXT_INPUT_V3_CONTENT_HINT_HIDDEN_TEXT | ZWP_TEXT_INPUT_V3_CONTENT_HINT_SENSITIVE_DATA);
break;
case SDL_TEXTINPUT_TYPE_NUMBER_PASSWORD_VISIBLE:
purpose = ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_PIN;
hint |= ZWP_TEXT_INPUT_V3_CONTENT_HINT_SENSITIVE_DATA;
break;
}
switch (SDL_GetTextInputCapitalization(props)) {
default:
case SDL_CAPITALIZE_NONE:
break;
case SDL_CAPITALIZE_LETTERS:
hint |= ZWP_TEXT_INPUT_V3_CONTENT_HINT_UPPERCASE;
break;
case SDL_CAPITALIZE_WORDS:
hint |= ZWP_TEXT_INPUT_V3_CONTENT_HINT_TITLECASE;
break;
case SDL_CAPITALIZE_SENTENCES:
hint |= ZWP_TEXT_INPUT_V3_CONTENT_HINT_AUTO_CAPITALIZATION;
break;
}
if (SDL_GetTextInputAutocorrect(props)) {
hint |= (ZWP_TEXT_INPUT_V3_CONTENT_HINT_COMPLETION | ZWP_TEXT_INPUT_V3_CONTENT_HINT_SPELLCHECK);
}
if (SDL_GetTextInputMultiline(props)) {
hint |= ZWP_TEXT_INPUT_V3_CONTENT_HINT_MULTILINE;
}
zwp_text_input_v3_enable(input->text_input->text_input);
// Now that it's enabled, set the input properties
zwp_text_input_v3_set_content_type(input->text_input->text_input, hint, purpose);
if (!SDL_RectEmpty(rect)) {
// This gets reset on enable so we have to cache it
zwp_text_input_v3_set_cursor_rectangle(input->text_input->text_input,
rect->x,
rect->y,
rect->w,
rect->h);
}
zwp_text_input_v3_commit(input->text_input->text_input);
}
}
if (input && input->xkb.compose_state) {
// Reset compose state so composite and dead keys don't carry over
WAYLAND_xkb_compose_state_reset(input->xkb.compose_state);
}
return Wayland_UpdateTextInputArea(_this, window);
}
bool Wayland_StopTextInput(SDL_VideoDevice *_this, SDL_Window *window)
{
SDL_VideoData *internal = _this->internal;
struct SDL_WaylandInput *input = internal->input;
if (internal->text_input_manager) {
if (input && input->text_input) {
zwp_text_input_v3_disable(input->text_input->text_input);
zwp_text_input_v3_commit(input->text_input->text_input);
}
}
#ifdef SDL_USE_IME
else {
SDL_IME_Reset();
}
#endif
if (input && input->xkb.compose_state) {
// Reset compose state so composite and dead keys don't carry over
WAYLAND_xkb_compose_state_reset(input->xkb.compose_state);
}
return true;
}
bool Wayland_UpdateTextInputArea(SDL_VideoDevice *_this, SDL_Window *window)
{
SDL_VideoData *internal = _this->internal;
if (internal->text_input_manager) {
struct SDL_WaylandInput *input = internal->input;
if (input && input->text_input) {
if (!SDL_RectsEqual(&window->text_input_rect, &input->text_input->cursor_rect)) {
SDL_copyp(&input->text_input->cursor_rect, &window->text_input_rect);
zwp_text_input_v3_set_cursor_rectangle(input->text_input->text_input,
window->text_input_rect.x,
window->text_input_rect.y,
window->text_input_rect.w,
window->text_input_rect.h);
zwp_text_input_v3_commit(input->text_input->text_input);
}
}
}
#ifdef SDL_USE_IME
else {
SDL_IME_UpdateTextInputArea(window);
}
#endif
return true;
}
bool Wayland_HasScreenKeyboardSupport(SDL_VideoDevice *_this)
{
/* In reality we just want to return true when the screen keyboard is the
* _only_ way to get text input. So, in addition to checking for the text
* input protocol, make sure we don't have any physical keyboards either.
*/
SDL_VideoData *internal = _this->internal;
bool haskeyboard = (internal->input != NULL) && (internal->input->keyboard != NULL);
bool hastextmanager = (internal->text_input_manager != NULL);
return !haskeyboard && hastextmanager;
}
#endif // SDL_VIDEO_DRIVER_WAYLAND
| 1 | 0.698616 | 1 | 0.698616 | game-dev | MEDIA | 0.557278 | game-dev | 0.713789 | 1 | 0.713789 |
microsoft/Win2D | 7,085 | winrt/test.internal/xaml/CanvasAnimatedControlTestAdapter.h | // Copyright (c) Microsoft Corporation. All rights reserved.
//
// Licensed under the MIT License. See LICENSE.txt in the project root for license information.
#pragma once
#include <lib/xaml/CanvasGameLoop.h>
#include "BaseControlTestAdapter.h"
#include "CanvasSwapChainPanelTestAdapter.h"
#include "MockShape.h"
#include "StubDispatcher.h"
class FakeGameThread : public IGameLoopThread
{
ComPtr<StubDispatcher> m_dispatcher;
bool m_dispatcherActive;
std::vector<ComPtr<AnimatedControlAsyncAction>> m_pendingActions;
public:
FakeGameThread()
: m_dispatcher(Make<StubDispatcher>())
, m_dispatcherActive(false)
{
}
void Tick()
{
for (auto& action : m_pendingActions)
{
action->InvokeAndFireCompletion();
}
m_pendingActions.clear();
if (m_dispatcherActive)
{
m_dispatcher->TickAll();
}
}
StubDispatcher* GetDispatcher()
{
return m_dispatcher.Get();
}
bool HasPendingActions()
{
return m_dispatcher->HasPendingActions();
}
virtual void StartDispatcher() override
{
m_dispatcherActive = true;
}
virtual void StopDispatcher() override
{
m_dispatcherActive = false;
}
virtual ComPtr<IAsyncAction> RunAsync(IDispatcherQueueHandler* handler) override
{
auto action = Make<AnimatedControlAsyncAction>(handler);
if (m_dispatcherActive)
{
auto callback = Callback<AddFtmBase<IDispatcherQueueHandler>::Type>(
[action]() {
auto result = action->InvokeAndFireCompletion();
if (SUCCEEDED(result.ActionResult))
{
return result.ActionResult;
}
else
{
return result.CompletedHandlerResult;
}
});
boolean result;
ThrowIfFailed(m_dispatcher->TryEnqueueWithPriority(DispatcherQueuePriority_Low, callback.Get(), &result));
}
else
{
m_pendingActions.push_back(action);
}
return action;
}
virtual bool HasThreadAccess() override
{
boolean result;
ThrowIfFailed(m_dispatcher->get_HasThreadAccess(&result));
return !!result;
}
};
class CanvasAnimatedControlTestAdapter : public BaseControlTestAdapter<CanvasAnimatedControlTraits>
{
std::shared_ptr<CanvasSwapChainPanelTestAdapter> m_swapChainPanelAdapter;
int64_t m_performanceCounter;
ComPtr<StubSwapChainPanel> m_swapChainPanel;
std::weak_ptr<FakeGameThread> m_gameThread;
ComPtr<MockShape> m_shape;
public:
CALL_COUNTER_WITH_MOCK(CreateCanvasSwapChainMethod, ComPtr<CanvasSwapChain>(ICanvasDevice*, float, float, float, CanvasAlphaMode));
ComPtr<StubCanvasDevice> InitialDevice;
CanvasAnimatedControlTestAdapter(StubCanvasDevice* initialDevice = nullptr)
: m_performanceCounter(1)
, InitialDevice(initialDevice)
, m_swapChainPanel(Make<StubSwapChainPanel>())
{
m_swapChainPanel->SetSwapChainMethod.AllowAnyCall(
[=](IDXGISwapChain*)
{
return S_OK;
});
m_swapChainPanelAdapter = std::make_shared<CanvasSwapChainPanelTestAdapter>(m_swapChainPanel);
}
virtual ComPtr<CanvasSwapChain> CreateCanvasSwapChain(
ICanvasDevice* device,
float width,
float height,
float dpi,
CanvasAlphaMode alphaMode) override
{
return CreateCanvasSwapChainMethod.WasCalled(device, width, height, dpi, alphaMode);
}
virtual ComPtr<CanvasSwapChainPanel> CreateCanvasSwapChainPanel() override
{
auto swapChainPanel = Make<CanvasSwapChainPanel>(m_swapChainPanelAdapter);
return swapChainPanel;
}
virtual ComPtr<IShape> CreateDesignModeShape() override
{
m_shape = Make<MockShape>();
return m_shape;
}
StubSwapChainPanel* GetSwapChainPanel()
{
return m_swapChainPanel.Get();
}
MockShape* GetShape()
{
return m_shape.Get();
}
StubDispatcher* GetGameThreadDispatcher()
{
if (auto thread = m_gameThread.lock())
return thread->GetDispatcher();
else
return nullptr;
}
bool GameThreadHasPendingWork()
{
if (auto thread = m_gameThread.lock())
return thread->HasPendingActions();
else
return false;
}
virtual std::unique_ptr<CanvasGameLoop> CreateAndStartGameLoop(CanvasAnimatedControl* control, ISwapChainPanel*) override
{
// CanvasGameLoop takes ownership of the IGameLoopThread we give it.
// However, for our tests we also want to allow the adapter to hold on
// to the thread. So we store the underlying FakeGameThread in a
// shared_ptr, and pass a unique_ptr to this proxy to CanvasGameLoop.
class GameThreadProxy : public IGameLoopThread
{
std::shared_ptr<IGameLoopThread> m_thread;
ICanvasGameLoopClient* m_client;
public:
GameThreadProxy(std::shared_ptr<IGameLoopThread> thread, ICanvasGameLoopClient* client)
: m_thread(thread)
, m_client(client)
{
m_client->OnGameLoopStarting();
}
~GameThreadProxy()
{
m_client->OnGameLoopStopped();
}
virtual void StartDispatcher() { m_thread->StartDispatcher(); }
virtual void StopDispatcher() { m_thread->StopDispatcher(); }
virtual ComPtr<IAsyncAction> RunAsync(IDispatcherQueueHandler* handler) { return m_thread->RunAsync(handler); }
virtual bool HasThreadAccess() { return m_thread->HasThreadAccess(); }
};
auto gameThread = std::make_shared<FakeGameThread>();
auto gameLoop = std::make_unique<CanvasGameLoop>(control, std::make_unique<GameThreadProxy>(gameThread, control));
m_gameThread = gameThread;
return gameLoop;
}
void DoChanged()
{
TickUiThread();
}
void Tick()
{
if (auto thread = m_gameThread.lock())
thread->Tick();
}
ComPtr<IInspectable> CreateSwapChainPanel(IInspectable* canvasSwapChainPanel)
{
return m_swapChainPanelAdapter->CreateSwapChainPanel(canvasSwapChainPanel);
}
std::function<void(DWORD)> m_sleepFn;
virtual void Sleep(DWORD timeInMs) override
{
if (m_sleepFn) m_sleepFn(timeInMs);
}
void SetTime(int64_t time)
{
m_performanceCounter = time;
}
void ProgressTime(int64_t ticks)
{
m_performanceCounter += ticks;
}
virtual int64_t GetPerformanceCounter() override
{
return m_performanceCounter;
}
virtual int64_t GetPerformanceFrequency() override
{
return StepTimer::TicksPerSecond;
}
};
| 1 | 0.897504 | 1 | 0.897504 | game-dev | MEDIA | 0.392323 | game-dev | 0.846028 | 1 | 0.846028 |
maikel233/X-HOOK-For-CSGO | 23,772 | DX9 SDK/Include/gameux.h |
/* this ALWAYS GENERATED file contains the definitions for the interfaces */
/* File created by MIDL compiler version 7.00.0550 */
/* Compiler settings for gameux.idl:
Oicf, W1, Zp8, env=Win32 (32b run), target_arch=X86 7.00.0550
protocol : dce , ms_ext, c_ext, robust
error checks: allocation ref bounds_check enum stub_data
VC __declspec() decoration level:
__declspec(uuid()), __declspec(selectany), __declspec(novtable)
DECLSPEC_UUID(), MIDL_INTERFACE()
*/
/* @@MIDL_FILE_HEADING( ) */
#pragma warning( disable: 4049 ) /* more than 64k source lines */
/* verify that the <rpcndr.h> version is high enough to compile this file*/
#ifndef __REQUIRED_RPCNDR_H_VERSION__
#define __REQUIRED_RPCNDR_H_VERSION__ 475
#endif
/* verify that the <rpcsal.h> version is high enough to compile this file*/
#ifndef __REQUIRED_RPCSAL_H_VERSION__
#define __REQUIRED_RPCSAL_H_VERSION__ 100
#endif
#include "rpc.h"
#include "rpcndr.h"
#ifndef __RPCNDR_H_VERSION__
#error this stub requires an updated version of <rpcndr.h>
#endif // __RPCNDR_H_VERSION__
#ifndef COM_NO_WINDOWS_H
#include "windows.h"
#include "ole2.h"
#endif /*COM_NO_WINDOWS_H*/
#ifndef __gameux_h__
#define __gameux_h__
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
#pragma once
#endif
/* Forward Declarations */
#ifndef __IGameExplorer_FWD_DEFINED__
#define __IGameExplorer_FWD_DEFINED__
typedef interface IGameExplorer IGameExplorer;
#endif /* __IGameExplorer_FWD_DEFINED__ */
#ifndef __IGameStatistics_FWD_DEFINED__
#define __IGameStatistics_FWD_DEFINED__
typedef interface IGameStatistics IGameStatistics;
#endif /* __IGameStatistics_FWD_DEFINED__ */
#ifndef __IGameStatisticsMgr_FWD_DEFINED__
#define __IGameStatisticsMgr_FWD_DEFINED__
typedef interface IGameStatisticsMgr IGameStatisticsMgr;
#endif /* __IGameStatisticsMgr_FWD_DEFINED__ */
#ifndef __IGameExplorer2_FWD_DEFINED__
#define __IGameExplorer2_FWD_DEFINED__
typedef interface IGameExplorer2 IGameExplorer2;
#endif /* __IGameExplorer2_FWD_DEFINED__ */
#ifndef __GameExplorer_FWD_DEFINED__
#define __GameExplorer_FWD_DEFINED__
#ifdef __cplusplus
typedef class GameExplorer GameExplorer;
#else
typedef struct GameExplorer GameExplorer;
#endif /* __cplusplus */
#endif /* __GameExplorer_FWD_DEFINED__ */
#ifndef __GameStatistics_FWD_DEFINED__
#define __GameStatistics_FWD_DEFINED__
#ifdef __cplusplus
typedef class GameStatistics GameStatistics;
#else
typedef struct GameStatistics GameStatistics;
#endif /* __cplusplus */
#endif /* __GameStatistics_FWD_DEFINED__ */
/* header files for imported files */
#include "oaidl.h"
#include "ocidl.h"
#include "shobjidl.h"
#ifdef __cplusplus
extern "C"{
#endif
/* interface __MIDL_itf_gameux_0000_0000 */
/* [local] */
#define ID_GDF_XML __GDF_XML
#define ID_GDF_THUMBNAIL __GDF_THUMBNAIL
#define ID_ICON_ICO __ICON_ICO
#define ID_GDF_XML_STR L"__GDF_XML"
#define ID_GDF_THUMBNAIL_STR L"__GDF_THUMBNAIL"
typedef /* [v1_enum] */
enum GAME_INSTALL_SCOPE
{ GIS_NOT_INSTALLED = 1,
GIS_CURRENT_USER = 2,
GIS_ALL_USERS = 3
} GAME_INSTALL_SCOPE;
extern RPC_IF_HANDLE __MIDL_itf_gameux_0000_0000_v0_0_c_ifspec;
extern RPC_IF_HANDLE __MIDL_itf_gameux_0000_0000_v0_0_s_ifspec;
#ifndef __IGameExplorer_INTERFACE_DEFINED__
#define __IGameExplorer_INTERFACE_DEFINED__
/* interface IGameExplorer */
/* [unique][helpstring][uuid][object] */
EXTERN_C const IID IID_IGameExplorer;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("E7B2FB72-D728-49B3-A5F2-18EBF5F1349E")
IGameExplorer : public IUnknown
{
public:
virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE AddGame(
/* [in] */ __RPC__in BSTR bstrGDFBinaryPath,
/* [in] */ __RPC__in BSTR bstrGameInstallDirectory,
/* [in] */ GAME_INSTALL_SCOPE installScope,
/* [out][in] */ __RPC__inout GUID *pguidInstanceID) = 0;
virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE RemoveGame(
/* [in] */ GUID guidInstanceID) = 0;
virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE UpdateGame(
/* [in] */ GUID guidInstanceID) = 0;
virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE VerifyAccess(
/* [in] */ __RPC__in BSTR bstrGDFBinaryPath,
/* [out] */ __RPC__out BOOL *pfHasAccess) = 0;
};
#else /* C style interface */
typedef struct IGameExplorerVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
__RPC__in IGameExplorer * This,
/* [in] */ __RPC__in REFIID riid,
/* [annotation][iid_is][out] */
__RPC__deref_out void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
__RPC__in IGameExplorer * This);
ULONG ( STDMETHODCALLTYPE *Release )(
__RPC__in IGameExplorer * This);
/* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *AddGame )(
__RPC__in IGameExplorer * This,
/* [in] */ __RPC__in BSTR bstrGDFBinaryPath,
/* [in] */ __RPC__in BSTR bstrGameInstallDirectory,
/* [in] */ GAME_INSTALL_SCOPE installScope,
/* [out][in] */ __RPC__inout GUID *pguidInstanceID);
/* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *RemoveGame )(
__RPC__in IGameExplorer * This,
/* [in] */ GUID guidInstanceID);
/* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *UpdateGame )(
__RPC__in IGameExplorer * This,
/* [in] */ GUID guidInstanceID);
/* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *VerifyAccess )(
__RPC__in IGameExplorer * This,
/* [in] */ __RPC__in BSTR bstrGDFBinaryPath,
/* [out] */ __RPC__out BOOL *pfHasAccess);
END_INTERFACE
} IGameExplorerVtbl;
interface IGameExplorer
{
CONST_VTBL struct IGameExplorerVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IGameExplorer_QueryInterface(This,riid,ppvObject) \
( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) )
#define IGameExplorer_AddRef(This) \
( (This)->lpVtbl -> AddRef(This) )
#define IGameExplorer_Release(This) \
( (This)->lpVtbl -> Release(This) )
#define IGameExplorer_AddGame(This,bstrGDFBinaryPath,bstrGameInstallDirectory,installScope,pguidInstanceID) \
( (This)->lpVtbl -> AddGame(This,bstrGDFBinaryPath,bstrGameInstallDirectory,installScope,pguidInstanceID) )
#define IGameExplorer_RemoveGame(This,guidInstanceID) \
( (This)->lpVtbl -> RemoveGame(This,guidInstanceID) )
#define IGameExplorer_UpdateGame(This,guidInstanceID) \
( (This)->lpVtbl -> UpdateGame(This,guidInstanceID) )
#define IGameExplorer_VerifyAccess(This,bstrGDFBinaryPath,pfHasAccess) \
( (This)->lpVtbl -> VerifyAccess(This,bstrGDFBinaryPath,pfHasAccess) )
#endif /* COBJMACROS */
#endif /* C style interface */
#endif /* __IGameExplorer_INTERFACE_DEFINED__ */
/* interface __MIDL_itf_gameux_0000_0001 */
/* [local] */
typedef /* [v1_enum] */
enum GAMESTATS_OPEN_TYPE
{ GAMESTATS_OPEN_OPENORCREATE = 0,
GAMESTATS_OPEN_OPENONLY = 1
} GAMESTATS_OPEN_TYPE;
typedef /* [v1_enum] */
enum GAMESTATS_OPEN_RESULT
{ GAMESTATS_OPEN_CREATED = 0,
GAMESTATS_OPEN_OPENED = 1
} GAMESTATS_OPEN_RESULT;
extern RPC_IF_HANDLE __MIDL_itf_gameux_0000_0001_v0_0_c_ifspec;
extern RPC_IF_HANDLE __MIDL_itf_gameux_0000_0001_v0_0_s_ifspec;
#ifndef __IGameStatistics_INTERFACE_DEFINED__
#define __IGameStatistics_INTERFACE_DEFINED__
/* interface IGameStatistics */
/* [unique][helpstring][uuid][object] */
EXTERN_C const IID IID_IGameStatistics;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("3887C9CA-04A0-42ae-BC4C-5FA6C7721145")
IGameStatistics : public IUnknown
{
public:
virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE GetMaxCategoryLength(
/* [retval][out] */ __RPC__out UINT *cch) = 0;
virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE GetMaxNameLength(
/* [retval][out] */ __RPC__out UINT *cch) = 0;
virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE GetMaxValueLength(
/* [retval][out] */ __RPC__out UINT *cch) = 0;
virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE GetMaxCategories(
/* [retval][out] */ __RPC__out WORD *pMax) = 0;
virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE GetMaxStatsPerCategory(
/* [retval][out] */ __RPC__out WORD *pMax) = 0;
virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE SetCategoryTitle(
/* [in] */ WORD categoryIndex,
/* [string][in] */ __RPC__in_string LPCWSTR title) = 0;
virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE GetCategoryTitle(
/* [in] */ WORD categoryIndex,
/* [retval][string][out] */ __RPC__deref_out_opt_string LPWSTR *pTitle) = 0;
virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE GetStatistic(
/* [in] */ WORD categoryIndex,
/* [in] */ WORD statIndex,
/* [string][unique][out][in] */ __RPC__deref_opt_inout_opt_string LPWSTR *pName,
/* [string][unique][out][in] */ __RPC__deref_opt_inout_opt_string LPWSTR *pValue) = 0;
virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE SetStatistic(
/* [in] */ WORD categoryIndex,
/* [in] */ WORD statIndex,
/* [string][in] */ __RPC__in_string LPCWSTR name,
/* [string][in] */ __RPC__in_string LPCWSTR value) = 0;
virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE Save(
/* [in] */ BOOL trackChanges) = 0;
virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE SetLastPlayedCategory(
/* [in] */ UINT categoryIndex) = 0;
virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE GetLastPlayedCategory(
/* [retval][out] */ __RPC__out UINT *pCategoryIndex) = 0;
};
#else /* C style interface */
typedef struct IGameStatisticsVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
__RPC__in IGameStatistics * This,
/* [in] */ __RPC__in REFIID riid,
/* [annotation][iid_is][out] */
__RPC__deref_out void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
__RPC__in IGameStatistics * This);
ULONG ( STDMETHODCALLTYPE *Release )(
__RPC__in IGameStatistics * This);
/* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetMaxCategoryLength )(
__RPC__in IGameStatistics * This,
/* [retval][out] */ __RPC__out UINT *cch);
/* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetMaxNameLength )(
__RPC__in IGameStatistics * This,
/* [retval][out] */ __RPC__out UINT *cch);
/* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetMaxValueLength )(
__RPC__in IGameStatistics * This,
/* [retval][out] */ __RPC__out UINT *cch);
/* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetMaxCategories )(
__RPC__in IGameStatistics * This,
/* [retval][out] */ __RPC__out WORD *pMax);
/* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetMaxStatsPerCategory )(
__RPC__in IGameStatistics * This,
/* [retval][out] */ __RPC__out WORD *pMax);
/* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *SetCategoryTitle )(
__RPC__in IGameStatistics * This,
/* [in] */ WORD categoryIndex,
/* [string][in] */ __RPC__in_string LPCWSTR title);
/* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetCategoryTitle )(
__RPC__in IGameStatistics * This,
/* [in] */ WORD categoryIndex,
/* [retval][string][out] */ __RPC__deref_out_opt_string LPWSTR *pTitle);
/* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetStatistic )(
__RPC__in IGameStatistics * This,
/* [in] */ WORD categoryIndex,
/* [in] */ WORD statIndex,
/* [string][unique][out][in] */ __RPC__deref_opt_inout_opt_string LPWSTR *pName,
/* [string][unique][out][in] */ __RPC__deref_opt_inout_opt_string LPWSTR *pValue);
/* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *SetStatistic )(
__RPC__in IGameStatistics * This,
/* [in] */ WORD categoryIndex,
/* [in] */ WORD statIndex,
/* [string][in] */ __RPC__in_string LPCWSTR name,
/* [string][in] */ __RPC__in_string LPCWSTR value);
/* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *Save )(
__RPC__in IGameStatistics * This,
/* [in] */ BOOL trackChanges);
/* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *SetLastPlayedCategory )(
__RPC__in IGameStatistics * This,
/* [in] */ UINT categoryIndex);
/* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetLastPlayedCategory )(
__RPC__in IGameStatistics * This,
/* [retval][out] */ __RPC__out UINT *pCategoryIndex);
END_INTERFACE
} IGameStatisticsVtbl;
interface IGameStatistics
{
CONST_VTBL struct IGameStatisticsVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IGameStatistics_QueryInterface(This,riid,ppvObject) \
( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) )
#define IGameStatistics_AddRef(This) \
( (This)->lpVtbl -> AddRef(This) )
#define IGameStatistics_Release(This) \
( (This)->lpVtbl -> Release(This) )
#define IGameStatistics_GetMaxCategoryLength(This,cch) \
( (This)->lpVtbl -> GetMaxCategoryLength(This,cch) )
#define IGameStatistics_GetMaxNameLength(This,cch) \
( (This)->lpVtbl -> GetMaxNameLength(This,cch) )
#define IGameStatistics_GetMaxValueLength(This,cch) \
( (This)->lpVtbl -> GetMaxValueLength(This,cch) )
#define IGameStatistics_GetMaxCategories(This,pMax) \
( (This)->lpVtbl -> GetMaxCategories(This,pMax) )
#define IGameStatistics_GetMaxStatsPerCategory(This,pMax) \
( (This)->lpVtbl -> GetMaxStatsPerCategory(This,pMax) )
#define IGameStatistics_SetCategoryTitle(This,categoryIndex,title) \
( (This)->lpVtbl -> SetCategoryTitle(This,categoryIndex,title) )
#define IGameStatistics_GetCategoryTitle(This,categoryIndex,pTitle) \
( (This)->lpVtbl -> GetCategoryTitle(This,categoryIndex,pTitle) )
#define IGameStatistics_GetStatistic(This,categoryIndex,statIndex,pName,pValue) \
( (This)->lpVtbl -> GetStatistic(This,categoryIndex,statIndex,pName,pValue) )
#define IGameStatistics_SetStatistic(This,categoryIndex,statIndex,name,value) \
( (This)->lpVtbl -> SetStatistic(This,categoryIndex,statIndex,name,value) )
#define IGameStatistics_Save(This,trackChanges) \
( (This)->lpVtbl -> Save(This,trackChanges) )
#define IGameStatistics_SetLastPlayedCategory(This,categoryIndex) \
( (This)->lpVtbl -> SetLastPlayedCategory(This,categoryIndex) )
#define IGameStatistics_GetLastPlayedCategory(This,pCategoryIndex) \
( (This)->lpVtbl -> GetLastPlayedCategory(This,pCategoryIndex) )
#endif /* COBJMACROS */
#endif /* C style interface */
#endif /* __IGameStatistics_INTERFACE_DEFINED__ */
#ifndef __IGameStatisticsMgr_INTERFACE_DEFINED__
#define __IGameStatisticsMgr_INTERFACE_DEFINED__
/* interface IGameStatisticsMgr */
/* [unique][helpstring][uuid][object] */
EXTERN_C const IID IID_IGameStatisticsMgr;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("AFF3EA11-E70E-407d-95DD-35E612C41CE2")
IGameStatisticsMgr : public IUnknown
{
public:
virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE GetGameStatistics(
/* [string][in] */ __RPC__in_string LPCWSTR GDFBinaryPath,
/* [in] */ GAMESTATS_OPEN_TYPE openType,
/* [out] */ __RPC__out GAMESTATS_OPEN_RESULT *pOpenResult,
/* [retval][out] */ __RPC__deref_out_opt IGameStatistics **ppiStats) = 0;
virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE RemoveGameStatistics(
/* [string][in] */ __RPC__in_string LPCWSTR GDFBinaryPath) = 0;
};
#else /* C style interface */
typedef struct IGameStatisticsMgrVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
__RPC__in IGameStatisticsMgr * This,
/* [in] */ __RPC__in REFIID riid,
/* [annotation][iid_is][out] */
__RPC__deref_out void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
__RPC__in IGameStatisticsMgr * This);
ULONG ( STDMETHODCALLTYPE *Release )(
__RPC__in IGameStatisticsMgr * This);
/* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetGameStatistics )(
__RPC__in IGameStatisticsMgr * This,
/* [string][in] */ __RPC__in_string LPCWSTR GDFBinaryPath,
/* [in] */ GAMESTATS_OPEN_TYPE openType,
/* [out] */ __RPC__out GAMESTATS_OPEN_RESULT *pOpenResult,
/* [retval][out] */ __RPC__deref_out_opt IGameStatistics **ppiStats);
/* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *RemoveGameStatistics )(
__RPC__in IGameStatisticsMgr * This,
/* [string][in] */ __RPC__in_string LPCWSTR GDFBinaryPath);
END_INTERFACE
} IGameStatisticsMgrVtbl;
interface IGameStatisticsMgr
{
CONST_VTBL struct IGameStatisticsMgrVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IGameStatisticsMgr_QueryInterface(This,riid,ppvObject) \
( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) )
#define IGameStatisticsMgr_AddRef(This) \
( (This)->lpVtbl -> AddRef(This) )
#define IGameStatisticsMgr_Release(This) \
( (This)->lpVtbl -> Release(This) )
#define IGameStatisticsMgr_GetGameStatistics(This,GDFBinaryPath,openType,pOpenResult,ppiStats) \
( (This)->lpVtbl -> GetGameStatistics(This,GDFBinaryPath,openType,pOpenResult,ppiStats) )
#define IGameStatisticsMgr_RemoveGameStatistics(This,GDFBinaryPath) \
( (This)->lpVtbl -> RemoveGameStatistics(This,GDFBinaryPath) )
#endif /* COBJMACROS */
#endif /* C style interface */
#endif /* __IGameStatisticsMgr_INTERFACE_DEFINED__ */
#ifndef __IGameExplorer2_INTERFACE_DEFINED__
#define __IGameExplorer2_INTERFACE_DEFINED__
/* interface IGameExplorer2 */
/* [unique][helpstring][uuid][object] */
EXTERN_C const IID IID_IGameExplorer2;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("86874AA7-A1ED-450d-A7EB-B89E20B2FFF3")
IGameExplorer2 : public IUnknown
{
public:
virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE InstallGame(
/* [string][in] */ __RPC__in_string LPCWSTR binaryGDFPath,
/* [unique][in] */ __RPC__in_opt LPCWSTR installDirectory,
/* [in] */ GAME_INSTALL_SCOPE installScope) = 0;
virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE UninstallGame(
/* [string][in] */ __RPC__in_string LPCWSTR binaryGDFPath) = 0;
virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE CheckAccess(
/* [string][in] */ __RPC__in_string LPCWSTR binaryGDFPath,
/* [retval][out] */ __RPC__out BOOL *pHasAccess) = 0;
};
#else /* C style interface */
typedef struct IGameExplorer2Vtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
__RPC__in IGameExplorer2 * This,
/* [in] */ __RPC__in REFIID riid,
/* [annotation][iid_is][out] */
__RPC__deref_out void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
__RPC__in IGameExplorer2 * This);
ULONG ( STDMETHODCALLTYPE *Release )(
__RPC__in IGameExplorer2 * This);
/* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *InstallGame )(
__RPC__in IGameExplorer2 * This,
/* [string][in] */ __RPC__in_string LPCWSTR binaryGDFPath,
/* [unique][in] */ __RPC__in_opt LPCWSTR installDirectory,
/* [in] */ GAME_INSTALL_SCOPE installScope);
/* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *UninstallGame )(
__RPC__in IGameExplorer2 * This,
/* [string][in] */ __RPC__in_string LPCWSTR binaryGDFPath);
/* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *CheckAccess )(
__RPC__in IGameExplorer2 * This,
/* [string][in] */ __RPC__in_string LPCWSTR binaryGDFPath,
/* [retval][out] */ __RPC__out BOOL *pHasAccess);
END_INTERFACE
} IGameExplorer2Vtbl;
interface IGameExplorer2
{
CONST_VTBL struct IGameExplorer2Vtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IGameExplorer2_QueryInterface(This,riid,ppvObject) \
( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) )
#define IGameExplorer2_AddRef(This) \
( (This)->lpVtbl -> AddRef(This) )
#define IGameExplorer2_Release(This) \
( (This)->lpVtbl -> Release(This) )
#define IGameExplorer2_InstallGame(This,binaryGDFPath,installDirectory,installScope) \
( (This)->lpVtbl -> InstallGame(This,binaryGDFPath,installDirectory,installScope) )
#define IGameExplorer2_UninstallGame(This,binaryGDFPath) \
( (This)->lpVtbl -> UninstallGame(This,binaryGDFPath) )
#define IGameExplorer2_CheckAccess(This,binaryGDFPath,pHasAccess) \
( (This)->lpVtbl -> CheckAccess(This,binaryGDFPath,pHasAccess) )
#endif /* COBJMACROS */
#endif /* C style interface */
#endif /* __IGameExplorer2_INTERFACE_DEFINED__ */
#ifndef __gameuxLib_LIBRARY_DEFINED__
#define __gameuxLib_LIBRARY_DEFINED__
/* library gameuxLib */
/* [helpstring][version][uuid] */
EXTERN_C const IID LIBID_gameuxLib;
EXTERN_C const CLSID CLSID_GameExplorer;
#ifdef __cplusplus
class DECLSPEC_UUID("9A5EA990-3034-4D6F-9128-01F3C61022BC")
GameExplorer;
#endif
EXTERN_C const CLSID CLSID_GameStatistics;
#ifdef __cplusplus
class DECLSPEC_UUID("DBC85A2C-C0DC-4961-B6E2-D28B62C11AD4")
GameStatistics;
#endif
#endif /* __gameuxLib_LIBRARY_DEFINED__ */
/* Additional Prototypes for ALL interfaces */
unsigned long __RPC_USER BSTR_UserSize( __RPC__in unsigned long *, unsigned long , __RPC__in BSTR * );
unsigned char * __RPC_USER BSTR_UserMarshal( __RPC__in unsigned long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in BSTR * );
unsigned char * __RPC_USER BSTR_UserUnmarshal(__RPC__in unsigned long *, __RPC__in_xcount(0) unsigned char *, __RPC__out BSTR * );
void __RPC_USER BSTR_UserFree( __RPC__in unsigned long *, __RPC__in BSTR * );
unsigned long __RPC_USER BSTR_UserSize64( __RPC__in unsigned long *, unsigned long , __RPC__in BSTR * );
unsigned char * __RPC_USER BSTR_UserMarshal64( __RPC__in unsigned long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in BSTR * );
unsigned char * __RPC_USER BSTR_UserUnmarshal64(__RPC__in unsigned long *, __RPC__in_xcount(0) unsigned char *, __RPC__out BSTR * );
void __RPC_USER BSTR_UserFree64( __RPC__in unsigned long *, __RPC__in BSTR * );
/* end of Additional Prototypes */
#ifdef __cplusplus
}
#endif
#endif
| 1 | 0.810512 | 1 | 0.810512 | game-dev | MEDIA | 0.323504 | game-dev | 0.635834 | 1 | 0.635834 |
revolucas/CoC-Xray | 20,988 | src/xrGame/object_handler_planner_weapon.cpp | ////////////////////////////////////////////////////////////////////////////
// Module : object_handler_planner_weapon.cpp
// Created : 11.03.2004
// Modified : 01.12.2004
// Author : Dmitriy Iassenev
// Description : Object handler action planner weapon handling
////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "object_handler_planner.h"
#include "object_property_evaluators.h"
#include "object_actions.h"
#include "object_handler_space.h"
#include "weapon.h"
#include "object_handler_planner_impl.h"
#include "ai/stalker/ai_stalker.h"
using namespace ObjectHandlerSpace;
void CObjectHandlerPlanner::add_evaluators (CWeapon *weapon)
{
u16 id = weapon->ID();
// dynamic state properties
//. add_evaluator (uid(id,eWorldPropertyHidden) ,xr_new<CObjectPropertyEvaluatorState>(weapon,m_object,CWeapon::eHidden));
add_evaluator (uid(id,eWorldPropertyHidden) ,xr_new<CObjectPropertyEvaluatorWeaponHidden>(weapon,m_object));
// dynamic member properties
add_evaluator (uid(id,eWorldPropertyAimed1) ,xr_new<CObjectPropertyEvaluatorMember>(&m_storage,eWorldPropertyAimed1,true));
add_evaluator (uid(id,eWorldPropertyAimed2) ,xr_new<CObjectPropertyEvaluatorMember>(&m_storage,eWorldPropertyAimed2,true));
add_evaluator (uid(id,eWorldPropertyStrapped) ,xr_new<CObjectPropertyEvaluatorMember>(&m_storage,eWorldPropertyStrapped,true));
add_evaluator (uid(id,eWorldPropertyStrapped2Idle) ,xr_new<CObjectPropertyEvaluatorMember>(&m_storage,eWorldPropertyStrapped2Idle,true));
// dynamic properties
add_evaluator (uid(id,eWorldPropertyAmmo1) ,xr_new<CObjectPropertyEvaluatorAmmo> (weapon,m_object,0));
add_evaluator (uid(id,eWorldPropertyAmmo2) ,xr_new<CObjectPropertyEvaluatorAmmo> (weapon,m_object,1));
add_evaluator (uid(id,eWorldPropertyEmpty1) ,xr_new<CObjectPropertyEvaluatorEmpty>(weapon,m_object,0));
add_evaluator (uid(id,eWorldPropertyEmpty2) ,xr_new<CObjectPropertyEvaluatorEmpty>(weapon,m_object,1));
add_evaluator (uid(id,eWorldPropertyFull1) ,xr_new<CObjectPropertyEvaluatorFull> (weapon,m_object,0));
add_evaluator (uid(id,eWorldPropertyFull2) ,xr_new<CObjectPropertyEvaluatorFull> (weapon,m_object,1));
add_evaluator (uid(id,eWorldPropertyReady1) ,xr_new<CObjectPropertyEvaluatorReady>(weapon,m_object,0));
add_evaluator (uid(id,eWorldPropertyReady2) ,xr_new<CObjectPropertyEvaluatorReady>(weapon,m_object,1));
add_evaluator (uid(id,eWorldPropertyQueueWait1) ,xr_new<CObjectPropertyEvaluatorQueue>(weapon,m_object,0));
add_evaluator (uid(id,eWorldPropertyQueueWait2) ,xr_new<CObjectPropertyEvaluatorQueue>(weapon,m_object,1));
// temporary const properties
add_evaluator (uid(id,eWorldPropertySwitch1) ,xr_new<CObjectPropertyEvaluatorConst>(true));
add_evaluator (uid(id,eWorldPropertySwitch2) ,xr_new<CObjectPropertyEvaluatorConst>(false));
// const properties
add_evaluator (uid(id,eWorldPropertyFiring1) ,xr_new<CObjectPropertyEvaluatorConst>(false));
add_evaluator (uid(id,eWorldPropertyFiringNoReload1) ,xr_new<CObjectPropertyEvaluatorConst>(false));
add_evaluator (uid(id,eWorldPropertyFiring2) ,xr_new<CObjectPropertyEvaluatorConst>(false));
add_evaluator (uid(id,eWorldPropertyIdle) ,xr_new<CObjectPropertyEvaluatorConst>(false));
add_evaluator (uid(id,eWorldPropertyIdleStrap) ,xr_new<CObjectPropertyEvaluatorConst>(false));
add_evaluator (uid(id,eWorldPropertyDropped) ,xr_new<CObjectPropertyEvaluatorConst>(false));
add_evaluator (uid(id,eWorldPropertyAiming1) ,xr_new<CObjectPropertyEvaluatorConst>(false));
add_evaluator (uid(id,eWorldPropertyAiming2) ,xr_new<CObjectPropertyEvaluatorConst>(false));
add_evaluator (uid(id,eWorldPropertyAimingReady1) ,xr_new<CObjectPropertyEvaluatorConst>(false));
add_evaluator (uid(id,eWorldPropertyAimingReady2) ,xr_new<CObjectPropertyEvaluatorConst>(false));
add_evaluator (uid(id,eWorldPropertyAimForceFull1) ,xr_new<CObjectPropertyEvaluatorConst>(false));
add_evaluator (uid(id,eWorldPropertyAimForceFull2) ,xr_new<CObjectPropertyEvaluatorConst>(false));
}
void CObjectHandlerPlanner::add_operators (CWeapon *weapon)
{
u16 id = weapon->ID(), ff = 0xffff;
CActionBase<CAI_Stalker> *action;
// show
action = xr_new<CObjectActionShow>(weapon,m_object,&m_storage,"show");
add_condition (action,id,eWorldPropertyHidden, true);
add_condition (action,ff,eWorldPropertyItemID, true);
add_effect (action,ff,eWorldPropertyItemID, false);
add_effect (action,id,eWorldPropertyHidden, false);
add_operator (uid(id,eWorldOperatorShow), action);
// hide
action = xr_new<CObjectActionHide>(weapon,m_object,&m_storage,"hide");
add_condition (action,id,eWorldPropertyHidden, false);
add_condition (action,ff,eWorldPropertyItemID, false);
add_condition (action,id,eWorldPropertyStrapped, false);
add_condition (action,id,eWorldPropertyStrapped2Idle, false);
add_effect (action,ff,eWorldPropertyItemID, true);
add_effect (action,id,eWorldPropertyHidden, true);
add_effect (action,id,eWorldPropertyAimed1, false);
add_effect (action,id,eWorldPropertyAimed2, false);
add_operator (uid(id,eWorldOperatorHide), action);
// drop
action = xr_new<CObjectActionDrop>(weapon,m_object,&m_storage,"drop");
add_condition (action,id,eWorldPropertyHidden, false);
add_condition (action,id,eWorldPropertyStrapped, false);
add_condition (action,id,eWorldPropertyStrapped2Idle, false);
add_effect (action,id,eWorldPropertyDropped, true);
add_effect (action,id,eWorldPropertyAimed1, false);
add_effect (action,id,eWorldPropertyAimed2, false);
add_operator (uid(id,eWorldOperatorDrop), action);
// idle
action = xr_new<CSObjectActionBase>(weapon,m_object,&m_storage,"idle");
add_condition (action,id,eWorldPropertyHidden, false);
add_condition (action,id,eWorldPropertyStrapped, false);
add_condition (action,id,eWorldPropertyStrapped2Idle, false);
add_effect (action,id,eWorldPropertyIdle, true);
add_effect (action,id,eWorldPropertyAimed1, false);
add_effect (action,id,eWorldPropertyAimed2, false);
add_operator (uid(id,eWorldOperatorIdle), action);
// strapping
action = xr_new<CObjectActionStrapping>(weapon,m_object,&m_storage,"strapping");
add_condition (action,id,eWorldPropertyHidden, false);
add_condition (action,id,eWorldPropertyStrapped, false);
add_effect (action,id,eWorldPropertyStrapped2Idle, true);
add_effect (action,id,eWorldPropertyStrapped, true);
add_effect (action,id,eWorldPropertyAimed1, false);
add_effect (action,id,eWorldPropertyAimed2, false);
add_operator (uid(id,eWorldOperatorStrapping), action);
action = xr_new<CObjectActionStrappingToIdle>(weapon,m_object,&m_storage,"strapping to idle");
add_condition (action,id,eWorldPropertyHidden, false);
add_condition (action,id,eWorldPropertyStrapped, true);
add_condition (action,id,eWorldPropertyStrapped2Idle, true);
add_effect (action,id,eWorldPropertyStrapped2Idle, false);
add_operator (uid(id,eWorldOperatorStrapping2Idle), action);
// unstrapping
action = xr_new<CObjectActionUnstrapping>(weapon,m_object,&m_storage,"unstrapping");
add_condition (action,id,eWorldPropertyHidden, false);
add_condition (action,id,eWorldPropertyStrapped, true);
add_effect (action,id,eWorldPropertyStrapped, false);
add_effect (action,id,eWorldPropertyStrapped2Idle, true);
add_operator (uid(id,eWorldOperatorUnstrapping), action);
action = xr_new<CObjectActionUnstrappingToIdle>(weapon,m_object,&m_storage,"unstrapping to idle");
add_condition (action,id,eWorldPropertyHidden, false);
add_condition (action,id,eWorldPropertyStrapped, false);
add_condition (action,id,eWorldPropertyStrapped2Idle, true);
add_effect (action,id,eWorldPropertyStrapped2Idle, false);
add_operator (uid(id,eWorldOperatorUnstrapping2Idle),action);
// strapped
action = xr_new<CSObjectActionBase>(weapon,m_object,&m_storage,"strapped");
add_condition (action,id,eWorldPropertyHidden, false);
add_condition (action,id,eWorldPropertyStrapped, true);
add_condition (action,id,eWorldPropertyStrapped2Idle, false);
add_condition (action,id,eWorldPropertyIdleStrap, false);
add_effect (action,id,eWorldPropertyIdleStrap, true);
add_operator (uid(id,eWorldOperatorStrapped), action);
// aim1
action = xr_new<CObjectActionAim>(weapon,m_object,&m_storage,eWorldPropertyAimed1,true,"aim1");
add_condition (action,id,eWorldPropertyHidden, false);
add_condition (action,id,eWorldPropertySwitch1, true);
add_condition (action,id,eWorldPropertyStrapped, false);
add_condition (action,id,eWorldPropertyStrapped2Idle, false);
add_effect (action,id,eWorldPropertyAimed1, true);
add_effect (action,id,eWorldPropertyAiming1, true);
add_effect (action,id,eWorldPropertyAimed2, false);
add_operator (uid(id,eWorldOperatorAim1), action);
// aim2
action = xr_new<CObjectActionAim>(weapon,m_object,&m_storage,eWorldPropertyAimed2,true,"aim2");
add_condition (action,id,eWorldPropertyHidden, false);
add_condition (action,id,eWorldPropertySwitch2, true);
add_condition (action,id,eWorldPropertyStrapped, false);
add_condition (action,id,eWorldPropertyStrapped2Idle, false);
add_effect (action,id,eWorldPropertyAimed2, true);
add_effect (action,id,eWorldPropertyAiming2, true);
add_effect (action,id,eWorldPropertyAimed1, false);
add_operator (uid(id,eWorldOperatorAim2), action);
// aim_queue1
action = xr_new<CObjectActionQueueWait>(weapon,m_object,&m_storage,uid(id,eWorldPropertyQueueWait1),"aim_queue1");
add_condition (action,id,eWorldPropertyHidden, false);
add_condition (action,id,eWorldPropertySwitch1, true);
add_condition (action,id,eWorldPropertyQueueWait1,false);
add_condition (action,id,eWorldPropertyStrapped, false);
add_condition (action,id,eWorldPropertyStrapped2Idle, false);
add_effect (action,id,eWorldPropertyQueueWait1,true);
add_effect (action,id,eWorldPropertyAimed2, false);
add_operator (uid(id,eWorldOperatorQueueWait1), action);
// aim_queue2
action = xr_new<CObjectActionQueueWait>(weapon,m_object,&m_storage,uid(id,eWorldPropertyQueueWait2),"aim_queue2");
add_condition (action,id,eWorldPropertyHidden, false);
add_condition (action,id,eWorldPropertySwitch1, true);
add_condition (action,id,eWorldPropertyQueueWait2,false);
add_condition (action,id,eWorldPropertyStrapped, false);
add_condition (action,id,eWorldPropertyStrapped2Idle, false);
add_effect (action,id,eWorldPropertyQueueWait2,true);
add_effect (action,id,eWorldPropertyAimed1, false);
add_operator (uid(id,eWorldOperatorQueueWait2), action);
// fire1
action = xr_new<CObjectActionFire>(weapon,m_object,&m_storage,uid(id,eWorldPropertyQueueWait1),"fire1");
add_condition (action,id,eWorldPropertyHidden, false);
add_condition (action,id,eWorldPropertyReady1, true);
add_condition (action,id,eWorldPropertyEmpty1, false);
add_condition (action,id,eWorldPropertyAimed1, true);
add_condition (action,id,eWorldPropertySwitch1, true);
add_condition (action,id,eWorldPropertyQueueWait1,true);
add_condition (action,id,eWorldPropertyStrapped, false);
add_condition (action,id,eWorldPropertyStrapped2Idle, false);
add_effect (action,id,eWorldPropertyFiring1, true);
add_operator (uid(id,eWorldOperatorFire1), action);
// fire no reload
action = xr_new<CObjectActionFireNoReload>(weapon,m_object,&m_storage,uid(id,eWorldPropertyQueueWait1),"fire_no_reload");
add_condition (action,id,eWorldPropertyHidden, false);
// add_condition (action,id,eWorldPropertyEmpty1, false);
// add_condition (action,id,eWorldPropertyAimed1, true);
add_condition (action,id,eWorldPropertySwitch1, true);
// add_condition (action,id,eWorldPropertyQueueWait1,true);
add_condition (action,id,eWorldPropertyStrapped, false);
add_condition (action,id,eWorldPropertyStrapped2Idle, false);
add_effect (action,id,eWorldPropertyFiringNoReload1, true);
add_operator (uid(id,eWorldOperatorFireNoReload),action);
// fire2
action = xr_new<CObjectActionFire>(weapon,m_object,&m_storage,uid(id,eWorldPropertyQueueWait2),"fire2");
add_condition (action,id,eWorldPropertyHidden, false);
add_condition (action,id,eWorldPropertyReady2, true);
add_condition (action,id,eWorldPropertyEmpty2, false);
add_condition (action,id,eWorldPropertyAimed2, true);
add_condition (action,id,eWorldPropertySwitch2, true);
add_condition (action,id,eWorldPropertyQueueWait2,true);
add_condition (action,id,eWorldPropertyStrapped, false);
add_condition (action,id,eWorldPropertyStrapped2Idle, false);
add_effect (action,id,eWorldPropertyFiring2, true);
add_operator (uid(id,eWorldOperatorFire2), action);
// reload1
action = xr_new<CObjectActionReload>(weapon,m_object,&m_storage,0,"reload1");
add_condition (action,id,eWorldPropertyHidden, false);
add_condition (action,id,eWorldPropertyReady1, false);
add_condition (action,id,eWorldPropertyAmmo1, true);
add_condition (action,id,eWorldPropertyStrapped, false);
add_condition (action,id,eWorldPropertyStrapped2Idle, false);
add_effect (action,id,eWorldPropertyEmpty1, false);
add_effect (action,id,eWorldPropertyReady1, true);
add_effect (action,id,eWorldPropertyAimed1, false);
add_effect (action,id,eWorldPropertyAimed2, false);
add_operator (uid(id,eWorldOperatorReload1), action);
// reload2
action = xr_new<CObjectActionReload>(weapon,m_object,&m_storage,1,"reload2");
add_condition (action,id,eWorldPropertyHidden, false);
add_condition (action,id,eWorldPropertyReady2, false);
add_condition (action,id,eWorldPropertyAmmo2, true);
add_condition (action,id,eWorldPropertyStrapped, false);
add_condition (action,id,eWorldPropertyStrapped2Idle, false);
add_effect (action,id,eWorldPropertyEmpty2, false);
add_effect (action,id,eWorldPropertyReady2, true);
add_effect (action,id,eWorldPropertyAimed1, false);
add_effect (action,id,eWorldPropertyAimed2, false);
add_operator (uid(id,eWorldOperatorReload2), action);
// force_reload1
action = xr_new<CObjectActionReload>(weapon,m_object,&m_storage,0,"force_reload1");
add_condition (action,id,eWorldPropertyHidden, false);
add_condition (action,id,eWorldPropertyFull1, false);
add_condition (action,id,eWorldPropertyAmmo1, true);
add_condition (action,id,eWorldPropertyStrapped, false);
add_condition (action,id,eWorldPropertyStrapped2Idle, false);
add_effect (action,id,eWorldPropertyEmpty1, false);
add_effect (action,id,eWorldPropertyReady1, true);
add_effect (action,id,eWorldPropertyFull1, true);
add_effect (action,id,eWorldPropertyAimed1, false);
add_effect (action,id,eWorldPropertyAimed2, false);
add_operator (uid(id,eWorldOperatorForceReload1),action);
// force_reload2
action = xr_new<CObjectActionReload>(weapon,m_object,&m_storage,0,"force_reload2");
add_condition (action,id,eWorldPropertyHidden, false);
add_condition (action,id,eWorldPropertyFull2, false);
add_condition (action,id,eWorldPropertyAmmo2, true);
add_condition (action,id,eWorldPropertyStrapped, false);
add_condition (action,id,eWorldPropertyStrapped2Idle, false);
add_effect (action,id,eWorldPropertyEmpty2, false);
add_effect (action,id,eWorldPropertyReady2, true);
add_effect (action,id,eWorldPropertyFull2, true);
add_effect (action,id,eWorldPropertyAimed1, false);
add_effect (action,id,eWorldPropertyAimed2, false);
add_operator (uid(id,eWorldOperatorForceReload2),action);
// switch1
action = xr_new<CObjectActionSwitch>(weapon,m_object,&m_storage,0,"switch1");
add_condition (action,id,eWorldPropertySwitch1, false);
add_condition (action,id,eWorldPropertySwitch2, true);
add_condition (action,id,eWorldPropertyStrapped, false);
add_condition (action,id,eWorldPropertyStrapped2Idle, false);
add_effect (action,id,eWorldPropertySwitch1, true);
add_effect (action,id,eWorldPropertySwitch2, false);
add_effect (action,id,eWorldPropertyAimed1, false);
add_effect (action,id,eWorldPropertyAimed2, false);
add_operator (uid(id,eWorldOperatorSwitch1), action);
// switch2
action = xr_new<CObjectActionSwitch>(weapon,m_object,&m_storage,1,"switch2");
add_condition (action,id,eWorldPropertySwitch1, true);
add_condition (action,id,eWorldPropertySwitch2, false);
add_condition (action,id,eWorldPropertyStrapped, false);
add_condition (action,id,eWorldPropertyStrapped2Idle, false);
add_effect (action,id,eWorldPropertySwitch1, false);
add_effect (action,id,eWorldPropertySwitch2, true);
add_effect (action,id,eWorldPropertyAimed1, false);
add_effect (action,id,eWorldPropertyAimed2, false);
add_operator (uid(id,eWorldOperatorSwitch2), action);
// aiming ready1
action = xr_new<CObjectActionAim>(weapon,m_object,&m_storage,eWorldPropertyAimed1,true,"aim_ready1");
add_condition (action,id,eWorldPropertyHidden, false);
add_condition (action,id,eWorldPropertySwitch1, true);
add_condition (action,id,eWorldPropertyReady1, true);
add_condition (action,id,eWorldPropertyStrapped, false);
add_condition (action,id,eWorldPropertyStrapped2Idle, false);
add_effect (action,id,eWorldPropertyAimed1, true);
add_effect (action,id,eWorldPropertyAimingReady1,true);
add_effect (action,id,eWorldPropertyAimed2, false);
add_operator (uid(id,eWorldOperatorAimingReady1),action);
// aiming ready2
action = xr_new<CObjectActionAim>(weapon,m_object,&m_storage,eWorldPropertyAimed2,true,"aim_ready2");
add_condition (action,id,eWorldPropertyHidden, false);
add_condition (action,id,eWorldPropertySwitch2, true);
add_condition (action,id,eWorldPropertyStrapped, false);
add_condition (action,id,eWorldPropertyStrapped2Idle, false);
add_effect (action,id,eWorldPropertyAimed2, true);
add_effect (action,id,eWorldPropertyAimingReady2,true);
add_effect (action,id,eWorldPropertyAimed1, false);
add_operator (uid(id,eWorldOperatorAimingReady2),action);
// force aim full 1
action = xr_new<CObjectActionAim>(weapon,m_object,&m_storage,eWorldPropertyAimed1,true,"aim_ready1");
add_condition (action,id,eWorldPropertyHidden, false);
add_condition (action,id,eWorldPropertySwitch1, true);
add_condition (action,id,eWorldPropertyReady1, true);
add_condition (action,id,eWorldPropertyFull1, true);
add_condition (action,id,eWorldPropertyStrapped, false);
add_condition (action,id,eWorldPropertyStrapped2Idle, false);
add_effect (action,id,eWorldPropertyAimed1, true);
add_effect (action,id,eWorldPropertyAimForceFull1, true);
// add_effect (action,id,eWorldPropertyAimingReady1,true);
add_effect (action,id,eWorldPropertyAimed2, false);
add_operator (uid(id,eWorldOperatorAimForceFull1),action);
// force aim full 2
action = xr_new<CObjectActionAim>(weapon,m_object,&m_storage,eWorldPropertyAimed2,true,"aim_ready2");
add_condition (action,id,eWorldPropertyHidden, false);
add_condition (action,id,eWorldPropertySwitch2, true);
add_condition (action,id,eWorldPropertyReady2, true);
add_condition (action,id,eWorldPropertyFull2, true);
add_condition (action,id,eWorldPropertyStrapped, false);
add_condition (action,id,eWorldPropertyStrapped2Idle, false);
add_effect (action,id,eWorldPropertyAimed2, true);
add_effect (action,id,eWorldPropertyAimForceFull2, true);
// add_effect (action,id,eWorldPropertyAimingReady2,true);
add_effect (action,id,eWorldPropertyAimed1, false);
add_operator (uid(id,eWorldOperatorAimForceFull2),action);
// fake action get ammo
action = xr_new<CSObjectActionBase>(weapon,m_object,&m_storage,"fake_get_ammo1");
add_condition (action,id,eWorldPropertyHidden, false);
add_condition (action,id,eWorldPropertyAmmo1, false);
add_condition (action,id,eWorldPropertyStrapped, false);
add_condition (action,id,eWorldPropertyStrapped2Idle, false);
add_effect (action,id,eWorldPropertyAmmo1, true);
add_operator (uid(id,eWorldOperatorGetAmmo1), action);
action = xr_new<CSObjectActionBase>(weapon,m_object,&m_storage,"fake_get_ammo2");
add_condition (action,id,eWorldPropertyHidden, false);
add_condition (action,id,eWorldPropertyAmmo2, false);
add_condition (action,id,eWorldPropertyStrapped, false);
add_condition (action,id,eWorldPropertyStrapped2Idle, false);
add_effect (action,id,eWorldPropertyAmmo2, true);
add_operator (uid(id,eWorldOperatorGetAmmo2), action);
this->action(uid(id,eWorldOperatorAim1)).set_inertia_time(500);
this->action(uid(id,eWorldOperatorAim2)).set_inertia_time(500);
this->action(uid(id,eWorldOperatorAimingReady1)).set_inertia_time(500);
this->action(uid(id,eWorldOperatorAimingReady2)).set_inertia_time(500);
this->action(uid(id,eWorldOperatorAimForceFull1)).set_inertia_time(500);
this->action(uid(id,eWorldOperatorAimForceFull2)).set_inertia_time(500);
this->action(uid(id,eWorldOperatorQueueWait1)).set_inertia_time(300);
this->action(uid(id,eWorldOperatorQueueWait2)).set_inertia_time(300);
}
| 1 | 0.79099 | 1 | 0.79099 | game-dev | MEDIA | 0.749777 | game-dev,desktop-app | 0.920938 | 1 | 0.920938 |
The-Evil-Pickle/Replay-the-Spire | 4,364 | src/main/java/com/megacrit/cardcrawl/mod/replay/actions/unique/AbandonAction.java | package com.megacrit.cardcrawl.mod.replay.actions.unique;
import com.megacrit.cardcrawl.localization.*;
import com.megacrit.cardcrawl.mod.replay.actions.*;
import com.megacrit.cardcrawl.mod.replay.actions.common.*;
import com.megacrit.cardcrawl.mod.replay.cards.*;
import com.megacrit.cardcrawl.actions.AbstractGameAction;
//import com.megacrit.cardcrawl.actions.ActionType;
import com.megacrit.cardcrawl.actions.common.DrawCardAction;
import com.megacrit.cardcrawl.actions.common.ExhaustAction;
import com.megacrit.cardcrawl.cards.AbstractCard;
import com.megacrit.cardcrawl.characters.*;
import com.megacrit.cardcrawl.core.*;
import com.megacrit.cardcrawl.dungeons.*;
import java.util.*;
public class AbandonAction extends AbstractGameAction
{
private static final UIStrings uiStrings;
public static final String[] TEXT;
private AbstractPlayer p;
private boolean isRandom;
private boolean anyNumber;
private boolean canPickZero;
public static int numExhausted;
/*
public AbandonAction(final AbstractCreature target, final AbstractCreature source, final int amount, final boolean isRandom) {
this(target, source, amount, isRandom, false, false);
}
public AbandonAction(final AbstractCreature target, final AbstractCreature source, final int amount, final boolean isRandom, final boolean anyNumber, final boolean canPickZero) {
this.canPickZero = false;
this.anyNumber = anyNumber;
this.canPickZero = canPickZero;
this.p = (AbstractPlayer)target;
this.isRandom = isRandom;
this.setValues(target, source, amount);
this.duration = Settings.ACTION_DUR_FAST;
this.actionType = ActionType.EXHAUST;
}
public AbandonAction(final AbstractCreature target, final AbstractCreature source, final int amount, final boolean isRandom, final boolean anyNumber) {
this(target, source, amount, isRandom, anyNumber, false);
}
*/
public AbandonAction(final AbstractCreature target, final AbstractCreature source, final int amount, final boolean isUpgraded) {
this.canPickZero = false;
this.anyNumber = isUpgraded;
this.canPickZero = isUpgraded;
this.p = (AbstractPlayer)target;
this.isRandom = false;
this.setValues(target, source, amount);
this.duration = Settings.ACTION_DUR_FAST;
this.actionType = ActionType.EXHAUST;
}
@Override
public void update() {
if (this.duration == Settings.ACTION_DUR_FAST) {
if (this.p.hand.size() == 0) {
this.isDone = true;
return;
}
if (!this.anyNumber && this.p.hand.size() <= this.amount) {
this.amount = this.p.hand.size();
ExhaustAction.numExhausted = this.amount;
for (int tmp = this.p.hand.size(), i = 0; i < tmp; ++i) {
final AbstractCard c = this.p.hand.getTopCard();
this.p.hand.moveToExhaustPile(c);
AbstractDungeon.actionManager.addToTop(new DrawCardAction(this.p, 1));
}
CardCrawlGame.dungeon.checkForPactAchievement();
return;
}
if (!this.isRandom) {
ExhaustAction.numExhausted = this.amount;
AbstractDungeon.handCardSelectScreen.open(AbandonAction.TEXT[0], this.amount, this.anyNumber, this.canPickZero);
this.tickDuration();
return;
}
for (int j = 0; j < this.amount; ++j) {
this.p.hand.moveToExhaustPile(this.p.hand.getRandomCard(false));
}
CardCrawlGame.dungeon.checkForPactAchievement();
}
if (!AbstractDungeon.handCardSelectScreen.wereCardsRetrieved) {
for (final AbstractCard c2 : AbstractDungeon.handCardSelectScreen.selectedCards.group) {
this.p.hand.moveToExhaustPile(c2);
AbstractDungeon.actionManager.addToTop(new DrawCardAction(this.p, 1));
}
CardCrawlGame.dungeon.checkForPactAchievement();
AbstractDungeon.handCardSelectScreen.wereCardsRetrieved = true;
}
this.tickDuration();
}
static {
uiStrings = CardCrawlGame.languagePack.getUIString("ExhaustAction");
TEXT = AbandonAction.uiStrings.TEXT;
}
}
| 1 | 0.935123 | 1 | 0.935123 | game-dev | MEDIA | 0.958406 | game-dev | 0.988277 | 1 | 0.988277 |
Caeden117/ChroMapper | 4,464 | Assets/__Scripts/Singletons/SceneTransitionManager.cs | using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Localization.Settings;
using UnityEngine.SceneManagement;
using UnityEngine.Serialization;
public class SceneTransitionManager : MonoBehaviour
{
private static readonly Queue<IEnumerator> externalRoutines = new Queue<IEnumerator>();
[FormerlySerializedAs("darkThemeSO")] [SerializeField] private DarkThemeSO darkThemeSo;
private Coroutine loadingCoroutine; //For stopping.
public static bool IsLoading { get; private set; }
public static SceneTransitionManager Instance { get; private set; }
private void Awake()
{
if (Instance != null)
{
Destroy(gameObject);
return;
}
DontDestroyOnLoad(gameObject);
Instance = this;
}
public void LoadScene(string scene, params IEnumerator[] routines)
{
if (IsLoading) return;
darkThemeSo.DarkThemeifyUI();
Cursor.lockState = CursorLockMode.None;
IsLoading = true;
externalRoutines.Clear();
foreach (var routine in routines) externalRoutines.Enqueue(routine);
loadingCoroutine = StartCoroutine(SceneTransition(scene));
}
public void CancelLoading(string message)
{
if (!IsLoading || loadingCoroutine == null)
return; //LoadingCoroutine set when LoadScene is called, null when this is called, or SceneTransition finishes.
StopCoroutine(loadingCoroutine);
IsLoading = false;
loadingCoroutine = null;
StartCoroutine(CancelLoadingTransitionAndDisplay(message));
}
public void AddLoadRoutine(IEnumerator routine)
{
if (IsLoading) externalRoutines.Enqueue(routine);
}
public void AddAsyncLoadRoutine(IEnumerator routine)
{
if (IsLoading) externalRoutines.Enqueue(routine);
}
private IEnumerator CancelSongLoadingRoutine()
{
while (IsLoading)
{
yield return new WaitForEndOfFrame();
if (Input.GetKey(KeyCode.Escape) && !PersistentUI.Instance.DialogBoxIsEnabled)
{
PersistentUI.Instance.ShowDialogBox("PersistentUI", "songloading",
HandleCancelSongLoading, PersistentUI.DialogBoxPresetType.YesNo);
}
}
}
private void HandleCancelSongLoading(int res)
{
if (res == 0)
{
StopAllCoroutines();
IsLoading = false;
PersistentUI.Instance.LevelLoadSlider.value = 1;
PersistentUI.Instance.LevelLoadSliderLabel.text = "Canceling...";
LoadScene("02_SongEditMenu");
}
}
private IEnumerator SceneTransition(string scene)
{
yield return PersistentUI.Instance.FadeInLoadingScreen();
yield return StartCoroutine(RunExternalRoutines());
//foreach (IEnumerator routine in routines) yield return StartCoroutine(routine);
yield return SceneManager.LoadSceneAsync(scene);
if (scene.StartsWith("03")) StartCoroutine(CancelSongLoadingRoutine());
//yield return new WaitForSeconds(1f);
yield return
StartCoroutine(
RunExternalRoutines()); //We need to do this a second time in case any classes registered a routine to run on scene start.
darkThemeSo.DarkThemeifyUI();
OptionsController.IsActive = false;
PersistentUI.Instance.LevelLoadSlider.gameObject.SetActive(false);
PersistentUI.Instance.LevelLoadSliderLabel.text = "";
yield return PersistentUI.Instance.FadeOutLoadingScreen();
IsLoading = false;
loadingCoroutine = null;
}
private IEnumerator RunExternalRoutines()
{
//This block runs the routines one by one, which isn't ideal
while (externalRoutines.Count > 0)
yield return StartCoroutine(externalRoutines.Dequeue());
}
private IEnumerator CancelLoadingTransitionAndDisplay(string key)
{
if (!string.IsNullOrEmpty(key))
{
var message = LocalizationSettings.StringDatabase.GetLocalizedString("SongEditMenu", key);
var notification =
new PersistentUI.MessageDisplayer.NotificationMessage(message, PersistentUI.DisplayMessageType.Bottom);
yield return PersistentUI.Instance.DisplayMessage(notification);
}
yield return PersistentUI.Instance.FadeOutLoadingScreen();
}
}
| 1 | 0.866839 | 1 | 0.866839 | game-dev | MEDIA | 0.716692 | game-dev | 0.986427 | 1 | 0.986427 |
ikt32/GTAVManualTransmission | 1,928 | Gears/Util/ScriptUtils.cpp | #include "ScriptUtils.h"
#include "MathExt.h"
#include "../Memory/VehicleExtensions.hpp"
#include <inc/natives.h>
#include <fmt/format.h>
void Controls::SetControlADZ(eControl control, float value, float adz) {
PAD::SET_CONTROL_VALUE_NEXT_FRAME(0, control, sgn(value) * adz + (1.0f - adz) * value);
}
bool Util::PlayerAvailable(Player player, Ped playerPed) {
if (!PLAYER::IS_PLAYER_CONTROL_ON(player) ||
PLAYER::IS_PLAYER_BEING_ARRESTED(player, TRUE) ||
CUTSCENE::IS_CUTSCENE_PLAYING() ||
!ENTITY::DOES_ENTITY_EXIST(playerPed) ||
ENTITY::IS_ENTITY_DEAD(playerPed, 0)) {
return false;
}
return true;
}
bool Util::VehicleAvailable(Vehicle vehicle, Ped playerPed) {
return vehicle != 0 &&
ENTITY::DOES_ENTITY_EXIST(vehicle) &&
PED::IS_PED_SITTING_IN_VEHICLE(playerPed, vehicle) &&
playerPed == VEHICLE::GET_PED_IN_VEHICLE_SEAT(vehicle, -1, 0);
}
bool Util::IsPedOnSeat(Vehicle vehicle, Ped ped, int seat) {
Vehicle pedVehicle = PED::GET_VEHICLE_PED_IS_IN(ped, false);
return vehicle == pedVehicle &&
VEHICLE::GET_PED_IN_VEHICLE_SEAT(pedVehicle, seat, 0) == ped;
}
// TODO: Would be neat if natives could be ditched.
std::vector<Vector3> Util::GetWheelCoords(Vehicle handle) {
std::vector<Vector3> worldCoords;
std::vector<Vector3> positions = VehicleExtensions::GetWheelOffsets(handle);
Vector3 position = ENTITY::GET_ENTITY_COORDS(handle, true);
Vector3 rotation = ENTITY::GET_ENTITY_ROTATION(handle, 0);
rotation.x = deg2rad(rotation.x);
rotation.y = deg2rad(rotation.y);
rotation.z = deg2rad(rotation.z);
Vector3 direction = ENTITY::GET_ENTITY_FORWARD_VECTOR(handle);
worldCoords.reserve(positions.size());
for (const auto& wheelPos : positions) {
worldCoords.emplace_back(GetOffsetInWorldCoords(position, rotation, direction, wheelPos));
}
return worldCoords;
}
| 1 | 0.870338 | 1 | 0.870338 | game-dev | MEDIA | 0.977543 | game-dev | 0.953835 | 1 | 0.953835 |
linClubs/Calibration-Is-All-You-Need | 3,893 | kalibr/aslam_offline_calibration/kalibr/src/module.cpp | // It is extremely important to use this header
// if you are using the numpy_eigen interface
#include <numpy_eigen/boost_python_headers.hpp>
#include <aslam/backend/ErrorTerm.hpp>
#include <kalibr_errorterms/EuclideanError.hpp>
#include <kalibr_errorterms/GyroscopeError.hpp>
#include <kalibr_errorterms/AccelerometerError.hpp>
// The title of this library must match exactly
BOOST_PYTHON_MODULE(libkalibr_errorterms_python)
{
using namespace boost::python;
using namespace kalibr_errorterms;
using namespace aslam::backend;
// class_<EuclideanError, boost::shared_ptr<EuclideanError>, boost::noncopyable, bases< ErrorTerm > >("EuclideanError", no_init);
class_<EuclideanError, boost::shared_ptr<EuclideanError>, boost::noncopyable, bases< ErrorTerm > >("EuclideanError", init<const Eigen::Vector3d & , const Eigen::Matrix3d & ,
const aslam::backend::EuclideanExpression &>("EuclideanError(measurement, invR, predicted_measurement)"))
.def("getMeasurement", &EuclideanError::getMeasurement)
.def("getPredictedMeasurement", &EuclideanError::getPredictedMeasurement);
// fill this in with boost::python export code
class_<GyroscopeError, boost::shared_ptr<GyroscopeError>, bases< EuclideanError > >
("GyroscopeError", init<const Eigen::Vector3d & , const Eigen::Matrix3d & ,
const aslam::backend::EuclideanExpression &, const aslam::backend::EuclideanExpression & >
("GyroscopeError(measurement, invR, angularVelocity, bias)"));
class_<AccelerometerError, boost::shared_ptr<AccelerometerError>, bases< EuclideanError > >
("AccelerometerError", init<const Eigen::Vector3d &, const Eigen::Matrix3d &,
const aslam::backend::RotationExpression &, const aslam::backend::EuclideanExpression &,
const aslam::backend::EuclideanExpression &, const aslam::backend::EuclideanExpression &>
("AccelerometerError(measurement, invR, C_b_w, acceleration_w, bias, g_w)"));
class_<GyroscopeNoBiasError, boost::shared_ptr<GyroscopeNoBiasError>, bases< ErrorTerm > >
("GyroscopeNoBiasError", init<const Eigen::Vector3d & , const Eigen::Matrix3d & ,
const aslam::backend::EuclideanExpression & >
("GyroscopeError(measurement, invR, angularVelocity)"));
class_<AccelerometerErrorEccentric, boost::shared_ptr<AccelerometerErrorEccentric>,
bases<EuclideanError> >
("AccelerometerErrorEccentric", init<
const Eigen::Vector3d &,
const Eigen::Matrix3d &,
const aslam::backend::MatrixExpression &,
const aslam::backend::RotationExpression &,
const aslam::backend::EuclideanExpression &,
const aslam::backend::EuclideanExpression &,
const aslam::backend::EuclideanExpression &,
const aslam::backend::RotationExpression &,
const aslam::backend::EuclideanExpression &,
const aslam::backend::EuclideanExpression &,
const aslam::backend::EuclideanExpression &,
const aslam::backend::EuclideanExpression &,
const aslam::backend::EuclideanExpression &>
("AccelerometerErrorEccentric(measurement, invR, M, C_b_w, acceleration_w, angularVelocity_b, angularAcceleration_b,)"
"C_i_b, rx_b, ry_b, rz_b, bias, g_w"));
class_<GyroscopeErrorEccentric, boost::shared_ptr<GyroscopeErrorEccentric>,
bases<EuclideanError> >
("GyroscopeErrorEccentric", init<
const Eigen::Vector3d &,
const Eigen::Matrix3d &,
const aslam::backend::MatrixExpression &,
const aslam::backend::MatrixExpression &,
const aslam::backend::RotationExpression &,
const aslam::backend::EuclideanExpression &,
const aslam::backend::EuclideanExpression &,
const aslam::backend::EuclideanExpression &,
const aslam::backend::RotationExpression &,
const aslam::backend::EuclideanExpression &,
const aslam::backend::EuclideanExpression &,
const aslam::backend::EuclideanExpression &>
("GyroscopeErrorEccentric(measurement, invR, M, Ma, C_b_w, acceleration_w, angularVelocity_b, angularAcceleration_b,)"
"C_i_b, r_b, bias, g_w"));
}
| 1 | 0.744078 | 1 | 0.744078 | game-dev | MEDIA | 0.314303 | game-dev | 0.696318 | 1 | 0.696318 |
CmdrDats/igoki | 3,649 | src/igoki/inferrence.clj | (ns igoki.inferrence
(:require
[igoki.util :as util]
[igoki.sgf :as sgf]))
(defn simple-board-view [{:keys [board size]}]
(let [[width height] size]
(for [y (range height)]
(for [x (range width)]
(case (get-in board [(sgf/convert-coord x y) :stone])
:white :w :black :b nil)))))
(defn reconstruct [{:keys [moves current-branch-path movenumber] :as game}]
(let [visiblepath (vec (take movenumber (mapcat identity current-branch-path)))
constructed (sgf/construct-board moves [visiblepath])]
(assoc game
:constructed constructed
:kifu-board (simple-board-view constructed))))
(defn play-move [{:keys [moves current-branch-path movenumber] :as game} [x y o n :as move]]
(let [visiblepath (vec (take movenumber (mapcat identity current-branch-path)))
[node path] (sgf/collect-node moves {(if (= n :b) :black :white) [(sgf/convert-coord x y)]} [visiblepath])
updatedgame
(->
game
(assoc :moves node :dirty false :current-branch-path path)
(update :movenumber (fnil inc 0)))]
(reconstruct updatedgame)))
(defn print-boards [& boards]
(println
(apply str
(interpose "\n"
(apply map
#(apply str
(interpose " | "
(for [m %&]
(apply str (map (fn [i] (str " " (if i (name i) "."))) m)))))
boards)))))
(defn walk-boards [cellfn & boards]
(apply map
(fn [& rs]
(apply map cellfn rs))
boards))
(defn subtract-board [a b]
(walk-boards
(fn [ca cb]
(if cb nil ca)) a b))
(defn mask-board [a b]
(walk-boards
(fn [ca cb]
(if (and ca cb) ca)) a b))
(defn point-map [board]
(for [[y rows] (map-indexed vector board)
[x cell] (map-indexed vector rows)
:when cell]
[x y cell]))
(defn clean-updatelist
[initial updatelist final-position]
(->>
;; We need to propagate the final-position backward
(reverse updatelist)
;; Go through the board snapshot, ripping off any cells that were previously nil
;; so that only the stuff that stays put for the duration of the game is left
(reduce
(fn [[a result] u]
(let [f (mask-board a u)]
[f (conj result f)]))
[(subtract-board final-position initial) []])
;; Get the result
second
;; Remove some noise
dedupe
;; Back to original direction (probably not needed)
reverse
;; Convert into [x y c] point vectors
(mapcat point-map)
frequencies
(group-by #(nth (first %) 2))
(map (fn [[k v]] [k (map first (reverse (sort-by second v)))]))
(into {})))
(defn infer-moves
"From a base game state, a board updatelist and a final-position, infer the move
sequence.
The meat of the algorithm is the clean-updatelist - Once that's done, it can
just interleave the black and white moves and play them to see if it ends up
as the final-position. Will return nil if a match didn't come out of the woodwork."
[game updatelist final-position]
(let [{:keys [kifu-board constructed]} game
{:keys [b w] :as clean} (clean-updatelist kifu-board updatelist final-position)
moves (apply util/interleave-all (if (= (:player-turn constructed) :black) [b w] [w b]))
inferred
(reduce
(fn [g [x y cell]]
(if (= (-> g :constructed :player-turn) ({:b :black :w :white} cell))
(play-move g [x y nil cell])
g))
game
moves)]
(print-boards (:kifu-board game) (:kifu-board inferred) final-position)
(if (= (:kifu-board inferred) final-position) inferred))) | 1 | 0.951788 | 1 | 0.951788 | game-dev | MEDIA | 0.943531 | game-dev | 0.990987 | 1 | 0.990987 |
binary-husky/hmp2g | 1,136,263 | VISUALIZE/threejsmod/examples/jsm/libs/OimoPhysics/OimoPhysics.js | // Generated by Haxe 4.2.0
var oimo = oimo || {};
if(!oimo.collision) oimo.collision = {};
if(!oimo.collision.broadphase) oimo.collision.broadphase = {};
oimo.collision.broadphase.BroadPhase = class oimo_collision_broadphase_BroadPhase {
constructor(type) {
this._type = type;
this._numProxies = 0;
this._proxyList = null;
this._proxyListLast = null;
this._proxyPairList = null;
this._incremental = false;
this._testCount = 0;
this._proxyPairPool = null;
this._idCount = 0;
this._convexSweep = new oimo.collision.broadphase._BroadPhase.ConvexSweepGeometry();
this._aabb = new oimo.collision.broadphase._BroadPhase.AabbGeometry();
this.identity = new oimo.common.Transform();
this.zero = new oimo.common.Vec3();
this.rayCastHit = new oimo.collision.geometry.RayCastHit();
}
createProxy(userData,aabb) {
return null;
}
destroyProxy(proxy) {
}
moveProxy(proxy,aabb,displacement) {
}
isOverlapping(proxy1,proxy2) {
if(proxy1._aabbMinX < proxy2._aabbMaxX && proxy1._aabbMaxX > proxy2._aabbMinX && proxy1._aabbMinY < proxy2._aabbMaxY && proxy1._aabbMaxY > proxy2._aabbMinY && proxy1._aabbMinZ < proxy2._aabbMaxZ) {
return proxy1._aabbMaxZ > proxy2._aabbMinZ;
} else {
return false;
}
}
collectPairs() {
}
getProxyPairList() {
return this._proxyPairList;
}
isIncremental() {
return this._incremental;
}
getTestCount() {
return this._testCount;
}
rayCast(begin,end,callback) {
}
convexCast(convex,begin,translation,callback) {
}
aabbTest(aabb,callback) {
}
}
if(!oimo.collision.geometry) oimo.collision.geometry = {};
oimo.collision.geometry.Geometry = class oimo_collision_geometry_Geometry {
constructor(type) {
this._type = type;
this._volume = 0;
}
_updateMass() {
}
_computeAabb(aabb,tf) {
}
_rayCastLocal(beginX,beginY,beginZ,endX,endY,endZ,hit) {
return false;
}
getType() {
return this._type;
}
getVolume() {
return this._volume;
}
rayCast(begin,end,transform,hit) {
let beginLocalX;
let beginLocalY;
let beginLocalZ;
let endLocalX;
let endLocalY;
let endLocalZ;
beginLocalX = begin.x;
beginLocalY = begin.y;
beginLocalZ = begin.z;
endLocalX = end.x;
endLocalY = end.y;
endLocalZ = end.z;
beginLocalX -= transform._positionX;
beginLocalY -= transform._positionY;
beginLocalZ -= transform._positionZ;
endLocalX -= transform._positionX;
endLocalY -= transform._positionY;
endLocalZ -= transform._positionZ;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = transform._rotation00 * beginLocalX + transform._rotation10 * beginLocalY + transform._rotation20 * beginLocalZ;
__tmp__Y = transform._rotation01 * beginLocalX + transform._rotation11 * beginLocalY + transform._rotation21 * beginLocalZ;
__tmp__Z = transform._rotation02 * beginLocalX + transform._rotation12 * beginLocalY + transform._rotation22 * beginLocalZ;
beginLocalX = __tmp__X;
beginLocalY = __tmp__Y;
beginLocalZ = __tmp__Z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = transform._rotation00 * endLocalX + transform._rotation10 * endLocalY + transform._rotation20 * endLocalZ;
__tmp__Y1 = transform._rotation01 * endLocalX + transform._rotation11 * endLocalY + transform._rotation21 * endLocalZ;
__tmp__Z1 = transform._rotation02 * endLocalX + transform._rotation12 * endLocalY + transform._rotation22 * endLocalZ;
endLocalX = __tmp__X1;
endLocalY = __tmp__Y1;
endLocalZ = __tmp__Z1;
if(this._rayCastLocal(beginLocalX,beginLocalY,beginLocalZ,endLocalX,endLocalY,endLocalZ,hit)) {
let localPosX;
let localPosY;
let localPosZ;
let localNormalX;
let localNormalY;
let localNormalZ;
let v = hit.position;
localPosX = v.x;
localPosY = v.y;
localPosZ = v.z;
let v1 = hit.normal;
localNormalX = v1.x;
localNormalY = v1.y;
localNormalZ = v1.z;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = transform._rotation00 * localPosX + transform._rotation01 * localPosY + transform._rotation02 * localPosZ;
__tmp__Y = transform._rotation10 * localPosX + transform._rotation11 * localPosY + transform._rotation12 * localPosZ;
__tmp__Z = transform._rotation20 * localPosX + transform._rotation21 * localPosY + transform._rotation22 * localPosZ;
localPosX = __tmp__X;
localPosY = __tmp__Y;
localPosZ = __tmp__Z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = transform._rotation00 * localNormalX + transform._rotation01 * localNormalY + transform._rotation02 * localNormalZ;
__tmp__Y1 = transform._rotation10 * localNormalX + transform._rotation11 * localNormalY + transform._rotation12 * localNormalZ;
__tmp__Z1 = transform._rotation20 * localNormalX + transform._rotation21 * localNormalY + transform._rotation22 * localNormalZ;
localNormalX = __tmp__X1;
localNormalY = __tmp__Y1;
localNormalZ = __tmp__Z1;
localPosX += transform._positionX;
localPosY += transform._positionY;
localPosZ += transform._positionZ;
let v2 = hit.position;
v2.x = localPosX;
v2.y = localPosY;
v2.z = localPosZ;
let v3 = hit.normal;
v3.x = localNormalX;
v3.y = localNormalY;
v3.z = localNormalZ;
return true;
}
return false;
}
}
oimo.collision.geometry.ConvexGeometry = class oimo_collision_geometry_ConvexGeometry extends oimo.collision.geometry.Geometry {
constructor(type) {
super(type);
this._gjkMargin = oimo.common.Setting.defaultGJKMargin;
this._useGjkRayCast = false;
}
getGjkMergin() {
return this._gjkMargin;
}
setGjkMergin(gjkMergin) {
if(gjkMergin < 0) {
gjkMergin = 0;
}
this._gjkMargin = gjkMergin;
}
computeLocalSupportingVertex(dir,out) {
}
rayCast(begin,end,transform,hit) {
if(this._useGjkRayCast) {
return oimo.collision.narrowphase.detector.gjkepa.GjkEpa.instance.rayCast(this,transform,begin,end,hit);
} else {
return super.rayCast(begin,end,transform,hit);
}
}
}
if(!oimo.collision.broadphase._BroadPhase) oimo.collision.broadphase._BroadPhase = {};
oimo.collision.broadphase._BroadPhase.ConvexSweepGeometry = class oimo_collision_broadphase__$BroadPhase_ConvexSweepGeometry extends oimo.collision.geometry.ConvexGeometry {
constructor() {
super(-1);
}
init(c,transform,translation) {
this.c = c;
let trX;
let trY;
let trZ;
trX = translation.x;
trY = translation.y;
trZ = translation.z;
let localTrX;
let localTrY;
let localTrZ;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = transform._rotation00 * trX + transform._rotation10 * trY + transform._rotation20 * trZ;
__tmp__Y = transform._rotation01 * trX + transform._rotation11 * trY + transform._rotation21 * trZ;
__tmp__Z = transform._rotation02 * trX + transform._rotation12 * trY + transform._rotation22 * trZ;
localTrX = __tmp__X;
localTrY = __tmp__Y;
localTrZ = __tmp__Z;
this.localTranslation = new oimo.common.Vec3();
let v = this.localTranslation;
v.x = localTrX;
v.y = localTrY;
v.z = localTrZ;
this._gjkMargin = c._gjkMargin;
}
computeLocalSupportingVertex(dir,out) {
this.c.computeLocalSupportingVertex(dir,out);
let v = this.localTranslation;
if(dir.x * v.x + dir.y * v.y + dir.z * v.z > 0) {
let v = this.localTranslation;
out.x += v.x;
out.y += v.y;
out.z += v.z;
}
}
}
oimo.collision.broadphase._BroadPhase.AabbGeometry = class oimo_collision_broadphase__$BroadPhase_AabbGeometry extends oimo.collision.geometry.ConvexGeometry {
constructor() {
super(-1);
this.min = new oimo.common.Vec3();
this.max = new oimo.common.Vec3();
}
computeLocalSupportingVertex(dir,out) {
out.x = dir.x > 0 ? this.max.x : this.min.x;
out.y = dir.y > 0 ? this.max.y : this.min.y;
out.z = dir.z > 0 ? this.max.z : this.min.z;
}
}
oimo.collision.broadphase.BroadPhaseProxyCallback = class oimo_collision_broadphase_BroadPhaseProxyCallback {
constructor() {
}
process(proxy) {
}
}
oimo.collision.broadphase.BroadPhaseType = class oimo_collision_broadphase_BroadPhaseType {
}
oimo.collision.broadphase.Proxy = class oimo_collision_broadphase_Proxy {
constructor(userData,id) {
this.userData = userData;
this._id = id;
this._prev = null;
this._next = null;
this._aabbMinX = 0;
this._aabbMinY = 0;
this._aabbMinZ = 0;
this._aabbMaxX = 0;
this._aabbMaxY = 0;
this._aabbMaxZ = 0;
}
getId() {
return this._id;
}
getFatAabb() {
let aabb = new oimo.collision.geometry.Aabb();
aabb._minX = this._aabbMinX;
aabb._minY = this._aabbMinY;
aabb._minZ = this._aabbMinZ;
aabb._maxX = this._aabbMaxX;
aabb._maxY = this._aabbMaxY;
aabb._maxZ = this._aabbMaxZ;
return aabb;
}
getFatAabbTo(aabb) {
aabb._minX = this._aabbMinX;
aabb._minY = this._aabbMinY;
aabb._minZ = this._aabbMinZ;
aabb._maxX = this._aabbMaxX;
aabb._maxY = this._aabbMaxY;
aabb._maxZ = this._aabbMaxZ;
}
}
oimo.collision.broadphase.ProxyPair = class oimo_collision_broadphase_ProxyPair {
constructor() {
this._p1 = null;
this._p2 = null;
}
getProxy1() {
return this._p1;
}
getProxy2() {
return this._p2;
}
getNext() {
return this._next;
}
}
if(!oimo.collision.broadphase.bruteforce) oimo.collision.broadphase.bruteforce = {};
oimo.collision.broadphase.bruteforce.BruteForceBroadPhase = class oimo_collision_broadphase_bruteforce_BruteForceBroadPhase extends oimo.collision.broadphase.BroadPhase {
constructor() {
super(1);
this._incremental = false;
}
createProxy(userData,aabb) {
let proxy = new oimo.collision.broadphase.Proxy(userData,this._idCount++);
this._numProxies++;
if(this._proxyList == null) {
this._proxyList = proxy;
this._proxyListLast = proxy;
} else {
this._proxyListLast._next = proxy;
proxy._prev = this._proxyListLast;
this._proxyListLast = proxy;
}
proxy._aabbMinX = aabb._minX;
proxy._aabbMinY = aabb._minY;
proxy._aabbMinZ = aabb._minZ;
proxy._aabbMaxX = aabb._maxX;
proxy._aabbMaxY = aabb._maxY;
proxy._aabbMaxZ = aabb._maxZ;
return proxy;
}
destroyProxy(proxy) {
this._numProxies--;
let prev = proxy._prev;
let next = proxy._next;
if(prev != null) {
prev._next = next;
}
if(next != null) {
next._prev = prev;
}
if(proxy == this._proxyList) {
this._proxyList = this._proxyList._next;
}
if(proxy == this._proxyListLast) {
this._proxyListLast = this._proxyListLast._prev;
}
proxy._next = null;
proxy._prev = null;
proxy.userData = null;
}
moveProxy(proxy,aabb,dislacement) {
proxy._aabbMinX = aabb._minX;
proxy._aabbMinY = aabb._minY;
proxy._aabbMinZ = aabb._minZ;
proxy._aabbMaxX = aabb._maxX;
proxy._aabbMaxY = aabb._maxY;
proxy._aabbMaxZ = aabb._maxZ;
}
collectPairs() {
let p = this._proxyPairList;
if(p != null) {
while(true) {
p._p1 = null;
p._p2 = null;
p = p._next;
if(!(p != null)) {
break;
}
}
this._proxyPairList._next = this._proxyPairPool;
this._proxyPairPool = this._proxyPairList;
this._proxyPairList = null;
}
this._testCount = 0;
let p1 = this._proxyList;
while(p1 != null) {
let n = p1._next;
let p2 = p1._next;
while(p2 != null) {
let n = p2._next;
this._testCount++;
if(p1._aabbMinX < p2._aabbMaxX && p1._aabbMaxX > p2._aabbMinX && p1._aabbMinY < p2._aabbMaxY && p1._aabbMaxY > p2._aabbMinY && p1._aabbMinZ < p2._aabbMaxZ && p1._aabbMaxZ > p2._aabbMinZ) {
let first = this._proxyPairPool;
if(first != null) {
this._proxyPairPool = first._next;
first._next = null;
} else {
first = new oimo.collision.broadphase.ProxyPair();
}
let pp = first;
if(this._proxyPairList == null) {
this._proxyPairList = pp;
} else {
pp._next = this._proxyPairList;
this._proxyPairList = pp;
}
pp._p1 = p1;
pp._p2 = p2;
}
p2 = n;
}
p1 = n;
}
}
rayCast(begin,end,callback) {
let p1X;
let p1Y;
let p1Z;
let p2X;
let p2Y;
let p2Z;
p1X = begin.x;
p1Y = begin.y;
p1Z = begin.z;
p2X = end.x;
p2Y = end.y;
p2Z = end.z;
let p = this._proxyList;
while(p != null) {
let n = p._next;
let x1 = p1X;
let y1 = p1Y;
let z1 = p1Z;
let x2 = p2X;
let y2 = p2Y;
let z2 = p2Z;
let pminx = p._aabbMinX;
let pminy = p._aabbMinY;
let pminz = p._aabbMinZ;
let pmaxx = p._aabbMaxX;
let pmaxy = p._aabbMaxY;
let pmaxz = p._aabbMaxZ;
let tmp;
if(pminx > (x1 > x2 ? x1 : x2) || pmaxx < (x1 < x2 ? x1 : x2) || pminy > (y1 > y2 ? y1 : y2) || pmaxy < (y1 < y2 ? y1 : y2) || pminz > (z1 > z2 ? z1 : z2) || pmaxz < (z1 < z2 ? z1 : z2)) {
tmp = false;
} else {
let dx = x2 - x1;
let dy = y2 - y1;
let dz = z2 - z1;
let adx = dx < 0 ? -dx : dx;
let ady = dy < 0 ? -dy : dy;
let adz = dz < 0 ? -dz : dz;
let pextx = (pmaxx - pminx) * 0.5;
let pexty = (pmaxy - pminy) * 0.5;
let pextz = (pmaxz - pminz) * 0.5;
let cpx = x1 - (pmaxx + pminx) * 0.5;
let cpy = y1 - (pmaxy + pminy) * 0.5;
let cpz = z1 - (pmaxz + pminz) * 0.5;
let tmp1;
let tmp2;
let x = cpy * dz - cpz * dy;
if(!((x < 0 ? -x : x) - (pexty * adz + pextz * ady) > 0)) {
let x = cpz * dx - cpx * dz;
tmp2 = (x < 0 ? -x : x) - (pextz * adx + pextx * adz) > 0;
} else {
tmp2 = true;
}
if(!tmp2) {
let x = cpx * dy - cpy * dx;
tmp1 = (x < 0 ? -x : x) - (pextx * ady + pexty * adx) > 0;
} else {
tmp1 = true;
}
tmp = tmp1 ? false : true;
}
if(tmp) {
callback.process(p);
}
p = n;
}
}
convexCast(convex,begin,translation,callback) {
let p = this._proxyList;
while(p != null) {
let n = p._next;
let v = this._aabb.min;
v.x = p._aabbMinX;
v.y = p._aabbMinY;
v.z = p._aabbMinZ;
let v1 = this._aabb.max;
v1.x = p._aabbMaxX;
v1.y = p._aabbMaxY;
v1.z = p._aabbMaxZ;
this._convexSweep.init(convex,begin,translation);
let gjkEpa = oimo.collision.narrowphase.detector.gjkepa.GjkEpa.instance;
if(gjkEpa.computeClosestPointsImpl(this._convexSweep,this._aabb,begin,this.identity,null,false) == 0 && gjkEpa.distance <= 0) {
callback.process(p);
}
p = n;
}
}
aabbTest(aabb,callback) {
let p = this._proxyList;
while(p != null) {
let n = p._next;
if(aabb._minX < p._aabbMaxX && aabb._maxX > p._aabbMinX && aabb._minY < p._aabbMaxY && aabb._maxY > p._aabbMinY && aabb._minZ < p._aabbMaxZ && aabb._maxZ > p._aabbMinZ) {
callback.process(p);
}
p = n;
}
}
}
if(!oimo.collision.broadphase.bvh) oimo.collision.broadphase.bvh = {};
oimo.collision.broadphase.bvh.BvhBroadPhase = class oimo_collision_broadphase_bvh_BvhBroadPhase extends oimo.collision.broadphase.BroadPhase {
constructor() {
super(2);
this._incremental = true;
this._tree = new oimo.collision.broadphase.bvh.BvhTree();
this.movedProxies = new Array(1024);
this.numMovedProxies = 0;
}
collide(n1,n2) {
this._testCount++;
let l1 = n1._height == 0;
let l2 = n2._height == 0;
if(n1 == n2) {
if(l1) {
return;
}
this.collide(n1._children[0],n2);
this.collide(n1._children[1],n2);
return;
}
if(!(n1._aabbMinX < n2._aabbMaxX && n1._aabbMaxX > n2._aabbMinX && n1._aabbMinY < n2._aabbMaxY && n1._aabbMaxY > n2._aabbMinY && n1._aabbMinZ < n2._aabbMaxZ && n1._aabbMaxZ > n2._aabbMinZ)) {
return;
}
if(l1 && l2) {
let first = this._proxyPairPool;
if(first != null) {
this._proxyPairPool = first._next;
first._next = null;
} else {
first = new oimo.collision.broadphase.ProxyPair();
}
let pp = first;
if(this._proxyPairList == null) {
this._proxyPairList = pp;
} else {
pp._next = this._proxyPairList;
this._proxyPairList = pp;
}
pp._p1 = n1._proxy;
pp._p2 = n2._proxy;
return;
}
if(l2 || n1._height > n2._height) {
this.collide(n1._children[0],n2);
this.collide(n1._children[1],n2);
} else {
this.collide(n2._children[0],n1);
this.collide(n2._children[1],n1);
}
}
rayCastRecursive(node,_p1X,_p1Y,_p1Z,_p2X,_p2Y,_p2Z,callback) {
let x1 = _p1X;
let y1 = _p1Y;
let z1 = _p1Z;
let x2 = _p2X;
let y2 = _p2Y;
let z2 = _p2Z;
let pminx = node._aabbMinX;
let pminy = node._aabbMinY;
let pminz = node._aabbMinZ;
let pmaxx = node._aabbMaxX;
let pmaxy = node._aabbMaxY;
let pmaxz = node._aabbMaxZ;
let tmp;
if(pminx > (x1 > x2 ? x1 : x2) || pmaxx < (x1 < x2 ? x1 : x2) || pminy > (y1 > y2 ? y1 : y2) || pmaxy < (y1 < y2 ? y1 : y2) || pminz > (z1 > z2 ? z1 : z2) || pmaxz < (z1 < z2 ? z1 : z2)) {
tmp = false;
} else {
let dx = x2 - x1;
let dy = y2 - y1;
let dz = z2 - z1;
let adx = dx < 0 ? -dx : dx;
let ady = dy < 0 ? -dy : dy;
let adz = dz < 0 ? -dz : dz;
let pextx = (pmaxx - pminx) * 0.5;
let pexty = (pmaxy - pminy) * 0.5;
let pextz = (pmaxz - pminz) * 0.5;
let cpx = x1 - (pmaxx + pminx) * 0.5;
let cpy = y1 - (pmaxy + pminy) * 0.5;
let cpz = z1 - (pmaxz + pminz) * 0.5;
let tmp1;
let tmp2;
let x = cpy * dz - cpz * dy;
if(!((x < 0 ? -x : x) - (pexty * adz + pextz * ady) > 0)) {
let x = cpz * dx - cpx * dz;
tmp2 = (x < 0 ? -x : x) - (pextz * adx + pextx * adz) > 0;
} else {
tmp2 = true;
}
if(!tmp2) {
let x = cpx * dy - cpy * dx;
tmp1 = (x < 0 ? -x : x) - (pextx * ady + pexty * adx) > 0;
} else {
tmp1 = true;
}
tmp = tmp1 ? false : true;
}
if(!tmp) {
return;
}
if(node._height == 0) {
callback.process(node._proxy);
return;
}
this.rayCastRecursive(node._children[0],_p1X,_p1Y,_p1Z,_p2X,_p2Y,_p2Z,callback);
this.rayCastRecursive(node._children[1],_p1X,_p1Y,_p1Z,_p2X,_p2Y,_p2Z,callback);
}
convexCastRecursive(node,convex,begin,translation,callback) {
let v = this._aabb.min;
v.x = node._aabbMinX;
v.y = node._aabbMinY;
v.z = node._aabbMinZ;
let v1 = this._aabb.max;
v1.x = node._aabbMaxX;
v1.y = node._aabbMaxY;
v1.z = node._aabbMaxZ;
this._convexSweep.init(convex,begin,translation);
let gjkEpa = oimo.collision.narrowphase.detector.gjkepa.GjkEpa.instance;
if(!(gjkEpa.computeClosestPointsImpl(this._convexSweep,this._aabb,begin,this.identity,null,false) == 0 && gjkEpa.distance <= 0)) {
return;
}
if(node._height == 0) {
callback.process(node._proxy);
return;
}
this.convexCastRecursive(node._children[0],convex,begin,translation,callback);
this.convexCastRecursive(node._children[1],convex,begin,translation,callback);
}
aabbTestRecursive(node,aabb,callback) {
if(!(node._aabbMinX < aabb._maxX && node._aabbMaxX > aabb._minX && node._aabbMinY < aabb._maxY && node._aabbMaxY > aabb._minY && node._aabbMinZ < aabb._maxZ && node._aabbMaxZ > aabb._minZ)) {
return;
}
if(node._height == 0) {
callback.process(node._proxy);
return;
}
this.aabbTestRecursive(node._children[0],aabb,callback);
this.aabbTestRecursive(node._children[1],aabb,callback);
}
createProxy(userData,aabb) {
let p = new oimo.collision.broadphase.bvh.BvhProxy(userData,this._idCount++);
this._numProxies++;
if(this._proxyList == null) {
this._proxyList = p;
this._proxyListLast = p;
} else {
this._proxyListLast._next = p;
p._prev = this._proxyListLast;
this._proxyListLast = p;
}
p._aabbMinX = aabb._minX;
p._aabbMinY = aabb._minY;
p._aabbMinZ = aabb._minZ;
p._aabbMaxX = aabb._maxX;
p._aabbMaxY = aabb._maxY;
p._aabbMaxZ = aabb._maxZ;
let padding = oimo.common.Setting.bvhProxyPadding;
p._aabbMinX -= padding;
p._aabbMinY -= padding;
p._aabbMinZ -= padding;
p._aabbMaxX += padding;
p._aabbMaxY += padding;
p._aabbMaxZ += padding;
let _this = this._tree;
let first = _this._nodePool;
if(first != null) {
_this._nodePool = first._next;
first._next = null;
} else {
first = new oimo.collision.broadphase.bvh.BvhNode();
}
let leaf = first;
leaf._proxy = p;
p._leaf = leaf;
leaf._aabbMinX = p._aabbMinX;
leaf._aabbMinY = p._aabbMinY;
leaf._aabbMinZ = p._aabbMinZ;
leaf._aabbMaxX = p._aabbMaxX;
leaf._aabbMaxY = p._aabbMaxY;
leaf._aabbMaxZ = p._aabbMaxZ;
_this._numLeaves++;
if(_this.leafList == null) {
_this.leafList = leaf;
_this.leafListLast = leaf;
} else {
_this.leafListLast._nextLeaf = leaf;
leaf._prevLeaf = _this.leafListLast;
_this.leafListLast = leaf;
}
if(_this._root == null) {
_this._root = leaf;
} else {
let sibling = _this._root;
while(sibling._height > 0) {
let nextStep = _this._strategy._decideInsertion(sibling,leaf);
if(nextStep == -1) {
break;
} else {
sibling = sibling._children[nextStep];
}
}
let parent = sibling._parent;
let first = _this._nodePool;
if(first != null) {
_this._nodePool = first._next;
first._next = null;
} else {
first = new oimo.collision.broadphase.bvh.BvhNode();
}
let node = first;
if(parent == null) {
_this._root = node;
} else {
let index = sibling._childIndex;
parent._children[index] = node;
node._parent = parent;
node._childIndex = index;
}
let index = sibling._childIndex;
node._children[index] = sibling;
sibling._parent = node;
sibling._childIndex = index;
let index1 = sibling._childIndex ^ 1;
node._children[index1] = leaf;
leaf._parent = node;
leaf._childIndex = index1;
while(node != null) {
if(_this._strategy._balancingEnabled) {
if(node._height >= 2) {
let p = node._parent;
let l = node._children[0];
let r = node._children[1];
let balance = l._height - r._height;
let nodeIndex = node._childIndex;
if(balance > 1) {
let ll = l._children[0];
let lr = l._children[1];
if(ll._height > lr._height) {
l._children[1] = node;
node._parent = l;
node._childIndex = 1;
node._children[0] = lr;
lr._parent = node;
lr._childIndex = 0;
let c1 = l._children[0];
let c2 = l._children[1];
l._aabbMinX = c1._aabbMinX < c2._aabbMinX ? c1._aabbMinX : c2._aabbMinX;
l._aabbMinY = c1._aabbMinY < c2._aabbMinY ? c1._aabbMinY : c2._aabbMinY;
l._aabbMinZ = c1._aabbMinZ < c2._aabbMinZ ? c1._aabbMinZ : c2._aabbMinZ;
l._aabbMaxX = c1._aabbMaxX > c2._aabbMaxX ? c1._aabbMaxX : c2._aabbMaxX;
l._aabbMaxY = c1._aabbMaxY > c2._aabbMaxY ? c1._aabbMaxY : c2._aabbMaxY;
l._aabbMaxZ = c1._aabbMaxZ > c2._aabbMaxZ ? c1._aabbMaxZ : c2._aabbMaxZ;
let h1 = l._children[0]._height;
let h2 = l._children[1]._height;
l._height = (h1 > h2 ? h1 : h2) + 1;
let c11 = node._children[0];
let c21 = node._children[1];
node._aabbMinX = c11._aabbMinX < c21._aabbMinX ? c11._aabbMinX : c21._aabbMinX;
node._aabbMinY = c11._aabbMinY < c21._aabbMinY ? c11._aabbMinY : c21._aabbMinY;
node._aabbMinZ = c11._aabbMinZ < c21._aabbMinZ ? c11._aabbMinZ : c21._aabbMinZ;
node._aabbMaxX = c11._aabbMaxX > c21._aabbMaxX ? c11._aabbMaxX : c21._aabbMaxX;
node._aabbMaxY = c11._aabbMaxY > c21._aabbMaxY ? c11._aabbMaxY : c21._aabbMaxY;
node._aabbMaxZ = c11._aabbMaxZ > c21._aabbMaxZ ? c11._aabbMaxZ : c21._aabbMaxZ;
let h11 = node._children[0]._height;
let h21 = node._children[1]._height;
node._height = (h11 > h21 ? h11 : h21) + 1;
} else {
l._children[0] = node;
node._parent = l;
node._childIndex = 0;
node._children[0] = ll;
ll._parent = node;
ll._childIndex = 0;
let c1 = l._children[0];
let c2 = l._children[1];
l._aabbMinX = c1._aabbMinX < c2._aabbMinX ? c1._aabbMinX : c2._aabbMinX;
l._aabbMinY = c1._aabbMinY < c2._aabbMinY ? c1._aabbMinY : c2._aabbMinY;
l._aabbMinZ = c1._aabbMinZ < c2._aabbMinZ ? c1._aabbMinZ : c2._aabbMinZ;
l._aabbMaxX = c1._aabbMaxX > c2._aabbMaxX ? c1._aabbMaxX : c2._aabbMaxX;
l._aabbMaxY = c1._aabbMaxY > c2._aabbMaxY ? c1._aabbMaxY : c2._aabbMaxY;
l._aabbMaxZ = c1._aabbMaxZ > c2._aabbMaxZ ? c1._aabbMaxZ : c2._aabbMaxZ;
let h1 = l._children[0]._height;
let h2 = l._children[1]._height;
l._height = (h1 > h2 ? h1 : h2) + 1;
let c11 = node._children[0];
let c21 = node._children[1];
node._aabbMinX = c11._aabbMinX < c21._aabbMinX ? c11._aabbMinX : c21._aabbMinX;
node._aabbMinY = c11._aabbMinY < c21._aabbMinY ? c11._aabbMinY : c21._aabbMinY;
node._aabbMinZ = c11._aabbMinZ < c21._aabbMinZ ? c11._aabbMinZ : c21._aabbMinZ;
node._aabbMaxX = c11._aabbMaxX > c21._aabbMaxX ? c11._aabbMaxX : c21._aabbMaxX;
node._aabbMaxY = c11._aabbMaxY > c21._aabbMaxY ? c11._aabbMaxY : c21._aabbMaxY;
node._aabbMaxZ = c11._aabbMaxZ > c21._aabbMaxZ ? c11._aabbMaxZ : c21._aabbMaxZ;
let h11 = node._children[0]._height;
let h21 = node._children[1]._height;
node._height = (h11 > h21 ? h11 : h21) + 1;
}
if(p != null) {
p._children[nodeIndex] = l;
l._parent = p;
l._childIndex = nodeIndex;
} else {
_this._root = l;
l._parent = null;
}
node = l;
} else if(balance < -1) {
let rl = r._children[0];
let rr = r._children[1];
if(rl._height > rr._height) {
r._children[1] = node;
node._parent = r;
node._childIndex = 1;
node._children[1] = rr;
rr._parent = node;
rr._childIndex = 1;
let c1 = r._children[0];
let c2 = r._children[1];
r._aabbMinX = c1._aabbMinX < c2._aabbMinX ? c1._aabbMinX : c2._aabbMinX;
r._aabbMinY = c1._aabbMinY < c2._aabbMinY ? c1._aabbMinY : c2._aabbMinY;
r._aabbMinZ = c1._aabbMinZ < c2._aabbMinZ ? c1._aabbMinZ : c2._aabbMinZ;
r._aabbMaxX = c1._aabbMaxX > c2._aabbMaxX ? c1._aabbMaxX : c2._aabbMaxX;
r._aabbMaxY = c1._aabbMaxY > c2._aabbMaxY ? c1._aabbMaxY : c2._aabbMaxY;
r._aabbMaxZ = c1._aabbMaxZ > c2._aabbMaxZ ? c1._aabbMaxZ : c2._aabbMaxZ;
let h1 = r._children[0]._height;
let h2 = r._children[1]._height;
r._height = (h1 > h2 ? h1 : h2) + 1;
let c11 = node._children[0];
let c21 = node._children[1];
node._aabbMinX = c11._aabbMinX < c21._aabbMinX ? c11._aabbMinX : c21._aabbMinX;
node._aabbMinY = c11._aabbMinY < c21._aabbMinY ? c11._aabbMinY : c21._aabbMinY;
node._aabbMinZ = c11._aabbMinZ < c21._aabbMinZ ? c11._aabbMinZ : c21._aabbMinZ;
node._aabbMaxX = c11._aabbMaxX > c21._aabbMaxX ? c11._aabbMaxX : c21._aabbMaxX;
node._aabbMaxY = c11._aabbMaxY > c21._aabbMaxY ? c11._aabbMaxY : c21._aabbMaxY;
node._aabbMaxZ = c11._aabbMaxZ > c21._aabbMaxZ ? c11._aabbMaxZ : c21._aabbMaxZ;
let h11 = node._children[0]._height;
let h21 = node._children[1]._height;
node._height = (h11 > h21 ? h11 : h21) + 1;
} else {
r._children[0] = node;
node._parent = r;
node._childIndex = 0;
node._children[1] = rl;
rl._parent = node;
rl._childIndex = 1;
let c1 = r._children[0];
let c2 = r._children[1];
r._aabbMinX = c1._aabbMinX < c2._aabbMinX ? c1._aabbMinX : c2._aabbMinX;
r._aabbMinY = c1._aabbMinY < c2._aabbMinY ? c1._aabbMinY : c2._aabbMinY;
r._aabbMinZ = c1._aabbMinZ < c2._aabbMinZ ? c1._aabbMinZ : c2._aabbMinZ;
r._aabbMaxX = c1._aabbMaxX > c2._aabbMaxX ? c1._aabbMaxX : c2._aabbMaxX;
r._aabbMaxY = c1._aabbMaxY > c2._aabbMaxY ? c1._aabbMaxY : c2._aabbMaxY;
r._aabbMaxZ = c1._aabbMaxZ > c2._aabbMaxZ ? c1._aabbMaxZ : c2._aabbMaxZ;
let h1 = r._children[0]._height;
let h2 = r._children[1]._height;
r._height = (h1 > h2 ? h1 : h2) + 1;
let c11 = node._children[0];
let c21 = node._children[1];
node._aabbMinX = c11._aabbMinX < c21._aabbMinX ? c11._aabbMinX : c21._aabbMinX;
node._aabbMinY = c11._aabbMinY < c21._aabbMinY ? c11._aabbMinY : c21._aabbMinY;
node._aabbMinZ = c11._aabbMinZ < c21._aabbMinZ ? c11._aabbMinZ : c21._aabbMinZ;
node._aabbMaxX = c11._aabbMaxX > c21._aabbMaxX ? c11._aabbMaxX : c21._aabbMaxX;
node._aabbMaxY = c11._aabbMaxY > c21._aabbMaxY ? c11._aabbMaxY : c21._aabbMaxY;
node._aabbMaxZ = c11._aabbMaxZ > c21._aabbMaxZ ? c11._aabbMaxZ : c21._aabbMaxZ;
let h11 = node._children[0]._height;
let h21 = node._children[1]._height;
node._height = (h11 > h21 ? h11 : h21) + 1;
}
if(p != null) {
p._children[nodeIndex] = r;
r._parent = p;
r._childIndex = nodeIndex;
} else {
_this._root = r;
r._parent = null;
}
node = r;
}
}
}
let h1 = node._children[0]._height;
let h2 = node._children[1]._height;
node._height = (h1 > h2 ? h1 : h2) + 1;
let c1 = node._children[0];
let c2 = node._children[1];
node._aabbMinX = c1._aabbMinX < c2._aabbMinX ? c1._aabbMinX : c2._aabbMinX;
node._aabbMinY = c1._aabbMinY < c2._aabbMinY ? c1._aabbMinY : c2._aabbMinY;
node._aabbMinZ = c1._aabbMinZ < c2._aabbMinZ ? c1._aabbMinZ : c2._aabbMinZ;
node._aabbMaxX = c1._aabbMaxX > c2._aabbMaxX ? c1._aabbMaxX : c2._aabbMaxX;
node._aabbMaxY = c1._aabbMaxY > c2._aabbMaxY ? c1._aabbMaxY : c2._aabbMaxY;
node._aabbMaxZ = c1._aabbMaxZ > c2._aabbMaxZ ? c1._aabbMaxZ : c2._aabbMaxZ;
node = node._parent;
}
}
if(!p._moved) {
p._moved = true;
if(this.movedProxies.length == this.numMovedProxies) {
let newArray = new Array(this.numMovedProxies << 1);
let _g = 0;
let _g1 = this.numMovedProxies;
while(_g < _g1) {
let i = _g++;
newArray[i] = this.movedProxies[i];
this.movedProxies[i] = null;
}
this.movedProxies = newArray;
}
this.movedProxies[this.numMovedProxies++] = p;
}
return p;
}
destroyProxy(proxy) {
this._numProxies--;
let prev = proxy._prev;
let next = proxy._next;
if(prev != null) {
prev._next = next;
}
if(next != null) {
next._prev = prev;
}
if(proxy == this._proxyList) {
this._proxyList = this._proxyList._next;
}
if(proxy == this._proxyListLast) {
this._proxyListLast = this._proxyListLast._prev;
}
proxy._next = null;
proxy._prev = null;
let bvhProxy = proxy;
let _this = this._tree;
let leaf = bvhProxy._leaf;
_this._numLeaves--;
let prev1 = leaf._prevLeaf;
let next1 = leaf._nextLeaf;
if(prev1 != null) {
prev1._nextLeaf = next1;
}
if(next1 != null) {
next1._prevLeaf = prev1;
}
if(leaf == _this.leafList) {
_this.leafList = _this.leafList._nextLeaf;
}
if(leaf == _this.leafListLast) {
_this.leafListLast = _this.leafListLast._prevLeaf;
}
leaf._nextLeaf = null;
leaf._prevLeaf = null;
if(_this._root == leaf) {
_this._root = null;
} else {
let parent = leaf._parent;
let sibling = parent._children[leaf._childIndex ^ 1];
let grandParent = parent._parent;
if(grandParent == null) {
sibling._parent = null;
sibling._childIndex = 0;
_this._root = sibling;
parent._next = null;
parent._childIndex = 0;
parent._children[0] = null;
parent._children[1] = null;
parent._childIndex = 0;
parent._parent = null;
parent._height = 0;
parent._proxy = null;
parent._next = _this._nodePool;
_this._nodePool = parent;
} else {
sibling._parent = grandParent;
let index = parent._childIndex;
grandParent._children[index] = sibling;
sibling._parent = grandParent;
sibling._childIndex = index;
parent._next = null;
parent._childIndex = 0;
parent._children[0] = null;
parent._children[1] = null;
parent._childIndex = 0;
parent._parent = null;
parent._height = 0;
parent._proxy = null;
parent._next = _this._nodePool;
_this._nodePool = parent;
let node = grandParent;
while(node != null) {
if(_this._strategy._balancingEnabled) {
if(node._height >= 2) {
let p = node._parent;
let l = node._children[0];
let r = node._children[1];
let balance = l._height - r._height;
let nodeIndex = node._childIndex;
if(balance > 1) {
let ll = l._children[0];
let lr = l._children[1];
if(ll._height > lr._height) {
l._children[1] = node;
node._parent = l;
node._childIndex = 1;
node._children[0] = lr;
lr._parent = node;
lr._childIndex = 0;
let c1 = l._children[0];
let c2 = l._children[1];
l._aabbMinX = c1._aabbMinX < c2._aabbMinX ? c1._aabbMinX : c2._aabbMinX;
l._aabbMinY = c1._aabbMinY < c2._aabbMinY ? c1._aabbMinY : c2._aabbMinY;
l._aabbMinZ = c1._aabbMinZ < c2._aabbMinZ ? c1._aabbMinZ : c2._aabbMinZ;
l._aabbMaxX = c1._aabbMaxX > c2._aabbMaxX ? c1._aabbMaxX : c2._aabbMaxX;
l._aabbMaxY = c1._aabbMaxY > c2._aabbMaxY ? c1._aabbMaxY : c2._aabbMaxY;
l._aabbMaxZ = c1._aabbMaxZ > c2._aabbMaxZ ? c1._aabbMaxZ : c2._aabbMaxZ;
let h1 = l._children[0]._height;
let h2 = l._children[1]._height;
l._height = (h1 > h2 ? h1 : h2) + 1;
let c11 = node._children[0];
let c21 = node._children[1];
node._aabbMinX = c11._aabbMinX < c21._aabbMinX ? c11._aabbMinX : c21._aabbMinX;
node._aabbMinY = c11._aabbMinY < c21._aabbMinY ? c11._aabbMinY : c21._aabbMinY;
node._aabbMinZ = c11._aabbMinZ < c21._aabbMinZ ? c11._aabbMinZ : c21._aabbMinZ;
node._aabbMaxX = c11._aabbMaxX > c21._aabbMaxX ? c11._aabbMaxX : c21._aabbMaxX;
node._aabbMaxY = c11._aabbMaxY > c21._aabbMaxY ? c11._aabbMaxY : c21._aabbMaxY;
node._aabbMaxZ = c11._aabbMaxZ > c21._aabbMaxZ ? c11._aabbMaxZ : c21._aabbMaxZ;
let h11 = node._children[0]._height;
let h21 = node._children[1]._height;
node._height = (h11 > h21 ? h11 : h21) + 1;
} else {
l._children[0] = node;
node._parent = l;
node._childIndex = 0;
node._children[0] = ll;
ll._parent = node;
ll._childIndex = 0;
let c1 = l._children[0];
let c2 = l._children[1];
l._aabbMinX = c1._aabbMinX < c2._aabbMinX ? c1._aabbMinX : c2._aabbMinX;
l._aabbMinY = c1._aabbMinY < c2._aabbMinY ? c1._aabbMinY : c2._aabbMinY;
l._aabbMinZ = c1._aabbMinZ < c2._aabbMinZ ? c1._aabbMinZ : c2._aabbMinZ;
l._aabbMaxX = c1._aabbMaxX > c2._aabbMaxX ? c1._aabbMaxX : c2._aabbMaxX;
l._aabbMaxY = c1._aabbMaxY > c2._aabbMaxY ? c1._aabbMaxY : c2._aabbMaxY;
l._aabbMaxZ = c1._aabbMaxZ > c2._aabbMaxZ ? c1._aabbMaxZ : c2._aabbMaxZ;
let h1 = l._children[0]._height;
let h2 = l._children[1]._height;
l._height = (h1 > h2 ? h1 : h2) + 1;
let c11 = node._children[0];
let c21 = node._children[1];
node._aabbMinX = c11._aabbMinX < c21._aabbMinX ? c11._aabbMinX : c21._aabbMinX;
node._aabbMinY = c11._aabbMinY < c21._aabbMinY ? c11._aabbMinY : c21._aabbMinY;
node._aabbMinZ = c11._aabbMinZ < c21._aabbMinZ ? c11._aabbMinZ : c21._aabbMinZ;
node._aabbMaxX = c11._aabbMaxX > c21._aabbMaxX ? c11._aabbMaxX : c21._aabbMaxX;
node._aabbMaxY = c11._aabbMaxY > c21._aabbMaxY ? c11._aabbMaxY : c21._aabbMaxY;
node._aabbMaxZ = c11._aabbMaxZ > c21._aabbMaxZ ? c11._aabbMaxZ : c21._aabbMaxZ;
let h11 = node._children[0]._height;
let h21 = node._children[1]._height;
node._height = (h11 > h21 ? h11 : h21) + 1;
}
if(p != null) {
p._children[nodeIndex] = l;
l._parent = p;
l._childIndex = nodeIndex;
} else {
_this._root = l;
l._parent = null;
}
node = l;
} else if(balance < -1) {
let rl = r._children[0];
let rr = r._children[1];
if(rl._height > rr._height) {
r._children[1] = node;
node._parent = r;
node._childIndex = 1;
node._children[1] = rr;
rr._parent = node;
rr._childIndex = 1;
let c1 = r._children[0];
let c2 = r._children[1];
r._aabbMinX = c1._aabbMinX < c2._aabbMinX ? c1._aabbMinX : c2._aabbMinX;
r._aabbMinY = c1._aabbMinY < c2._aabbMinY ? c1._aabbMinY : c2._aabbMinY;
r._aabbMinZ = c1._aabbMinZ < c2._aabbMinZ ? c1._aabbMinZ : c2._aabbMinZ;
r._aabbMaxX = c1._aabbMaxX > c2._aabbMaxX ? c1._aabbMaxX : c2._aabbMaxX;
r._aabbMaxY = c1._aabbMaxY > c2._aabbMaxY ? c1._aabbMaxY : c2._aabbMaxY;
r._aabbMaxZ = c1._aabbMaxZ > c2._aabbMaxZ ? c1._aabbMaxZ : c2._aabbMaxZ;
let h1 = r._children[0]._height;
let h2 = r._children[1]._height;
r._height = (h1 > h2 ? h1 : h2) + 1;
let c11 = node._children[0];
let c21 = node._children[1];
node._aabbMinX = c11._aabbMinX < c21._aabbMinX ? c11._aabbMinX : c21._aabbMinX;
node._aabbMinY = c11._aabbMinY < c21._aabbMinY ? c11._aabbMinY : c21._aabbMinY;
node._aabbMinZ = c11._aabbMinZ < c21._aabbMinZ ? c11._aabbMinZ : c21._aabbMinZ;
node._aabbMaxX = c11._aabbMaxX > c21._aabbMaxX ? c11._aabbMaxX : c21._aabbMaxX;
node._aabbMaxY = c11._aabbMaxY > c21._aabbMaxY ? c11._aabbMaxY : c21._aabbMaxY;
node._aabbMaxZ = c11._aabbMaxZ > c21._aabbMaxZ ? c11._aabbMaxZ : c21._aabbMaxZ;
let h11 = node._children[0]._height;
let h21 = node._children[1]._height;
node._height = (h11 > h21 ? h11 : h21) + 1;
} else {
r._children[0] = node;
node._parent = r;
node._childIndex = 0;
node._children[1] = rl;
rl._parent = node;
rl._childIndex = 1;
let c1 = r._children[0];
let c2 = r._children[1];
r._aabbMinX = c1._aabbMinX < c2._aabbMinX ? c1._aabbMinX : c2._aabbMinX;
r._aabbMinY = c1._aabbMinY < c2._aabbMinY ? c1._aabbMinY : c2._aabbMinY;
r._aabbMinZ = c1._aabbMinZ < c2._aabbMinZ ? c1._aabbMinZ : c2._aabbMinZ;
r._aabbMaxX = c1._aabbMaxX > c2._aabbMaxX ? c1._aabbMaxX : c2._aabbMaxX;
r._aabbMaxY = c1._aabbMaxY > c2._aabbMaxY ? c1._aabbMaxY : c2._aabbMaxY;
r._aabbMaxZ = c1._aabbMaxZ > c2._aabbMaxZ ? c1._aabbMaxZ : c2._aabbMaxZ;
let h1 = r._children[0]._height;
let h2 = r._children[1]._height;
r._height = (h1 > h2 ? h1 : h2) + 1;
let c11 = node._children[0];
let c21 = node._children[1];
node._aabbMinX = c11._aabbMinX < c21._aabbMinX ? c11._aabbMinX : c21._aabbMinX;
node._aabbMinY = c11._aabbMinY < c21._aabbMinY ? c11._aabbMinY : c21._aabbMinY;
node._aabbMinZ = c11._aabbMinZ < c21._aabbMinZ ? c11._aabbMinZ : c21._aabbMinZ;
node._aabbMaxX = c11._aabbMaxX > c21._aabbMaxX ? c11._aabbMaxX : c21._aabbMaxX;
node._aabbMaxY = c11._aabbMaxY > c21._aabbMaxY ? c11._aabbMaxY : c21._aabbMaxY;
node._aabbMaxZ = c11._aabbMaxZ > c21._aabbMaxZ ? c11._aabbMaxZ : c21._aabbMaxZ;
let h11 = node._children[0]._height;
let h21 = node._children[1]._height;
node._height = (h11 > h21 ? h11 : h21) + 1;
}
if(p != null) {
p._children[nodeIndex] = r;
r._parent = p;
r._childIndex = nodeIndex;
} else {
_this._root = r;
r._parent = null;
}
node = r;
}
}
}
let h1 = node._children[0]._height;
let h2 = node._children[1]._height;
node._height = (h1 > h2 ? h1 : h2) + 1;
let c1 = node._children[0];
let c2 = node._children[1];
node._aabbMinX = c1._aabbMinX < c2._aabbMinX ? c1._aabbMinX : c2._aabbMinX;
node._aabbMinY = c1._aabbMinY < c2._aabbMinY ? c1._aabbMinY : c2._aabbMinY;
node._aabbMinZ = c1._aabbMinZ < c2._aabbMinZ ? c1._aabbMinZ : c2._aabbMinZ;
node._aabbMaxX = c1._aabbMaxX > c2._aabbMaxX ? c1._aabbMaxX : c2._aabbMaxX;
node._aabbMaxY = c1._aabbMaxY > c2._aabbMaxY ? c1._aabbMaxY : c2._aabbMaxY;
node._aabbMaxZ = c1._aabbMaxZ > c2._aabbMaxZ ? c1._aabbMaxZ : c2._aabbMaxZ;
node = node._parent;
}
}
}
bvhProxy._leaf = null;
leaf._next = null;
leaf._childIndex = 0;
leaf._children[0] = null;
leaf._children[1] = null;
leaf._childIndex = 0;
leaf._parent = null;
leaf._height = 0;
leaf._proxy = null;
leaf._next = _this._nodePool;
_this._nodePool = leaf;
bvhProxy.userData = null;
bvhProxy._next = null;
bvhProxy._prev = null;
if(bvhProxy._moved) {
bvhProxy._moved = false;
}
}
moveProxy(proxy,aabb,displacement) {
let p = proxy;
if(p._aabbMinX <= aabb._minX && p._aabbMaxX >= aabb._maxX && p._aabbMinY <= aabb._minY && p._aabbMaxY >= aabb._maxY && p._aabbMinZ <= aabb._minZ && p._aabbMaxZ >= aabb._maxZ) {
return;
}
p._aabbMinX = aabb._minX;
p._aabbMinY = aabb._minY;
p._aabbMinZ = aabb._minZ;
p._aabbMaxX = aabb._maxX;
p._aabbMaxY = aabb._maxY;
p._aabbMaxZ = aabb._maxZ;
let padding = oimo.common.Setting.bvhProxyPadding;
p._aabbMinX -= padding;
p._aabbMinY -= padding;
p._aabbMinZ -= padding;
p._aabbMaxX += padding;
p._aabbMaxY += padding;
p._aabbMaxZ += padding;
if(displacement != null) {
let dX;
let dY;
let dZ;
let zeroX;
let zeroY;
let zeroZ;
let addToMinX;
let addToMinY;
let addToMinZ;
let addToMaxX;
let addToMaxY;
let addToMaxZ;
zeroX = 0;
zeroY = 0;
zeroZ = 0;
dX = displacement.x;
dY = displacement.y;
dZ = displacement.z;
addToMinX = zeroX < dX ? zeroX : dX;
addToMinY = zeroY < dY ? zeroY : dY;
addToMinZ = zeroZ < dZ ? zeroZ : dZ;
addToMaxX = zeroX > dX ? zeroX : dX;
addToMaxY = zeroY > dY ? zeroY : dY;
addToMaxZ = zeroZ > dZ ? zeroZ : dZ;
p._aabbMinX += addToMinX;
p._aabbMinY += addToMinY;
p._aabbMinZ += addToMinZ;
p._aabbMaxX += addToMaxX;
p._aabbMaxY += addToMaxY;
p._aabbMaxZ += addToMaxZ;
}
if(!p._moved) {
p._moved = true;
if(this.movedProxies.length == this.numMovedProxies) {
let newArray = new Array(this.numMovedProxies << 1);
let _g = 0;
let _g1 = this.numMovedProxies;
while(_g < _g1) {
let i = _g++;
newArray[i] = this.movedProxies[i];
this.movedProxies[i] = null;
}
this.movedProxies = newArray;
}
this.movedProxies[this.numMovedProxies++] = p;
}
}
collectPairs() {
let p = this._proxyPairList;
if(p != null) {
while(true) {
p._p1 = null;
p._p2 = null;
p = p._next;
if(!(p != null)) {
break;
}
}
this._proxyPairList._next = this._proxyPairPool;
this._proxyPairPool = this._proxyPairList;
this._proxyPairList = null;
}
this._testCount = 0;
if(this._numProxies < 2) {
return;
}
let incrementalCollision = this.numMovedProxies / this._numProxies < oimo.common.Setting.bvhIncrementalCollisionThreshold;
let _g = 0;
let _g1 = this.numMovedProxies;
while(_g < _g1) {
let i = _g++;
let p = this.movedProxies[i];
if(p._moved) {
let _this = this._tree;
let leaf = p._leaf;
_this._numLeaves--;
let prev = leaf._prevLeaf;
let next = leaf._nextLeaf;
if(prev != null) {
prev._nextLeaf = next;
}
if(next != null) {
next._prevLeaf = prev;
}
if(leaf == _this.leafList) {
_this.leafList = _this.leafList._nextLeaf;
}
if(leaf == _this.leafListLast) {
_this.leafListLast = _this.leafListLast._prevLeaf;
}
leaf._nextLeaf = null;
leaf._prevLeaf = null;
if(_this._root == leaf) {
_this._root = null;
} else {
let parent = leaf._parent;
let sibling = parent._children[leaf._childIndex ^ 1];
let grandParent = parent._parent;
if(grandParent == null) {
sibling._parent = null;
sibling._childIndex = 0;
_this._root = sibling;
parent._next = null;
parent._childIndex = 0;
parent._children[0] = null;
parent._children[1] = null;
parent._childIndex = 0;
parent._parent = null;
parent._height = 0;
parent._proxy = null;
parent._next = _this._nodePool;
_this._nodePool = parent;
} else {
sibling._parent = grandParent;
let index = parent._childIndex;
grandParent._children[index] = sibling;
sibling._parent = grandParent;
sibling._childIndex = index;
parent._next = null;
parent._childIndex = 0;
parent._children[0] = null;
parent._children[1] = null;
parent._childIndex = 0;
parent._parent = null;
parent._height = 0;
parent._proxy = null;
parent._next = _this._nodePool;
_this._nodePool = parent;
let node = grandParent;
while(node != null) {
if(_this._strategy._balancingEnabled) {
if(node._height >= 2) {
let p = node._parent;
let l = node._children[0];
let r = node._children[1];
let balance = l._height - r._height;
let nodeIndex = node._childIndex;
if(balance > 1) {
let ll = l._children[0];
let lr = l._children[1];
if(ll._height > lr._height) {
l._children[1] = node;
node._parent = l;
node._childIndex = 1;
node._children[0] = lr;
lr._parent = node;
lr._childIndex = 0;
let c1 = l._children[0];
let c2 = l._children[1];
l._aabbMinX = c1._aabbMinX < c2._aabbMinX ? c1._aabbMinX : c2._aabbMinX;
l._aabbMinY = c1._aabbMinY < c2._aabbMinY ? c1._aabbMinY : c2._aabbMinY;
l._aabbMinZ = c1._aabbMinZ < c2._aabbMinZ ? c1._aabbMinZ : c2._aabbMinZ;
l._aabbMaxX = c1._aabbMaxX > c2._aabbMaxX ? c1._aabbMaxX : c2._aabbMaxX;
l._aabbMaxY = c1._aabbMaxY > c2._aabbMaxY ? c1._aabbMaxY : c2._aabbMaxY;
l._aabbMaxZ = c1._aabbMaxZ > c2._aabbMaxZ ? c1._aabbMaxZ : c2._aabbMaxZ;
let h1 = l._children[0]._height;
let h2 = l._children[1]._height;
l._height = (h1 > h2 ? h1 : h2) + 1;
let c11 = node._children[0];
let c21 = node._children[1];
node._aabbMinX = c11._aabbMinX < c21._aabbMinX ? c11._aabbMinX : c21._aabbMinX;
node._aabbMinY = c11._aabbMinY < c21._aabbMinY ? c11._aabbMinY : c21._aabbMinY;
node._aabbMinZ = c11._aabbMinZ < c21._aabbMinZ ? c11._aabbMinZ : c21._aabbMinZ;
node._aabbMaxX = c11._aabbMaxX > c21._aabbMaxX ? c11._aabbMaxX : c21._aabbMaxX;
node._aabbMaxY = c11._aabbMaxY > c21._aabbMaxY ? c11._aabbMaxY : c21._aabbMaxY;
node._aabbMaxZ = c11._aabbMaxZ > c21._aabbMaxZ ? c11._aabbMaxZ : c21._aabbMaxZ;
let h11 = node._children[0]._height;
let h21 = node._children[1]._height;
node._height = (h11 > h21 ? h11 : h21) + 1;
} else {
l._children[0] = node;
node._parent = l;
node._childIndex = 0;
node._children[0] = ll;
ll._parent = node;
ll._childIndex = 0;
let c1 = l._children[0];
let c2 = l._children[1];
l._aabbMinX = c1._aabbMinX < c2._aabbMinX ? c1._aabbMinX : c2._aabbMinX;
l._aabbMinY = c1._aabbMinY < c2._aabbMinY ? c1._aabbMinY : c2._aabbMinY;
l._aabbMinZ = c1._aabbMinZ < c2._aabbMinZ ? c1._aabbMinZ : c2._aabbMinZ;
l._aabbMaxX = c1._aabbMaxX > c2._aabbMaxX ? c1._aabbMaxX : c2._aabbMaxX;
l._aabbMaxY = c1._aabbMaxY > c2._aabbMaxY ? c1._aabbMaxY : c2._aabbMaxY;
l._aabbMaxZ = c1._aabbMaxZ > c2._aabbMaxZ ? c1._aabbMaxZ : c2._aabbMaxZ;
let h1 = l._children[0]._height;
let h2 = l._children[1]._height;
l._height = (h1 > h2 ? h1 : h2) + 1;
let c11 = node._children[0];
let c21 = node._children[1];
node._aabbMinX = c11._aabbMinX < c21._aabbMinX ? c11._aabbMinX : c21._aabbMinX;
node._aabbMinY = c11._aabbMinY < c21._aabbMinY ? c11._aabbMinY : c21._aabbMinY;
node._aabbMinZ = c11._aabbMinZ < c21._aabbMinZ ? c11._aabbMinZ : c21._aabbMinZ;
node._aabbMaxX = c11._aabbMaxX > c21._aabbMaxX ? c11._aabbMaxX : c21._aabbMaxX;
node._aabbMaxY = c11._aabbMaxY > c21._aabbMaxY ? c11._aabbMaxY : c21._aabbMaxY;
node._aabbMaxZ = c11._aabbMaxZ > c21._aabbMaxZ ? c11._aabbMaxZ : c21._aabbMaxZ;
let h11 = node._children[0]._height;
let h21 = node._children[1]._height;
node._height = (h11 > h21 ? h11 : h21) + 1;
}
if(p != null) {
p._children[nodeIndex] = l;
l._parent = p;
l._childIndex = nodeIndex;
} else {
_this._root = l;
l._parent = null;
}
node = l;
} else if(balance < -1) {
let rl = r._children[0];
let rr = r._children[1];
if(rl._height > rr._height) {
r._children[1] = node;
node._parent = r;
node._childIndex = 1;
node._children[1] = rr;
rr._parent = node;
rr._childIndex = 1;
let c1 = r._children[0];
let c2 = r._children[1];
r._aabbMinX = c1._aabbMinX < c2._aabbMinX ? c1._aabbMinX : c2._aabbMinX;
r._aabbMinY = c1._aabbMinY < c2._aabbMinY ? c1._aabbMinY : c2._aabbMinY;
r._aabbMinZ = c1._aabbMinZ < c2._aabbMinZ ? c1._aabbMinZ : c2._aabbMinZ;
r._aabbMaxX = c1._aabbMaxX > c2._aabbMaxX ? c1._aabbMaxX : c2._aabbMaxX;
r._aabbMaxY = c1._aabbMaxY > c2._aabbMaxY ? c1._aabbMaxY : c2._aabbMaxY;
r._aabbMaxZ = c1._aabbMaxZ > c2._aabbMaxZ ? c1._aabbMaxZ : c2._aabbMaxZ;
let h1 = r._children[0]._height;
let h2 = r._children[1]._height;
r._height = (h1 > h2 ? h1 : h2) + 1;
let c11 = node._children[0];
let c21 = node._children[1];
node._aabbMinX = c11._aabbMinX < c21._aabbMinX ? c11._aabbMinX : c21._aabbMinX;
node._aabbMinY = c11._aabbMinY < c21._aabbMinY ? c11._aabbMinY : c21._aabbMinY;
node._aabbMinZ = c11._aabbMinZ < c21._aabbMinZ ? c11._aabbMinZ : c21._aabbMinZ;
node._aabbMaxX = c11._aabbMaxX > c21._aabbMaxX ? c11._aabbMaxX : c21._aabbMaxX;
node._aabbMaxY = c11._aabbMaxY > c21._aabbMaxY ? c11._aabbMaxY : c21._aabbMaxY;
node._aabbMaxZ = c11._aabbMaxZ > c21._aabbMaxZ ? c11._aabbMaxZ : c21._aabbMaxZ;
let h11 = node._children[0]._height;
let h21 = node._children[1]._height;
node._height = (h11 > h21 ? h11 : h21) + 1;
} else {
r._children[0] = node;
node._parent = r;
node._childIndex = 0;
node._children[1] = rl;
rl._parent = node;
rl._childIndex = 1;
let c1 = r._children[0];
let c2 = r._children[1];
r._aabbMinX = c1._aabbMinX < c2._aabbMinX ? c1._aabbMinX : c2._aabbMinX;
r._aabbMinY = c1._aabbMinY < c2._aabbMinY ? c1._aabbMinY : c2._aabbMinY;
r._aabbMinZ = c1._aabbMinZ < c2._aabbMinZ ? c1._aabbMinZ : c2._aabbMinZ;
r._aabbMaxX = c1._aabbMaxX > c2._aabbMaxX ? c1._aabbMaxX : c2._aabbMaxX;
r._aabbMaxY = c1._aabbMaxY > c2._aabbMaxY ? c1._aabbMaxY : c2._aabbMaxY;
r._aabbMaxZ = c1._aabbMaxZ > c2._aabbMaxZ ? c1._aabbMaxZ : c2._aabbMaxZ;
let h1 = r._children[0]._height;
let h2 = r._children[1]._height;
r._height = (h1 > h2 ? h1 : h2) + 1;
let c11 = node._children[0];
let c21 = node._children[1];
node._aabbMinX = c11._aabbMinX < c21._aabbMinX ? c11._aabbMinX : c21._aabbMinX;
node._aabbMinY = c11._aabbMinY < c21._aabbMinY ? c11._aabbMinY : c21._aabbMinY;
node._aabbMinZ = c11._aabbMinZ < c21._aabbMinZ ? c11._aabbMinZ : c21._aabbMinZ;
node._aabbMaxX = c11._aabbMaxX > c21._aabbMaxX ? c11._aabbMaxX : c21._aabbMaxX;
node._aabbMaxY = c11._aabbMaxY > c21._aabbMaxY ? c11._aabbMaxY : c21._aabbMaxY;
node._aabbMaxZ = c11._aabbMaxZ > c21._aabbMaxZ ? c11._aabbMaxZ : c21._aabbMaxZ;
let h11 = node._children[0]._height;
let h21 = node._children[1]._height;
node._height = (h11 > h21 ? h11 : h21) + 1;
}
if(p != null) {
p._children[nodeIndex] = r;
r._parent = p;
r._childIndex = nodeIndex;
} else {
_this._root = r;
r._parent = null;
}
node = r;
}
}
}
let h1 = node._children[0]._height;
let h2 = node._children[1]._height;
node._height = (h1 > h2 ? h1 : h2) + 1;
let c1 = node._children[0];
let c2 = node._children[1];
node._aabbMinX = c1._aabbMinX < c2._aabbMinX ? c1._aabbMinX : c2._aabbMinX;
node._aabbMinY = c1._aabbMinY < c2._aabbMinY ? c1._aabbMinY : c2._aabbMinY;
node._aabbMinZ = c1._aabbMinZ < c2._aabbMinZ ? c1._aabbMinZ : c2._aabbMinZ;
node._aabbMaxX = c1._aabbMaxX > c2._aabbMaxX ? c1._aabbMaxX : c2._aabbMaxX;
node._aabbMaxY = c1._aabbMaxY > c2._aabbMaxY ? c1._aabbMaxY : c2._aabbMaxY;
node._aabbMaxZ = c1._aabbMaxZ > c2._aabbMaxZ ? c1._aabbMaxZ : c2._aabbMaxZ;
node = node._parent;
}
}
}
p._leaf = null;
leaf._next = null;
leaf._childIndex = 0;
leaf._children[0] = null;
leaf._children[1] = null;
leaf._childIndex = 0;
leaf._parent = null;
leaf._height = 0;
leaf._proxy = null;
leaf._next = _this._nodePool;
_this._nodePool = leaf;
let _this1 = this._tree;
let first = _this1._nodePool;
if(first != null) {
_this1._nodePool = first._next;
first._next = null;
} else {
first = new oimo.collision.broadphase.bvh.BvhNode();
}
let leaf1 = first;
leaf1._proxy = p;
p._leaf = leaf1;
leaf1._aabbMinX = p._aabbMinX;
leaf1._aabbMinY = p._aabbMinY;
leaf1._aabbMinZ = p._aabbMinZ;
leaf1._aabbMaxX = p._aabbMaxX;
leaf1._aabbMaxY = p._aabbMaxY;
leaf1._aabbMaxZ = p._aabbMaxZ;
_this1._numLeaves++;
if(_this1.leafList == null) {
_this1.leafList = leaf1;
_this1.leafListLast = leaf1;
} else {
_this1.leafListLast._nextLeaf = leaf1;
leaf1._prevLeaf = _this1.leafListLast;
_this1.leafListLast = leaf1;
}
if(_this1._root == null) {
_this1._root = leaf1;
} else {
let sibling = _this1._root;
while(sibling._height > 0) {
let nextStep = _this1._strategy._decideInsertion(sibling,leaf1);
if(nextStep == -1) {
break;
} else {
sibling = sibling._children[nextStep];
}
}
let parent = sibling._parent;
let first = _this1._nodePool;
if(first != null) {
_this1._nodePool = first._next;
first._next = null;
} else {
first = new oimo.collision.broadphase.bvh.BvhNode();
}
let node = first;
if(parent == null) {
_this1._root = node;
} else {
let index = sibling._childIndex;
parent._children[index] = node;
node._parent = parent;
node._childIndex = index;
}
let index = sibling._childIndex;
node._children[index] = sibling;
sibling._parent = node;
sibling._childIndex = index;
let index1 = sibling._childIndex ^ 1;
node._children[index1] = leaf1;
leaf1._parent = node;
leaf1._childIndex = index1;
while(node != null) {
if(_this1._strategy._balancingEnabled) {
if(node._height >= 2) {
let p = node._parent;
let l = node._children[0];
let r = node._children[1];
let balance = l._height - r._height;
let nodeIndex = node._childIndex;
if(balance > 1) {
let ll = l._children[0];
let lr = l._children[1];
if(ll._height > lr._height) {
l._children[1] = node;
node._parent = l;
node._childIndex = 1;
node._children[0] = lr;
lr._parent = node;
lr._childIndex = 0;
let c1 = l._children[0];
let c2 = l._children[1];
l._aabbMinX = c1._aabbMinX < c2._aabbMinX ? c1._aabbMinX : c2._aabbMinX;
l._aabbMinY = c1._aabbMinY < c2._aabbMinY ? c1._aabbMinY : c2._aabbMinY;
l._aabbMinZ = c1._aabbMinZ < c2._aabbMinZ ? c1._aabbMinZ : c2._aabbMinZ;
l._aabbMaxX = c1._aabbMaxX > c2._aabbMaxX ? c1._aabbMaxX : c2._aabbMaxX;
l._aabbMaxY = c1._aabbMaxY > c2._aabbMaxY ? c1._aabbMaxY : c2._aabbMaxY;
l._aabbMaxZ = c1._aabbMaxZ > c2._aabbMaxZ ? c1._aabbMaxZ : c2._aabbMaxZ;
let h1 = l._children[0]._height;
let h2 = l._children[1]._height;
l._height = (h1 > h2 ? h1 : h2) + 1;
let c11 = node._children[0];
let c21 = node._children[1];
node._aabbMinX = c11._aabbMinX < c21._aabbMinX ? c11._aabbMinX : c21._aabbMinX;
node._aabbMinY = c11._aabbMinY < c21._aabbMinY ? c11._aabbMinY : c21._aabbMinY;
node._aabbMinZ = c11._aabbMinZ < c21._aabbMinZ ? c11._aabbMinZ : c21._aabbMinZ;
node._aabbMaxX = c11._aabbMaxX > c21._aabbMaxX ? c11._aabbMaxX : c21._aabbMaxX;
node._aabbMaxY = c11._aabbMaxY > c21._aabbMaxY ? c11._aabbMaxY : c21._aabbMaxY;
node._aabbMaxZ = c11._aabbMaxZ > c21._aabbMaxZ ? c11._aabbMaxZ : c21._aabbMaxZ;
let h11 = node._children[0]._height;
let h21 = node._children[1]._height;
node._height = (h11 > h21 ? h11 : h21) + 1;
} else {
l._children[0] = node;
node._parent = l;
node._childIndex = 0;
node._children[0] = ll;
ll._parent = node;
ll._childIndex = 0;
let c1 = l._children[0];
let c2 = l._children[1];
l._aabbMinX = c1._aabbMinX < c2._aabbMinX ? c1._aabbMinX : c2._aabbMinX;
l._aabbMinY = c1._aabbMinY < c2._aabbMinY ? c1._aabbMinY : c2._aabbMinY;
l._aabbMinZ = c1._aabbMinZ < c2._aabbMinZ ? c1._aabbMinZ : c2._aabbMinZ;
l._aabbMaxX = c1._aabbMaxX > c2._aabbMaxX ? c1._aabbMaxX : c2._aabbMaxX;
l._aabbMaxY = c1._aabbMaxY > c2._aabbMaxY ? c1._aabbMaxY : c2._aabbMaxY;
l._aabbMaxZ = c1._aabbMaxZ > c2._aabbMaxZ ? c1._aabbMaxZ : c2._aabbMaxZ;
let h1 = l._children[0]._height;
let h2 = l._children[1]._height;
l._height = (h1 > h2 ? h1 : h2) + 1;
let c11 = node._children[0];
let c21 = node._children[1];
node._aabbMinX = c11._aabbMinX < c21._aabbMinX ? c11._aabbMinX : c21._aabbMinX;
node._aabbMinY = c11._aabbMinY < c21._aabbMinY ? c11._aabbMinY : c21._aabbMinY;
node._aabbMinZ = c11._aabbMinZ < c21._aabbMinZ ? c11._aabbMinZ : c21._aabbMinZ;
node._aabbMaxX = c11._aabbMaxX > c21._aabbMaxX ? c11._aabbMaxX : c21._aabbMaxX;
node._aabbMaxY = c11._aabbMaxY > c21._aabbMaxY ? c11._aabbMaxY : c21._aabbMaxY;
node._aabbMaxZ = c11._aabbMaxZ > c21._aabbMaxZ ? c11._aabbMaxZ : c21._aabbMaxZ;
let h11 = node._children[0]._height;
let h21 = node._children[1]._height;
node._height = (h11 > h21 ? h11 : h21) + 1;
}
if(p != null) {
p._children[nodeIndex] = l;
l._parent = p;
l._childIndex = nodeIndex;
} else {
_this1._root = l;
l._parent = null;
}
node = l;
} else if(balance < -1) {
let rl = r._children[0];
let rr = r._children[1];
if(rl._height > rr._height) {
r._children[1] = node;
node._parent = r;
node._childIndex = 1;
node._children[1] = rr;
rr._parent = node;
rr._childIndex = 1;
let c1 = r._children[0];
let c2 = r._children[1];
r._aabbMinX = c1._aabbMinX < c2._aabbMinX ? c1._aabbMinX : c2._aabbMinX;
r._aabbMinY = c1._aabbMinY < c2._aabbMinY ? c1._aabbMinY : c2._aabbMinY;
r._aabbMinZ = c1._aabbMinZ < c2._aabbMinZ ? c1._aabbMinZ : c2._aabbMinZ;
r._aabbMaxX = c1._aabbMaxX > c2._aabbMaxX ? c1._aabbMaxX : c2._aabbMaxX;
r._aabbMaxY = c1._aabbMaxY > c2._aabbMaxY ? c1._aabbMaxY : c2._aabbMaxY;
r._aabbMaxZ = c1._aabbMaxZ > c2._aabbMaxZ ? c1._aabbMaxZ : c2._aabbMaxZ;
let h1 = r._children[0]._height;
let h2 = r._children[1]._height;
r._height = (h1 > h2 ? h1 : h2) + 1;
let c11 = node._children[0];
let c21 = node._children[1];
node._aabbMinX = c11._aabbMinX < c21._aabbMinX ? c11._aabbMinX : c21._aabbMinX;
node._aabbMinY = c11._aabbMinY < c21._aabbMinY ? c11._aabbMinY : c21._aabbMinY;
node._aabbMinZ = c11._aabbMinZ < c21._aabbMinZ ? c11._aabbMinZ : c21._aabbMinZ;
node._aabbMaxX = c11._aabbMaxX > c21._aabbMaxX ? c11._aabbMaxX : c21._aabbMaxX;
node._aabbMaxY = c11._aabbMaxY > c21._aabbMaxY ? c11._aabbMaxY : c21._aabbMaxY;
node._aabbMaxZ = c11._aabbMaxZ > c21._aabbMaxZ ? c11._aabbMaxZ : c21._aabbMaxZ;
let h11 = node._children[0]._height;
let h21 = node._children[1]._height;
node._height = (h11 > h21 ? h11 : h21) + 1;
} else {
r._children[0] = node;
node._parent = r;
node._childIndex = 0;
node._children[1] = rl;
rl._parent = node;
rl._childIndex = 1;
let c1 = r._children[0];
let c2 = r._children[1];
r._aabbMinX = c1._aabbMinX < c2._aabbMinX ? c1._aabbMinX : c2._aabbMinX;
r._aabbMinY = c1._aabbMinY < c2._aabbMinY ? c1._aabbMinY : c2._aabbMinY;
r._aabbMinZ = c1._aabbMinZ < c2._aabbMinZ ? c1._aabbMinZ : c2._aabbMinZ;
r._aabbMaxX = c1._aabbMaxX > c2._aabbMaxX ? c1._aabbMaxX : c2._aabbMaxX;
r._aabbMaxY = c1._aabbMaxY > c2._aabbMaxY ? c1._aabbMaxY : c2._aabbMaxY;
r._aabbMaxZ = c1._aabbMaxZ > c2._aabbMaxZ ? c1._aabbMaxZ : c2._aabbMaxZ;
let h1 = r._children[0]._height;
let h2 = r._children[1]._height;
r._height = (h1 > h2 ? h1 : h2) + 1;
let c11 = node._children[0];
let c21 = node._children[1];
node._aabbMinX = c11._aabbMinX < c21._aabbMinX ? c11._aabbMinX : c21._aabbMinX;
node._aabbMinY = c11._aabbMinY < c21._aabbMinY ? c11._aabbMinY : c21._aabbMinY;
node._aabbMinZ = c11._aabbMinZ < c21._aabbMinZ ? c11._aabbMinZ : c21._aabbMinZ;
node._aabbMaxX = c11._aabbMaxX > c21._aabbMaxX ? c11._aabbMaxX : c21._aabbMaxX;
node._aabbMaxY = c11._aabbMaxY > c21._aabbMaxY ? c11._aabbMaxY : c21._aabbMaxY;
node._aabbMaxZ = c11._aabbMaxZ > c21._aabbMaxZ ? c11._aabbMaxZ : c21._aabbMaxZ;
let h11 = node._children[0]._height;
let h21 = node._children[1]._height;
node._height = (h11 > h21 ? h11 : h21) + 1;
}
if(p != null) {
p._children[nodeIndex] = r;
r._parent = p;
r._childIndex = nodeIndex;
} else {
_this1._root = r;
r._parent = null;
}
node = r;
}
}
}
let h1 = node._children[0]._height;
let h2 = node._children[1]._height;
node._height = (h1 > h2 ? h1 : h2) + 1;
let c1 = node._children[0];
let c2 = node._children[1];
node._aabbMinX = c1._aabbMinX < c2._aabbMinX ? c1._aabbMinX : c2._aabbMinX;
node._aabbMinY = c1._aabbMinY < c2._aabbMinY ? c1._aabbMinY : c2._aabbMinY;
node._aabbMinZ = c1._aabbMinZ < c2._aabbMinZ ? c1._aabbMinZ : c2._aabbMinZ;
node._aabbMaxX = c1._aabbMaxX > c2._aabbMaxX ? c1._aabbMaxX : c2._aabbMaxX;
node._aabbMaxY = c1._aabbMaxY > c2._aabbMaxY ? c1._aabbMaxY : c2._aabbMaxY;
node._aabbMaxZ = c1._aabbMaxZ > c2._aabbMaxZ ? c1._aabbMaxZ : c2._aabbMaxZ;
node = node._parent;
}
}
if(incrementalCollision) {
this.collide(this._tree._root,p._leaf);
}
p._moved = false;
}
this.movedProxies[i] = null;
}
if(!incrementalCollision) {
this.collide(this._tree._root,this._tree._root);
}
this.numMovedProxies = 0;
}
rayCast(begin,end,callback) {
if(this._tree._root == null) {
return;
}
let p1X;
let p1Y;
let p1Z;
let p2X;
let p2Y;
let p2Z;
p1X = begin.x;
p1Y = begin.y;
p1Z = begin.z;
p2X = end.x;
p2Y = end.y;
p2Z = end.z;
this.rayCastRecursive(this._tree._root,p1X,p1Y,p1Z,p2X,p2Y,p2Z,callback);
}
convexCast(convex,begin,translation,callback) {
if(this._tree._root == null) {
return;
}
this.convexCastRecursive(this._tree._root,convex,begin,translation,callback);
}
aabbTest(aabb,callback) {
if(this._tree._root == null) {
return;
}
this.aabbTestRecursive(this._tree._root,aabb,callback);
}
getTreeBalance() {
return this._tree._getBalance();
}
}
oimo.collision.broadphase.bvh.BvhInsertionStrategy = class oimo_collision_broadphase_bvh_BvhInsertionStrategy {
}
oimo.collision.broadphase.bvh.BvhNode = class oimo_collision_broadphase_bvh_BvhNode {
constructor() {
this._next = null;
this._prevLeaf = null;
this._nextLeaf = null;
this._children = new Array(2);
this._childIndex = 0;
this._parent = null;
this._height = 0;
this._proxy = null;
this._aabbMinX = 0;
this._aabbMinY = 0;
this._aabbMinZ = 0;
this._aabbMaxX = 0;
this._aabbMaxY = 0;
this._aabbMaxZ = 0;
}
}
oimo.collision.broadphase.bvh.BvhProxy = class oimo_collision_broadphase_bvh_BvhProxy extends oimo.collision.broadphase.Proxy {
constructor(userData,id) {
super(userData,id);
this._leaf = null;
this._moved = false;
}
}
oimo.collision.broadphase.bvh.BvhStrategy = class oimo_collision_broadphase_bvh_BvhStrategy {
constructor() {
this._insertionStrategy = 0;
this._balancingEnabled = false;
}
_decideInsertion(currentNode,leaf) {
switch(this._insertionStrategy) {
case 0:
let centerX;
let centerY;
let centerZ;
centerX = leaf._aabbMinX + leaf._aabbMaxX;
centerY = leaf._aabbMinY + leaf._aabbMaxY;
centerZ = leaf._aabbMinZ + leaf._aabbMaxZ;
let c1 = currentNode._children[0];
let c2 = currentNode._children[1];
let diff1X;
let diff1Y;
let diff1Z;
let diff2X;
let diff2Y;
let diff2Z;
diff1X = c1._aabbMinX + c1._aabbMaxX;
diff1Y = c1._aabbMinY + c1._aabbMaxY;
diff1Z = c1._aabbMinZ + c1._aabbMaxZ;
diff2X = c2._aabbMinX + c2._aabbMaxX;
diff2Y = c2._aabbMinY + c2._aabbMaxY;
diff2Z = c2._aabbMinZ + c2._aabbMaxZ;
diff1X -= centerX;
diff1Y -= centerY;
diff1Z -= centerZ;
diff2X -= centerX;
diff2Y -= centerY;
diff2Z -= centerZ;
if(diff1X * diff1X + diff1Y * diff1Y + diff1Z * diff1Z < diff2X * diff2X + diff2Y * diff2Y + diff2Z * diff2Z) {
return 0;
} else {
return 1;
}
break;
case 1:
let c11 = currentNode._children[0];
let c21 = currentNode._children[1];
let ey = currentNode._aabbMaxY - currentNode._aabbMinY;
let ez = currentNode._aabbMaxZ - currentNode._aabbMinZ;
let combinedMinX;
let combinedMinY;
let combinedMinZ;
let combinedMaxX;
let combinedMaxY;
let combinedMaxZ;
combinedMinX = currentNode._aabbMinX < leaf._aabbMinX ? currentNode._aabbMinX : leaf._aabbMinX;
combinedMinY = currentNode._aabbMinY < leaf._aabbMinY ? currentNode._aabbMinY : leaf._aabbMinY;
combinedMinZ = currentNode._aabbMinZ < leaf._aabbMinZ ? currentNode._aabbMinZ : leaf._aabbMinZ;
combinedMaxX = currentNode._aabbMaxX > leaf._aabbMaxX ? currentNode._aabbMaxX : leaf._aabbMaxX;
combinedMaxY = currentNode._aabbMaxY > leaf._aabbMaxY ? currentNode._aabbMaxY : leaf._aabbMaxY;
combinedMaxZ = currentNode._aabbMaxZ > leaf._aabbMaxZ ? currentNode._aabbMaxZ : leaf._aabbMaxZ;
let ey1 = combinedMaxY - combinedMinY;
let ez1 = combinedMaxZ - combinedMinZ;
let newArea = ((combinedMaxX - combinedMinX) * (ey1 + ez1) + ey1 * ez1) * 2;
let creatingCost = newArea * 2;
let incrementalCost = (newArea - ((currentNode._aabbMaxX - currentNode._aabbMinX) * (ey + ez) + ey * ez) * 2) * 2;
let descendingCost1;
combinedMinX = c11._aabbMinX < leaf._aabbMinX ? c11._aabbMinX : leaf._aabbMinX;
combinedMinY = c11._aabbMinY < leaf._aabbMinY ? c11._aabbMinY : leaf._aabbMinY;
combinedMinZ = c11._aabbMinZ < leaf._aabbMinZ ? c11._aabbMinZ : leaf._aabbMinZ;
combinedMaxX = c11._aabbMaxX > leaf._aabbMaxX ? c11._aabbMaxX : leaf._aabbMaxX;
combinedMaxY = c11._aabbMaxY > leaf._aabbMaxY ? c11._aabbMaxY : leaf._aabbMaxY;
combinedMaxZ = c11._aabbMaxZ > leaf._aabbMaxZ ? c11._aabbMaxZ : leaf._aabbMaxZ;
if(c11._height == 0) {
let ey = combinedMaxY - combinedMinY;
let ez = combinedMaxZ - combinedMinZ;
descendingCost1 = incrementalCost + ((combinedMaxX - combinedMinX) * (ey + ez) + ey * ez) * 2;
} else {
let ey = combinedMaxY - combinedMinY;
let ez = combinedMaxZ - combinedMinZ;
let ey1 = c11._aabbMaxY - c11._aabbMinY;
let ez1 = c11._aabbMaxZ - c11._aabbMinZ;
descendingCost1 = incrementalCost + (((combinedMaxX - combinedMinX) * (ey + ez) + ey * ez) * 2 - ((c11._aabbMaxX - c11._aabbMinX) * (ey1 + ez1) + ey1 * ez1) * 2);
}
let descendingCost2;
combinedMinX = c21._aabbMinX < leaf._aabbMinX ? c21._aabbMinX : leaf._aabbMinX;
combinedMinY = c21._aabbMinY < leaf._aabbMinY ? c21._aabbMinY : leaf._aabbMinY;
combinedMinZ = c21._aabbMinZ < leaf._aabbMinZ ? c21._aabbMinZ : leaf._aabbMinZ;
combinedMaxX = c21._aabbMaxX > leaf._aabbMaxX ? c21._aabbMaxX : leaf._aabbMaxX;
combinedMaxY = c21._aabbMaxY > leaf._aabbMaxY ? c21._aabbMaxY : leaf._aabbMaxY;
combinedMaxZ = c21._aabbMaxZ > leaf._aabbMaxZ ? c21._aabbMaxZ : leaf._aabbMaxZ;
if(c21._height == 0) {
let ey = combinedMaxY - combinedMinY;
let ez = combinedMaxZ - combinedMinZ;
descendingCost2 = incrementalCost + ((combinedMaxX - combinedMinX) * (ey + ez) + ey * ez) * 2;
} else {
let ey = combinedMaxY - combinedMinY;
let ez = combinedMaxZ - combinedMinZ;
let ey1 = c21._aabbMaxY - c21._aabbMinY;
let ez1 = c21._aabbMaxZ - c21._aabbMinZ;
descendingCost2 = incrementalCost + (((combinedMaxX - combinedMinX) * (ey + ez) + ey * ez) * 2 - ((c21._aabbMaxX - c21._aabbMinX) * (ey1 + ez1) + ey1 * ez1) * 2);
}
if(creatingCost < descendingCost1) {
if(creatingCost < descendingCost2) {
return -1;
} else {
return 1;
}
} else if(descendingCost1 < descendingCost2) {
return 0;
} else {
return 1;
}
break;
default:
console.log("src/oimo/collision/broadphase/bvh/BvhStrategy.hx:37:","invalid BVH insertion strategy: " + this._insertionStrategy);
return -1;
}
}
_splitLeaves(leaves,from,until) {
let invN = 1.0 / (until - from);
let centerMeanX;
let centerMeanY;
let centerMeanZ;
centerMeanX = 0;
centerMeanY = 0;
centerMeanZ = 0;
let _g = from;
while(_g < until) {
let leaf = leaves[_g++];
leaf._tmpX = leaf._aabbMaxX + leaf._aabbMinX;
leaf._tmpY = leaf._aabbMaxY + leaf._aabbMinY;
leaf._tmpZ = leaf._aabbMaxZ + leaf._aabbMinZ;
centerMeanX += leaf._tmpX;
centerMeanY += leaf._tmpY;
centerMeanZ += leaf._tmpZ;
}
centerMeanX *= invN;
centerMeanY *= invN;
centerMeanZ *= invN;
let varianceX;
let varianceY;
let varianceZ;
varianceX = 0;
varianceY = 0;
varianceZ = 0;
let _g1 = from;
while(_g1 < until) {
let leaf = leaves[_g1++];
let diffX;
let diffY;
let diffZ;
diffX = leaf._tmpX - centerMeanX;
diffY = leaf._tmpY - centerMeanY;
diffZ = leaf._tmpZ - centerMeanZ;
diffX *= diffX;
diffY *= diffY;
diffZ *= diffZ;
varianceX += diffX;
varianceY += diffY;
varianceZ += diffZ;
}
let varX = varianceX;
let varY = varianceY;
let varZ = varianceZ;
let l = from;
let r = until - 1;
if(varX > varY) {
if(varX > varZ) {
let mean = centerMeanX;
while(true) {
while(!(leaves[l]._tmpX <= mean)) ++l;
while(!(leaves[r]._tmpX >= mean)) --r;
if(l >= r) {
break;
}
let tmp = leaves[l];
leaves[l] = leaves[r];
leaves[r] = tmp;
++l;
--r;
}
} else {
let mean = centerMeanZ;
while(true) {
while(!(leaves[l]._tmpZ <= mean)) ++l;
while(!(leaves[r]._tmpZ >= mean)) --r;
if(l >= r) {
break;
}
let tmp = leaves[l];
leaves[l] = leaves[r];
leaves[r] = tmp;
++l;
--r;
}
}
} else if(varY > varZ) {
let mean = centerMeanY;
while(true) {
while(!(leaves[l]._tmpY <= mean)) ++l;
while(!(leaves[r]._tmpY >= mean)) --r;
if(l >= r) {
break;
}
let tmp = leaves[l];
leaves[l] = leaves[r];
leaves[r] = tmp;
++l;
--r;
}
} else {
let mean = centerMeanZ;
while(true) {
while(!(leaves[l]._tmpZ <= mean)) ++l;
while(!(leaves[r]._tmpZ >= mean)) --r;
if(l >= r) {
break;
}
let tmp = leaves[l];
leaves[l] = leaves[r];
leaves[r] = tmp;
++l;
--r;
}
}
return l;
}
}
oimo.collision.broadphase.bvh.BvhTree = class oimo_collision_broadphase_bvh_BvhTree {
constructor() {
this._root = null;
this._numLeaves = 0;
this._strategy = new oimo.collision.broadphase.bvh.BvhStrategy();
this._nodePool = null;
this.leafList = null;
this.leafListLast = null;
this.tmp = new Array(1024);
}
_print(root,indent) {
if(indent == null) {
indent = "";
}
if(root == null) {
return;
}
if(root._height == 0) {
console.log("src/oimo/collision/broadphase/bvh/BvhTree.hx:39:",indent + root._proxy._id);
} else {
this._print(root._children[0],indent + " ");
let tmp;
let sizeX;
let sizeY;
let sizeZ;
sizeX = root._aabbMaxX - root._aabbMinX;
sizeY = root._aabbMaxY - root._aabbMinY;
sizeZ = root._aabbMaxZ - root._aabbMinZ;
let y = sizeY;
let z = sizeZ;
if(sizeX * (y + z) + y * z > 0) {
let sizeX;
let sizeY;
let sizeZ;
sizeX = root._aabbMaxX - root._aabbMinX;
sizeY = root._aabbMaxY - root._aabbMinY;
sizeZ = root._aabbMaxZ - root._aabbMinZ;
let y = sizeY;
let z = sizeZ;
tmp = ((sizeX * (y + z) + y * z) * 1000 + 0.5 | 0) / 1000;
} else {
let sizeX;
let sizeY;
let sizeZ;
sizeX = root._aabbMaxX - root._aabbMinX;
sizeY = root._aabbMaxY - root._aabbMinY;
sizeZ = root._aabbMaxZ - root._aabbMinZ;
let y = sizeY;
let z = sizeZ;
tmp = ((sizeX * (y + z) + y * z) * 1000 - 0.5 | 0) / 1000;
}
console.log("src/oimo/collision/broadphase/bvh/BvhTree.hx:42:",indent + "#" + root._height + ", " + tmp);
this._print(root._children[1],indent + " ");
}
}
_getBalance() {
return this.getBalanceRecursive(this._root);
}
deleteRecursive(root) {
if(root._height == 0) {
let prev = root._prevLeaf;
let next = root._nextLeaf;
if(prev != null) {
prev._nextLeaf = next;
}
if(next != null) {
next._prevLeaf = prev;
}
if(root == this.leafList) {
this.leafList = this.leafList._nextLeaf;
}
if(root == this.leafListLast) {
this.leafListLast = this.leafListLast._prevLeaf;
}
root._nextLeaf = null;
root._prevLeaf = null;
root._proxy._leaf = null;
root._next = null;
root._childIndex = 0;
root._children[0] = null;
root._children[1] = null;
root._childIndex = 0;
root._parent = null;
root._height = 0;
root._proxy = null;
root._next = this._nodePool;
this._nodePool = root;
return;
}
this.deleteRecursive(root._children[0]);
this.deleteRecursive(root._children[1]);
root._next = null;
root._childIndex = 0;
root._children[0] = null;
root._children[1] = null;
root._childIndex = 0;
root._parent = null;
root._height = 0;
root._proxy = null;
root._next = this._nodePool;
this._nodePool = root;
}
decomposeRecursive(root) {
if(root._height == 0) {
root._childIndex = 0;
root._parent = null;
return;
}
this.decomposeRecursive(root._children[0]);
this.decomposeRecursive(root._children[1]);
root._next = null;
root._childIndex = 0;
root._children[0] = null;
root._children[1] = null;
root._childIndex = 0;
root._parent = null;
root._height = 0;
root._proxy = null;
root._next = this._nodePool;
this._nodePool = root;
}
buildTopDownRecursive(leaves,from,until) {
if(until - from == 1) {
let leaf = leaves[from];
let proxy = leaf._proxy;
leaf._aabbMinX = proxy._aabbMinX;
leaf._aabbMinY = proxy._aabbMinY;
leaf._aabbMinZ = proxy._aabbMinZ;
leaf._aabbMaxX = proxy._aabbMaxX;
leaf._aabbMaxY = proxy._aabbMaxY;
leaf._aabbMaxZ = proxy._aabbMaxZ;
return leaf;
}
let splitAt = this._strategy._splitLeaves(leaves,from,until);
let child1 = this.buildTopDownRecursive(leaves,from,splitAt);
let child2 = this.buildTopDownRecursive(leaves,splitAt,until);
let first = this._nodePool;
if(first != null) {
this._nodePool = first._next;
first._next = null;
} else {
first = new oimo.collision.broadphase.bvh.BvhNode();
}
let parent = first;
parent._children[0] = child1;
child1._parent = parent;
child1._childIndex = 0;
parent._children[1] = child2;
child2._parent = parent;
child2._childIndex = 1;
let c1 = parent._children[0];
let c2 = parent._children[1];
parent._aabbMinX = c1._aabbMinX < c2._aabbMinX ? c1._aabbMinX : c2._aabbMinX;
parent._aabbMinY = c1._aabbMinY < c2._aabbMinY ? c1._aabbMinY : c2._aabbMinY;
parent._aabbMinZ = c1._aabbMinZ < c2._aabbMinZ ? c1._aabbMinZ : c2._aabbMinZ;
parent._aabbMaxX = c1._aabbMaxX > c2._aabbMaxX ? c1._aabbMaxX : c2._aabbMaxX;
parent._aabbMaxY = c1._aabbMaxY > c2._aabbMaxY ? c1._aabbMaxY : c2._aabbMaxY;
parent._aabbMaxZ = c1._aabbMaxZ > c2._aabbMaxZ ? c1._aabbMaxZ : c2._aabbMaxZ;
let h1 = parent._children[0]._height;
let h2 = parent._children[1]._height;
parent._height = (h1 > h2 ? h1 : h2) + 1;
return parent;
}
getBalanceRecursive(root) {
if(root == null || root._height == 0) {
return 0;
}
let balance = root._children[0]._height - root._children[1]._height;
if(balance < 0) {
balance = -balance;
}
return balance + this.getBalanceRecursive(root._children[0]) + this.getBalanceRecursive(root._children[1]);
}
}
oimo.collision.geometry.Aabb = class oimo_collision_geometry_Aabb {
constructor() {
this._minX = 0;
this._minY = 0;
this._minZ = 0;
this._maxX = 0;
this._maxY = 0;
this._maxZ = 0;
}
init(min,max) {
this._minX = min.x;
this._minY = min.y;
this._minZ = min.z;
this._maxX = max.x;
this._maxY = max.y;
this._maxZ = max.z;
return this;
}
getMin() {
let min = new oimo.common.Vec3();
min.x = this._minX;
min.y = this._minY;
min.z = this._minZ;
return min;
}
getMinTo(min) {
min.x = this._minX;
min.y = this._minY;
min.z = this._minZ;
}
setMin(min) {
this._minX = min.x;
this._minY = min.y;
this._minZ = min.z;
return this;
}
getMax() {
let max = new oimo.common.Vec3();
max.x = this._maxX;
max.y = this._maxY;
max.z = this._maxZ;
return max;
}
getMaxTo(max) {
max.x = this._maxX;
max.y = this._maxY;
max.z = this._maxZ;
}
setMax(max) {
this._maxX = max.x;
this._maxY = max.y;
this._maxZ = max.z;
return this;
}
getCenter() {
let v = new oimo.common.Vec3();
let cX;
let cY;
let cZ;
cX = this._minX + this._maxX;
cY = this._minY + this._maxY;
cZ = this._minZ + this._maxZ;
cX *= 0.5;
cY *= 0.5;
cZ *= 0.5;
v.x = cX;
v.y = cY;
v.z = cZ;
return v;
}
getCenterTo(center) {
let cX;
let cY;
let cZ;
cX = this._minX + this._maxX;
cY = this._minY + this._maxY;
cZ = this._minZ + this._maxZ;
cX *= 0.5;
cY *= 0.5;
cZ *= 0.5;
center.x = cX;
center.y = cY;
center.z = cZ;
}
getExtents() {
let v = new oimo.common.Vec3();
let cX;
let cY;
let cZ;
cX = this._maxX - this._minX;
cY = this._maxY - this._minY;
cZ = this._maxZ - this._minZ;
cX *= 0.5;
cY *= 0.5;
cZ *= 0.5;
v.x = cX;
v.y = cY;
v.z = cZ;
return v;
}
getExtentsTo(halfExtents) {
let cX;
let cY;
let cZ;
cX = this._maxX - this._minX;
cY = this._maxY - this._minY;
cZ = this._maxZ - this._minZ;
cX *= 0.5;
cY *= 0.5;
cZ *= 0.5;
halfExtents.x = cX;
halfExtents.y = cY;
halfExtents.z = cZ;
}
combine(other) {
this._minX = this._minX < other._minX ? this._minX : other._minX;
this._minY = this._minY < other._minY ? this._minY : other._minY;
this._minZ = this._minZ < other._minZ ? this._minZ : other._minZ;
this._maxX = this._maxX > other._maxX ? this._maxX : other._maxX;
this._maxY = this._maxY > other._maxY ? this._maxY : other._maxY;
this._maxZ = this._maxZ > other._maxZ ? this._maxZ : other._maxZ;
return this;
}
combined(other) {
let aabb = new oimo.collision.geometry.Aabb();
aabb._minX = this._minX < other._minX ? this._minX : other._minX;
aabb._minY = this._minY < other._minY ? this._minY : other._minY;
aabb._minZ = this._minZ < other._minZ ? this._minZ : other._minZ;
aabb._maxX = this._maxX > other._maxX ? this._maxX : other._maxX;
aabb._maxY = this._maxY > other._maxY ? this._maxY : other._maxY;
aabb._maxZ = this._maxZ > other._maxZ ? this._maxZ : other._maxZ;
return aabb;
}
overlap(other) {
if(this._minX < other._maxX && this._maxX > other._minX && this._minY < other._maxY && this._maxY > other._minY && this._minZ < other._maxZ) {
return this._maxZ > other._minZ;
} else {
return false;
}
}
getIntersection(other) {
let aabb = new oimo.collision.geometry.Aabb();
aabb._minX = this._minX > other._minX ? this._minX : other._minX;
aabb._minY = this._minY > other._minY ? this._minY : other._minY;
aabb._minZ = this._minZ > other._minZ ? this._minZ : other._minZ;
aabb._maxX = this._maxX < other._maxX ? this._maxX : other._maxX;
aabb._maxY = this._maxY < other._maxY ? this._maxY : other._maxY;
aabb._maxZ = this._maxZ < other._maxZ ? this._maxZ : other._maxZ;
return aabb;
}
getIntersectionTo(other,intersection) {
intersection._minX = this._minX > other._minX ? this._minX : other._minX;
intersection._minY = this._minY > other._minY ? this._minY : other._minY;
intersection._minZ = this._minZ > other._minZ ? this._minZ : other._minZ;
intersection._maxX = this._maxX < other._maxX ? this._maxX : other._maxX;
intersection._maxY = this._maxY < other._maxY ? this._maxY : other._maxY;
intersection._maxZ = this._maxZ < other._maxZ ? this._maxZ : other._maxZ;
}
copyFrom(aabb) {
this._minX = aabb._minX;
this._minY = aabb._minY;
this._minZ = aabb._minZ;
this._maxX = aabb._maxX;
this._maxY = aabb._maxY;
this._maxZ = aabb._maxZ;
return this;
}
clone() {
let aabb = new oimo.collision.geometry.Aabb();
aabb._minX = this._minX;
aabb._minY = this._minY;
aabb._minZ = this._minZ;
aabb._maxX = this._maxX;
aabb._maxY = this._maxY;
aabb._maxZ = this._maxZ;
return aabb;
}
}
oimo.collision.geometry.BoxGeometry = class oimo_collision_geometry_BoxGeometry extends oimo.collision.geometry.ConvexGeometry {
constructor(halfExtents) {
super(1);
this._halfExtentsX = halfExtents.x;
this._halfExtentsY = halfExtents.y;
this._halfExtentsZ = halfExtents.z;
this._halfAxisXX = halfExtents.x;
this._halfAxisXY = 0;
this._halfAxisXZ = 0;
this._halfAxisYX = 0;
this._halfAxisYY = halfExtents.y;
this._halfAxisYZ = 0;
this._halfAxisZX = 0;
this._halfAxisZY = 0;
this._halfAxisZZ = halfExtents.z;
this._updateMass();
let minHalfExtents = halfExtents.x < halfExtents.y ? halfExtents.z < halfExtents.x ? halfExtents.z : halfExtents.x : halfExtents.z < halfExtents.y ? halfExtents.z : halfExtents.y;
if(this._gjkMargin > minHalfExtents * 0.2) {
this._gjkMargin = minHalfExtents * 0.2;
}
}
getHalfExtents() {
let v = new oimo.common.Vec3();
v.x = this._halfExtentsX;
v.y = this._halfExtentsY;
v.z = this._halfExtentsZ;
return v;
}
getHalfExtentsTo(halfExtents) {
halfExtents.x = this._halfExtentsX;
halfExtents.y = this._halfExtentsY;
halfExtents.z = this._halfExtentsZ;
}
_updateMass() {
this._volume = 8 * (this._halfExtentsX * this._halfExtentsY * this._halfExtentsZ);
let sqX;
let sqY;
let sqZ;
sqX = this._halfExtentsX * this._halfExtentsX;
sqY = this._halfExtentsY * this._halfExtentsY;
sqZ = this._halfExtentsZ * this._halfExtentsZ;
this._inertiaCoeff00 = 0.33333333333333331 * (sqY + sqZ);
this._inertiaCoeff01 = 0;
this._inertiaCoeff02 = 0;
this._inertiaCoeff10 = 0;
this._inertiaCoeff11 = 0.33333333333333331 * (sqZ + sqX);
this._inertiaCoeff12 = 0;
this._inertiaCoeff20 = 0;
this._inertiaCoeff21 = 0;
this._inertiaCoeff22 = 0.33333333333333331 * (sqX + sqY);
}
_computeAabb(aabb,tf) {
let tfxX;
let tfxY;
let tfxZ;
let tfyX;
let tfyY;
let tfyZ;
let tfzX;
let tfzY;
let tfzZ;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = tf._rotation00 * this._halfAxisXX + tf._rotation01 * this._halfAxisXY + tf._rotation02 * this._halfAxisXZ;
__tmp__Y = tf._rotation10 * this._halfAxisXX + tf._rotation11 * this._halfAxisXY + tf._rotation12 * this._halfAxisXZ;
__tmp__Z = tf._rotation20 * this._halfAxisXX + tf._rotation21 * this._halfAxisXY + tf._rotation22 * this._halfAxisXZ;
tfxX = __tmp__X;
tfxY = __tmp__Y;
tfxZ = __tmp__Z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = tf._rotation00 * this._halfAxisYX + tf._rotation01 * this._halfAxisYY + tf._rotation02 * this._halfAxisYZ;
__tmp__Y1 = tf._rotation10 * this._halfAxisYX + tf._rotation11 * this._halfAxisYY + tf._rotation12 * this._halfAxisYZ;
__tmp__Z1 = tf._rotation20 * this._halfAxisYX + tf._rotation21 * this._halfAxisYY + tf._rotation22 * this._halfAxisYZ;
tfyX = __tmp__X1;
tfyY = __tmp__Y1;
tfyZ = __tmp__Z1;
let __tmp__X2;
let __tmp__Y2;
let __tmp__Z2;
__tmp__X2 = tf._rotation00 * this._halfAxisZX + tf._rotation01 * this._halfAxisZY + tf._rotation02 * this._halfAxisZZ;
__tmp__Y2 = tf._rotation10 * this._halfAxisZX + tf._rotation11 * this._halfAxisZY + tf._rotation12 * this._halfAxisZZ;
__tmp__Z2 = tf._rotation20 * this._halfAxisZX + tf._rotation21 * this._halfAxisZY + tf._rotation22 * this._halfAxisZZ;
tfzX = __tmp__X2;
tfzY = __tmp__Y2;
tfzZ = __tmp__Z2;
if(tfxX < 0) {
tfxX = -tfxX;
}
if(tfxY < 0) {
tfxY = -tfxY;
}
if(tfxZ < 0) {
tfxZ = -tfxZ;
}
if(tfyX < 0) {
tfyX = -tfyX;
}
if(tfyY < 0) {
tfyY = -tfyY;
}
if(tfyZ < 0) {
tfyZ = -tfyZ;
}
if(tfzX < 0) {
tfzX = -tfzX;
}
if(tfzY < 0) {
tfzY = -tfzY;
}
if(tfzZ < 0) {
tfzZ = -tfzZ;
}
let tfsX;
let tfsY;
let tfsZ;
tfsX = tfxX + tfyX;
tfsY = tfxY + tfyY;
tfsZ = tfxZ + tfyZ;
tfsX += tfzX;
tfsY += tfzY;
tfsZ += tfzZ;
aabb._minX = tf._positionX - tfsX;
aabb._minY = tf._positionY - tfsY;
aabb._minZ = tf._positionZ - tfsZ;
aabb._maxX = tf._positionX + tfsX;
aabb._maxY = tf._positionY + tfsY;
aabb._maxZ = tf._positionZ + tfsZ;
}
computeLocalSupportingVertex(dir,out) {
let gjkMarginsX;
let gjkMarginsY;
let gjkMarginsZ;
let coreExtentsX;
let coreExtentsY;
let coreExtentsZ;
gjkMarginsX = this._gjkMargin;
gjkMarginsY = this._gjkMargin;
gjkMarginsZ = this._gjkMargin;
if(!(gjkMarginsX < this._halfExtentsX)) {
gjkMarginsX = this._halfExtentsX;
}
if(!(gjkMarginsY < this._halfExtentsY)) {
gjkMarginsY = this._halfExtentsY;
}
if(!(gjkMarginsZ < this._halfExtentsZ)) {
gjkMarginsZ = this._halfExtentsZ;
}
coreExtentsX = this._halfExtentsX - gjkMarginsX;
coreExtentsY = this._halfExtentsY - gjkMarginsY;
coreExtentsZ = this._halfExtentsZ - gjkMarginsZ;
out.x = dir.x > 0 ? coreExtentsX : -coreExtentsX;
out.y = dir.y > 0 ? coreExtentsY : -coreExtentsY;
out.z = dir.z > 0 ? coreExtentsZ : -coreExtentsZ;
}
_rayCastLocal(beginX,beginY,beginZ,endX,endY,endZ,hit) {
let halfW = this._halfExtentsX;
let halfH = this._halfExtentsY;
let halfD = this._halfExtentsZ;
let dx = endX - beginX;
let dy = endY - beginY;
let dz = endZ - beginZ;
let tminx = 0;
let tminy = 0;
let tminz = 0;
let tmaxx = 1;
let tmaxy = 1;
let tmaxz = 1;
if(dx > -1e-6 && dx < 1e-6) {
if(beginX <= -halfW || beginX >= halfW) {
return false;
}
} else {
let invDx = 1 / dx;
let t1 = (-halfW - beginX) * invDx;
let t2 = (halfW - beginX) * invDx;
if(t1 > t2) {
let tmp = t1;
t1 = t2;
t2 = tmp;
}
if(t1 > 0) {
tminx = t1;
}
if(t2 < 1) {
tmaxx = t2;
}
}
if(dy > -1e-6 && dy < 1e-6) {
if(beginY <= -halfH || beginY >= halfH) {
return false;
}
} else {
let invDy = 1 / dy;
let t1 = (-halfH - beginY) * invDy;
let t2 = (halfH - beginY) * invDy;
if(t1 > t2) {
let tmp = t1;
t1 = t2;
t2 = tmp;
}
if(t1 > 0) {
tminy = t1;
}
if(t2 < 1) {
tmaxy = t2;
}
}
if(dz > -1e-6 && dz < 1e-6) {
if(beginZ <= -halfD || beginZ >= halfD) {
return false;
}
} else {
let invDz = 1 / dz;
let t1 = (-halfD - beginZ) * invDz;
let t2 = (halfD - beginZ) * invDz;
if(t1 > t2) {
let tmp = t1;
t1 = t2;
t2 = tmp;
}
if(t1 > 0) {
tminz = t1;
}
if(t2 < 1) {
tmaxz = t2;
}
}
if(tminx >= 1 || tminy >= 1 || tminz >= 1 || tmaxx <= 0 || tmaxy <= 0 || tmaxz <= 0) {
return false;
}
let min = tminx;
let max = tmaxx;
let hitDirection = 0;
if(tminy > min) {
min = tminy;
hitDirection = 1;
}
if(tminz > min) {
min = tminz;
hitDirection = 2;
}
if(tmaxy < max) {
max = tmaxy;
}
if(tmaxz < max) {
max = tmaxz;
}
if(min > max) {
return false;
}
if(min == 0) {
return false;
}
switch(hitDirection) {
case 0:
hit.normal.init(dx > 0 ? -1 : 1,0,0);
break;
case 1:
hit.normal.init(0,dy > 0 ? -1 : 1,0);
break;
case 2:
hit.normal.init(0,0,dz > 0 ? -1 : 1);
break;
}
hit.position.init(beginX + min * dx,beginY + min * dy,beginZ + min * dz);
hit.fraction = min;
return true;
}
}
oimo.collision.geometry.CapsuleGeometry = class oimo_collision_geometry_CapsuleGeometry extends oimo.collision.geometry.ConvexGeometry {
constructor(radius,halfHeight) {
super(4);
this._radius = radius;
this._halfHeight = halfHeight;
this._gjkMargin = this._radius;
this._updateMass();
}
getRadius() {
return this._radius;
}
getHalfHeight() {
return this._halfHeight;
}
_updateMass() {
let r2 = this._radius * this._radius;
let hh2 = this._halfHeight * this._halfHeight;
let cylinderVolume = 6.28318530717958 * r2 * this._halfHeight;
let sphereVolume = 3.14159265358979 * r2 * this._radius * 4 / 3;
this._volume = cylinderVolume + sphereVolume;
let invVolume = this._volume == 0 ? 0 : 1 / this._volume;
let inertiaXZ = invVolume * (cylinderVolume * (r2 * 0.25 + hh2 / 3) + sphereVolume * (r2 * 0.4 + this._halfHeight * this._radius * 0.75 + hh2));
this._inertiaCoeff00 = inertiaXZ;
this._inertiaCoeff01 = 0;
this._inertiaCoeff02 = 0;
this._inertiaCoeff10 = 0;
this._inertiaCoeff11 = invVolume * (cylinderVolume * r2 * 0.5 + sphereVolume * r2 * 0.4);
this._inertiaCoeff12 = 0;
this._inertiaCoeff20 = 0;
this._inertiaCoeff21 = 0;
this._inertiaCoeff22 = inertiaXZ;
}
_computeAabb(aabb,tf) {
let radVecX;
let radVecY;
let radVecZ;
radVecX = this._radius;
radVecY = this._radius;
radVecZ = this._radius;
let axisX;
let axisY;
let axisZ;
axisX = tf._rotation01;
axisY = tf._rotation11;
axisZ = tf._rotation21;
if(axisX < 0) {
axisX = -axisX;
}
if(axisY < 0) {
axisY = -axisY;
}
if(axisZ < 0) {
axisZ = -axisZ;
}
axisX *= this._halfHeight;
axisY *= this._halfHeight;
axisZ *= this._halfHeight;
radVecX += axisX;
radVecY += axisY;
radVecZ += axisZ;
aabb._minX = tf._positionX - radVecX;
aabb._minY = tf._positionY - radVecY;
aabb._minZ = tf._positionZ - radVecZ;
aabb._maxX = tf._positionX + radVecX;
aabb._maxY = tf._positionY + radVecY;
aabb._maxZ = tf._positionZ + radVecZ;
}
computeLocalSupportingVertex(dir,out) {
if(dir.y > 0) {
out.init(0,this._halfHeight,0);
} else {
out.init(0,-this._halfHeight,0);
}
}
_rayCastLocal(beginX,beginY,beginZ,endX,endY,endZ,hit) {
let halfH = this._halfHeight;
let dx = endX - beginX;
let dz = endZ - beginZ;
let tminxz = 0;
let tmaxxz;
let a = dx * dx + dz * dz;
let b = beginX * dx + beginZ * dz;
let c = beginX * beginX + beginZ * beginZ - this._radius * this._radius;
let D = b * b - a * c;
if(D < 0) {
return false;
}
if(a > 0) {
let sqrtD = Math.sqrt(D);
tminxz = (-b - sqrtD) / a;
tmaxxz = (-b + sqrtD) / a;
if(tminxz >= 1 || tmaxxz <= 0) {
return false;
}
} else {
if(c >= 0) {
return false;
}
tminxz = 0;
}
let crossY = beginY + (endY - beginY) * tminxz;
let min;
if(crossY > -halfH && crossY < halfH) {
if(tminxz > 0) {
min = tminxz;
let _this = hit.normal.init(beginX + dx * min,0,beginZ + dz * min);
let invLen = Math.sqrt(_this.x * _this.x + _this.y * _this.y + _this.z * _this.z);
if(invLen > 0) {
invLen = 1 / invLen;
}
_this.x *= invLen;
_this.y *= invLen;
_this.z *= invLen;
hit.position.init(beginX + min * dx,crossY,beginZ + min * dz);
hit.fraction = min;
return true;
}
return false;
}
let spherePosX;
let spherePosY;
let spherePosZ;
let sphereToBeginX;
let sphereToBeginY;
let sphereToBeginZ;
spherePosX = 0;
spherePosY = crossY < 0 ? -halfH : halfH;
spherePosZ = 0;
sphereToBeginX = beginX - spherePosX;
sphereToBeginY = beginY - spherePosY;
sphereToBeginZ = beginZ - spherePosZ;
let dX;
let dY;
let dZ;
dX = endX - beginX;
dY = endY - beginY;
dZ = endZ - beginZ;
a = dX * dX + dY * dY + dZ * dZ;
b = sphereToBeginX * dX + sphereToBeginY * dY + sphereToBeginZ * dZ;
c = sphereToBeginX * sphereToBeginX + sphereToBeginY * sphereToBeginY + sphereToBeginZ * sphereToBeginZ - this._radius * this._radius;
D = b * b - a * c;
if(D < 0) {
return false;
}
let t = (-b - Math.sqrt(D)) / a;
if(t < 0 || t > 1) {
return false;
}
let hitPosX;
let hitPosY;
let hitPosZ;
let hitNormalX;
let hitNormalY;
let hitNormalZ;
hitPosX = sphereToBeginX + dX * t;
hitPosY = sphereToBeginY + dY * t;
hitPosZ = sphereToBeginZ + dZ * t;
let l = hitPosX * hitPosX + hitPosY * hitPosY + hitPosZ * hitPosZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
hitNormalX = hitPosX * l;
hitNormalY = hitPosY * l;
hitNormalZ = hitPosZ * l;
hitPosX += spherePosX;
hitPosY += spherePosY;
hitPosZ += spherePosZ;
let v = hit.position;
v.x = hitPosX;
v.y = hitPosY;
v.z = hitPosZ;
let v1 = hit.normal;
v1.x = hitNormalX;
v1.y = hitNormalY;
v1.z = hitNormalZ;
hit.fraction = t;
return true;
}
}
oimo.collision.geometry.ConeGeometry = class oimo_collision_geometry_ConeGeometry extends oimo.collision.geometry.ConvexGeometry {
constructor(radius,halfHeight) {
super(3);
this._radius = radius;
this._halfHeight = halfHeight;
this.sinTheta = radius / Math.sqrt(radius * radius + 4 * halfHeight * halfHeight);
this.cosTheta = 2 * halfHeight / Math.sqrt(radius * radius + 4 * halfHeight * halfHeight);
this._updateMass();
}
getRadius() {
return this._radius;
}
getHalfHeight() {
return this._halfHeight;
}
_updateMass() {
let r2 = this._radius * this._radius;
let h2 = this._halfHeight * this._halfHeight * 4;
this._volume = 3.14159265358979 * r2 * this._halfHeight * 2 / 3;
this._inertiaCoeff00 = 0.05 * (3 * r2 + 2 * h2);
this._inertiaCoeff01 = 0;
this._inertiaCoeff02 = 0;
this._inertiaCoeff10 = 0;
this._inertiaCoeff11 = 0.3 * r2;
this._inertiaCoeff12 = 0;
this._inertiaCoeff20 = 0;
this._inertiaCoeff21 = 0;
this._inertiaCoeff22 = 0.05 * (3 * r2 + 2 * h2);
}
_computeAabb(aabb,tf) {
let axisX;
let axisY;
let axisZ;
let axis2X;
let axis2Y;
let axis2Z;
let ehX;
let ehY;
let ehZ;
let erX;
let erY;
let erZ;
axisX = tf._rotation01;
axisY = tf._rotation11;
axisZ = tf._rotation21;
axis2X = axisX * axisX;
axis2Y = axisY * axisY;
axis2Z = axisZ * axisZ;
erX = Math.sqrt(1 - axis2X);
erY = Math.sqrt(1 - axis2Y);
erZ = Math.sqrt(1 - axis2Z);
erX *= this._radius;
erY *= this._radius;
erZ *= this._radius;
ehX = axisX * this._halfHeight;
ehY = axisY * this._halfHeight;
ehZ = axisZ * this._halfHeight;
let rminX;
let rminY;
let rminZ;
let rmaxX;
let rmaxY;
let rmaxZ;
rminX = -ehX;
rminY = -ehY;
rminZ = -ehZ;
rminX -= erX;
rminY -= erY;
rminZ -= erZ;
rmaxX = -ehX;
rmaxY = -ehY;
rmaxZ = -ehZ;
rmaxX += erX;
rmaxY += erY;
rmaxZ += erZ;
let maxX;
let maxY;
let maxZ;
let minX;
let minY;
let minZ;
maxX = rminX > rmaxX ? rminX : rmaxX;
maxY = rminY > rmaxY ? rminY : rmaxY;
maxZ = rminZ > rmaxZ ? rminZ : rmaxZ;
if(!(maxX > ehX)) {
maxX = ehX;
}
if(!(maxY > ehY)) {
maxY = ehY;
}
if(!(maxZ > ehZ)) {
maxZ = ehZ;
}
minX = rminX < rmaxX ? rminX : rmaxX;
minY = rminY < rmaxY ? rminY : rmaxY;
minZ = rminZ < rmaxZ ? rminZ : rmaxZ;
if(!(minX < ehX)) {
minX = ehX;
}
if(!(minY < ehY)) {
minY = ehY;
}
if(!(minZ < ehZ)) {
minZ = ehZ;
}
aabb._minX = tf._positionX + minX;
aabb._minY = tf._positionY + minY;
aabb._minZ = tf._positionZ + minZ;
aabb._maxX = tf._positionX + maxX;
aabb._maxY = tf._positionY + maxY;
aabb._maxZ = tf._positionZ + maxZ;
}
computeLocalSupportingVertex(dir,out) {
let dx = dir.x;
let dy = dir.y;
let dz = dir.z;
if(dy > 0 && dy * dy > this.sinTheta * this.sinTheta * (dx * dx + dy * dy + dz * dz)) {
out.init(0,this._halfHeight - this._gjkMargin / this.sinTheta,0);
if(out.y < 0) {
out.y = 0;
}
return;
}
let rx = dir.x;
let rz = dir.z;
let len = rx * rx + rz * rz;
let height = 2 * this._halfHeight;
let coreRadius = (height - this._gjkMargin) / height * this._radius - this._gjkMargin / this.cosTheta;
if(coreRadius < 0) {
coreRadius = 0;
}
let invLen = len > 0 ? coreRadius / Math.sqrt(len) : 0;
let coreHalfHeight = this._halfHeight - this._gjkMargin;
if(coreHalfHeight < 0) {
coreHalfHeight = 0;
}
out.x = rx * invLen;
out.y = -coreHalfHeight;
out.z = rz * invLen;
}
_rayCastLocal(beginX,beginY,beginZ,endX,endY,endZ,hit) {
let p1y;
let halfH = this._halfHeight;
let dx = endX - beginX;
let dy = endY - beginY;
let dz = endZ - beginZ;
let tminy = 0;
let tmaxy = 1;
if(dy > -1e-6 && dy < 1e-6) {
if(beginY <= -halfH || beginY >= halfH) {
return false;
}
} else {
let invDy = 1 / dy;
let t1 = (-halfH - beginY) * invDy;
let t2 = (halfH - beginY) * invDy;
if(t1 > t2) {
let tmp = t1;
t1 = t2;
t2 = tmp;
}
if(t1 > 0) {
tminy = t1;
}
if(t2 < 1) {
tmaxy = t2;
}
}
if(tminy >= 1 || tmaxy <= 0) {
return false;
}
let tminxz = 0;
let tmaxxz = 0;
p1y = beginY - halfH;
let cos2 = this.cosTheta * this.cosTheta;
let a = cos2 * (dx * dx + dy * dy + dz * dz) - dy * dy;
let b = cos2 * (beginX * dx + p1y * dy + beginZ * dz) - p1y * dy;
let c = cos2 * (beginX * beginX + p1y * p1y + beginZ * beginZ) - p1y * p1y;
let D = b * b - a * c;
if(a != 0) {
if(D < 0) {
return false;
}
let sqrtD = Math.sqrt(D);
if(a < 0) {
if(dy > 0) {
tminxz = 0;
tmaxxz = (-b + sqrtD) / a;
if(tmaxxz <= 0) {
return false;
}
} else {
tminxz = (-b - sqrtD) / a;
tmaxxz = 1;
if(tminxz >= 1) {
return false;
}
}
} else {
tminxz = (-b - sqrtD) / a;
tmaxxz = (-b + sqrtD) / a;
if(tminxz >= 1 || tmaxxz <= 0) {
return false;
}
}
} else {
let t = -c / (2 * b);
if(b > 0) {
tminxz = 0;
tmaxxz = t;
if(t <= 0) {
return false;
}
} else {
tminxz = t;
tmaxxz = 1;
if(t >= 1) {
return false;
}
}
}
p1y += halfH;
let min;
if(tmaxxz <= tminy || tmaxy <= tminxz) {
return false;
}
if(tminxz < tminy) {
min = tminy;
if(min == 0) {
return false;
}
hit.normal.init(0,dy > 0 ? -1 : 1,0);
} else {
min = tminxz;
if(min == 0) {
return false;
}
let _this = hit.normal.init(beginX + dx * min,0,beginZ + dz * min);
let invLen = Math.sqrt(_this.x * _this.x + _this.y * _this.y + _this.z * _this.z);
if(invLen > 0) {
invLen = 1 / invLen;
}
_this.x *= invLen;
_this.y *= invLen;
_this.z *= invLen;
let s = this.cosTheta;
_this.x *= s;
_this.y *= s;
_this.z *= s;
hit.normal.y += this.sinTheta;
}
hit.position.init(beginX + min * dx,p1y + min * dy,beginZ + min * dz);
hit.fraction = min;
return true;
}
}
oimo.collision.geometry.ConvexHullGeometry = class oimo_collision_geometry_ConvexHullGeometry extends oimo.collision.geometry.ConvexGeometry {
constructor(vertices) {
super(5);
this._numVertices = vertices.length;
this._vertices = new Array(this._numVertices);
this._tmpVertices = new Array(this._numVertices);
let _g = 0;
let _g1 = this._numVertices;
while(_g < _g1) {
let i = _g++;
this._vertices[i] = vertices[i];
this._tmpVertices[i] = new oimo.common.Vec3();
}
this._useGjkRayCast = true;
this._updateMass();
}
getVertices() {
return this._vertices;
}
_updateMass() {
this._volume = 1;
this._inertiaCoeff00 = 1;
this._inertiaCoeff01 = 0;
this._inertiaCoeff02 = 0;
this._inertiaCoeff10 = 0;
this._inertiaCoeff11 = 1;
this._inertiaCoeff12 = 0;
this._inertiaCoeff20 = 0;
this._inertiaCoeff21 = 0;
this._inertiaCoeff22 = 1;
let minx = this._vertices[0].x;
let miny = this._vertices[0].y;
let minz = this._vertices[0].z;
let maxx = this._vertices[0].x;
let maxy = this._vertices[0].y;
let maxz = this._vertices[0].z;
let _g = 1;
let _g1 = this._numVertices;
while(_g < _g1) {
let i = _g++;
let vx = this._vertices[i].x;
let vy = this._vertices[i].y;
let vz = this._vertices[i].z;
if(vx < minx) {
minx = vx;
} else if(vx > maxx) {
maxx = vx;
}
if(vy < miny) {
miny = vy;
} else if(vy > maxy) {
maxy = vy;
}
if(vz < minz) {
minz = vz;
} else if(vz > maxz) {
maxz = vz;
}
}
let sizex = maxx - minx;
let sizey = maxy - miny;
let sizez = maxz - minz;
this._volume = sizex * sizey * sizez;
let diffCog = ((minx + maxx) * (minx + maxx) + (miny + maxy) * (miny + maxy) + (minz + maxz) * (minz + maxz)) * 0.25;
sizex = sizex * sizex * 0.25;
sizey = sizey * sizey * 0.25;
sizez = sizez * sizez * 0.25;
this._inertiaCoeff00 = 0.33333333333333331 * (sizey + sizez) + diffCog;
this._inertiaCoeff01 = 0;
this._inertiaCoeff02 = 0;
this._inertiaCoeff10 = 0;
this._inertiaCoeff11 = 0.33333333333333331 * (sizez + sizex) + diffCog;
this._inertiaCoeff12 = 0;
this._inertiaCoeff20 = 0;
this._inertiaCoeff21 = 0;
this._inertiaCoeff22 = 0.33333333333333331 * (sizex + sizey) + diffCog;
}
_computeAabb(aabb,tf) {
let minX;
let minY;
let minZ;
let maxX;
let maxY;
let maxZ;
let marginX;
let marginY;
let marginZ;
marginX = this._gjkMargin;
marginY = this._gjkMargin;
marginZ = this._gjkMargin;
let localVX;
let localVY;
let localVZ;
let v = this._vertices[0];
localVX = v.x;
localVY = v.y;
localVZ = v.z;
let worldVX;
let worldVY;
let worldVZ;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = tf._rotation00 * localVX + tf._rotation01 * localVY + tf._rotation02 * localVZ;
__tmp__Y = tf._rotation10 * localVX + tf._rotation11 * localVY + tf._rotation12 * localVZ;
__tmp__Z = tf._rotation20 * localVX + tf._rotation21 * localVY + tf._rotation22 * localVZ;
worldVX = __tmp__X;
worldVY = __tmp__Y;
worldVZ = __tmp__Z;
worldVX += tf._positionX;
worldVY += tf._positionY;
worldVZ += tf._positionZ;
minX = worldVX;
minY = worldVY;
minZ = worldVZ;
maxX = worldVX;
maxY = worldVY;
maxZ = worldVZ;
let _g = 1;
let _g1 = this._numVertices;
while(_g < _g1) {
let v = this._vertices[_g++];
localVX = v.x;
localVY = v.y;
localVZ = v.z;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = tf._rotation00 * localVX + tf._rotation01 * localVY + tf._rotation02 * localVZ;
__tmp__Y = tf._rotation10 * localVX + tf._rotation11 * localVY + tf._rotation12 * localVZ;
__tmp__Z = tf._rotation20 * localVX + tf._rotation21 * localVY + tf._rotation22 * localVZ;
worldVX = __tmp__X;
worldVY = __tmp__Y;
worldVZ = __tmp__Z;
worldVX += tf._positionX;
worldVY += tf._positionY;
worldVZ += tf._positionZ;
if(!(minX < worldVX)) {
minX = worldVX;
}
if(!(minY < worldVY)) {
minY = worldVY;
}
if(!(minZ < worldVZ)) {
minZ = worldVZ;
}
if(!(maxX > worldVX)) {
maxX = worldVX;
}
if(!(maxY > worldVY)) {
maxY = worldVY;
}
if(!(maxZ > worldVZ)) {
maxZ = worldVZ;
}
}
aabb._minX = minX - marginX;
aabb._minY = minY - marginY;
aabb._minZ = minZ - marginZ;
aabb._maxX = maxX + marginX;
aabb._maxY = maxY + marginY;
aabb._maxZ = maxZ + marginZ;
}
computeLocalSupportingVertex(dir,out) {
let _this = this._vertices[0];
let maxDot = _this.x * dir.x + _this.y * dir.y + _this.z * dir.z;
let maxIndex = 0;
let _g = 1;
let _g1 = this._numVertices;
while(_g < _g1) {
let i = _g++;
let _this = this._vertices[i];
let dot = _this.x * dir.x + _this.y * dir.y + _this.z * dir.z;
if(dot > maxDot) {
maxDot = dot;
maxIndex = i;
}
}
let v = this._vertices[maxIndex];
out.x = v.x;
out.y = v.y;
out.z = v.z;
}
}
oimo.collision.geometry.CylinderGeometry = class oimo_collision_geometry_CylinderGeometry extends oimo.collision.geometry.ConvexGeometry {
constructor(radius,halfHeight) {
super(2);
this._radius = radius;
this._halfHeight = halfHeight;
this._updateMass();
}
getRadius() {
return this._radius;
}
getHalfHeight() {
return this._halfHeight;
}
_updateMass() {
let r2 = this._radius * this._radius;
let h2 = this._halfHeight * this._halfHeight * 4;
this._volume = 3.14159265358979 * r2 * this._halfHeight * 2;
this._inertiaCoeff00 = 0.083333333333333329 * (3 * r2 + h2);
this._inertiaCoeff01 = 0;
this._inertiaCoeff02 = 0;
this._inertiaCoeff10 = 0;
this._inertiaCoeff11 = 0.5 * r2;
this._inertiaCoeff12 = 0;
this._inertiaCoeff20 = 0;
this._inertiaCoeff21 = 0;
this._inertiaCoeff22 = 0.083333333333333329 * (3 * r2 + h2);
}
_computeAabb(aabb,tf) {
let axisX;
let axisY;
let axisZ;
let axis2X;
let axis2Y;
let axis2Z;
let ehX;
let ehY;
let ehZ;
let erX;
let erY;
let erZ;
axisX = tf._rotation01;
axisY = tf._rotation11;
axisZ = tf._rotation21;
if(axisX < 0) {
axisX = -axisX;
}
if(axisY < 0) {
axisY = -axisY;
}
if(axisZ < 0) {
axisZ = -axisZ;
}
axis2X = axisX * axisX;
axis2Y = axisY * axisY;
axis2Z = axisZ * axisZ;
erX = Math.sqrt(1 - axis2X);
erY = Math.sqrt(1 - axis2Y);
erZ = Math.sqrt(1 - axis2Z);
erX *= this._radius;
erY *= this._radius;
erZ *= this._radius;
ehX = axisX * this._halfHeight;
ehY = axisY * this._halfHeight;
ehZ = axisZ * this._halfHeight;
let maxX;
let maxY;
let maxZ;
maxX = erX + ehX;
maxY = erY + ehY;
maxZ = erZ + ehZ;
aabb._minX = tf._positionX - maxX;
aabb._minY = tf._positionY - maxY;
aabb._minZ = tf._positionZ - maxZ;
aabb._maxX = tf._positionX + maxX;
aabb._maxY = tf._positionY + maxY;
aabb._maxZ = tf._positionZ + maxZ;
}
computeLocalSupportingVertex(dir,out) {
let rx = dir.x;
let rz = dir.z;
let len = rx * rx + rz * rz;
let coreRadius = this._radius - this._gjkMargin;
if(coreRadius < 0) {
coreRadius = 0;
}
let invLen = len > 0 ? coreRadius / Math.sqrt(len) : 0;
let coreHeight = this._halfHeight - this._gjkMargin;
if(coreHeight < 0) {
coreHeight = 0;
}
out.x = rx * invLen;
out.y = dir.y > 0 ? coreHeight : -coreHeight;
out.z = rz * invLen;
}
_rayCastLocal(beginX,beginY,beginZ,endX,endY,endZ,hit) {
let halfH = this._halfHeight;
let dx = endX - beginX;
let dy = endY - beginY;
let dz = endZ - beginZ;
let tminy = 0;
let tmaxy = 1;
if(dy > -1e-6 && dy < 1e-6) {
if(beginY <= -halfH || beginY >= halfH) {
return false;
}
} else {
let invDy = 1 / dy;
let t1 = (-halfH - beginY) * invDy;
let t2 = (halfH - beginY) * invDy;
if(t1 > t2) {
let tmp = t1;
t1 = t2;
t2 = tmp;
}
if(t1 > 0) {
tminy = t1;
}
if(t2 < 1) {
tmaxy = t2;
}
}
if(tminy >= 1 || tmaxy <= 0) {
return false;
}
let tminxz = 0;
let tmaxxz;
let a = dx * dx + dz * dz;
let b = beginX * dx + beginZ * dz;
let c = beginX * beginX + beginZ * beginZ - this._radius * this._radius;
let D = b * b - a * c;
if(D < 0) {
return false;
}
if(a > 0) {
let sqrtD = Math.sqrt(D);
tminxz = (-b - sqrtD) / a;
tmaxxz = (-b + sqrtD) / a;
if(tminxz >= 1 || tmaxxz <= 0) {
return false;
}
} else {
if(c >= 0) {
return false;
}
tminxz = 0;
tmaxxz = 1;
}
let min;
if(tmaxxz <= tminy || tmaxy <= tminxz) {
return false;
}
if(tminxz < tminy) {
min = tminy;
if(min == 0) {
return false;
}
hit.normal.init(0,dy > 0 ? -1 : 1,0);
} else {
min = tminxz;
if(min == 0) {
return false;
}
let _this = hit.normal.init(beginX + dx * min,0,beginZ + dz * min);
let invLen = Math.sqrt(_this.x * _this.x + _this.y * _this.y + _this.z * _this.z);
if(invLen > 0) {
invLen = 1 / invLen;
}
_this.x *= invLen;
_this.y *= invLen;
_this.z *= invLen;
}
hit.position.init(beginX + min * dx,beginY + min * dy,beginZ + min * dz);
hit.fraction = min;
return true;
}
}
oimo.collision.geometry.GeometryType = class oimo_collision_geometry_GeometryType {
}
oimo.collision.geometry.RayCastHit = class oimo_collision_geometry_RayCastHit {
constructor() {
this.position = new oimo.common.Vec3();
this.normal = new oimo.common.Vec3();
this.fraction = 0;
}
}
oimo.collision.geometry.SphereGeometry = class oimo_collision_geometry_SphereGeometry extends oimo.collision.geometry.ConvexGeometry {
constructor(radius) {
super(0);
this._radius = radius;
this._gjkMargin = this._radius;
this._updateMass();
}
getRadius() {
return this._radius;
}
_updateMass() {
this._volume = 4.1887902047863861 * this._radius * this._radius * this._radius;
this._inertiaCoeff00 = 0.4 * this._radius * this._radius;
this._inertiaCoeff01 = 0;
this._inertiaCoeff02 = 0;
this._inertiaCoeff10 = 0;
this._inertiaCoeff11 = 0.4 * this._radius * this._radius;
this._inertiaCoeff12 = 0;
this._inertiaCoeff20 = 0;
this._inertiaCoeff21 = 0;
this._inertiaCoeff22 = 0.4 * this._radius * this._radius;
}
_computeAabb(aabb,tf) {
let radVecX;
let radVecY;
let radVecZ;
radVecX = this._radius;
radVecY = this._radius;
radVecZ = this._radius;
aabb._minX = tf._positionX - radVecX;
aabb._minY = tf._positionY - radVecY;
aabb._minZ = tf._positionZ - radVecZ;
aabb._maxX = tf._positionX + radVecX;
aabb._maxY = tf._positionY + radVecY;
aabb._maxZ = tf._positionZ + radVecZ;
}
computeLocalSupportingVertex(dir,out) {
out.zero();
}
_rayCastLocal(beginX,beginY,beginZ,endX,endY,endZ,hit) {
let dX;
let dY;
let dZ;
dX = endX - beginX;
dY = endY - beginY;
dZ = endZ - beginZ;
let a = dX * dX + dY * dY + dZ * dZ;
let b = beginX * dX + beginY * dY + beginZ * dZ;
let D = b * b - a * (beginX * beginX + beginY * beginY + beginZ * beginZ - this._radius * this._radius);
if(D < 0) {
return false;
}
let t = (-b - Math.sqrt(D)) / a;
if(t < 0 || t > 1) {
return false;
}
let hitPosX;
let hitPosY;
let hitPosZ;
let hitNormalX;
let hitNormalY;
let hitNormalZ;
hitPosX = beginX + dX * t;
hitPosY = beginY + dY * t;
hitPosZ = beginZ + dZ * t;
let l = hitPosX * hitPosX + hitPosY * hitPosY + hitPosZ * hitPosZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
hitNormalX = hitPosX * l;
hitNormalY = hitPosY * l;
hitNormalZ = hitPosZ * l;
let v = hit.position;
v.x = hitPosX;
v.y = hitPosY;
v.z = hitPosZ;
let v1 = hit.normal;
v1.x = hitNormalX;
v1.y = hitNormalY;
v1.z = hitNormalZ;
hit.fraction = t;
return true;
}
}
if(!oimo.collision.narrowphase) oimo.collision.narrowphase = {};
oimo.collision.narrowphase.CollisionMatrix = class oimo_collision_narrowphase_CollisionMatrix {
constructor() {
this.detectors = new Array(8);
this.detectors[0] = new Array(8);
this.detectors[1] = new Array(8);
this.detectors[2] = new Array(8);
this.detectors[3] = new Array(8);
this.detectors[4] = new Array(8);
this.detectors[5] = new Array(8);
let gjkEpaDetector = new oimo.collision.narrowphase.detector.GjkEpaDetector();
this.detectors[0][0] = new oimo.collision.narrowphase.detector.SphereSphereDetector();
this.detectors[0][1] = new oimo.collision.narrowphase.detector.SphereBoxDetector(false);
this.detectors[0][2] = gjkEpaDetector;
this.detectors[0][3] = gjkEpaDetector;
this.detectors[0][4] = new oimo.collision.narrowphase.detector.SphereCapsuleDetector(false);
this.detectors[0][5] = gjkEpaDetector;
this.detectors[1][0] = new oimo.collision.narrowphase.detector.SphereBoxDetector(true);
this.detectors[1][1] = new oimo.collision.narrowphase.detector.BoxBoxDetector();
this.detectors[1][2] = gjkEpaDetector;
this.detectors[1][3] = gjkEpaDetector;
this.detectors[1][4] = gjkEpaDetector;
this.detectors[1][5] = gjkEpaDetector;
this.detectors[2][0] = gjkEpaDetector;
this.detectors[2][1] = gjkEpaDetector;
this.detectors[2][2] = gjkEpaDetector;
this.detectors[2][3] = gjkEpaDetector;
this.detectors[2][4] = gjkEpaDetector;
this.detectors[2][5] = gjkEpaDetector;
this.detectors[3][0] = gjkEpaDetector;
this.detectors[3][1] = gjkEpaDetector;
this.detectors[3][2] = gjkEpaDetector;
this.detectors[3][3] = gjkEpaDetector;
this.detectors[3][4] = gjkEpaDetector;
this.detectors[3][5] = gjkEpaDetector;
this.detectors[4][0] = new oimo.collision.narrowphase.detector.SphereCapsuleDetector(true);
this.detectors[4][1] = gjkEpaDetector;
this.detectors[4][2] = gjkEpaDetector;
this.detectors[4][3] = gjkEpaDetector;
this.detectors[4][4] = new oimo.collision.narrowphase.detector.CapsuleCapsuleDetector();
this.detectors[4][5] = gjkEpaDetector;
this.detectors[5][0] = gjkEpaDetector;
this.detectors[5][1] = gjkEpaDetector;
this.detectors[5][2] = gjkEpaDetector;
this.detectors[5][3] = gjkEpaDetector;
this.detectors[5][4] = gjkEpaDetector;
this.detectors[5][5] = gjkEpaDetector;
}
getDetector(geomType1,geomType2) {
return this.detectors[geomType1][geomType2];
}
}
oimo.collision.narrowphase.DetectorResult = class oimo_collision_narrowphase_DetectorResult {
constructor() {
this.numPoints = 0;
this.normal = new oimo.common.Vec3();
this.points = new Array(oimo.common.Setting.maxManifoldPoints);
this.incremental = false;
let _g = 0;
let _g1 = oimo.common.Setting.maxManifoldPoints;
while(_g < _g1) this.points[_g++] = new oimo.collision.narrowphase.DetectorResultPoint();
}
getMaxDepth() {
let max = 0;
let _g = 0;
let _g1 = this.numPoints;
while(_g < _g1) {
let i = _g++;
if(this.points[i].depth > max) {
max = this.points[i].depth;
}
}
return max;
}
clear() {
this.numPoints = 0;
let _g = 0;
let _g1 = this.points;
while(_g < _g1.length) {
let p = _g1[_g];
++_g;
p.position1.zero();
p.position2.zero();
p.depth = 0;
p.id = 0;
}
this.normal.zero();
}
}
oimo.collision.narrowphase.DetectorResultPoint = class oimo_collision_narrowphase_DetectorResultPoint {
constructor() {
this.position1 = new oimo.common.Vec3();
this.position2 = new oimo.common.Vec3();
this.depth = 0;
this.id = 0;
}
}
if(!oimo.collision.narrowphase.detector) oimo.collision.narrowphase.detector = {};
oimo.collision.narrowphase.detector.Detector = class oimo_collision_narrowphase_detector_Detector {
constructor(swapped) {
this.swapped = swapped;
}
setNormal(result,nX,nY,nZ) {
let v = result.normal;
v.x = nX;
v.y = nY;
v.z = nZ;
if(this.swapped) {
let _this = result.normal;
_this.x = -_this.x;
_this.y = -_this.y;
_this.z = -_this.z;
}
}
addPoint(result,pos1X,pos1Y,pos1Z,pos2X,pos2Y,pos2Z,depth,id) {
let p = result.points[result.numPoints++];
p.depth = depth;
p.id = id;
if(this.swapped) {
let v = p.position1;
v.x = pos2X;
v.y = pos2Y;
v.z = pos2Z;
let v1 = p.position2;
v1.x = pos1X;
v1.y = pos1Y;
v1.z = pos1Z;
} else {
let v = p.position1;
v.x = pos1X;
v.y = pos1Y;
v.z = pos1Z;
let v1 = p.position2;
v1.x = pos2X;
v1.y = pos2Y;
v1.z = pos2Z;
}
}
detectImpl(result,geom1,geom2,tf1,tf2,cachedData) {
}
detect(result,geom1,geom2,transform1,transform2,cachedData) {
result.numPoints = 0;
let _g = 0;
let _g1 = result.points;
while(_g < _g1.length) {
let p = _g1[_g];
++_g;
p.position1.zero();
p.position2.zero();
p.depth = 0;
p.id = 0;
}
result.normal.zero();
if(this.swapped) {
this.detectImpl(result,geom2,geom1,transform2,transform1,cachedData);
} else {
this.detectImpl(result,geom1,geom2,transform1,transform2,cachedData);
}
}
}
oimo.collision.narrowphase.detector.BoxBoxDetector = class oimo_collision_narrowphase_detector_BoxBoxDetector extends oimo.collision.narrowphase.detector.Detector {
constructor() {
super(false);
this.clipper = new oimo.collision.narrowphase.detector._BoxBoxDetector.FaceClipper();
}
detectImpl(result,geom1,geom2,tf1,tf2,cachedData) {
let b1 = geom1;
let b2 = geom2;
result.incremental = false;
let c1X;
let c1Y;
let c1Z;
let c2X;
let c2Y;
let c2Z;
let c12X;
let c12Y;
let c12Z;
c1X = tf1._positionX;
c1Y = tf1._positionY;
c1Z = tf1._positionZ;
c2X = tf2._positionX;
c2Y = tf2._positionY;
c2Z = tf2._positionZ;
c12X = c2X - c1X;
c12Y = c2Y - c1Y;
c12Z = c2Z - c1Z;
let x1X;
let x1Y;
let x1Z;
let y1X;
let y1Y;
let y1Z;
let z1X;
let z1Y;
let z1Z;
let x2X;
let x2Y;
let x2Z;
let y2X;
let y2Y;
let y2Z;
let z2X;
let z2Y;
let z2Z;
x1X = tf1._rotation00;
x1Y = tf1._rotation10;
x1Z = tf1._rotation20;
y1X = tf1._rotation01;
y1Y = tf1._rotation11;
y1Z = tf1._rotation21;
z1X = tf1._rotation02;
z1Y = tf1._rotation12;
z1Z = tf1._rotation22;
x2X = tf2._rotation00;
x2Y = tf2._rotation10;
x2Z = tf2._rotation20;
y2X = tf2._rotation01;
y2Y = tf2._rotation11;
y2Z = tf2._rotation21;
z2X = tf2._rotation02;
z2Y = tf2._rotation12;
z2Z = tf2._rotation22;
let w1 = b1._halfExtentsX;
let h1 = b1._halfExtentsY;
let d1 = b1._halfExtentsZ;
let w2 = b2._halfExtentsX;
let h2 = b2._halfExtentsY;
let d2 = b2._halfExtentsZ;
let sx1X;
let sx1Y;
let sx1Z;
let sy1X;
let sy1Y;
let sy1Z;
let sz1X;
let sz1Y;
let sz1Z;
let sx2X;
let sx2Y;
let sx2Z;
let sy2X;
let sy2Y;
let sy2Z;
let sz2X;
let sz2Y;
let sz2Z;
sx1X = x1X * w1;
sx1Y = x1Y * w1;
sx1Z = x1Z * w1;
sy1X = y1X * h1;
sy1Y = y1Y * h1;
sy1Z = y1Z * h1;
sz1X = z1X * d1;
sz1Y = z1Y * d1;
sz1Z = z1Z * d1;
sx2X = x2X * w2;
sx2Y = x2Y * w2;
sx2Z = x2Z * w2;
sy2X = y2X * h2;
sy2Y = y2Y * h2;
sy2Z = y2Z * h2;
sz2X = z2X * d2;
sz2Y = z2Y * d2;
sz2Z = z2Z * d2;
let mDepth = 1e65536;
let mId = -1;
let mSign = 0;
let mAxisX;
let mAxisY;
let mAxisZ;
mAxisX = 0;
mAxisY = 0;
mAxisZ = 0;
let proj1 = w1;
let dx = x1X * sx2X + x1Y * sx2Y + x1Z * sx2Z;
let dy = x1X * sy2X + x1Y * sy2Y + x1Z * sy2Z;
let dz = x1X * sz2X + x1Y * sz2Y + x1Z * sz2Z;
if(dx < 0) {
dx = -dx;
}
if(dy < 0) {
dy = -dy;
}
if(dz < 0) {
dz = -dz;
}
let proj2 = dx + dy + dz;
let projC12 = x1X * c12X + x1Y * c12Y + x1Z * c12Z;
let sum = proj1 + proj2;
let neg = projC12 < 0;
let abs = neg ? -projC12 : projC12;
if(abs < sum) {
let depth = sum - abs;
if(depth < 1e65536) {
mDepth = depth;
mId = 0;
mAxisX = x1X;
mAxisY = x1Y;
mAxisZ = x1Z;
mSign = neg ? -1 : 1;
}
} else {
return;
}
proj1 = h1;
let dx1 = y1X * sx2X + y1Y * sx2Y + y1Z * sx2Z;
let dy1 = y1X * sy2X + y1Y * sy2Y + y1Z * sy2Z;
let dz1 = y1X * sz2X + y1Y * sz2Y + y1Z * sz2Z;
if(dx1 < 0) {
dx1 = -dx1;
}
if(dy1 < 0) {
dy1 = -dy1;
}
if(dz1 < 0) {
dz1 = -dz1;
}
proj2 = dx1 + dy1 + dz1;
projC12 = y1X * c12X + y1Y * c12Y + y1Z * c12Z;
let sum1 = proj1 + proj2;
let neg1 = projC12 < 0;
let abs1 = neg1 ? -projC12 : projC12;
if(abs1 < sum1) {
let depth = sum1 - abs1;
if(depth < mDepth) {
mDepth = depth;
mId = 1;
mAxisX = y1X;
mAxisY = y1Y;
mAxisZ = y1Z;
mSign = neg1 ? -1 : 1;
}
} else {
return;
}
proj1 = d1;
let dx2 = z1X * sx2X + z1Y * sx2Y + z1Z * sx2Z;
let dy2 = z1X * sy2X + z1Y * sy2Y + z1Z * sy2Z;
let dz2 = z1X * sz2X + z1Y * sz2Y + z1Z * sz2Z;
if(dx2 < 0) {
dx2 = -dx2;
}
if(dy2 < 0) {
dy2 = -dy2;
}
if(dz2 < 0) {
dz2 = -dz2;
}
proj2 = dx2 + dy2 + dz2;
projC12 = z1X * c12X + z1Y * c12Y + z1Z * c12Z;
let sum2 = proj1 + proj2;
let neg2 = projC12 < 0;
let abs2 = neg2 ? -projC12 : projC12;
if(abs2 < sum2) {
let depth = sum2 - abs2;
if(depth < mDepth) {
mDepth = depth;
mId = 2;
mAxisX = z1X;
mAxisY = z1Y;
mAxisZ = z1Z;
mSign = neg2 ? -1 : 1;
}
} else {
return;
}
if(mDepth > oimo.common.Setting.linearSlop) {
mDepth -= oimo.common.Setting.linearSlop;
} else {
mDepth = 0;
}
let dx3 = x2X * sx1X + x2Y * sx1Y + x2Z * sx1Z;
let dy3 = x2X * sy1X + x2Y * sy1Y + x2Z * sy1Z;
let dz3 = x2X * sz1X + x2Y * sz1Y + x2Z * sz1Z;
if(dx3 < 0) {
dx3 = -dx3;
}
if(dy3 < 0) {
dy3 = -dy3;
}
if(dz3 < 0) {
dz3 = -dz3;
}
proj1 = dx3 + dy3 + dz3;
proj2 = w2;
projC12 = x2X * c12X + x2Y * c12Y + x2Z * c12Z;
let sum3 = proj1 + proj2;
let neg3 = projC12 < 0;
let abs3 = neg3 ? -projC12 : projC12;
if(abs3 < sum3) {
let depth = sum3 - abs3;
if(depth < mDepth) {
mDepth = depth;
mId = 3;
mAxisX = x2X;
mAxisY = x2Y;
mAxisZ = x2Z;
mSign = neg3 ? -1 : 1;
}
} else {
return;
}
let dx4 = y2X * sx1X + y2Y * sx1Y + y2Z * sx1Z;
let dy4 = y2X * sy1X + y2Y * sy1Y + y2Z * sy1Z;
let dz4 = y2X * sz1X + y2Y * sz1Y + y2Z * sz1Z;
if(dx4 < 0) {
dx4 = -dx4;
}
if(dy4 < 0) {
dy4 = -dy4;
}
if(dz4 < 0) {
dz4 = -dz4;
}
proj1 = dx4 + dy4 + dz4;
proj2 = h2;
projC12 = y2X * c12X + y2Y * c12Y + y2Z * c12Z;
let sum4 = proj1 + proj2;
let neg4 = projC12 < 0;
let abs4 = neg4 ? -projC12 : projC12;
if(abs4 < sum4) {
let depth = sum4 - abs4;
if(depth < mDepth) {
mDepth = depth;
mId = 4;
mAxisX = y2X;
mAxisY = y2Y;
mAxisZ = y2Z;
mSign = neg4 ? -1 : 1;
}
} else {
return;
}
let dx5 = z2X * sx1X + z2Y * sx1Y + z2Z * sx1Z;
let dy5 = z2X * sy1X + z2Y * sy1Y + z2Z * sy1Z;
let dz5 = z2X * sz1X + z2Y * sz1Y + z2Z * sz1Z;
if(dx5 < 0) {
dx5 = -dx5;
}
if(dy5 < 0) {
dy5 = -dy5;
}
if(dz5 < 0) {
dz5 = -dz5;
}
proj1 = dx5 + dy5 + dz5;
proj2 = d2;
projC12 = z2X * c12X + z2Y * c12Y + z2Z * c12Z;
let sum5 = proj1 + proj2;
let neg5 = projC12 < 0;
let abs5 = neg5 ? -projC12 : projC12;
if(abs5 < sum5) {
let depth = sum5 - abs5;
if(depth < mDepth) {
mDepth = depth;
mId = 5;
mAxisX = z2X;
mAxisY = z2Y;
mAxisZ = z2Z;
mSign = neg5 ? -1 : 1;
}
} else {
return;
}
if(mDepth > oimo.common.Setting.linearSlop) {
mDepth -= oimo.common.Setting.linearSlop;
} else {
mDepth = 0;
}
let edgeAxisX;
let edgeAxisY;
let edgeAxisZ;
edgeAxisX = x1Y * x2Z - x1Z * x2Y;
edgeAxisY = x1Z * x2X - x1X * x2Z;
edgeAxisZ = x1X * x2Y - x1Y * x2X;
if(!(edgeAxisX == 0 && edgeAxisY == 0 && edgeAxisZ == 0)) {
let l = edgeAxisX * edgeAxisX + edgeAxisY * edgeAxisY + edgeAxisZ * edgeAxisZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
edgeAxisX *= l;
edgeAxisY *= l;
edgeAxisZ *= l;
let dx = edgeAxisX * sy1X + edgeAxisY * sy1Y + edgeAxisZ * sy1Z;
let dy = edgeAxisX * sz1X + edgeAxisY * sz1Y + edgeAxisZ * sz1Z;
if(dx < 0) {
dx = -dx;
}
if(dy < 0) {
dy = -dy;
}
proj1 = dx + dy;
let dx1 = edgeAxisX * sy2X + edgeAxisY * sy2Y + edgeAxisZ * sy2Z;
let dy1 = edgeAxisX * sz2X + edgeAxisY * sz2Y + edgeAxisZ * sz2Z;
if(dx1 < 0) {
dx1 = -dx1;
}
if(dy1 < 0) {
dy1 = -dy1;
}
proj2 = dx1 + dy1;
projC12 = edgeAxisX * c12X + edgeAxisY * c12Y + edgeAxisZ * c12Z;
let sum = proj1 + proj2;
let neg = projC12 < 0;
let abs = neg ? -projC12 : projC12;
if(abs < sum) {
let depth = sum - abs;
if(depth < mDepth) {
mDepth = depth;
mId = 6;
mAxisX = edgeAxisX;
mAxisY = edgeAxisY;
mAxisZ = edgeAxisZ;
mSign = neg ? -1 : 1;
}
} else {
return;
}
}
edgeAxisX = x1Y * y2Z - x1Z * y2Y;
edgeAxisY = x1Z * y2X - x1X * y2Z;
edgeAxisZ = x1X * y2Y - x1Y * y2X;
if(!(edgeAxisX == 0 && edgeAxisY == 0 && edgeAxisZ == 0)) {
let l = edgeAxisX * edgeAxisX + edgeAxisY * edgeAxisY + edgeAxisZ * edgeAxisZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
edgeAxisX *= l;
edgeAxisY *= l;
edgeAxisZ *= l;
let dx = edgeAxisX * sy1X + edgeAxisY * sy1Y + edgeAxisZ * sy1Z;
let dy = edgeAxisX * sz1X + edgeAxisY * sz1Y + edgeAxisZ * sz1Z;
if(dx < 0) {
dx = -dx;
}
if(dy < 0) {
dy = -dy;
}
proj1 = dx + dy;
let dx1 = edgeAxisX * sx2X + edgeAxisY * sx2Y + edgeAxisZ * sx2Z;
let dy1 = edgeAxisX * sz2X + edgeAxisY * sz2Y + edgeAxisZ * sz2Z;
if(dx1 < 0) {
dx1 = -dx1;
}
if(dy1 < 0) {
dy1 = -dy1;
}
proj2 = dx1 + dy1;
projC12 = edgeAxisX * c12X + edgeAxisY * c12Y + edgeAxisZ * c12Z;
let sum = proj1 + proj2;
let neg = projC12 < 0;
let abs = neg ? -projC12 : projC12;
if(abs < sum) {
let depth = sum - abs;
if(depth < mDepth) {
mDepth = depth;
mId = 7;
mAxisX = edgeAxisX;
mAxisY = edgeAxisY;
mAxisZ = edgeAxisZ;
mSign = neg ? -1 : 1;
}
} else {
return;
}
}
edgeAxisX = x1Y * z2Z - x1Z * z2Y;
edgeAxisY = x1Z * z2X - x1X * z2Z;
edgeAxisZ = x1X * z2Y - x1Y * z2X;
if(!(edgeAxisX == 0 && edgeAxisY == 0 && edgeAxisZ == 0)) {
let l = edgeAxisX * edgeAxisX + edgeAxisY * edgeAxisY + edgeAxisZ * edgeAxisZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
edgeAxisX *= l;
edgeAxisY *= l;
edgeAxisZ *= l;
let dx = edgeAxisX * sy1X + edgeAxisY * sy1Y + edgeAxisZ * sy1Z;
let dy = edgeAxisX * sz1X + edgeAxisY * sz1Y + edgeAxisZ * sz1Z;
if(dx < 0) {
dx = -dx;
}
if(dy < 0) {
dy = -dy;
}
proj1 = dx + dy;
let dx1 = edgeAxisX * sx2X + edgeAxisY * sx2Y + edgeAxisZ * sx2Z;
let dy1 = edgeAxisX * sy2X + edgeAxisY * sy2Y + edgeAxisZ * sy2Z;
if(dx1 < 0) {
dx1 = -dx1;
}
if(dy1 < 0) {
dy1 = -dy1;
}
proj2 = dx1 + dy1;
projC12 = edgeAxisX * c12X + edgeAxisY * c12Y + edgeAxisZ * c12Z;
let sum = proj1 + proj2;
let neg = projC12 < 0;
let abs = neg ? -projC12 : projC12;
if(abs < sum) {
let depth = sum - abs;
if(depth < mDepth) {
mDepth = depth;
mId = 8;
mAxisX = edgeAxisX;
mAxisY = edgeAxisY;
mAxisZ = edgeAxisZ;
mSign = neg ? -1 : 1;
}
} else {
return;
}
}
edgeAxisX = y1Y * x2Z - y1Z * x2Y;
edgeAxisY = y1Z * x2X - y1X * x2Z;
edgeAxisZ = y1X * x2Y - y1Y * x2X;
if(!(edgeAxisX == 0 && edgeAxisY == 0 && edgeAxisZ == 0)) {
let l = edgeAxisX * edgeAxisX + edgeAxisY * edgeAxisY + edgeAxisZ * edgeAxisZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
edgeAxisX *= l;
edgeAxisY *= l;
edgeAxisZ *= l;
let dx = edgeAxisX * sx1X + edgeAxisY * sx1Y + edgeAxisZ * sx1Z;
let dy = edgeAxisX * sz1X + edgeAxisY * sz1Y + edgeAxisZ * sz1Z;
if(dx < 0) {
dx = -dx;
}
if(dy < 0) {
dy = -dy;
}
proj1 = dx + dy;
let dx1 = edgeAxisX * sy2X + edgeAxisY * sy2Y + edgeAxisZ * sy2Z;
let dy1 = edgeAxisX * sz2X + edgeAxisY * sz2Y + edgeAxisZ * sz2Z;
if(dx1 < 0) {
dx1 = -dx1;
}
if(dy1 < 0) {
dy1 = -dy1;
}
proj2 = dx1 + dy1;
projC12 = edgeAxisX * c12X + edgeAxisY * c12Y + edgeAxisZ * c12Z;
let sum = proj1 + proj2;
let neg = projC12 < 0;
let abs = neg ? -projC12 : projC12;
if(abs < sum) {
let depth = sum - abs;
if(depth < mDepth) {
mDepth = depth;
mId = 9;
mAxisX = edgeAxisX;
mAxisY = edgeAxisY;
mAxisZ = edgeAxisZ;
mSign = neg ? -1 : 1;
}
} else {
return;
}
}
edgeAxisX = y1Y * y2Z - y1Z * y2Y;
edgeAxisY = y1Z * y2X - y1X * y2Z;
edgeAxisZ = y1X * y2Y - y1Y * y2X;
if(!(edgeAxisX == 0 && edgeAxisY == 0 && edgeAxisZ == 0)) {
let l = edgeAxisX * edgeAxisX + edgeAxisY * edgeAxisY + edgeAxisZ * edgeAxisZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
edgeAxisX *= l;
edgeAxisY *= l;
edgeAxisZ *= l;
let dx = edgeAxisX * sx1X + edgeAxisY * sx1Y + edgeAxisZ * sx1Z;
let dy = edgeAxisX * sz1X + edgeAxisY * sz1Y + edgeAxisZ * sz1Z;
if(dx < 0) {
dx = -dx;
}
if(dy < 0) {
dy = -dy;
}
proj1 = dx + dy;
let dx1 = edgeAxisX * sx2X + edgeAxisY * sx2Y + edgeAxisZ * sx2Z;
let dy1 = edgeAxisX * sz2X + edgeAxisY * sz2Y + edgeAxisZ * sz2Z;
if(dx1 < 0) {
dx1 = -dx1;
}
if(dy1 < 0) {
dy1 = -dy1;
}
proj2 = dx1 + dy1;
projC12 = edgeAxisX * c12X + edgeAxisY * c12Y + edgeAxisZ * c12Z;
let sum = proj1 + proj2;
let neg = projC12 < 0;
let abs = neg ? -projC12 : projC12;
if(abs < sum) {
let depth = sum - abs;
if(depth < mDepth) {
mDepth = depth;
mId = 10;
mAxisX = edgeAxisX;
mAxisY = edgeAxisY;
mAxisZ = edgeAxisZ;
mSign = neg ? -1 : 1;
}
} else {
return;
}
}
edgeAxisX = y1Y * z2Z - y1Z * z2Y;
edgeAxisY = y1Z * z2X - y1X * z2Z;
edgeAxisZ = y1X * z2Y - y1Y * z2X;
if(!(edgeAxisX == 0 && edgeAxisY == 0 && edgeAxisZ == 0)) {
let l = edgeAxisX * edgeAxisX + edgeAxisY * edgeAxisY + edgeAxisZ * edgeAxisZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
edgeAxisX *= l;
edgeAxisY *= l;
edgeAxisZ *= l;
let dx = edgeAxisX * sx1X + edgeAxisY * sx1Y + edgeAxisZ * sx1Z;
let dy = edgeAxisX * sz1X + edgeAxisY * sz1Y + edgeAxisZ * sz1Z;
if(dx < 0) {
dx = -dx;
}
if(dy < 0) {
dy = -dy;
}
proj1 = dx + dy;
let dx1 = edgeAxisX * sx2X + edgeAxisY * sx2Y + edgeAxisZ * sx2Z;
let dy1 = edgeAxisX * sy2X + edgeAxisY * sy2Y + edgeAxisZ * sy2Z;
if(dx1 < 0) {
dx1 = -dx1;
}
if(dy1 < 0) {
dy1 = -dy1;
}
proj2 = dx1 + dy1;
projC12 = edgeAxisX * c12X + edgeAxisY * c12Y + edgeAxisZ * c12Z;
let sum = proj1 + proj2;
let neg = projC12 < 0;
let abs = neg ? -projC12 : projC12;
if(abs < sum) {
let depth = sum - abs;
if(depth < mDepth) {
mDepth = depth;
mId = 11;
mAxisX = edgeAxisX;
mAxisY = edgeAxisY;
mAxisZ = edgeAxisZ;
mSign = neg ? -1 : 1;
}
} else {
return;
}
}
edgeAxisX = z1Y * x2Z - z1Z * x2Y;
edgeAxisY = z1Z * x2X - z1X * x2Z;
edgeAxisZ = z1X * x2Y - z1Y * x2X;
if(!(edgeAxisX == 0 && edgeAxisY == 0 && edgeAxisZ == 0)) {
let l = edgeAxisX * edgeAxisX + edgeAxisY * edgeAxisY + edgeAxisZ * edgeAxisZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
edgeAxisX *= l;
edgeAxisY *= l;
edgeAxisZ *= l;
let dx = edgeAxisX * sx1X + edgeAxisY * sx1Y + edgeAxisZ * sx1Z;
let dy = edgeAxisX * sy1X + edgeAxisY * sy1Y + edgeAxisZ * sy1Z;
if(dx < 0) {
dx = -dx;
}
if(dy < 0) {
dy = -dy;
}
proj1 = dx + dy;
let dx1 = edgeAxisX * sy2X + edgeAxisY * sy2Y + edgeAxisZ * sy2Z;
let dy1 = edgeAxisX * sz2X + edgeAxisY * sz2Y + edgeAxisZ * sz2Z;
if(dx1 < 0) {
dx1 = -dx1;
}
if(dy1 < 0) {
dy1 = -dy1;
}
proj2 = dx1 + dy1;
projC12 = edgeAxisX * c12X + edgeAxisY * c12Y + edgeAxisZ * c12Z;
let sum = proj1 + proj2;
let neg = projC12 < 0;
let abs = neg ? -projC12 : projC12;
if(abs < sum) {
let depth = sum - abs;
if(depth < mDepth) {
mDepth = depth;
mId = 12;
mAxisX = edgeAxisX;
mAxisY = edgeAxisY;
mAxisZ = edgeAxisZ;
mSign = neg ? -1 : 1;
}
} else {
return;
}
}
edgeAxisX = z1Y * y2Z - z1Z * y2Y;
edgeAxisY = z1Z * y2X - z1X * y2Z;
edgeAxisZ = z1X * y2Y - z1Y * y2X;
if(!(edgeAxisX == 0 && edgeAxisY == 0 && edgeAxisZ == 0)) {
let l = edgeAxisX * edgeAxisX + edgeAxisY * edgeAxisY + edgeAxisZ * edgeAxisZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
edgeAxisX *= l;
edgeAxisY *= l;
edgeAxisZ *= l;
let dx = edgeAxisX * sx1X + edgeAxisY * sx1Y + edgeAxisZ * sx1Z;
let dy = edgeAxisX * sy1X + edgeAxisY * sy1Y + edgeAxisZ * sy1Z;
if(dx < 0) {
dx = -dx;
}
if(dy < 0) {
dy = -dy;
}
proj1 = dx + dy;
let dx1 = edgeAxisX * sx2X + edgeAxisY * sx2Y + edgeAxisZ * sx2Z;
let dy1 = edgeAxisX * sz2X + edgeAxisY * sz2Y + edgeAxisZ * sz2Z;
if(dx1 < 0) {
dx1 = -dx1;
}
if(dy1 < 0) {
dy1 = -dy1;
}
proj2 = dx1 + dy1;
projC12 = edgeAxisX * c12X + edgeAxisY * c12Y + edgeAxisZ * c12Z;
let sum = proj1 + proj2;
let neg = projC12 < 0;
let abs = neg ? -projC12 : projC12;
if(abs < sum) {
let depth = sum - abs;
if(depth < mDepth) {
mDepth = depth;
mId = 13;
mAxisX = edgeAxisX;
mAxisY = edgeAxisY;
mAxisZ = edgeAxisZ;
mSign = neg ? -1 : 1;
}
} else {
return;
}
}
edgeAxisX = z1Y * z2Z - z1Z * z2Y;
edgeAxisY = z1Z * z2X - z1X * z2Z;
edgeAxisZ = z1X * z2Y - z1Y * z2X;
if(!(edgeAxisX == 0 && edgeAxisY == 0 && edgeAxisZ == 0)) {
let l = edgeAxisX * edgeAxisX + edgeAxisY * edgeAxisY + edgeAxisZ * edgeAxisZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
edgeAxisX *= l;
edgeAxisY *= l;
edgeAxisZ *= l;
let dx = edgeAxisX * sx1X + edgeAxisY * sx1Y + edgeAxisZ * sx1Z;
let dy = edgeAxisX * sy1X + edgeAxisY * sy1Y + edgeAxisZ * sy1Z;
if(dx < 0) {
dx = -dx;
}
if(dy < 0) {
dy = -dy;
}
proj1 = dx + dy;
let dx1 = edgeAxisX * sx2X + edgeAxisY * sx2Y + edgeAxisZ * sx2Z;
let dy1 = edgeAxisX * sy2X + edgeAxisY * sy2Y + edgeAxisZ * sy2Z;
if(dx1 < 0) {
dx1 = -dx1;
}
if(dy1 < 0) {
dy1 = -dy1;
}
proj2 = dx1 + dy1;
projC12 = edgeAxisX * c12X + edgeAxisY * c12Y + edgeAxisZ * c12Z;
let sum = proj1 + proj2;
let neg = projC12 < 0;
let abs = neg ? -projC12 : projC12;
if(abs < sum) {
let depth = sum - abs;
if(depth < mDepth) {
mDepth = depth;
mId = 14;
mAxisX = edgeAxisX;
mAxisY = edgeAxisY;
mAxisZ = edgeAxisZ;
mSign = neg ? -1 : 1;
}
} else {
return;
}
}
if(mId >= 6) {
mAxisX *= mSign;
mAxisY *= mSign;
mAxisZ *= mSign;
let id1 = (mId - 6) / 3 | 0;
let id2 = mId - 6 - id1 * 3;
let p1X;
let p1Y;
let p1Z;
let p2X;
let p2Y;
let p2Z;
let d1X;
let d1Y;
let d1Z;
let d2X;
let d2Y;
let d2Z;
switch(id1) {
case 0:
d1X = x1X;
d1Y = x1Y;
d1Z = x1Z;
let signY = sz1X * mAxisX + sz1Y * mAxisY + sz1Z * mAxisZ > 0;
if(sy1X * mAxisX + sy1Y * mAxisY + sy1Z * mAxisZ > 0) {
if(signY) {
p1X = sy1X + sz1X;
p1Y = sy1Y + sz1Y;
p1Z = sy1Z + sz1Z;
} else {
p1X = sy1X - sz1X;
p1Y = sy1Y - sz1Y;
p1Z = sy1Z - sz1Z;
}
} else if(signY) {
p1X = sz1X - sy1X;
p1Y = sz1Y - sy1Y;
p1Z = sz1Z - sy1Z;
} else {
p1X = sy1X + sz1X;
p1Y = sy1Y + sz1Y;
p1Z = sy1Z + sz1Z;
p1X = -p1X;
p1Y = -p1Y;
p1Z = -p1Z;
}
break;
case 1:
d1X = y1X;
d1Y = y1Y;
d1Z = y1Z;
let signY1 = sz1X * mAxisX + sz1Y * mAxisY + sz1Z * mAxisZ > 0;
if(sx1X * mAxisX + sx1Y * mAxisY + sx1Z * mAxisZ > 0) {
if(signY1) {
p1X = sx1X + sz1X;
p1Y = sx1Y + sz1Y;
p1Z = sx1Z + sz1Z;
} else {
p1X = sx1X - sz1X;
p1Y = sx1Y - sz1Y;
p1Z = sx1Z - sz1Z;
}
} else if(signY1) {
p1X = sz1X - sx1X;
p1Y = sz1Y - sx1Y;
p1Z = sz1Z - sx1Z;
} else {
p1X = sx1X + sz1X;
p1Y = sx1Y + sz1Y;
p1Z = sx1Z + sz1Z;
p1X = -p1X;
p1Y = -p1Y;
p1Z = -p1Z;
}
break;
default:
d1X = z1X;
d1Y = z1Y;
d1Z = z1Z;
let signY2 = sy1X * mAxisX + sy1Y * mAxisY + sy1Z * mAxisZ > 0;
if(sx1X * mAxisX + sx1Y * mAxisY + sx1Z * mAxisZ > 0) {
if(signY2) {
p1X = sx1X + sy1X;
p1Y = sx1Y + sy1Y;
p1Z = sx1Z + sy1Z;
} else {
p1X = sx1X - sy1X;
p1Y = sx1Y - sy1Y;
p1Z = sx1Z - sy1Z;
}
} else if(signY2) {
p1X = sy1X - sx1X;
p1Y = sy1Y - sx1Y;
p1Z = sy1Z - sx1Z;
} else {
p1X = sx1X + sy1X;
p1Y = sx1Y + sy1Y;
p1Z = sx1Z + sy1Z;
p1X = -p1X;
p1Y = -p1Y;
p1Z = -p1Z;
}
}
p1X = c1X + p1X;
p1Y = c1Y + p1Y;
p1Z = c1Z + p1Z;
switch(id2) {
case 0:
d2X = x2X;
d2Y = x2Y;
d2Z = x2Z;
let signY3 = sz2X * mAxisX + sz2Y * mAxisY + sz2Z * mAxisZ > 0;
if(sy2X * mAxisX + sy2Y * mAxisY + sy2Z * mAxisZ > 0) {
if(signY3) {
p2X = sy2X + sz2X;
p2Y = sy2Y + sz2Y;
p2Z = sy2Z + sz2Z;
} else {
p2X = sy2X - sz2X;
p2Y = sy2Y - sz2Y;
p2Z = sy2Z - sz2Z;
}
} else if(signY3) {
p2X = sz2X - sy2X;
p2Y = sz2Y - sy2Y;
p2Z = sz2Z - sy2Z;
} else {
p2X = sy2X + sz2X;
p2Y = sy2Y + sz2Y;
p2Z = sy2Z + sz2Z;
p2X = -p2X;
p2Y = -p2Y;
p2Z = -p2Z;
}
break;
case 1:
d2X = y2X;
d2Y = y2Y;
d2Z = y2Z;
let signY4 = sz2X * mAxisX + sz2Y * mAxisY + sz2Z * mAxisZ > 0;
if(sx2X * mAxisX + sx2Y * mAxisY + sx2Z * mAxisZ > 0) {
if(signY4) {
p2X = sx2X + sz2X;
p2Y = sx2Y + sz2Y;
p2Z = sx2Z + sz2Z;
} else {
p2X = sx2X - sz2X;
p2Y = sx2Y - sz2Y;
p2Z = sx2Z - sz2Z;
}
} else if(signY4) {
p2X = sz2X - sx2X;
p2Y = sz2Y - sx2Y;
p2Z = sz2Z - sx2Z;
} else {
p2X = sx2X + sz2X;
p2Y = sx2Y + sz2Y;
p2Z = sx2Z + sz2Z;
p2X = -p2X;
p2Y = -p2Y;
p2Z = -p2Z;
}
break;
default:
d2X = z2X;
d2Y = z2Y;
d2Z = z2Z;
let signY5 = sy2X * mAxisX + sy2Y * mAxisY + sy2Z * mAxisZ > 0;
if(sx2X * mAxisX + sx2Y * mAxisY + sx2Z * mAxisZ > 0) {
if(signY5) {
p2X = sx2X + sy2X;
p2Y = sx2Y + sy2Y;
p2Z = sx2Z + sy2Z;
} else {
p2X = sx2X - sy2X;
p2Y = sx2Y - sy2Y;
p2Z = sx2Z - sy2Z;
}
} else if(signY5) {
p2X = sy2X - sx2X;
p2Y = sy2Y - sx2Y;
p2Z = sy2Z - sx2Z;
} else {
p2X = sx2X + sy2X;
p2Y = sx2Y + sy2Y;
p2Z = sx2Z + sy2Z;
p2X = -p2X;
p2Y = -p2Y;
p2Z = -p2Z;
}
}
p2X = c2X - p2X;
p2Y = c2Y - p2Y;
p2Z = c2Z - p2Z;
let rX;
let rY;
let rZ;
rX = p1X - p2X;
rY = p1Y - p2Y;
rZ = p1Z - p2Z;
let dot12 = d1X * d2X + d1Y * d2Y + d1Z * d2Z;
let dot1r = d1X * rX + d1Y * rY + d1Z * rZ;
let dot2r = d2X * rX + d2Y * rY + d2Z * rZ;
let invDet = 1 / (1 - dot12 * dot12);
let t1 = (dot12 * dot2r - dot1r) * invDet;
let t2 = (dot2r - dot12 * dot1r) * invDet;
let cp1X;
let cp1Y;
let cp1Z;
let cp2X;
let cp2Y;
let cp2Z;
cp1X = p1X + d1X * t1;
cp1Y = p1Y + d1Y * t1;
cp1Z = p1Z + d1Z * t1;
cp2X = p2X + d2X * t2;
cp2Y = p2Y + d2Y * t2;
cp2Z = p2Z + d2Z * t2;
let normalX;
let normalY;
let normalZ;
normalX = -mAxisX;
normalY = -mAxisY;
normalZ = -mAxisZ;
this.setNormal(result,normalX,normalY,normalZ);
this.addPoint(result,cp1X,cp1Y,cp1Z,cp2X,cp2Y,cp2Z,mDepth,4);
return;
}
let tmpX;
let tmpY;
let tmpZ;
let swapped;
if(mId >= 3) {
mSign = -mSign;
c12X = -c12X;
c12Y = -c12Y;
c12Z = -c12Z;
w1 = w2;
h1 = h2;
d1 = d2;
c1X = c2X;
c1Y = c2Y;
c1Z = c2Z;
tmpX = x1X;
tmpY = x1Y;
tmpZ = x1Z;
x1X = x2X;
x1Y = x2Y;
x1Z = x2Z;
x2X = tmpX;
x2Y = tmpY;
x2Z = tmpZ;
tmpX = y1X;
tmpY = y1Y;
tmpZ = y1Z;
y1X = y2X;
y1Y = y2Y;
y1Z = y2Z;
y2X = tmpX;
y2Y = tmpY;
y2Z = tmpZ;
tmpX = z1X;
tmpY = z1Y;
tmpZ = z1Z;
z1X = z2X;
z1Y = z2Y;
z1Z = z2Z;
z2X = tmpX;
z2Y = tmpY;
z2Z = tmpZ;
tmpX = sx1X;
tmpY = sx1Y;
tmpZ = sx1Z;
sx1X = sx2X;
sx1Y = sx2Y;
sx1Z = sx2Z;
sx2X = tmpX;
sx2Y = tmpY;
sx2Z = tmpZ;
tmpX = sy1X;
tmpY = sy1Y;
tmpZ = sy1Z;
sy1X = sy2X;
sy1Y = sy2Y;
sy1Z = sy2Z;
sy2X = tmpX;
sy2Y = tmpY;
sy2Z = tmpZ;
tmpX = sz1X;
tmpY = sz1Y;
tmpZ = sz1Z;
sz1X = sz2X;
sz1Y = sz2Y;
sz1Z = sz2Z;
sz2X = tmpX;
sz2Y = tmpY;
sz2Z = tmpZ;
mId -= 3;
swapped = true;
} else {
swapped = false;
}
let refCenterX;
let refCenterY;
let refCenterZ;
let refNormalX;
let refNormalY;
let refNormalZ;
let refXX;
let refXY;
let refXZ;
let refYX;
let refYY;
let refYZ;
let refW;
let refH;
switch(mId) {
case 0:
refCenterX = sx1X;
refCenterY = sx1Y;
refCenterZ = sx1Z;
refNormalX = x1X;
refNormalY = x1Y;
refNormalZ = x1Z;
refXX = y1X;
refXY = y1Y;
refXZ = y1Z;
refYX = z1X;
refYY = z1Y;
refYZ = z1Z;
refW = h1;
refH = d1;
break;
case 1:
refCenterX = sy1X;
refCenterY = sy1Y;
refCenterZ = sy1Z;
refNormalX = y1X;
refNormalY = y1Y;
refNormalZ = y1Z;
refXX = z1X;
refXY = z1Y;
refXZ = z1Z;
refYX = x1X;
refYY = x1Y;
refYZ = x1Z;
refW = d1;
refH = w1;
break;
default:
refCenterX = sz1X;
refCenterY = sz1Y;
refCenterZ = sz1Z;
refNormalX = z1X;
refNormalY = z1Y;
refNormalZ = z1Z;
refXX = x1X;
refXY = x1Y;
refXZ = x1Z;
refYX = y1X;
refYY = y1Y;
refYZ = y1Z;
refW = w1;
refH = h1;
}
if(mSign < 0) {
refCenterX = -refCenterX;
refCenterY = -refCenterY;
refCenterZ = -refCenterZ;
refNormalX = -refNormalX;
refNormalY = -refNormalY;
refNormalZ = -refNormalZ;
tmpX = refXX;
tmpY = refXY;
tmpZ = refXZ;
refXX = refYX;
refXY = refYY;
refXZ = refYZ;
refYX = tmpX;
refYY = tmpY;
refYZ = tmpZ;
let tmp = refW;
refW = refH;
refH = tmp;
}
refCenterX += c1X;
refCenterY += c1Y;
refCenterZ += c1Z;
let minIncDot = 1;
let incId = 0;
let incDot = refNormalX * x2X + refNormalY * x2Y + refNormalZ * x2Z;
if(incDot < minIncDot) {
minIncDot = incDot;
incId = 0;
}
if(-incDot < minIncDot) {
minIncDot = -incDot;
incId = 1;
}
incDot = refNormalX * y2X + refNormalY * y2Y + refNormalZ * y2Z;
if(incDot < minIncDot) {
minIncDot = incDot;
incId = 2;
}
if(-incDot < minIncDot) {
minIncDot = -incDot;
incId = 3;
}
incDot = refNormalX * z2X + refNormalY * z2Y + refNormalZ * z2Z;
if(incDot < minIncDot) {
minIncDot = incDot;
incId = 4;
}
if(-incDot < minIncDot) {
incId = 5;
}
let incV1X;
let incV1Y;
let incV1Z;
let incV2X;
let incV2Y;
let incV2Z;
let incV3X;
let incV3Y;
let incV3Z;
let incV4X;
let incV4Y;
let incV4Z;
switch(incId) {
case 0:
incV1X = sx2X + sy2X;
incV1Y = sx2Y + sy2Y;
incV1Z = sx2Z + sy2Z;
incV1X += sz2X;
incV1Y += sz2Y;
incV1Z += sz2Z;
incV2X = sx2X - sy2X;
incV2Y = sx2Y - sy2Y;
incV2Z = sx2Z - sy2Z;
incV2X += sz2X;
incV2Y += sz2Y;
incV2Z += sz2Z;
incV3X = sx2X - sy2X;
incV3Y = sx2Y - sy2Y;
incV3Z = sx2Z - sy2Z;
incV3X -= sz2X;
incV3Y -= sz2Y;
incV3Z -= sz2Z;
incV4X = sx2X + sy2X;
incV4Y = sx2Y + sy2Y;
incV4Z = sx2Z + sy2Z;
incV4X -= sz2X;
incV4Y -= sz2Y;
incV4Z -= sz2Z;
break;
case 1:
incV1X = sy2X - sx2X;
incV1Y = sy2Y - sx2Y;
incV1Z = sy2Z - sx2Z;
incV1X += sz2X;
incV1Y += sz2Y;
incV1Z += sz2Z;
incV2X = sy2X - sx2X;
incV2Y = sy2Y - sx2Y;
incV2Z = sy2Z - sx2Z;
incV2X -= sz2X;
incV2Y -= sz2Y;
incV2Z -= sz2Z;
incV3X = sx2X + sy2X;
incV3Y = sx2Y + sy2Y;
incV3Z = sx2Z + sy2Z;
incV3X = -incV3X;
incV3Y = -incV3Y;
incV3Z = -incV3Z;
incV3X -= sz2X;
incV3Y -= sz2Y;
incV3Z -= sz2Z;
incV4X = sx2X + sy2X;
incV4Y = sx2Y + sy2Y;
incV4Z = sx2Z + sy2Z;
incV4X = -incV4X;
incV4Y = -incV4Y;
incV4Z = -incV4Z;
incV4X += sz2X;
incV4Y += sz2Y;
incV4Z += sz2Z;
break;
case 2:
incV1X = sx2X + sy2X;
incV1Y = sx2Y + sy2Y;
incV1Z = sx2Z + sy2Z;
incV1X += sz2X;
incV1Y += sz2Y;
incV1Z += sz2Z;
incV2X = sx2X + sy2X;
incV2Y = sx2Y + sy2Y;
incV2Z = sx2Z + sy2Z;
incV2X -= sz2X;
incV2Y -= sz2Y;
incV2Z -= sz2Z;
incV3X = sy2X - sx2X;
incV3Y = sy2Y - sx2Y;
incV3Z = sy2Z - sx2Z;
incV3X -= sz2X;
incV3Y -= sz2Y;
incV3Z -= sz2Z;
incV4X = sy2X - sx2X;
incV4Y = sy2Y - sx2Y;
incV4Z = sy2Z - sx2Z;
incV4X += sz2X;
incV4Y += sz2Y;
incV4Z += sz2Z;
break;
case 3:
incV1X = sx2X - sy2X;
incV1Y = sx2Y - sy2Y;
incV1Z = sx2Z - sy2Z;
incV1X += sz2X;
incV1Y += sz2Y;
incV1Z += sz2Z;
incV2X = sx2X + sy2X;
incV2Y = sx2Y + sy2Y;
incV2Z = sx2Z + sy2Z;
incV2X = -incV2X;
incV2Y = -incV2Y;
incV2Z = -incV2Z;
incV2X += sz2X;
incV2Y += sz2Y;
incV2Z += sz2Z;
incV3X = sx2X + sy2X;
incV3Y = sx2Y + sy2Y;
incV3Z = sx2Z + sy2Z;
incV3X = -incV3X;
incV3Y = -incV3Y;
incV3Z = -incV3Z;
incV3X -= sz2X;
incV3Y -= sz2Y;
incV3Z -= sz2Z;
incV4X = sx2X - sy2X;
incV4Y = sx2Y - sy2Y;
incV4Z = sx2Z - sy2Z;
incV4X -= sz2X;
incV4Y -= sz2Y;
incV4Z -= sz2Z;
break;
case 4:
incV1X = sx2X + sy2X;
incV1Y = sx2Y + sy2Y;
incV1Z = sx2Z + sy2Z;
incV1X += sz2X;
incV1Y += sz2Y;
incV1Z += sz2Z;
incV2X = sy2X - sx2X;
incV2Y = sy2Y - sx2Y;
incV2Z = sy2Z - sx2Z;
incV2X += sz2X;
incV2Y += sz2Y;
incV2Z += sz2Z;
incV3X = sx2X + sy2X;
incV3Y = sx2Y + sy2Y;
incV3Z = sx2Z + sy2Z;
incV3X = -incV3X;
incV3Y = -incV3Y;
incV3Z = -incV3Z;
incV3X += sz2X;
incV3Y += sz2Y;
incV3Z += sz2Z;
incV4X = sx2X - sy2X;
incV4Y = sx2Y - sy2Y;
incV4Z = sx2Z - sy2Z;
incV4X += sz2X;
incV4Y += sz2Y;
incV4Z += sz2Z;
break;
default:
incV1X = sx2X + sy2X;
incV1Y = sx2Y + sy2Y;
incV1Z = sx2Z + sy2Z;
incV1X -= sz2X;
incV1Y -= sz2Y;
incV1Z -= sz2Z;
incV2X = sx2X - sy2X;
incV2Y = sx2Y - sy2Y;
incV2Z = sx2Z - sy2Z;
incV2X -= sz2X;
incV2Y -= sz2Y;
incV2Z -= sz2Z;
incV3X = sx2X + sy2X;
incV3Y = sx2Y + sy2Y;
incV3Z = sx2Z + sy2Z;
incV3X = -incV3X;
incV3Y = -incV3Y;
incV3Z = -incV3Z;
incV3X -= sz2X;
incV3Y -= sz2Y;
incV3Z -= sz2Z;
incV4X = sy2X - sx2X;
incV4Y = sy2Y - sx2Y;
incV4Z = sy2Z - sx2Z;
incV4X -= sz2X;
incV4Y -= sz2Y;
incV4Z -= sz2Z;
}
incV1X += c12X;
incV1Y += c12Y;
incV1Z += c12Z;
incV2X += c12X;
incV2Y += c12Y;
incV2Z += c12Z;
incV3X += c12X;
incV3Y += c12Y;
incV3Z += c12Z;
incV4X += c12X;
incV4Y += c12Y;
incV4Z += c12Z;
let _this = this.clipper;
_this.w = refW;
_this.h = refH;
_this.numVertices = 0;
_this.numTmpVertices = 0;
let _this1 = this.clipper;
let _this2 = _this1.vertices[_this1.numVertices++];
_this2.x = incV1X * refXX + incV1Y * refXY + incV1Z * refXZ;
_this2.y = incV1X * refYX + incV1Y * refYY + incV1Z * refYZ;
_this2.wx = incV1X;
_this2.wy = incV1Y;
_this2.wz = incV1Z;
let _this3 = this.clipper;
let _this4 = _this3.vertices[_this3.numVertices++];
_this4.x = incV2X * refXX + incV2Y * refXY + incV2Z * refXZ;
_this4.y = incV2X * refYX + incV2Y * refYY + incV2Z * refYZ;
_this4.wx = incV2X;
_this4.wy = incV2Y;
_this4.wz = incV2Z;
let _this5 = this.clipper;
let _this6 = _this5.vertices[_this5.numVertices++];
_this6.x = incV3X * refXX + incV3Y * refXY + incV3Z * refXZ;
_this6.y = incV3X * refYX + incV3Y * refYY + incV3Z * refYZ;
_this6.wx = incV3X;
_this6.wy = incV3Y;
_this6.wz = incV3Z;
let _this7 = this.clipper;
let _this8 = _this7.vertices[_this7.numVertices++];
_this8.x = incV4X * refXX + incV4Y * refXY + incV4Z * refXZ;
_this8.y = incV4X * refYX + incV4Y * refYY + incV4Z * refYZ;
_this8.wx = incV4X;
_this8.wy = incV4Y;
_this8.wz = incV4Z;
this.clipper.clip();
this.clipper.reduce();
let normalX;
let normalY;
let normalZ;
if(swapped) {
normalX = refNormalX;
normalY = refNormalY;
normalZ = refNormalZ;
} else {
normalX = -refNormalX;
normalY = -refNormalY;
normalZ = -refNormalZ;
}
this.setNormal(result,normalX,normalY,normalZ);
let _g = 0;
let _g1 = this.clipper.numVertices;
while(_g < _g1) {
let i = _g++;
let v = this.clipper.vertices[i];
let clippedVertexX;
let clippedVertexY;
let clippedVertexZ;
clippedVertexX = v.wx;
clippedVertexY = v.wy;
clippedVertexZ = v.wz;
clippedVertexX += c1X;
clippedVertexY += c1Y;
clippedVertexZ += c1Z;
let clippedVertexToRefCenterX;
let clippedVertexToRefCenterY;
let clippedVertexToRefCenterZ;
clippedVertexToRefCenterX = refCenterX - clippedVertexX;
clippedVertexToRefCenterY = refCenterY - clippedVertexY;
clippedVertexToRefCenterZ = refCenterZ - clippedVertexZ;
let depth = clippedVertexToRefCenterX * refNormalX + clippedVertexToRefCenterY * refNormalY + clippedVertexToRefCenterZ * refNormalZ;
let clippedVertexOnRefFaceX;
let clippedVertexOnRefFaceY;
let clippedVertexOnRefFaceZ;
clippedVertexOnRefFaceX = clippedVertexX + refNormalX * depth;
clippedVertexOnRefFaceY = clippedVertexY + refNormalY * depth;
clippedVertexOnRefFaceZ = clippedVertexZ + refNormalZ * depth;
if(depth > -oimo.common.Setting.contactPersistenceThreshold) {
if(swapped) {
this.addPoint(result,clippedVertexX,clippedVertexY,clippedVertexZ,clippedVertexOnRefFaceX,clippedVertexOnRefFaceY,clippedVertexOnRefFaceZ,depth,i);
} else {
this.addPoint(result,clippedVertexOnRefFaceX,clippedVertexOnRefFaceY,clippedVertexOnRefFaceZ,clippedVertexX,clippedVertexY,clippedVertexZ,depth,i);
}
}
}
}
}
if(!oimo.collision.narrowphase.detector._BoxBoxDetector) oimo.collision.narrowphase.detector._BoxBoxDetector = {};
oimo.collision.narrowphase.detector._BoxBoxDetector.IncidentVertex = class oimo_collision_narrowphase_detector__$BoxBoxDetector_IncidentVertex {
constructor() {
this.x = 0;
this.y = 0;
this.wx = 0;
this.wy = 0;
this.wz = 0;
}
}
oimo.collision.narrowphase.detector._BoxBoxDetector.FaceClipper = class oimo_collision_narrowphase_detector__$BoxBoxDetector_FaceClipper {
constructor() {
this.w = 0;
this.h = 0;
this.numVertices = 0;
this.numTmpVertices = 0;
this.vertices = new Array(8);
this.tmpVertices = new Array(8);
this.vertices[0] = new oimo.collision.narrowphase.detector._BoxBoxDetector.IncidentVertex();
this.tmpVertices[0] = new oimo.collision.narrowphase.detector._BoxBoxDetector.IncidentVertex();
this.vertices[1] = new oimo.collision.narrowphase.detector._BoxBoxDetector.IncidentVertex();
this.tmpVertices[1] = new oimo.collision.narrowphase.detector._BoxBoxDetector.IncidentVertex();
this.vertices[2] = new oimo.collision.narrowphase.detector._BoxBoxDetector.IncidentVertex();
this.tmpVertices[2] = new oimo.collision.narrowphase.detector._BoxBoxDetector.IncidentVertex();
this.vertices[3] = new oimo.collision.narrowphase.detector._BoxBoxDetector.IncidentVertex();
this.tmpVertices[3] = new oimo.collision.narrowphase.detector._BoxBoxDetector.IncidentVertex();
this.vertices[4] = new oimo.collision.narrowphase.detector._BoxBoxDetector.IncidentVertex();
this.tmpVertices[4] = new oimo.collision.narrowphase.detector._BoxBoxDetector.IncidentVertex();
this.vertices[5] = new oimo.collision.narrowphase.detector._BoxBoxDetector.IncidentVertex();
this.tmpVertices[5] = new oimo.collision.narrowphase.detector._BoxBoxDetector.IncidentVertex();
this.vertices[6] = new oimo.collision.narrowphase.detector._BoxBoxDetector.IncidentVertex();
this.tmpVertices[6] = new oimo.collision.narrowphase.detector._BoxBoxDetector.IncidentVertex();
this.vertices[7] = new oimo.collision.narrowphase.detector._BoxBoxDetector.IncidentVertex();
this.tmpVertices[7] = new oimo.collision.narrowphase.detector._BoxBoxDetector.IncidentVertex();
}
clip() {
let _g = 0;
let _g1 = this.numVertices;
while(_g < _g1) {
let i = _g++;
let v1 = this.vertices[i];
let v2 = this.vertices[(i + 1) % this.numVertices];
let s1 = this.w + v1.x;
let s2 = this.w + v2.x;
if(s1 > 0 && s2 > 0) {
let _this = this.tmpVertices[this.numTmpVertices++];
_this.x = v1.x;
_this.y = v1.y;
_this.wx = v1.wx;
_this.wy = v1.wy;
_this.wz = v1.wz;
} else if(s1 > 0 && s2 <= 0) {
let _this = this.tmpVertices[this.numTmpVertices++];
_this.x = v1.x;
_this.y = v1.y;
_this.wx = v1.wx;
_this.wy = v1.wy;
_this.wz = v1.wz;
let t = s1 / (s1 - s2);
let _this1 = this.tmpVertices[this.numTmpVertices++];
_this1.x = v1.x + (v2.x - v1.x) * t;
_this1.y = v1.y + (v2.y - v1.y) * t;
_this1.wx = v1.wx + (v2.wx - v1.wx) * t;
_this1.wy = v1.wy + (v2.wy - v1.wy) * t;
_this1.wz = v1.wz + (v2.wz - v1.wz) * t;
} else if(s1 <= 0 && s2 > 0) {
let t = s1 / (s1 - s2);
let _this = this.tmpVertices[this.numTmpVertices++];
_this.x = v1.x + (v2.x - v1.x) * t;
_this.y = v1.y + (v2.y - v1.y) * t;
_this.wx = v1.wx + (v2.wx - v1.wx) * t;
_this.wy = v1.wy + (v2.wy - v1.wy) * t;
_this.wz = v1.wz + (v2.wz - v1.wz) * t;
}
}
let tmp = this.vertices;
this.vertices = this.tmpVertices;
this.tmpVertices = tmp;
this.numVertices = this.numTmpVertices;
this.numTmpVertices = 0;
let _g2 = 0;
let _g3 = this.numVertices;
while(_g2 < _g3) {
let i = _g2++;
let v1 = this.vertices[i];
let v2 = this.vertices[(i + 1) % this.numVertices];
let s1 = this.w - v1.x;
let s2 = this.w - v2.x;
if(s1 > 0 && s2 > 0) {
let _this = this.tmpVertices[this.numTmpVertices++];
_this.x = v1.x;
_this.y = v1.y;
_this.wx = v1.wx;
_this.wy = v1.wy;
_this.wz = v1.wz;
} else if(s1 > 0 && s2 <= 0) {
let _this = this.tmpVertices[this.numTmpVertices++];
_this.x = v1.x;
_this.y = v1.y;
_this.wx = v1.wx;
_this.wy = v1.wy;
_this.wz = v1.wz;
let t = s1 / (s1 - s2);
let _this1 = this.tmpVertices[this.numTmpVertices++];
_this1.x = v1.x + (v2.x - v1.x) * t;
_this1.y = v1.y + (v2.y - v1.y) * t;
_this1.wx = v1.wx + (v2.wx - v1.wx) * t;
_this1.wy = v1.wy + (v2.wy - v1.wy) * t;
_this1.wz = v1.wz + (v2.wz - v1.wz) * t;
} else if(s1 <= 0 && s2 > 0) {
let t = s1 / (s1 - s2);
let _this = this.tmpVertices[this.numTmpVertices++];
_this.x = v1.x + (v2.x - v1.x) * t;
_this.y = v1.y + (v2.y - v1.y) * t;
_this.wx = v1.wx + (v2.wx - v1.wx) * t;
_this.wy = v1.wy + (v2.wy - v1.wy) * t;
_this.wz = v1.wz + (v2.wz - v1.wz) * t;
}
}
let tmp1 = this.vertices;
this.vertices = this.tmpVertices;
this.tmpVertices = tmp1;
this.numVertices = this.numTmpVertices;
this.numTmpVertices = 0;
let _g4 = 0;
let _g5 = this.numVertices;
while(_g4 < _g5) {
let i = _g4++;
let v1 = this.vertices[i];
let v2 = this.vertices[(i + 1) % this.numVertices];
let s1 = this.h + v1.y;
let s2 = this.h + v2.y;
if(s1 > 0 && s2 > 0) {
let _this = this.tmpVertices[this.numTmpVertices++];
_this.x = v1.x;
_this.y = v1.y;
_this.wx = v1.wx;
_this.wy = v1.wy;
_this.wz = v1.wz;
} else if(s1 > 0 && s2 <= 0) {
let _this = this.tmpVertices[this.numTmpVertices++];
_this.x = v1.x;
_this.y = v1.y;
_this.wx = v1.wx;
_this.wy = v1.wy;
_this.wz = v1.wz;
let t = s1 / (s1 - s2);
let _this1 = this.tmpVertices[this.numTmpVertices++];
_this1.x = v1.x + (v2.x - v1.x) * t;
_this1.y = v1.y + (v2.y - v1.y) * t;
_this1.wx = v1.wx + (v2.wx - v1.wx) * t;
_this1.wy = v1.wy + (v2.wy - v1.wy) * t;
_this1.wz = v1.wz + (v2.wz - v1.wz) * t;
} else if(s1 <= 0 && s2 > 0) {
let t = s1 / (s1 - s2);
let _this = this.tmpVertices[this.numTmpVertices++];
_this.x = v1.x + (v2.x - v1.x) * t;
_this.y = v1.y + (v2.y - v1.y) * t;
_this.wx = v1.wx + (v2.wx - v1.wx) * t;
_this.wy = v1.wy + (v2.wy - v1.wy) * t;
_this.wz = v1.wz + (v2.wz - v1.wz) * t;
}
}
let tmp2 = this.vertices;
this.vertices = this.tmpVertices;
this.tmpVertices = tmp2;
this.numVertices = this.numTmpVertices;
this.numTmpVertices = 0;
let _g6 = 0;
let _g7 = this.numVertices;
while(_g6 < _g7) {
let i = _g6++;
let v1 = this.vertices[i];
let v2 = this.vertices[(i + 1) % this.numVertices];
let s1 = this.h - v1.y;
let s2 = this.h - v2.y;
if(s1 > 0 && s2 > 0) {
let _this = this.tmpVertices[this.numTmpVertices++];
_this.x = v1.x;
_this.y = v1.y;
_this.wx = v1.wx;
_this.wy = v1.wy;
_this.wz = v1.wz;
} else if(s1 > 0 && s2 <= 0) {
let _this = this.tmpVertices[this.numTmpVertices++];
_this.x = v1.x;
_this.y = v1.y;
_this.wx = v1.wx;
_this.wy = v1.wy;
_this.wz = v1.wz;
let t = s1 / (s1 - s2);
let _this1 = this.tmpVertices[this.numTmpVertices++];
_this1.x = v1.x + (v2.x - v1.x) * t;
_this1.y = v1.y + (v2.y - v1.y) * t;
_this1.wx = v1.wx + (v2.wx - v1.wx) * t;
_this1.wy = v1.wy + (v2.wy - v1.wy) * t;
_this1.wz = v1.wz + (v2.wz - v1.wz) * t;
} else if(s1 <= 0 && s2 > 0) {
let t = s1 / (s1 - s2);
let _this = this.tmpVertices[this.numTmpVertices++];
_this.x = v1.x + (v2.x - v1.x) * t;
_this.y = v1.y + (v2.y - v1.y) * t;
_this.wx = v1.wx + (v2.wx - v1.wx) * t;
_this.wy = v1.wy + (v2.wy - v1.wy) * t;
_this.wz = v1.wz + (v2.wz - v1.wz) * t;
}
}
let tmp3 = this.vertices;
this.vertices = this.tmpVertices;
this.tmpVertices = tmp3;
this.numVertices = this.numTmpVertices;
this.numTmpVertices = 0;
}
reduce() {
if(this.numVertices < 4) {
return;
}
let max1 = -1e65536;
let min1 = 1e65536;
let max2 = -1e65536;
let min2 = 1e65536;
let max1V = null;
let min1V = null;
let max2V = null;
let min2V = null;
let e1x = 1;
let e1y = 1;
let e2x = -1;
let e2y = 1;
let _g = 0;
let _g1 = this.numVertices;
while(_g < _g1) {
let v = this.vertices[_g++];
let dot1 = v.x * e1x + v.y * e1y;
let dot2 = v.x * e2x + v.y * e2y;
if(dot1 > max1) {
max1 = dot1;
max1V = v;
}
if(dot1 < min1) {
min1 = dot1;
min1V = v;
}
if(dot2 > max2) {
max2 = dot2;
max2V = v;
}
if(dot2 < min2) {
min2 = dot2;
min2V = v;
}
}
let _this = this.tmpVertices[this.numTmpVertices++];
_this.x = max1V.x;
_this.y = max1V.y;
_this.wx = max1V.wx;
_this.wy = max1V.wy;
_this.wz = max1V.wz;
let _this1 = this.tmpVertices[this.numTmpVertices++];
_this1.x = max2V.x;
_this1.y = max2V.y;
_this1.wx = max2V.wx;
_this1.wy = max2V.wy;
_this1.wz = max2V.wz;
let _this2 = this.tmpVertices[this.numTmpVertices++];
_this2.x = min1V.x;
_this2.y = min1V.y;
_this2.wx = min1V.wx;
_this2.wy = min1V.wy;
_this2.wz = min1V.wz;
let _this3 = this.tmpVertices[this.numTmpVertices++];
_this3.x = min2V.x;
_this3.y = min2V.y;
_this3.wx = min2V.wx;
_this3.wy = min2V.wy;
_this3.wz = min2V.wz;
let tmp = this.vertices;
this.vertices = this.tmpVertices;
this.tmpVertices = tmp;
this.numVertices = this.numTmpVertices;
this.numTmpVertices = 0;
}
}
oimo.collision.narrowphase.detector.BoxBoxDetectorMacro = class oimo_collision_narrowphase_detector_BoxBoxDetectorMacro {
}
oimo.collision.narrowphase.detector.CachedDetectorData = class oimo_collision_narrowphase_detector_CachedDetectorData {
constructor() {
}
_clear() {
if(this._gjkCache != null) {
this._gjkCache.clear();
}
}
}
oimo.collision.narrowphase.detector.CapsuleCapsuleDetector = class oimo_collision_narrowphase_detector_CapsuleCapsuleDetector extends oimo.collision.narrowphase.detector.Detector {
constructor() {
super(false);
}
detectImpl(result,geom1,geom2,tf1,tf2,cachedData) {
let c1 = geom1;
let c2 = geom2;
result.incremental = false;
let axis1X;
let axis1Y;
let axis1Z;
let axis2X;
let axis2Y;
let axis2Z;
axis1X = tf1._rotation01;
axis1Y = tf1._rotation11;
axis1Z = tf1._rotation21;
axis2X = tf2._rotation01;
axis2Y = tf2._rotation11;
axis2Z = tf2._rotation21;
let hh1 = c1._halfHeight;
let hh2 = c2._halfHeight;
let r1 = c1._radius;
let r2 = c2._radius;
let p1X;
let p1Y;
let p1Z;
let q1X;
let q1Y;
let q1Z;
let p2X;
let p2Y;
let p2Z;
let q2X;
let q2Y;
let q2Z;
p1X = tf1._positionX + axis1X * -hh1;
p1Y = tf1._positionY + axis1Y * -hh1;
p1Z = tf1._positionZ + axis1Z * -hh1;
q1X = tf1._positionX + axis1X * hh1;
q1Y = tf1._positionY + axis1Y * hh1;
q1Z = tf1._positionZ + axis1Z * hh1;
p2X = tf2._positionX + axis2X * -hh2;
p2Y = tf2._positionY + axis2Y * -hh2;
p2Z = tf2._positionZ + axis2Z * -hh2;
q2X = tf2._positionX + axis2X * hh2;
q2Y = tf2._positionY + axis2Y * hh2;
q2Z = tf2._positionZ + axis2Z * hh2;
let p12X;
let p12Y;
let p12Z;
p12X = p1X - p2X;
p12Y = p1Y - p2Y;
p12Z = p1Z - p2Z;
let d1X;
let d1Y;
let d1Z;
let d2X;
let d2Y;
let d2Z;
d1X = q1X - p1X;
d1Y = q1Y - p1Y;
d1Z = q1Z - p1Z;
d2X = q2X - p2X;
d2Y = q2Y - p2Y;
d2Z = q2Z - p2Z;
let p21d1 = -(p12X * d1X + p12Y * d1Y + p12Z * d1Z);
let p12d2 = p12X * d2X + p12Y * d2Y + p12Z * d2Z;
let d11 = hh1 * hh1 * 4;
let d12 = d1X * d2X + d1Y * d2Y + d1Z * d2Z;
let d22 = hh2 * hh2 * 4;
let t1;
let t2;
if(d11 == 0 && d22 == 0) {
t1 = 0;
t2 = 0;
} else if(d11 == 0) {
t1 = 0;
if(p12d2 < 0) {
t2 = 0;
} else if(p12d2 > d22) {
t2 = 1;
} else {
t2 = p12d2 / d22;
}
} else if(d22 == 0) {
t2 = 0;
if(p21d1 < 0) {
t1 = 0;
} else if(p21d1 > d11) {
t1 = 1;
} else {
t1 = p21d1 / d11;
}
} else {
let det = d11 * d22 - d12 * d12;
if(det == 0) {
t1 = 0;
} else {
t1 = d12 * p12d2 + d22 * p21d1;
if(t1 < 0) {
t1 = 0;
} else if(t1 > det) {
t1 = 1;
} else {
t1 /= det;
}
}
t2 = t1 * d12 + p12d2;
if(t2 < 0) {
t2 = 0;
if(p21d1 < 0) {
t1 = 0;
} else if(p21d1 > d11) {
t1 = 1;
} else {
t1 = p21d1 / d11;
}
} else if(t2 > d22) {
t2 = 1;
t1 = d12 + p21d1;
if(t1 < 0) {
t1 = 0;
} else if(t1 > d11) {
t1 = 1;
} else {
t1 /= d11;
}
} else {
t2 /= d22;
}
}
let cp1X;
let cp1Y;
let cp1Z;
let cp2X;
let cp2Y;
let cp2Z;
cp1X = p1X + d1X * t1;
cp1Y = p1Y + d1Y * t1;
cp1Z = p1Z + d1Z * t1;
cp2X = p2X + d2X * t2;
cp2Y = p2Y + d2Y * t2;
cp2Z = p2Z + d2Z * t2;
let dX;
let dY;
let dZ;
dX = cp1X - cp2X;
dY = cp1Y - cp2Y;
dZ = cp1Z - cp2Z;
let len2 = dX * dX + dY * dY + dZ * dZ;
if(len2 >= (r1 + r2) * (r1 + r2)) {
return;
}
let len = Math.sqrt(len2);
let nX;
let nY;
let nZ;
if(len > 0) {
nX = dX * (1 / len);
nY = dY * (1 / len);
nZ = dZ * (1 / len);
} else {
nX = 1;
nY = 0;
nZ = 0;
}
this.setNormal(result,nX,nY,nZ);
let pos1X;
let pos1Y;
let pos1Z;
let pos2X;
let pos2Y;
let pos2Z;
pos1X = cp1X + nX * -r1;
pos1Y = cp1Y + nY * -r1;
pos1Z = cp1Z + nZ * -r1;
pos2X = cp2X + nX * r2;
pos2Y = cp2Y + nY * r2;
pos2Z = cp2Z + nZ * r2;
this.addPoint(result,pos1X,pos1Y,pos1Z,pos2X,pos2Y,pos2Z,r1 + r2 - len,0);
}
}
oimo.collision.narrowphase.detector.GjkEpaDetector = class oimo_collision_narrowphase_detector_GjkEpaDetector extends oimo.collision.narrowphase.detector.Detector {
constructor() {
super(false);
}
detectImpl(result,geom1,geom2,tf1,tf2,cachedData) {
let gjkEpa = oimo.collision.narrowphase.detector.gjkepa.GjkEpa.instance;
let g1 = geom1;
let g2 = geom2;
let status = gjkEpa.computeClosestPointsImpl(g1,g2,tf1,tf2,oimo.common.Setting.enableGJKCaching ? cachedData : null,true);
result.incremental = true;
if(status != oimo.collision.narrowphase.detector.gjkepa.GjkEpaResultState.SUCCEEDED) {
console.log("src/oimo/collision/narrowphase/detector/GjkEpaDetector.hx:28:","GJK/EPA failed: status=" + status);
return;
}
if(gjkEpa.distance > g1._gjkMargin + g2._gjkMargin) {
return;
}
let pos1X;
let pos1Y;
let pos1Z;
let pos2X;
let pos2Y;
let pos2Z;
let v = gjkEpa.closestPoint1;
pos1X = v.x;
pos1Y = v.y;
pos1Z = v.z;
let v1 = gjkEpa.closestPoint2;
pos2X = v1.x;
pos2Y = v1.y;
pos2Z = v1.z;
let normalX;
let normalY;
let normalZ;
normalX = pos1X - pos2X;
normalY = pos1Y - pos2Y;
normalZ = pos1Z - pos2Z;
if(normalX * normalX + normalY * normalY + normalZ * normalZ == 0) {
return;
}
if(gjkEpa.distance < 0) {
normalX = -normalX;
normalY = -normalY;
normalZ = -normalZ;
}
let l = normalX * normalX + normalY * normalY + normalZ * normalZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
normalX *= l;
normalY *= l;
normalZ *= l;
this.setNormal(result,normalX,normalY,normalZ);
pos1X += normalX * -g1._gjkMargin;
pos1Y += normalY * -g1._gjkMargin;
pos1Z += normalZ * -g1._gjkMargin;
pos2X += normalX * g2._gjkMargin;
pos2Y += normalY * g2._gjkMargin;
pos2Z += normalZ * g2._gjkMargin;
this.addPoint(result,pos1X,pos1Y,pos1Z,pos2X,pos2Y,pos2Z,g1._gjkMargin + g2._gjkMargin - gjkEpa.distance,0);
}
}
oimo.collision.narrowphase.detector.SphereBoxDetector = class oimo_collision_narrowphase_detector_SphereBoxDetector extends oimo.collision.narrowphase.detector.Detector {
constructor(swapped) {
super(swapped);
}
detectImpl(result,geom1,geom2,tf1,tf2,cachedData) {
let b = geom2;
result.incremental = false;
let halfExtX;
let halfExtY;
let halfExtZ;
let negHalfExtX;
let negHalfExtY;
let negHalfExtZ;
halfExtX = b._halfExtentsX;
halfExtY = b._halfExtentsY;
halfExtZ = b._halfExtentsZ;
negHalfExtX = -halfExtX;
negHalfExtY = -halfExtY;
negHalfExtZ = -halfExtZ;
let r = geom1._radius;
let boxToSphereX;
let boxToSphereY;
let boxToSphereZ;
boxToSphereX = tf1._positionX - tf2._positionX;
boxToSphereY = tf1._positionY - tf2._positionY;
boxToSphereZ = tf1._positionZ - tf2._positionZ;
let boxToSphereInBoxX;
let boxToSphereInBoxY;
let boxToSphereInBoxZ;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = tf2._rotation00 * boxToSphereX + tf2._rotation10 * boxToSphereY + tf2._rotation20 * boxToSphereZ;
__tmp__Y = tf2._rotation01 * boxToSphereX + tf2._rotation11 * boxToSphereY + tf2._rotation21 * boxToSphereZ;
__tmp__Z = tf2._rotation02 * boxToSphereX + tf2._rotation12 * boxToSphereY + tf2._rotation22 * boxToSphereZ;
boxToSphereInBoxX = __tmp__X;
boxToSphereInBoxY = __tmp__Y;
boxToSphereInBoxZ = __tmp__Z;
if(negHalfExtX < boxToSphereInBoxX && halfExtX > boxToSphereInBoxX && negHalfExtY < boxToSphereInBoxY && halfExtY > boxToSphereInBoxY && negHalfExtZ < boxToSphereInBoxZ && halfExtZ > boxToSphereInBoxZ) {
let sphereToBoxSurfaceX;
let sphereToBoxSurfaceY;
let sphereToBoxSurfaceZ;
sphereToBoxSurfaceX = boxToSphereInBoxX < 0 ? -boxToSphereInBoxX : boxToSphereInBoxX;
sphereToBoxSurfaceY = boxToSphereInBoxY < 0 ? -boxToSphereInBoxY : boxToSphereInBoxY;
sphereToBoxSurfaceZ = boxToSphereInBoxZ < 0 ? -boxToSphereInBoxZ : boxToSphereInBoxZ;
sphereToBoxSurfaceX = halfExtX - sphereToBoxSurfaceX;
sphereToBoxSurfaceY = halfExtY - sphereToBoxSurfaceY;
sphereToBoxSurfaceZ = halfExtZ - sphereToBoxSurfaceZ;
let normalInBoxX;
let normalInBoxY;
let normalInBoxZ;
let distX = sphereToBoxSurfaceX;
let distY = sphereToBoxSurfaceY;
let distZ = sphereToBoxSurfaceZ;
let depth;
let projectionMaskX;
let projectionMaskY;
let projectionMaskZ;
if(distX < distY) {
if(distX < distZ) {
if(boxToSphereInBoxX > 0) {
normalInBoxX = 1;
normalInBoxY = 0;
normalInBoxZ = 0;
} else {
normalInBoxX = -1;
normalInBoxY = 0;
normalInBoxZ = 0;
}
projectionMaskX = 0;
projectionMaskY = 1;
projectionMaskZ = 1;
depth = distX;
} else {
if(boxToSphereInBoxZ > 0) {
normalInBoxX = 0;
normalInBoxY = 0;
normalInBoxZ = 1;
} else {
normalInBoxX = 0;
normalInBoxY = 0;
normalInBoxZ = -1;
}
projectionMaskX = 1;
projectionMaskY = 1;
projectionMaskZ = 0;
depth = distZ;
}
} else if(distY < distZ) {
if(boxToSphereInBoxY > 0) {
normalInBoxX = 0;
normalInBoxY = 1;
normalInBoxZ = 0;
} else {
normalInBoxX = 0;
normalInBoxY = -1;
normalInBoxZ = 0;
}
projectionMaskX = 1;
projectionMaskY = 0;
projectionMaskZ = 1;
depth = distY;
} else {
if(boxToSphereInBoxZ > 0) {
normalInBoxX = 0;
normalInBoxY = 0;
normalInBoxZ = 1;
} else {
normalInBoxX = 0;
normalInBoxY = 0;
normalInBoxZ = -1;
}
projectionMaskX = 1;
projectionMaskY = 1;
projectionMaskZ = 0;
depth = distZ;
}
let baseX;
let baseY;
let baseZ;
baseX = projectionMaskX * boxToSphereInBoxX;
baseY = projectionMaskY * boxToSphereInBoxY;
baseZ = projectionMaskZ * boxToSphereInBoxZ;
let boxToClosestPointInBoxX;
let boxToClosestPointInBoxY;
let boxToClosestPointInBoxZ;
boxToClosestPointInBoxX = normalInBoxX * halfExtX;
boxToClosestPointInBoxY = normalInBoxY * halfExtY;
boxToClosestPointInBoxZ = normalInBoxZ * halfExtZ;
boxToClosestPointInBoxX += baseX;
boxToClosestPointInBoxY += baseY;
boxToClosestPointInBoxZ += baseZ;
let boxToClosestPointX;
let boxToClosestPointY;
let boxToClosestPointZ;
let normalX;
let normalY;
let normalZ;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = tf2._rotation00 * boxToClosestPointInBoxX + tf2._rotation01 * boxToClosestPointInBoxY + tf2._rotation02 * boxToClosestPointInBoxZ;
__tmp__Y = tf2._rotation10 * boxToClosestPointInBoxX + tf2._rotation11 * boxToClosestPointInBoxY + tf2._rotation12 * boxToClosestPointInBoxZ;
__tmp__Z = tf2._rotation20 * boxToClosestPointInBoxX + tf2._rotation21 * boxToClosestPointInBoxY + tf2._rotation22 * boxToClosestPointInBoxZ;
boxToClosestPointX = __tmp__X;
boxToClosestPointY = __tmp__Y;
boxToClosestPointZ = __tmp__Z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = tf2._rotation00 * normalInBoxX + tf2._rotation01 * normalInBoxY + tf2._rotation02 * normalInBoxZ;
__tmp__Y1 = tf2._rotation10 * normalInBoxX + tf2._rotation11 * normalInBoxY + tf2._rotation12 * normalInBoxZ;
__tmp__Z1 = tf2._rotation20 * normalInBoxX + tf2._rotation21 * normalInBoxY + tf2._rotation22 * normalInBoxZ;
normalX = __tmp__X1;
normalY = __tmp__Y1;
normalZ = __tmp__Z1;
this.setNormal(result,normalX,normalY,normalZ);
let pos1X;
let pos1Y;
let pos1Z;
let pos2X;
let pos2Y;
let pos2Z;
pos1X = tf1._positionX + normalX * -r;
pos1Y = tf1._positionY + normalY * -r;
pos1Z = tf1._positionZ + normalZ * -r;
pos2X = tf2._positionX + boxToClosestPointX;
pos2Y = tf2._positionY + boxToClosestPointY;
pos2Z = tf2._positionZ + boxToClosestPointZ;
this.addPoint(result,pos1X,pos1Y,pos1Z,pos2X,pos2Y,pos2Z,depth,0);
return;
}
let boxToClosestPointInBoxX;
let boxToClosestPointInBoxY;
let boxToClosestPointInBoxZ;
halfExtX -= 1e-9;
halfExtY -= 1e-9;
halfExtZ -= 1e-9;
negHalfExtX += 1e-9;
negHalfExtY += 1e-9;
negHalfExtZ += 1e-9;
boxToClosestPointInBoxX = boxToSphereInBoxX < halfExtX ? boxToSphereInBoxX : halfExtX;
boxToClosestPointInBoxY = boxToSphereInBoxY < halfExtY ? boxToSphereInBoxY : halfExtY;
boxToClosestPointInBoxZ = boxToSphereInBoxZ < halfExtZ ? boxToSphereInBoxZ : halfExtZ;
if(!(boxToClosestPointInBoxX > negHalfExtX)) {
boxToClosestPointInBoxX = negHalfExtX;
}
if(!(boxToClosestPointInBoxY > negHalfExtY)) {
boxToClosestPointInBoxY = negHalfExtY;
}
if(!(boxToClosestPointInBoxZ > negHalfExtZ)) {
boxToClosestPointInBoxZ = negHalfExtZ;
}
let closestPointToSphereInBoxX;
let closestPointToSphereInBoxY;
let closestPointToSphereInBoxZ;
closestPointToSphereInBoxX = boxToSphereInBoxX - boxToClosestPointInBoxX;
closestPointToSphereInBoxY = boxToSphereInBoxY - boxToClosestPointInBoxY;
closestPointToSphereInBoxZ = boxToSphereInBoxZ - boxToClosestPointInBoxZ;
let dist = closestPointToSphereInBoxX * closestPointToSphereInBoxX + closestPointToSphereInBoxY * closestPointToSphereInBoxY + closestPointToSphereInBoxZ * closestPointToSphereInBoxZ;
if(dist >= r * r) {
return;
}
dist = Math.sqrt(dist);
let boxToClosestPointX;
let boxToClosestPointY;
let boxToClosestPointZ;
let closestPointToSphereX;
let closestPointToSphereY;
let closestPointToSphereZ;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = tf2._rotation00 * boxToClosestPointInBoxX + tf2._rotation01 * boxToClosestPointInBoxY + tf2._rotation02 * boxToClosestPointInBoxZ;
__tmp__Y1 = tf2._rotation10 * boxToClosestPointInBoxX + tf2._rotation11 * boxToClosestPointInBoxY + tf2._rotation12 * boxToClosestPointInBoxZ;
__tmp__Z1 = tf2._rotation20 * boxToClosestPointInBoxX + tf2._rotation21 * boxToClosestPointInBoxY + tf2._rotation22 * boxToClosestPointInBoxZ;
boxToClosestPointX = __tmp__X1;
boxToClosestPointY = __tmp__Y1;
boxToClosestPointZ = __tmp__Z1;
let __tmp__X2;
let __tmp__Y2;
let __tmp__Z2;
__tmp__X2 = tf2._rotation00 * closestPointToSphereInBoxX + tf2._rotation01 * closestPointToSphereInBoxY + tf2._rotation02 * closestPointToSphereInBoxZ;
__tmp__Y2 = tf2._rotation10 * closestPointToSphereInBoxX + tf2._rotation11 * closestPointToSphereInBoxY + tf2._rotation12 * closestPointToSphereInBoxZ;
__tmp__Z2 = tf2._rotation20 * closestPointToSphereInBoxX + tf2._rotation21 * closestPointToSphereInBoxY + tf2._rotation22 * closestPointToSphereInBoxZ;
closestPointToSphereX = __tmp__X2;
closestPointToSphereY = __tmp__Y2;
closestPointToSphereZ = __tmp__Z2;
let normalX;
let normalY;
let normalZ;
let l = closestPointToSphereX * closestPointToSphereX + closestPointToSphereY * closestPointToSphereY + closestPointToSphereZ * closestPointToSphereZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
normalX = closestPointToSphereX * l;
normalY = closestPointToSphereY * l;
normalZ = closestPointToSphereZ * l;
this.setNormal(result,normalX,normalY,normalZ);
let pos1X;
let pos1Y;
let pos1Z;
let pos2X;
let pos2Y;
let pos2Z;
pos1X = tf1._positionX + normalX * -r;
pos1Y = tf1._positionY + normalY * -r;
pos1Z = tf1._positionZ + normalZ * -r;
pos2X = tf2._positionX + boxToClosestPointX;
pos2Y = tf2._positionY + boxToClosestPointY;
pos2Z = tf2._positionZ + boxToClosestPointZ;
this.addPoint(result,pos1X,pos1Y,pos1Z,pos2X,pos2Y,pos2Z,r - dist,0);
}
}
oimo.collision.narrowphase.detector.SphereCapsuleDetector = class oimo_collision_narrowphase_detector_SphereCapsuleDetector extends oimo.collision.narrowphase.detector.Detector {
constructor(swapped) {
super(swapped);
}
detectImpl(result,geom1,geom2,tf1,tf2,cachedData) {
let c2 = geom2;
result.incremental = false;
let hh2 = c2._halfHeight;
let r1 = geom1._radius;
let r2 = c2._radius;
let axis2X;
let axis2Y;
let axis2Z;
axis2X = tf2._rotation01;
axis2Y = tf2._rotation11;
axis2Z = tf2._rotation21;
let cp1X;
let cp1Y;
let cp1Z;
cp1X = tf1._positionX;
cp1Y = tf1._positionY;
cp1Z = tf1._positionZ;
let p2X;
let p2Y;
let p2Z;
let q2X;
let q2Y;
let q2Z;
p2X = tf2._positionX + axis2X * -hh2;
p2Y = tf2._positionY + axis2Y * -hh2;
p2Z = tf2._positionZ + axis2Z * -hh2;
q2X = tf2._positionX + axis2X * hh2;
q2Y = tf2._positionY + axis2Y * hh2;
q2Z = tf2._positionZ + axis2Z * hh2;
let p12X;
let p12Y;
let p12Z;
p12X = cp1X - p2X;
p12Y = cp1Y - p2Y;
p12Z = cp1Z - p2Z;
let d2X;
let d2Y;
let d2Z;
d2X = q2X - p2X;
d2Y = q2Y - p2Y;
d2Z = q2Z - p2Z;
let d22 = hh2 * hh2 * 4;
let t = p12X * d2X + p12Y * d2Y + p12Z * d2Z;
if(t < 0) {
t = 0;
} else if(t > d22) {
t = 1;
} else {
t /= d22;
}
let cp2X;
let cp2Y;
let cp2Z;
cp2X = p2X + d2X * t;
cp2Y = p2Y + d2Y * t;
cp2Z = p2Z + d2Z * t;
let dX;
let dY;
let dZ;
dX = cp1X - cp2X;
dY = cp1Y - cp2Y;
dZ = cp1Z - cp2Z;
let len2 = dX * dX + dY * dY + dZ * dZ;
if(len2 >= (r1 + r2) * (r1 + r2)) {
return;
}
let len = Math.sqrt(len2);
let nX;
let nY;
let nZ;
if(len > 0) {
nX = dX * (1 / len);
nY = dY * (1 / len);
nZ = dZ * (1 / len);
} else {
nX = 1;
nY = 0;
nZ = 0;
}
this.setNormal(result,nX,nY,nZ);
let pos1X;
let pos1Y;
let pos1Z;
let pos2X;
let pos2Y;
let pos2Z;
pos1X = cp1X + nX * -r1;
pos1Y = cp1Y + nY * -r1;
pos1Z = cp1Z + nZ * -r1;
pos2X = cp2X + nX * r2;
pos2Y = cp2Y + nY * r2;
pos2Z = cp2Z + nZ * r2;
this.addPoint(result,pos1X,pos1Y,pos1Z,pos2X,pos2Y,pos2Z,r1 + r2 - len,0);
}
}
oimo.collision.narrowphase.detector.SphereSphereDetector = class oimo_collision_narrowphase_detector_SphereSphereDetector extends oimo.collision.narrowphase.detector.Detector {
constructor() {
super(false);
}
detectImpl(result,geom1,geom2,tf1,tf2,cachedData) {
result.incremental = false;
let dX;
let dY;
let dZ;
dX = tf1._positionX - tf2._positionX;
dY = tf1._positionY - tf2._positionY;
dZ = tf1._positionZ - tf2._positionZ;
let r1 = geom1._radius;
let r2 = geom2._radius;
let len2 = dX * dX + dY * dY + dZ * dZ;
if(len2 >= (r1 + r2) * (r1 + r2)) {
return;
}
let len = Math.sqrt(len2);
let nX;
let nY;
let nZ;
if(len > 0) {
nX = dX * (1 / len);
nY = dY * (1 / len);
nZ = dZ * (1 / len);
} else {
nX = 1;
nY = 0;
nZ = 0;
}
this.setNormal(result,nX,nY,nZ);
let pos1X;
let pos1Y;
let pos1Z;
let pos2X;
let pos2Y;
let pos2Z;
pos1X = tf1._positionX + nX * -r1;
pos1Y = tf1._positionY + nY * -r1;
pos1Z = tf1._positionZ + nZ * -r1;
pos2X = tf2._positionX + nX * r2;
pos2Y = tf2._positionY + nY * r2;
pos2Z = tf2._positionZ + nZ * r2;
this.addPoint(result,pos1X,pos1Y,pos1Z,pos2X,pos2Y,pos2Z,r1 + r2 - len,0);
}
}
if(!oimo.collision.narrowphase.detector.gjkepa) oimo.collision.narrowphase.detector.gjkepa = {};
oimo.collision.narrowphase.detector.gjkepa.EpaPolyhedron = class oimo_collision_narrowphase_detector_gjkepa_EpaPolyhedron {
constructor() {
this._vertices = new Array(oimo.common.Setting.maxEPAVertices);
this._center = new oimo.common.Vec3();
this._numVertices = 0;
this._triangleList = null;
this._triangleListLast = null;
this._numTriangles = 0;
this._trianglePool = null;
this._vertexPool = null;
}
dumpHoleEdge(first) {
}
validate() {
let t = this._triangleList;
while(t != null) {
t._vertices[0]._tmpEdgeLoopOuterTriangle = null;
t._vertices[0]._tmpEdgeLoopNext = null;
if(t._adjacentPairIndex[0] == -1) {
this._status = 2;
return false;
}
if(t._adjacentTriangles[0] == null) {
this._status = 3;
return false;
}
t._vertices[1]._tmpEdgeLoopOuterTriangle = null;
t._vertices[1]._tmpEdgeLoopNext = null;
if(t._adjacentPairIndex[1] == -1) {
this._status = 2;
return false;
}
if(t._adjacentTriangles[1] == null) {
this._status = 3;
return false;
}
t._vertices[2]._tmpEdgeLoopOuterTriangle = null;
t._vertices[2]._tmpEdgeLoopNext = null;
if(t._adjacentPairIndex[2] == -1) {
this._status = 2;
return false;
}
if(t._adjacentTriangles[2] == null) {
this._status = 3;
return false;
}
t = t._next;
}
return true;
}
findEdgeLoop(id,base,from) {
if(base._tmpDfsId == id) {
return;
}
base._tmpDfsId = id;
let _this = base.tmp;
_this.x = from.x;
_this.y = from.y;
_this.z = from.z;
let v = base._vertices[0].v;
_this.x -= v.x;
_this.y -= v.y;
_this.z -= v.z;
let _this1 = base.tmp;
let v1 = base._normal;
base._tmpDfsVisible = _this1.x * v1.x + _this1.y * v1.y + _this1.z * v1.z > 0;
if(!base._tmpDfsVisible) {
this._status = 6;
return;
}
let _g = 0;
while(_g < 3) {
let i = _g++;
let t = base._adjacentTriangles[i];
if(t == null) {
continue;
}
let _this = t.tmp;
_this.x = from.x;
_this.y = from.y;
_this.z = from.z;
let v = t._vertices[0].v;
_this.x -= v.x;
_this.y -= v.y;
_this.z -= v.z;
let _this1 = t.tmp;
let v1 = t._normal;
t._tmpDfsVisible = _this1.x * v1.x + _this1.y * v1.y + _this1.z * v1.z > 0;
if(t._tmpDfsVisible) {
this.findEdgeLoop(id,t,from);
} else {
let v1 = base._vertices[i];
v1._tmpEdgeLoopNext = base._vertices[base._nextIndex[i]];
v1._tmpEdgeLoopOuterTriangle = t;
}
}
let triangle = base._adjacentTriangles[0];
if(triangle != null) {
let pairIndex = base._adjacentPairIndex[0];
triangle._adjacentTriangles[pairIndex] = null;
triangle._adjacentPairIndex[pairIndex] = -1;
base._adjacentTriangles[0] = null;
base._adjacentPairIndex[0] = -1;
}
let triangle1 = base._adjacentTriangles[1];
if(triangle1 != null) {
let pairIndex = base._adjacentPairIndex[1];
triangle1._adjacentTriangles[pairIndex] = null;
triangle1._adjacentPairIndex[pairIndex] = -1;
base._adjacentTriangles[1] = null;
base._adjacentPairIndex[1] = -1;
}
let triangle2 = base._adjacentTriangles[2];
if(triangle2 != null) {
let pairIndex = base._adjacentPairIndex[2];
triangle2._adjacentTriangles[pairIndex] = null;
triangle2._adjacentPairIndex[pairIndex] = -1;
base._adjacentTriangles[2] = null;
base._adjacentPairIndex[2] = -1;
}
this._numTriangles--;
let prev = base._prev;
let next = base._next;
if(prev != null) {
prev._next = next;
}
if(next != null) {
next._prev = prev;
}
if(base == this._triangleList) {
this._triangleList = this._triangleList._next;
}
if(base == this._triangleListLast) {
this._triangleListLast = this._triangleListLast._prev;
}
base._next = null;
base._prev = null;
base.removeReferences();
base._next = this._trianglePool;
this._trianglePool = base;
}
_init(v1,v2,v3,v4) {
this._status = 0;
this._numVertices = 4;
this._vertices[0] = v1;
this._vertices[1] = v2;
this._vertices[2] = v3;
this._vertices[3] = v4;
let _this = this._center;
let v = v1.v;
_this.x = v.x;
_this.y = v.y;
_this.z = v.z;
let v5 = v2.v;
_this.x += v5.x;
_this.y += v5.y;
_this.z += v5.z;
let v6 = v3.v;
_this.x += v6.x;
_this.y += v6.y;
_this.z += v6.z;
let v7 = v4.v;
_this.x += v7.x;
_this.y += v7.y;
_this.z += v7.z;
_this.x *= 0.25;
_this.y *= 0.25;
_this.z *= 0.25;
let first = this._trianglePool;
if(first != null) {
this._trianglePool = first._next;
first._next = null;
} else {
first = new oimo.collision.narrowphase.detector.gjkepa.EpaTriangle();
}
let t1 = first;
let first1 = this._trianglePool;
if(first1 != null) {
this._trianglePool = first1._next;
first1._next = null;
} else {
first1 = new oimo.collision.narrowphase.detector.gjkepa.EpaTriangle();
}
let t2 = first1;
let first2 = this._trianglePool;
if(first2 != null) {
this._trianglePool = first2._next;
first2._next = null;
} else {
first2 = new oimo.collision.narrowphase.detector.gjkepa.EpaTriangle();
}
let t3 = first2;
let first3 = this._trianglePool;
if(first3 != null) {
this._trianglePool = first3._next;
first3._next = null;
} else {
first3 = new oimo.collision.narrowphase.detector.gjkepa.EpaTriangle();
}
let t4 = first3;
if(!t1.init(v1,v2,v3,this._center,true)) {
this._status = 1;
}
if(!t2.init(v1,v2,v4,this._center,true)) {
this._status = 1;
}
if(!t3.init(v1,v3,v4,this._center,true)) {
this._status = 1;
}
if(!t4.init(v2,v3,v4,this._center,true)) {
this._status = 1;
}
if(!t1.setAdjacentTriangle(t2)) {
this._status = 1;
}
if(!t1.setAdjacentTriangle(t3)) {
this._status = 1;
}
if(!t1.setAdjacentTriangle(t4)) {
this._status = 1;
}
if(!t2.setAdjacentTriangle(t3)) {
this._status = 1;
}
if(!t2.setAdjacentTriangle(t4)) {
this._status = 1;
}
if(!t3.setAdjacentTriangle(t4)) {
this._status = 1;
}
this._numTriangles++;
if(this._triangleList == null) {
this._triangleList = t1;
this._triangleListLast = t1;
} else {
this._triangleListLast._next = t1;
t1._prev = this._triangleListLast;
this._triangleListLast = t1;
}
this._numTriangles++;
if(this._triangleList == null) {
this._triangleList = t2;
this._triangleListLast = t2;
} else {
this._triangleListLast._next = t2;
t2._prev = this._triangleListLast;
this._triangleListLast = t2;
}
this._numTriangles++;
if(this._triangleList == null) {
this._triangleList = t3;
this._triangleListLast = t3;
} else {
this._triangleListLast._next = t3;
t3._prev = this._triangleListLast;
this._triangleListLast = t3;
}
this._numTriangles++;
if(this._triangleList == null) {
this._triangleList = t4;
this._triangleListLast = t4;
} else {
this._triangleListLast._next = t4;
t4._prev = this._triangleListLast;
this._triangleListLast = t4;
}
return this._status == 0;
}
_addVertex(vertex,base) {
this._vertices[this._numVertices++] = vertex;
let v1 = base._vertices[0];
this.findEdgeLoop(this._numVertices,base,vertex.v);
if(this._status != 0) {
return false;
}
let v = v1;
let prevT = null;
let firstT = null;
while(true) {
if(v._tmpEdgeLoopNext == null) {
this._dumpAsObjModel();
this._status = 4;
return false;
}
if(v._tmpEdgeLoopOuterTriangle == null) {
this._status = 5;
return false;
}
let first = this._trianglePool;
if(first != null) {
this._trianglePool = first._next;
first._next = null;
} else {
first = new oimo.collision.narrowphase.detector.gjkepa.EpaTriangle();
}
let t = first;
if(firstT == null) {
firstT = t;
}
if(!t.init(v,v._tmpEdgeLoopNext,vertex,this._center,false)) {
this._status = 1;
}
if(this._status != 0) {
return false;
}
this._numTriangles++;
if(this._triangleList == null) {
this._triangleList = t;
this._triangleListLast = t;
} else {
this._triangleListLast._next = t;
t._prev = this._triangleListLast;
this._triangleListLast = t;
}
if(!t.setAdjacentTriangle(v._tmpEdgeLoopOuterTriangle)) {
this._status = 1;
}
if(prevT != null) {
if(!t.setAdjacentTriangle(prevT)) {
this._status = 1;
}
}
prevT = t;
v = v._tmpEdgeLoopNext;
if(!(v != v1)) {
break;
}
}
if(!prevT.setAdjacentTriangle(firstT)) {
this._status = 1;
}
if(this._status == 0) {
return this.validate();
} else {
return false;
}
}
_dumpAsObjModel() {
}
}
oimo.collision.narrowphase.detector.gjkepa.EpaPolyhedronState = class oimo_collision_narrowphase_detector_gjkepa_EpaPolyhedronState {
}
oimo.collision.narrowphase.detector.gjkepa.EpaTriangle = class oimo_collision_narrowphase_detector_gjkepa_EpaTriangle {
constructor() {
this.id = ++oimo.collision.narrowphase.detector.gjkepa.EpaTriangle.count;
this._next = null;
this._prev = null;
this._normal = new oimo.common.Vec3();
this._distanceSq = 0;
this._tmpDfsId = 0;
this._tmpDfsVisible = false;
this._vertices = new Array(3);
this._adjacentTriangles = new Array(3);
this._adjacentPairIndex = new Array(3);
this.tmp = new oimo.common.Vec3();
this._nextIndex = new Array(3);
this._nextIndex[0] = 1;
this._nextIndex[1] = 2;
this._nextIndex[2] = 0;
}
init(vertex1,vertex2,vertex3,center,autoCheck) {
if(autoCheck == null) {
autoCheck = false;
}
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
let v3X;
let v3Y;
let v3Z;
let vcX;
let vcY;
let vcZ;
let v = vertex1.v;
v1X = v.x;
v1Y = v.y;
v1Z = v.z;
let v1 = vertex2.v;
v2X = v1.x;
v2Y = v1.y;
v2Z = v1.z;
let v2 = vertex3.v;
v3X = v2.x;
v3Y = v2.y;
v3Z = v2.z;
vcX = center.x;
vcY = center.y;
vcZ = center.z;
let v12X;
let v12Y;
let v12Z;
let v13X;
let v13Y;
let v13Z;
let vc1X;
let vc1Y;
let vc1Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
v13X = v3X - v1X;
v13Y = v3Y - v1Y;
v13Z = v3Z - v1Z;
vc1X = v1X - vcX;
vc1Y = v1Y - vcY;
vc1Z = v1Z - vcZ;
let inorX;
let inorY;
let inorZ;
inorX = v12Y * v13Z - v12Z * v13Y;
inorY = v12Z * v13X - v12X * v13Z;
inorZ = v12X * v13Y - v12Y * v13X;
let inverted = false;
if(vc1X * inorX + vc1Y * inorY + vc1Z * inorZ < 0) {
if(autoCheck) {
let tmp = vertex2;
vertex2 = vertex3;
vertex3 = tmp;
inorX *= -1;
inorY *= -1;
inorZ *= -1;
} else {
inverted = true;
}
}
this._vertices[0] = vertex1;
this._vertices[1] = vertex2;
this._vertices[2] = vertex3;
let v3 = this._normal;
v3.x = inorX;
v3.y = inorY;
v3.z = inorZ;
let vec1 = vertex1.v;
let vec2 = vertex2.v;
let vec3 = vertex3.v;
let out = this.tmp;
let v1X1;
let v1Y1;
let v1Z1;
let v2X1;
let v2Y1;
let v2Z1;
let v3X1;
let v3Y1;
let v3Z1;
let v12X1;
let v12Y1;
let v12Z1;
let v23X;
let v23Y;
let v23Z;
let v31X;
let v31Y;
let v31Z;
v1X1 = vec1.x;
v1Y1 = vec1.y;
v1Z1 = vec1.z;
v2X1 = vec2.x;
v2Y1 = vec2.y;
v2Z1 = vec2.z;
v3X1 = vec3.x;
v3Y1 = vec3.y;
v3Z1 = vec3.z;
v12X1 = v2X1 - v1X1;
v12Y1 = v2Y1 - v1Y1;
v12Z1 = v2Z1 - v1Z1;
v23X = v3X1 - v2X1;
v23Y = v3Y1 - v2Y1;
v23Z = v3Z1 - v2Z1;
v31X = v1X1 - v3X1;
v31Y = v1Y1 - v3Y1;
v31Z = v1Z1 - v3Z1;
let nX;
let nY;
let nZ;
nX = v12Y1 * v23Z - v12Z1 * v23Y;
nY = v12Z1 * v23X - v12X1 * v23Z;
nZ = v12X1 * v23Y - v12Y1 * v23X;
let n12X;
let n12Y;
let n12Z;
let n23X;
let n23Y;
let n23Z;
let n31X;
let n31Y;
let n31Z;
n12X = v12Y1 * nZ - v12Z1 * nY;
n12Y = v12Z1 * nX - v12X1 * nZ;
n12Z = v12X1 * nY - v12Y1 * nX;
n23X = v23Y * nZ - v23Z * nY;
n23Y = v23Z * nX - v23X * nZ;
n23Z = v23X * nY - v23Y * nX;
n31X = v31Y * nZ - v31Z * nY;
n31Y = v31Z * nX - v31X * nZ;
n31Z = v31X * nY - v31Y * nX;
let mind = -1;
let minvX;
let minvY;
let minvZ;
minvX = 0;
minvY = 0;
minvZ = 0;
if(v1X1 * n12X + v1Y1 * n12Y + v1Z1 * n12Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec1.x;
v1Y = vec1.y;
v1Z = vec1.z;
v2X = vec2.x;
v2Y = vec2.y;
v2Z = vec2.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
if(t < 0) {
out.x = v1X;
out.y = v1Y;
out.z = v1Z;
} else if(t > 1) {
out.x = v2X;
out.y = v2Y;
out.z = v2Z;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
out.x = pX;
out.y = pY;
out.z = pZ;
}
mind = out.x * out.x + out.y * out.y + out.z * out.z;
minvX = out.x;
minvY = out.y;
minvZ = out.z;
}
if(v2X1 * n23X + v2Y1 * n23Y + v2Z1 * n23Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec2.x;
v1Y = vec2.y;
v1Z = vec2.z;
v2X = vec3.x;
v2Y = vec3.y;
v2Z = vec3.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
if(t < 0) {
out.x = v1X;
out.y = v1Y;
out.z = v1Z;
} else if(t > 1) {
out.x = v2X;
out.y = v2Y;
out.z = v2Z;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
out.x = pX;
out.y = pY;
out.z = pZ;
}
let d = out.x * out.x + out.y * out.y + out.z * out.z;
if(mind < 0 || d < mind) {
mind = d;
minvX = out.x;
minvY = out.y;
minvZ = out.z;
}
}
if(v3X1 * n31X + v3Y1 * n31Y + v3Z1 * n31Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec1.x;
v1Y = vec1.y;
v1Z = vec1.z;
v2X = vec3.x;
v2Y = vec3.y;
v2Z = vec3.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
if(t < 0) {
out.x = v1X;
out.y = v1Y;
out.z = v1Z;
} else if(t > 1) {
out.x = v2X;
out.y = v2Y;
out.z = v2Z;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
out.x = pX;
out.y = pY;
out.z = pZ;
}
let d = out.x * out.x + out.y * out.y + out.z * out.z;
if(mind < 0 || d < mind) {
mind = d;
minvX = out.x;
minvY = out.y;
minvZ = out.z;
}
}
if(mind > 0) {
out.x = minvX;
out.y = minvY;
out.z = minvZ;
} else {
let l = nX * nX + nY * nY + nZ * nZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
nX *= l;
nY *= l;
nZ *= l;
let l2 = nX * nX + nY * nY + nZ * nZ;
l2 = (v1X1 * nX + v1Y1 * nY + v1Z1 * nZ) / l2;
minvX = nX * l2;
minvY = nY * l2;
minvZ = nZ * l2;
out.x = minvX;
out.y = minvY;
out.z = minvZ;
}
let _this = this.tmp;
this._distanceSq = _this.x * _this.x + _this.y * _this.y + _this.z * _this.z;
this._adjacentTriangles[0] = null;
this._adjacentTriangles[1] = null;
this._adjacentTriangles[2] = null;
this._adjacentPairIndex[0] = -1;
this._adjacentPairIndex[1] = -1;
this._adjacentPairIndex[2] = -1;
return !inverted;
}
setAdjacentTriangle(triangle) {
let count = 0;
if(this._vertices[0] == triangle._vertices[this._nextIndex[0]] && this._vertices[this._nextIndex[0]] == triangle._vertices[0]) {
this._adjacentTriangles[0] = triangle;
this._adjacentPairIndex[0] = 0;
triangle._adjacentTriangles[0] = this;
triangle._adjacentPairIndex[0] = 0;
count = 1;
}
if(this._vertices[0] == triangle._vertices[this._nextIndex[1]] && this._vertices[this._nextIndex[0]] == triangle._vertices[1]) {
this._adjacentTriangles[0] = triangle;
this._adjacentPairIndex[0] = 1;
triangle._adjacentTriangles[1] = this;
triangle._adjacentPairIndex[1] = 0;
++count;
}
if(this._vertices[0] == triangle._vertices[this._nextIndex[2]] && this._vertices[this._nextIndex[0]] == triangle._vertices[2]) {
this._adjacentTriangles[0] = triangle;
this._adjacentPairIndex[0] = 2;
triangle._adjacentTriangles[2] = this;
triangle._adjacentPairIndex[2] = 0;
++count;
}
if(this._vertices[1] == triangle._vertices[this._nextIndex[0]] && this._vertices[this._nextIndex[1]] == triangle._vertices[0]) {
this._adjacentTriangles[1] = triangle;
this._adjacentPairIndex[1] = 0;
triangle._adjacentTriangles[0] = this;
triangle._adjacentPairIndex[0] = 1;
++count;
}
if(this._vertices[1] == triangle._vertices[this._nextIndex[1]] && this._vertices[this._nextIndex[1]] == triangle._vertices[1]) {
this._adjacentTriangles[1] = triangle;
this._adjacentPairIndex[1] = 1;
triangle._adjacentTriangles[1] = this;
triangle._adjacentPairIndex[1] = 1;
++count;
}
if(this._vertices[1] == triangle._vertices[this._nextIndex[2]] && this._vertices[this._nextIndex[1]] == triangle._vertices[2]) {
this._adjacentTriangles[1] = triangle;
this._adjacentPairIndex[1] = 2;
triangle._adjacentTriangles[2] = this;
triangle._adjacentPairIndex[2] = 1;
++count;
}
if(this._vertices[2] == triangle._vertices[this._nextIndex[0]] && this._vertices[this._nextIndex[2]] == triangle._vertices[0]) {
this._adjacentTriangles[2] = triangle;
this._adjacentPairIndex[2] = 0;
triangle._adjacentTriangles[0] = this;
triangle._adjacentPairIndex[0] = 2;
++count;
}
if(this._vertices[2] == triangle._vertices[this._nextIndex[1]] && this._vertices[this._nextIndex[2]] == triangle._vertices[1]) {
this._adjacentTriangles[2] = triangle;
this._adjacentPairIndex[2] = 1;
triangle._adjacentTriangles[1] = this;
triangle._adjacentPairIndex[1] = 2;
++count;
}
if(this._vertices[2] == triangle._vertices[this._nextIndex[2]] && this._vertices[this._nextIndex[2]] == triangle._vertices[2]) {
this._adjacentTriangles[2] = triangle;
this._adjacentPairIndex[2] = 2;
triangle._adjacentTriangles[2] = this;
triangle._adjacentPairIndex[2] = 2;
++count;
}
if(count != 1) {
return false;
}
return true;
}
removeAdjacentTriangles() {
let triangle = this._adjacentTriangles[0];
if(triangle != null) {
let pairIndex = this._adjacentPairIndex[0];
triangle._adjacentTriangles[pairIndex] = null;
triangle._adjacentPairIndex[pairIndex] = -1;
this._adjacentTriangles[0] = null;
this._adjacentPairIndex[0] = -1;
}
let triangle1 = this._adjacentTriangles[1];
if(triangle1 != null) {
let pairIndex = this._adjacentPairIndex[1];
triangle1._adjacentTriangles[pairIndex] = null;
triangle1._adjacentPairIndex[pairIndex] = -1;
this._adjacentTriangles[1] = null;
this._adjacentPairIndex[1] = -1;
}
let triangle2 = this._adjacentTriangles[2];
if(triangle2 != null) {
let pairIndex = this._adjacentPairIndex[2];
triangle2._adjacentTriangles[pairIndex] = null;
triangle2._adjacentPairIndex[pairIndex] = -1;
this._adjacentTriangles[2] = null;
this._adjacentPairIndex[2] = -1;
}
}
removeReferences() {
this._next = null;
this._prev = null;
this._tmpDfsId = 0;
this._tmpDfsVisible = false;
this._distanceSq = 0;
this._vertices[0] = null;
this._vertices[1] = null;
this._vertices[2] = null;
this._adjacentTriangles[0] = null;
this._adjacentTriangles[1] = null;
this._adjacentTriangles[2] = null;
this._adjacentPairIndex[0] = 0;
this._adjacentPairIndex[1] = 0;
this._adjacentPairIndex[2] = 0;
}
dump() {
}
}
oimo.collision.narrowphase.detector.gjkepa.EpaVertex = class oimo_collision_narrowphase_detector_gjkepa_EpaVertex {
constructor() {
this.randId = Math.random() * 100000 | 0;
this.v = new oimo.common.Vec3();
this.w1 = new oimo.common.Vec3();
this.w2 = new oimo.common.Vec3();
}
init(v,w1,w2) {
let _this = this.v;
_this.x = v.x;
_this.y = v.y;
_this.z = v.z;
let _this1 = this.w1;
_this1.x = w1.x;
_this1.y = w1.y;
_this1.z = w1.z;
let _this2 = this.w2;
_this2.x = w2.x;
_this2.y = w2.y;
_this2.z = w2.z;
this._next = null;
this._tmpEdgeLoopNext = null;
this._tmpEdgeLoopOuterTriangle = null;
return this;
}
removeReferences() {
this._next = null;
this._tmpEdgeLoopNext = null;
this._tmpEdgeLoopOuterTriangle = null;
}
}
oimo.collision.narrowphase.detector.gjkepa.GjkCache = class oimo_collision_narrowphase_detector_gjkepa_GjkCache {
constructor() {
this.prevClosestDir = new oimo.common.Vec3();
}
clear() {
this.prevClosestDir.zero();
}
}
if(!oimo.common) oimo.common = {};
oimo.common.Vec3 = class oimo_common_Vec3 {
constructor(x,y,z) {
if(z == null) {
z = 0;
}
if(y == null) {
y = 0;
}
if(x == null) {
x = 0;
}
this.x = x;
this.y = y;
this.z = z;
oimo.common.Vec3.numCreations++;
}
init(x,y,z) {
this.x = x;
this.y = y;
this.z = z;
return this;
}
zero() {
this.x = 0;
this.y = 0;
this.z = 0;
return this;
}
add(v) {
return new oimo.common.Vec3(this.x + v.x,this.y + v.y,this.z + v.z);
}
add3(vx,vy,vz) {
return new oimo.common.Vec3(this.x + vx,this.y + vy,this.z + vz);
}
addScaled(v,s) {
return new oimo.common.Vec3(this.x + v.x * s,this.y + v.y * s,this.z + v.z * s);
}
sub(v) {
return new oimo.common.Vec3(this.x - v.x,this.y - v.y,this.z - v.z);
}
sub3(vx,vy,vz) {
return new oimo.common.Vec3(this.x - vx,this.y - vy,this.z - vz);
}
scale(s) {
return new oimo.common.Vec3(this.x * s,this.y * s,this.z * s);
}
scale3(sx,sy,sz) {
return new oimo.common.Vec3(this.x * sx,this.y * sy,this.z * sz);
}
dot(v) {
return this.x * v.x + this.y * v.y + this.z * v.z;
}
cross(v) {
return new oimo.common.Vec3(this.y * v.z - this.z * v.y,this.z * v.x - this.x * v.z,this.x * v.y - this.y * v.x);
}
addEq(v) {
this.x += v.x;
this.y += v.y;
this.z += v.z;
return this;
}
add3Eq(vx,vy,vz) {
this.x += vx;
this.y += vy;
this.z += vz;
return this;
}
addScaledEq(v,s) {
this.x += v.x * s;
this.y += v.y * s;
this.z += v.z * s;
return this;
}
subEq(v) {
this.x -= v.x;
this.y -= v.y;
this.z -= v.z;
return this;
}
sub3Eq(vx,vy,vz) {
this.x -= vx;
this.y -= vy;
this.z -= vz;
return this;
}
scaleEq(s) {
this.x *= s;
this.y *= s;
this.z *= s;
return this;
}
scale3Eq(sx,sy,sz) {
this.x *= sx;
this.y *= sy;
this.z *= sz;
return this;
}
crossEq(v) {
let y = this.z * v.x - this.x * v.z;
let z = this.x * v.y - this.y * v.x;
this.x = this.y * v.z - this.z * v.y;
this.y = y;
this.z = z;
return this;
}
mulMat3(m) {
return new oimo.common.Vec3(this.x * m.e00 + this.y * m.e01 + this.z * m.e02,this.x * m.e10 + this.y * m.e11 + this.z * m.e12,this.x * m.e20 + this.y * m.e21 + this.z * m.e22);
}
mulMat4(m) {
return new oimo.common.Vec3(this.x * m.e00 + this.y * m.e01 + this.z * m.e02 + m.e03,this.x * m.e10 + this.y * m.e11 + this.z * m.e12 + m.e13,this.x * m.e20 + this.y * m.e21 + this.z * m.e22 + m.e23);
}
mulTransform(tf) {
let vX;
let vY;
let vZ;
vX = this.x;
vY = this.y;
vZ = this.z;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = tf._rotation00 * vX + tf._rotation01 * vY + tf._rotation02 * vZ;
__tmp__Y = tf._rotation10 * vX + tf._rotation11 * vY + tf._rotation12 * vZ;
__tmp__Z = tf._rotation20 * vX + tf._rotation21 * vY + tf._rotation22 * vZ;
vX = __tmp__X;
vY = __tmp__Y;
vZ = __tmp__Z;
vX += tf._positionX;
vY += tf._positionY;
vZ += tf._positionZ;
let res = new oimo.common.Vec3();
res.x = vX;
res.y = vY;
res.z = vZ;
return res;
}
mulMat3Eq(m) {
let y = this.x * m.e10 + this.y * m.e11 + this.z * m.e12;
let z = this.x * m.e20 + this.y * m.e21 + this.z * m.e22;
this.x = this.x * m.e00 + this.y * m.e01 + this.z * m.e02;
this.y = y;
this.z = z;
return this;
}
mulMat4Eq(m) {
let y = this.x * m.e10 + this.y * m.e11 + this.z * m.e12 + m.e13;
let z = this.x * m.e20 + this.y * m.e21 + this.z * m.e22 + m.e23;
this.x = this.x * m.e00 + this.y * m.e01 + this.z * m.e02 + m.e03;
this.y = y;
this.z = z;
return this;
}
mulTransformEq(tf) {
let vX;
let vY;
let vZ;
vX = this.x;
vY = this.y;
vZ = this.z;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = tf._rotation00 * vX + tf._rotation01 * vY + tf._rotation02 * vZ;
__tmp__Y = tf._rotation10 * vX + tf._rotation11 * vY + tf._rotation12 * vZ;
__tmp__Z = tf._rotation20 * vX + tf._rotation21 * vY + tf._rotation22 * vZ;
vX = __tmp__X;
vY = __tmp__Y;
vZ = __tmp__Z;
vX += tf._positionX;
vY += tf._positionY;
vZ += tf._positionZ;
this.x = vX;
this.y = vY;
this.z = vZ;
return this;
}
length() {
return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
}
lengthSq() {
return this.x * this.x + this.y * this.y + this.z * this.z;
}
normalized() {
let invLen = Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
if(invLen > 0) {
invLen = 1 / invLen;
}
return new oimo.common.Vec3(this.x * invLen,this.y * invLen,this.z * invLen);
}
normalize() {
let invLen = Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
if(invLen > 0) {
invLen = 1 / invLen;
}
this.x *= invLen;
this.y *= invLen;
this.z *= invLen;
return this;
}
negate() {
return new oimo.common.Vec3(-this.x,-this.y,-this.z);
}
negateEq() {
this.x = -this.x;
this.y = -this.y;
this.z = -this.z;
return this;
}
copyFrom(v) {
this.x = v.x;
this.y = v.y;
this.z = v.z;
return this;
}
clone() {
return new oimo.common.Vec3(this.x,this.y,this.z);
}
toString() {
return "Vec3[" + (this.x > 0 ? (this.x * 10000000 + 0.5 | 0) / 10000000 : (this.x * 10000000 - 0.5 | 0) / 10000000) + ", " + (this.y > 0 ? (this.y * 10000000 + 0.5 | 0) / 10000000 : (this.y * 10000000 - 0.5 | 0) / 10000000) + ", " + (this.z > 0 ? (this.z * 10000000 + 0.5 | 0) / 10000000 : (this.z * 10000000 - 0.5 | 0) / 10000000) + "]";
}
}
oimo.common.Transform = class oimo_common_Transform {
constructor() {
this._positionX = 0;
this._positionY = 0;
this._positionZ = 0;
this._rotation00 = 1;
this._rotation01 = 0;
this._rotation02 = 0;
this._rotation10 = 0;
this._rotation11 = 1;
this._rotation12 = 0;
this._rotation20 = 0;
this._rotation21 = 0;
this._rotation22 = 1;
}
identity() {
this._positionX = 0;
this._positionY = 0;
this._positionZ = 0;
this._rotation00 = 1;
this._rotation01 = 0;
this._rotation02 = 0;
this._rotation10 = 0;
this._rotation11 = 1;
this._rotation12 = 0;
this._rotation20 = 0;
this._rotation21 = 0;
this._rotation22 = 1;
return this;
}
getPosition() {
let position = new oimo.common.Vec3();
position.x = this._positionX;
position.y = this._positionY;
position.z = this._positionZ;
return position;
}
getPositionTo(position) {
position.x = this._positionX;
position.y = this._positionY;
position.z = this._positionZ;
}
setPosition(position) {
this._positionX = position.x;
this._positionY = position.y;
this._positionZ = position.z;
return this;
}
translate(translation) {
let diffX;
let diffY;
let diffZ;
diffX = translation.x;
diffY = translation.y;
diffZ = translation.z;
this._positionX += diffX;
this._positionY += diffY;
this._positionZ += diffZ;
}
getRotation() {
let rotation = new oimo.common.Mat3();
rotation.e00 = this._rotation00;
rotation.e01 = this._rotation01;
rotation.e02 = this._rotation02;
rotation.e10 = this._rotation10;
rotation.e11 = this._rotation11;
rotation.e12 = this._rotation12;
rotation.e20 = this._rotation20;
rotation.e21 = this._rotation21;
rotation.e22 = this._rotation22;
return rotation;
}
getRotationTo(out) {
out.e00 = this._rotation00;
out.e01 = this._rotation01;
out.e02 = this._rotation02;
out.e10 = this._rotation10;
out.e11 = this._rotation11;
out.e12 = this._rotation12;
out.e20 = this._rotation20;
out.e21 = this._rotation21;
out.e22 = this._rotation22;
}
setRotation(rotation) {
this._rotation00 = rotation.e00;
this._rotation01 = rotation.e01;
this._rotation02 = rotation.e02;
this._rotation10 = rotation.e10;
this._rotation11 = rotation.e11;
this._rotation12 = rotation.e12;
this._rotation20 = rotation.e20;
this._rotation21 = rotation.e21;
this._rotation22 = rotation.e22;
return this;
}
setRotationXyz(eulerAngles) {
let xyzX;
let xyzY;
let xyzZ;
xyzX = eulerAngles.x;
xyzY = eulerAngles.y;
xyzZ = eulerAngles.z;
let sx = Math.sin(xyzX);
let sy = Math.sin(xyzY);
let sz = Math.sin(xyzZ);
let cx = Math.cos(xyzX);
let cy = Math.cos(xyzY);
let cz = Math.cos(xyzZ);
this._rotation00 = cy * cz;
this._rotation01 = -cy * sz;
this._rotation02 = sy;
this._rotation10 = cx * sz + cz * sx * sy;
this._rotation11 = cx * cz - sx * sy * sz;
this._rotation12 = -cy * sx;
this._rotation20 = sx * sz - cx * cz * sy;
this._rotation21 = cz * sx + cx * sy * sz;
this._rotation22 = cx * cy;
}
rotate(rotation) {
let rot00;
let rot01;
let rot02;
let rot10;
let rot11;
let rot12;
let rot20;
let rot21;
let rot22;
rot00 = rotation.e00;
rot01 = rotation.e01;
rot02 = rotation.e02;
rot10 = rotation.e10;
rot11 = rotation.e11;
rot12 = rotation.e12;
rot20 = rotation.e20;
rot21 = rotation.e21;
rot22 = rotation.e22;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = rot00 * this._rotation00 + rot01 * this._rotation10 + rot02 * this._rotation20;
__tmp__01 = rot00 * this._rotation01 + rot01 * this._rotation11 + rot02 * this._rotation21;
__tmp__02 = rot00 * this._rotation02 + rot01 * this._rotation12 + rot02 * this._rotation22;
__tmp__10 = rot10 * this._rotation00 + rot11 * this._rotation10 + rot12 * this._rotation20;
__tmp__11 = rot10 * this._rotation01 + rot11 * this._rotation11 + rot12 * this._rotation21;
__tmp__12 = rot10 * this._rotation02 + rot11 * this._rotation12 + rot12 * this._rotation22;
__tmp__20 = rot20 * this._rotation00 + rot21 * this._rotation10 + rot22 * this._rotation20;
__tmp__21 = rot20 * this._rotation01 + rot21 * this._rotation11 + rot22 * this._rotation21;
__tmp__22 = rot20 * this._rotation02 + rot21 * this._rotation12 + rot22 * this._rotation22;
this._rotation00 = __tmp__00;
this._rotation01 = __tmp__01;
this._rotation02 = __tmp__02;
this._rotation10 = __tmp__10;
this._rotation11 = __tmp__11;
this._rotation12 = __tmp__12;
this._rotation20 = __tmp__20;
this._rotation21 = __tmp__21;
this._rotation22 = __tmp__22;
}
rotateXyz(eulerAngles) {
let xyzX;
let xyzY;
let xyzZ;
let rot00;
let rot01;
let rot02;
let rot10;
let rot11;
let rot12;
let rot20;
let rot21;
let rot22;
xyzX = eulerAngles.x;
xyzY = eulerAngles.y;
xyzZ = eulerAngles.z;
let sx = Math.sin(xyzX);
let sy = Math.sin(xyzY);
let sz = Math.sin(xyzZ);
let cx = Math.cos(xyzX);
let cy = Math.cos(xyzY);
let cz = Math.cos(xyzZ);
rot00 = cy * cz;
rot01 = -cy * sz;
rot02 = sy;
rot10 = cx * sz + cz * sx * sy;
rot11 = cx * cz - sx * sy * sz;
rot12 = -cy * sx;
rot20 = sx * sz - cx * cz * sy;
rot21 = cz * sx + cx * sy * sz;
rot22 = cx * cy;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = rot00 * this._rotation00 + rot01 * this._rotation10 + rot02 * this._rotation20;
__tmp__01 = rot00 * this._rotation01 + rot01 * this._rotation11 + rot02 * this._rotation21;
__tmp__02 = rot00 * this._rotation02 + rot01 * this._rotation12 + rot02 * this._rotation22;
__tmp__10 = rot10 * this._rotation00 + rot11 * this._rotation10 + rot12 * this._rotation20;
__tmp__11 = rot10 * this._rotation01 + rot11 * this._rotation11 + rot12 * this._rotation21;
__tmp__12 = rot10 * this._rotation02 + rot11 * this._rotation12 + rot12 * this._rotation22;
__tmp__20 = rot20 * this._rotation00 + rot21 * this._rotation10 + rot22 * this._rotation20;
__tmp__21 = rot20 * this._rotation01 + rot21 * this._rotation11 + rot22 * this._rotation21;
__tmp__22 = rot20 * this._rotation02 + rot21 * this._rotation12 + rot22 * this._rotation22;
this._rotation00 = __tmp__00;
this._rotation01 = __tmp__01;
this._rotation02 = __tmp__02;
this._rotation10 = __tmp__10;
this._rotation11 = __tmp__11;
this._rotation12 = __tmp__12;
this._rotation20 = __tmp__20;
this._rotation21 = __tmp__21;
this._rotation22 = __tmp__22;
}
getOrientation() {
let q = new oimo.common.Quat();
let iqX;
let iqY;
let iqZ;
let iqW;
let e00 = this._rotation00;
let e11 = this._rotation11;
let e22 = this._rotation22;
let t = e00 + e11 + e22;
let s;
if(t > 0) {
s = Math.sqrt(t + 1);
iqW = 0.5 * s;
s = 0.5 / s;
iqX = (this._rotation21 - this._rotation12) * s;
iqY = (this._rotation02 - this._rotation20) * s;
iqZ = (this._rotation10 - this._rotation01) * s;
} else if(e00 > e11) {
if(e00 > e22) {
s = Math.sqrt(e00 - e11 - e22 + 1);
iqX = 0.5 * s;
s = 0.5 / s;
iqY = (this._rotation01 + this._rotation10) * s;
iqZ = (this._rotation02 + this._rotation20) * s;
iqW = (this._rotation21 - this._rotation12) * s;
} else {
s = Math.sqrt(e22 - e00 - e11 + 1);
iqZ = 0.5 * s;
s = 0.5 / s;
iqX = (this._rotation02 + this._rotation20) * s;
iqY = (this._rotation12 + this._rotation21) * s;
iqW = (this._rotation10 - this._rotation01) * s;
}
} else if(e11 > e22) {
s = Math.sqrt(e11 - e22 - e00 + 1);
iqY = 0.5 * s;
s = 0.5 / s;
iqX = (this._rotation01 + this._rotation10) * s;
iqZ = (this._rotation12 + this._rotation21) * s;
iqW = (this._rotation02 - this._rotation20) * s;
} else {
s = Math.sqrt(e22 - e00 - e11 + 1);
iqZ = 0.5 * s;
s = 0.5 / s;
iqX = (this._rotation02 + this._rotation20) * s;
iqY = (this._rotation12 + this._rotation21) * s;
iqW = (this._rotation10 - this._rotation01) * s;
}
q.x = iqX;
q.y = iqY;
q.z = iqZ;
q.w = iqW;
return q;
}
getOrientationTo(orientation) {
let iqX;
let iqY;
let iqZ;
let iqW;
let e00 = this._rotation00;
let e11 = this._rotation11;
let e22 = this._rotation22;
let t = e00 + e11 + e22;
let s;
if(t > 0) {
s = Math.sqrt(t + 1);
iqW = 0.5 * s;
s = 0.5 / s;
iqX = (this._rotation21 - this._rotation12) * s;
iqY = (this._rotation02 - this._rotation20) * s;
iqZ = (this._rotation10 - this._rotation01) * s;
} else if(e00 > e11) {
if(e00 > e22) {
s = Math.sqrt(e00 - e11 - e22 + 1);
iqX = 0.5 * s;
s = 0.5 / s;
iqY = (this._rotation01 + this._rotation10) * s;
iqZ = (this._rotation02 + this._rotation20) * s;
iqW = (this._rotation21 - this._rotation12) * s;
} else {
s = Math.sqrt(e22 - e00 - e11 + 1);
iqZ = 0.5 * s;
s = 0.5 / s;
iqX = (this._rotation02 + this._rotation20) * s;
iqY = (this._rotation12 + this._rotation21) * s;
iqW = (this._rotation10 - this._rotation01) * s;
}
} else if(e11 > e22) {
s = Math.sqrt(e11 - e22 - e00 + 1);
iqY = 0.5 * s;
s = 0.5 / s;
iqX = (this._rotation01 + this._rotation10) * s;
iqZ = (this._rotation12 + this._rotation21) * s;
iqW = (this._rotation02 - this._rotation20) * s;
} else {
s = Math.sqrt(e22 - e00 - e11 + 1);
iqZ = 0.5 * s;
s = 0.5 / s;
iqX = (this._rotation02 + this._rotation20) * s;
iqY = (this._rotation12 + this._rotation21) * s;
iqW = (this._rotation10 - this._rotation01) * s;
}
orientation.x = iqX;
orientation.y = iqY;
orientation.z = iqZ;
orientation.w = iqW;
}
setOrientation(quaternion) {
let qX;
let qY;
let qZ;
let qW;
qX = quaternion.x;
qY = quaternion.y;
qZ = quaternion.z;
qW = quaternion.w;
let x = qX;
let y = qY;
let z = qZ;
let w = qW;
let x2 = 2 * x;
let y2 = 2 * y;
let z2 = 2 * z;
let xx = x * x2;
let yy = y * y2;
let zz = z * z2;
let xy = x * y2;
let yz = y * z2;
let xz = x * z2;
let wx = w * x2;
let wy = w * y2;
let wz = w * z2;
this._rotation00 = 1 - yy - zz;
this._rotation01 = xy - wz;
this._rotation02 = xz + wy;
this._rotation10 = xy + wz;
this._rotation11 = 1 - xx - zz;
this._rotation12 = yz - wx;
this._rotation20 = xz - wy;
this._rotation21 = yz + wx;
this._rotation22 = 1 - xx - yy;
return this;
}
clone() {
let tf = new oimo.common.Transform();
tf._positionX = this._positionX;
tf._positionY = this._positionY;
tf._positionZ = this._positionZ;
tf._rotation00 = this._rotation00;
tf._rotation01 = this._rotation01;
tf._rotation02 = this._rotation02;
tf._rotation10 = this._rotation10;
tf._rotation11 = this._rotation11;
tf._rotation12 = this._rotation12;
tf._rotation20 = this._rotation20;
tf._rotation21 = this._rotation21;
tf._rotation22 = this._rotation22;
return tf;
}
copyFrom(transform) {
this._positionX = transform._positionX;
this._positionY = transform._positionY;
this._positionZ = transform._positionZ;
this._rotation00 = transform._rotation00;
this._rotation01 = transform._rotation01;
this._rotation02 = transform._rotation02;
this._rotation10 = transform._rotation10;
this._rotation11 = transform._rotation11;
this._rotation12 = transform._rotation12;
this._rotation20 = transform._rotation20;
this._rotation21 = transform._rotation21;
this._rotation22 = transform._rotation22;
return this;
}
}
oimo.common.Setting = class oimo_common_Setting {
}
oimo.collision.narrowphase.detector.gjkepa.GjkEpa = class oimo_collision_narrowphase_detector_gjkepa_GjkEpa {
constructor() {
this.s = new Array(4);
this.w1 = new Array(4);
this.w2 = new Array(4);
this.baseDirs = new Array(3);
this.baseDirs[0] = new oimo.common.Vec3(1,0,0);
this.baseDirs[1] = new oimo.common.Vec3(0,1,0);
this.baseDirs[2] = new oimo.common.Vec3(0,0,1);
this.tl1 = new oimo.common.Vec3();
this.tl2 = new oimo.common.Vec3();
this.rayX = new oimo.common.Vec3();
this.rayR = new oimo.common.Vec3();
this.tempTransform = new oimo.common.Transform();
this.s[0] = new oimo.common.Vec3();
this.w1[0] = new oimo.common.Vec3();
this.w2[0] = new oimo.common.Vec3();
this.s[1] = new oimo.common.Vec3();
this.w1[1] = new oimo.common.Vec3();
this.w2[1] = new oimo.common.Vec3();
this.s[2] = new oimo.common.Vec3();
this.w1[2] = new oimo.common.Vec3();
this.w2[2] = new oimo.common.Vec3();
this.s[3] = new oimo.common.Vec3();
this.w1[3] = new oimo.common.Vec3();
this.w2[3] = new oimo.common.Vec3();
this.dir = new oimo.common.Vec3();
this.closest = new oimo.common.Vec3();
this.closestPoint1 = new oimo.common.Vec3();
this.closestPoint2 = new oimo.common.Vec3();
this.polyhedron = new oimo.collision.narrowphase.detector.gjkepa.EpaPolyhedron();
}
computeClosestPointsImpl(c1,c2,tf1,tf2,cache,useEpa) {
this.c1 = c1;
this.c2 = c2;
this.tf1 = tf1;
this.tf2 = tf2;
let s = this.s;
let w1 = this.w1;
let w2 = this.w2;
let closest = this.closest;
let dir = this.dir;
if(cache != null) {
if(cache._gjkCache == null) {
cache._gjkCache = new oimo.collision.narrowphase.detector.gjkepa.GjkCache();
}
this.loadCache(cache._gjkCache);
} else {
dir.zero();
}
if(dir.x * dir.x + dir.y * dir.y + dir.z * dir.z == 0) {
let firstDirX;
let firstDirY;
let firstDirZ;
firstDirX = tf2._positionX - tf1._positionX;
firstDirY = tf2._positionY - tf1._positionY;
firstDirZ = tf2._positionZ - tf1._positionZ;
dir.x = firstDirX;
dir.y = firstDirY;
dir.z = firstDirZ;
if(dir.x * dir.x + dir.y * dir.y + dir.z * dir.z < 1e-6) {
dir.init(1,0,0);
}
}
this.simplexSize = 0;
this.computeWitnessPoint1(false);
this.computeWitnessPoint2(false);
let _this = this.s[this.simplexSize];
let v = this.w1[this.simplexSize];
_this.x = v.x;
_this.y = v.y;
_this.z = v.z;
let v1 = this.w2[this.simplexSize];
_this.x -= v1.x;
_this.y -= v1.y;
_this.z -= v1.z;
this.simplexSize = 1;
let count = 0;
while(count < 40) {
let v = 0;
switch(this.simplexSize) {
case 1:
let v1 = s[0];
closest.x = v1.x;
closest.y = v1.y;
closest.z = v1.z;
v = 1;
break;
case 2:
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
let v2 = s[0];
v1X = v2.x;
v1Y = v2.y;
v1Z = v2.z;
let v3 = s[1];
v2X = v3.x;
v2Y = v3.y;
v2Z = v3.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
v = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
v = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
v = 3;
}
break;
case 3:
let vec1 = s[0];
let vec2 = s[1];
let vec3 = s[2];
let v1X1;
let v1Y1;
let v1Z1;
let v2X1;
let v2Y1;
let v2Z1;
let v3X;
let v3Y;
let v3Z;
let v12X1;
let v12Y1;
let v12Z1;
let v23X;
let v23Y;
let v23Z;
let v31X;
let v31Y;
let v31Z;
v1X1 = vec1.x;
v1Y1 = vec1.y;
v1Z1 = vec1.z;
v2X1 = vec2.x;
v2Y1 = vec2.y;
v2Z1 = vec2.z;
v3X = vec3.x;
v3Y = vec3.y;
v3Z = vec3.z;
v12X1 = v2X1 - v1X1;
v12Y1 = v2Y1 - v1Y1;
v12Z1 = v2Z1 - v1Z1;
v23X = v3X - v2X1;
v23Y = v3Y - v2Y1;
v23Z = v3Z - v2Z1;
v31X = v1X1 - v3X;
v31Y = v1Y1 - v3Y;
v31Z = v1Z1 - v3Z;
let nX;
let nY;
let nZ;
nX = v12Y1 * v23Z - v12Z1 * v23Y;
nY = v12Z1 * v23X - v12X1 * v23Z;
nZ = v12X1 * v23Y - v12Y1 * v23X;
let n12X;
let n12Y;
let n12Z;
let n23X;
let n23Y;
let n23Z;
let n31X;
let n31Y;
let n31Z;
n12X = v12Y1 * nZ - v12Z1 * nY;
n12Y = v12Z1 * nX - v12X1 * nZ;
n12Z = v12X1 * nY - v12Y1 * nX;
n23X = v23Y * nZ - v23Z * nY;
n23Y = v23Z * nX - v23X * nZ;
n23Z = v23X * nY - v23Y * nX;
n31X = v31Y * nZ - v31Z * nY;
n31Y = v31Z * nX - v31X * nZ;
n31Z = v31X * nY - v31Y * nX;
let mind = -1;
let minvX;
let minvY;
let minvZ;
let mini = 0;
minvX = 0;
minvY = 0;
minvZ = 0;
if(v1X1 * n12X + v1Y1 * n12Y + v1Z1 * n12Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec1.x;
v1Y = vec1.y;
v1Z = vec1.z;
v2X = vec2.x;
v2Y = vec2.y;
v2Z = vec2.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
mini = b;
mind = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
if(v2X1 * n23X + v2Y1 * n23Y + v2Z1 * n23Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec2.x;
v1Y = vec2.y;
v1Z = vec2.z;
v2X = vec3.x;
v2Y = vec3.y;
v2Z = vec3.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
let d = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
if(mind < 0 || d < mind) {
mini = b << 1;
mind = d;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
}
if(v3X * n31X + v3Y * n31Y + v3Z * n31Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec1.x;
v1Y = vec1.y;
v1Z = vec1.z;
v2X = vec3.x;
v2Y = vec3.y;
v2Z = vec3.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
let d = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
if(mind < 0 || d < mind) {
mini = b & 1 | (b & 2) << 1;
mind = d;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
}
if(mind > 0) {
closest.x = minvX;
closest.y = minvY;
closest.z = minvZ;
v = mini;
} else {
let l = nX * nX + nY * nY + nZ * nZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
nX *= l;
nY *= l;
nZ *= l;
let l2 = nX * nX + nY * nY + nZ * nZ;
l2 = (v1X1 * nX + v1Y1 * nY + v1Z1 * nZ) / l2;
minvX = nX * l2;
minvY = nY * l2;
minvZ = nZ * l2;
closest.x = minvX;
closest.y = minvY;
closest.z = minvZ;
v = 7;
}
break;
case 4:
let vec11 = s[0];
let vec21 = s[1];
let vec31 = s[2];
let vec4 = s[3];
let v1X2;
let v1Y2;
let v1Z2;
let v2X2;
let v2Y2;
let v2Z2;
let v3X1;
let v3Y1;
let v3Z1;
let v4X;
let v4Y;
let v4Z;
let v12X2;
let v12Y2;
let v12Z2;
let v13X;
let v13Y;
let v13Z;
let v14X;
let v14Y;
let v14Z;
let v23X1;
let v23Y1;
let v23Z1;
let v24X;
let v24Y;
let v24Z;
v1X2 = vec11.x;
v1Y2 = vec11.y;
v1Z2 = vec11.z;
v2X2 = vec21.x;
v2Y2 = vec21.y;
v2Z2 = vec21.z;
v3X1 = vec31.x;
v3Y1 = vec31.y;
v3Z1 = vec31.z;
v4X = vec4.x;
v4Y = vec4.y;
v4Z = vec4.z;
v12X2 = v2X2 - v1X2;
v12Y2 = v2Y2 - v1Y2;
v12Z2 = v2Z2 - v1Z2;
v13X = v3X1 - v1X2;
v13Y = v3Y1 - v1Y2;
v13Z = v3Z1 - v1Z2;
v14X = v4X - v1X2;
v14Y = v4Y - v1Y2;
v14Z = v4Z - v1Z2;
v23X1 = v3X1 - v2X2;
v23Y1 = v3Y1 - v2Y2;
v23Z1 = v3Z1 - v2Z2;
v24X = v4X - v2X2;
v24Y = v4Y - v2Y2;
v24Z = v4Z - v2Z2;
let n123X;
let n123Y;
let n123Z;
let n134X;
let n134Y;
let n134Z;
let n142X;
let n142Y;
let n142Z;
let n243X;
let n243Y;
let n243Z;
n123X = v12Y2 * v13Z - v12Z2 * v13Y;
n123Y = v12Z2 * v13X - v12X2 * v13Z;
n123Z = v12X2 * v13Y - v12Y2 * v13X;
n134X = v13Y * v14Z - v13Z * v14Y;
n134Y = v13Z * v14X - v13X * v14Z;
n134Z = v13X * v14Y - v13Y * v14X;
n142X = v14Y * v12Z2 - v14Z * v12Y2;
n142Y = v14Z * v12X2 - v14X * v12Z2;
n142Z = v14X * v12Y2 - v14Y * v12X2;
n243X = v24Y * v23Z1 - v24Z * v23Y1;
n243Y = v24Z * v23X1 - v24X * v23Z1;
n243Z = v24X * v23Y1 - v24Y * v23X1;
let sign = v12X2 * n243X + v12Y2 * n243Y + v12Z2 * n243Z > 0 ? 1 : -1;
let mind1 = -1;
let minvX1;
let minvY1;
let minvZ1;
let mini1 = 0;
minvX1 = 0;
minvY1 = 0;
minvZ1 = 0;
if((v1X2 * n123X + v1Y2 * n123Y + v1Z2 * n123Z) * sign < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
let v3X;
let v3Y;
let v3Z;
let v12X;
let v12Y;
let v12Z;
let v23X;
let v23Y;
let v23Z;
let v31X;
let v31Y;
let v31Z;
v1X = vec11.x;
v1Y = vec11.y;
v1Z = vec11.z;
v2X = vec21.x;
v2Y = vec21.y;
v2Z = vec21.z;
v3X = vec31.x;
v3Y = vec31.y;
v3Z = vec31.z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
v23X = v3X - v2X;
v23Y = v3Y - v2Y;
v23Z = v3Z - v2Z;
v31X = v1X - v3X;
v31Y = v1Y - v3Y;
v31Z = v1Z - v3Z;
let nX;
let nY;
let nZ;
nX = v12Y * v23Z - v12Z * v23Y;
nY = v12Z * v23X - v12X * v23Z;
nZ = v12X * v23Y - v12Y * v23X;
let n12X;
let n12Y;
let n12Z;
let n23X;
let n23Y;
let n23Z;
let n31X;
let n31Y;
let n31Z;
n12X = v12Y * nZ - v12Z * nY;
n12Y = v12Z * nX - v12X * nZ;
n12Z = v12X * nY - v12Y * nX;
n23X = v23Y * nZ - v23Z * nY;
n23Y = v23Z * nX - v23X * nZ;
n23Z = v23X * nY - v23Y * nX;
n31X = v31Y * nZ - v31Z * nY;
n31Y = v31Z * nX - v31X * nZ;
n31Z = v31X * nY - v31Y * nX;
let mind = -1;
let minvX;
let minvY;
let minvZ;
let mini = 0;
minvX = 0;
minvY = 0;
minvZ = 0;
if(v1X * n12X + v1Y * n12Y + v1Z * n12Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec11.x;
v1Y = vec11.y;
v1Z = vec11.z;
v2X = vec21.x;
v2Y = vec21.y;
v2Z = vec21.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
mini = b;
mind = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
if(v2X * n23X + v2Y * n23Y + v2Z * n23Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec21.x;
v1Y = vec21.y;
v1Z = vec21.z;
v2X = vec31.x;
v2Y = vec31.y;
v2Z = vec31.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
let d = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
if(mind < 0 || d < mind) {
mini = b << 1;
mind = d;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
}
if(v3X * n31X + v3Y * n31Y + v3Z * n31Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec11.x;
v1Y = vec11.y;
v1Z = vec11.z;
v2X = vec31.x;
v2Y = vec31.y;
v2Z = vec31.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
let d = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
if(mind < 0 || d < mind) {
mini = b & 1 | (b & 2) << 1;
mind = d;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
}
let b;
if(mind > 0) {
closest.x = minvX;
closest.y = minvY;
closest.z = minvZ;
b = mini;
} else {
let l = nX * nX + nY * nY + nZ * nZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
nX *= l;
nY *= l;
nZ *= l;
let l2 = nX * nX + nY * nY + nZ * nZ;
l2 = (v1X * nX + v1Y * nY + v1Z * nZ) / l2;
minvX = nX * l2;
minvY = nY * l2;
minvZ = nZ * l2;
closest.x = minvX;
closest.y = minvY;
closest.z = minvZ;
b = 7;
}
mini1 = b;
mind1 = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
minvX1 = closest.x;
minvY1 = closest.y;
minvZ1 = closest.z;
}
if((v1X2 * n134X + v1Y2 * n134Y + v1Z2 * n134Z) * sign < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
let v3X;
let v3Y;
let v3Z;
let v12X;
let v12Y;
let v12Z;
let v23X;
let v23Y;
let v23Z;
let v31X;
let v31Y;
let v31Z;
v1X = vec11.x;
v1Y = vec11.y;
v1Z = vec11.z;
v2X = vec31.x;
v2Y = vec31.y;
v2Z = vec31.z;
v3X = vec4.x;
v3Y = vec4.y;
v3Z = vec4.z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
v23X = v3X - v2X;
v23Y = v3Y - v2Y;
v23Z = v3Z - v2Z;
v31X = v1X - v3X;
v31Y = v1Y - v3Y;
v31Z = v1Z - v3Z;
let nX;
let nY;
let nZ;
nX = v12Y * v23Z - v12Z * v23Y;
nY = v12Z * v23X - v12X * v23Z;
nZ = v12X * v23Y - v12Y * v23X;
let n12X;
let n12Y;
let n12Z;
let n23X;
let n23Y;
let n23Z;
let n31X;
let n31Y;
let n31Z;
n12X = v12Y * nZ - v12Z * nY;
n12Y = v12Z * nX - v12X * nZ;
n12Z = v12X * nY - v12Y * nX;
n23X = v23Y * nZ - v23Z * nY;
n23Y = v23Z * nX - v23X * nZ;
n23Z = v23X * nY - v23Y * nX;
n31X = v31Y * nZ - v31Z * nY;
n31Y = v31Z * nX - v31X * nZ;
n31Z = v31X * nY - v31Y * nX;
let mind = -1;
let minvX;
let minvY;
let minvZ;
let mini = 0;
minvX = 0;
minvY = 0;
minvZ = 0;
if(v1X * n12X + v1Y * n12Y + v1Z * n12Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec11.x;
v1Y = vec11.y;
v1Z = vec11.z;
v2X = vec31.x;
v2Y = vec31.y;
v2Z = vec31.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
mini = b;
mind = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
if(v2X * n23X + v2Y * n23Y + v2Z * n23Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec31.x;
v1Y = vec31.y;
v1Z = vec31.z;
v2X = vec4.x;
v2Y = vec4.y;
v2Z = vec4.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
let d = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
if(mind < 0 || d < mind) {
mini = b << 1;
mind = d;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
}
if(v3X * n31X + v3Y * n31Y + v3Z * n31Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec11.x;
v1Y = vec11.y;
v1Z = vec11.z;
v2X = vec4.x;
v2Y = vec4.y;
v2Z = vec4.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
let d = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
if(mind < 0 || d < mind) {
mini = b & 1 | (b & 2) << 1;
mind = d;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
}
let b;
if(mind > 0) {
closest.x = minvX;
closest.y = minvY;
closest.z = minvZ;
b = mini;
} else {
let l = nX * nX + nY * nY + nZ * nZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
nX *= l;
nY *= l;
nZ *= l;
let l2 = nX * nX + nY * nY + nZ * nZ;
l2 = (v1X * nX + v1Y * nY + v1Z * nZ) / l2;
minvX = nX * l2;
minvY = nY * l2;
minvZ = nZ * l2;
closest.x = minvX;
closest.y = minvY;
closest.z = minvZ;
b = 7;
}
let d = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
if(mind1 < 0 || d < mind1) {
mini1 = b & 1 | (b & 6) << 1;
mind1 = d;
minvX1 = closest.x;
minvY1 = closest.y;
minvZ1 = closest.z;
}
}
if((v1X2 * n142X + v1Y2 * n142Y + v1Z2 * n142Z) * sign < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
let v3X;
let v3Y;
let v3Z;
let v12X;
let v12Y;
let v12Z;
let v23X;
let v23Y;
let v23Z;
let v31X;
let v31Y;
let v31Z;
v1X = vec11.x;
v1Y = vec11.y;
v1Z = vec11.z;
v2X = vec21.x;
v2Y = vec21.y;
v2Z = vec21.z;
v3X = vec4.x;
v3Y = vec4.y;
v3Z = vec4.z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
v23X = v3X - v2X;
v23Y = v3Y - v2Y;
v23Z = v3Z - v2Z;
v31X = v1X - v3X;
v31Y = v1Y - v3Y;
v31Z = v1Z - v3Z;
let nX;
let nY;
let nZ;
nX = v12Y * v23Z - v12Z * v23Y;
nY = v12Z * v23X - v12X * v23Z;
nZ = v12X * v23Y - v12Y * v23X;
let n12X;
let n12Y;
let n12Z;
let n23X;
let n23Y;
let n23Z;
let n31X;
let n31Y;
let n31Z;
n12X = v12Y * nZ - v12Z * nY;
n12Y = v12Z * nX - v12X * nZ;
n12Z = v12X * nY - v12Y * nX;
n23X = v23Y * nZ - v23Z * nY;
n23Y = v23Z * nX - v23X * nZ;
n23Z = v23X * nY - v23Y * nX;
n31X = v31Y * nZ - v31Z * nY;
n31Y = v31Z * nX - v31X * nZ;
n31Z = v31X * nY - v31Y * nX;
let mind = -1;
let minvX;
let minvY;
let minvZ;
let mini = 0;
minvX = 0;
minvY = 0;
minvZ = 0;
if(v1X * n12X + v1Y * n12Y + v1Z * n12Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec11.x;
v1Y = vec11.y;
v1Z = vec11.z;
v2X = vec21.x;
v2Y = vec21.y;
v2Z = vec21.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
mini = b;
mind = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
if(v2X * n23X + v2Y * n23Y + v2Z * n23Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec21.x;
v1Y = vec21.y;
v1Z = vec21.z;
v2X = vec4.x;
v2Y = vec4.y;
v2Z = vec4.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
let d = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
if(mind < 0 || d < mind) {
mini = b << 1;
mind = d;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
}
if(v3X * n31X + v3Y * n31Y + v3Z * n31Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec11.x;
v1Y = vec11.y;
v1Z = vec11.z;
v2X = vec4.x;
v2Y = vec4.y;
v2Z = vec4.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
let d = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
if(mind < 0 || d < mind) {
mini = b & 1 | (b & 2) << 1;
mind = d;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
}
let b;
if(mind > 0) {
closest.x = minvX;
closest.y = minvY;
closest.z = minvZ;
b = mini;
} else {
let l = nX * nX + nY * nY + nZ * nZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
nX *= l;
nY *= l;
nZ *= l;
let l2 = nX * nX + nY * nY + nZ * nZ;
l2 = (v1X * nX + v1Y * nY + v1Z * nZ) / l2;
minvX = nX * l2;
minvY = nY * l2;
minvZ = nZ * l2;
closest.x = minvX;
closest.y = minvY;
closest.z = minvZ;
b = 7;
}
let d = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
if(mind1 < 0 || d < mind1) {
mini1 = b & 3 | (b & 4) << 1;
mind1 = d;
minvX1 = closest.x;
minvY1 = closest.y;
minvZ1 = closest.z;
}
}
if((v2X2 * n243X + v2Y2 * n243Y + v2Z2 * n243Z) * sign < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
let v3X;
let v3Y;
let v3Z;
let v12X;
let v12Y;
let v12Z;
let v23X;
let v23Y;
let v23Z;
let v31X;
let v31Y;
let v31Z;
v1X = vec21.x;
v1Y = vec21.y;
v1Z = vec21.z;
v2X = vec31.x;
v2Y = vec31.y;
v2Z = vec31.z;
v3X = vec4.x;
v3Y = vec4.y;
v3Z = vec4.z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
v23X = v3X - v2X;
v23Y = v3Y - v2Y;
v23Z = v3Z - v2Z;
v31X = v1X - v3X;
v31Y = v1Y - v3Y;
v31Z = v1Z - v3Z;
let nX;
let nY;
let nZ;
nX = v12Y * v23Z - v12Z * v23Y;
nY = v12Z * v23X - v12X * v23Z;
nZ = v12X * v23Y - v12Y * v23X;
let n12X;
let n12Y;
let n12Z;
let n23X;
let n23Y;
let n23Z;
let n31X;
let n31Y;
let n31Z;
n12X = v12Y * nZ - v12Z * nY;
n12Y = v12Z * nX - v12X * nZ;
n12Z = v12X * nY - v12Y * nX;
n23X = v23Y * nZ - v23Z * nY;
n23Y = v23Z * nX - v23X * nZ;
n23Z = v23X * nY - v23Y * nX;
n31X = v31Y * nZ - v31Z * nY;
n31Y = v31Z * nX - v31X * nZ;
n31Z = v31X * nY - v31Y * nX;
let mind = -1;
let minvX;
let minvY;
let minvZ;
let mini = 0;
minvX = 0;
minvY = 0;
minvZ = 0;
if(v1X * n12X + v1Y * n12Y + v1Z * n12Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec21.x;
v1Y = vec21.y;
v1Z = vec21.z;
v2X = vec31.x;
v2Y = vec31.y;
v2Z = vec31.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
mini = b;
mind = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
if(v2X * n23X + v2Y * n23Y + v2Z * n23Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec31.x;
v1Y = vec31.y;
v1Z = vec31.z;
v2X = vec4.x;
v2Y = vec4.y;
v2Z = vec4.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
let d = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
if(mind < 0 || d < mind) {
mini = b << 1;
mind = d;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
}
if(v3X * n31X + v3Y * n31Y + v3Z * n31Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec21.x;
v1Y = vec21.y;
v1Z = vec21.z;
v2X = vec4.x;
v2Y = vec4.y;
v2Z = vec4.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
let d = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
if(mind < 0 || d < mind) {
mini = b & 1 | (b & 2) << 1;
mind = d;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
}
let b;
if(mind > 0) {
closest.x = minvX;
closest.y = minvY;
closest.z = minvZ;
b = mini;
} else {
let l = nX * nX + nY * nY + nZ * nZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
nX *= l;
nY *= l;
nZ *= l;
let l2 = nX * nX + nY * nY + nZ * nZ;
l2 = (v1X * nX + v1Y * nY + v1Z * nZ) / l2;
minvX = nX * l2;
minvY = nY * l2;
minvZ = nZ * l2;
closest.x = minvX;
closest.y = minvY;
closest.z = minvZ;
b = 7;
}
let d = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
if(mind1 < 0 || d < mind1) {
mini1 = b << 1;
mind1 = d;
minvX1 = closest.x;
minvY1 = closest.y;
minvZ1 = closest.z;
}
}
if(mind1 > 0) {
closest.x = minvX1;
closest.y = minvY1;
closest.z = minvZ1;
v = mini1;
} else {
closest.zero();
v = 15;
}
break;
}
if(closest.x * closest.x + closest.y * closest.y + closest.z * closest.z < 1e-008) {
if(!useEpa) {
this.distance = 0;
return 0;
}
switch(this.simplexSize) {
case 1:
this.pointToTetrahedron();
break;
case 2:
this.lineToTetrahedron();
break;
case 3:
this.triangleToTetrahedron();
break;
}
if(this.simplexSize == 4) {
let epaState = this.computeDepth(c1,c2,tf1,tf2,s,w1,w2);
if(epaState != 0) {
this.distance = 0;
return epaState;
}
this.distance = -this.depth;
return 0;
}
this.distance = 0;
return 1;
}
this.shrinkSimplex(v);
dir.x = closest.x;
dir.y = closest.y;
dir.z = closest.z;
dir.x = -dir.x;
dir.y = -dir.y;
dir.z = -dir.z;
this.computeWitnessPoint1(false);
this.computeWitnessPoint2(false);
let _this = this.s[this.simplexSize];
let v4 = this.w1[this.simplexSize];
_this.x = v4.x;
_this.y = v4.y;
_this.z = v4.z;
let v5 = this.w2[this.simplexSize];
_this.x -= v5.x;
_this.y -= v5.y;
_this.z -= v5.z;
if(dir.x * dir.x + dir.y * dir.y + dir.z * dir.z < 1e-008) {
throw new Error("!?");
}
let _this1 = s[this.simplexSize];
if(_this1.x * dir.x + _this1.y * dir.y + _this1.z * dir.z - (closest.x * dir.x + closest.y * dir.y + closest.z * dir.z) < 1e-008) {
this.interpolateClosestPoints();
this.distance = Math.sqrt(closest.x * closest.x + closest.y * closest.y + closest.z * closest.z);
if(cache != null && cache._gjkCache != null) {
this.saveCache(cache._gjkCache);
}
return 0;
}
this.simplexSize++;
++count;
}
return 2;
}
convexCastImpl(c1,c2,tf1,tf2,tl1,tl2,hit) {
this.c1 = c1;
this.c2 = c2;
this.tf1 = tf1;
this.tf2 = tf2;
let s = this.s;
let closest = this.closest;
let dir = this.dir;
let firstDirX;
let firstDirY;
let firstDirZ;
firstDirX = tf2._positionX - tf1._positionX;
firstDirY = tf2._positionY - tf1._positionY;
firstDirZ = tf2._positionZ - tf1._positionZ;
dir.x = firstDirX;
dir.y = firstDirY;
dir.z = firstDirZ;
if(dir.x * dir.x + dir.y * dir.y + dir.z * dir.z < 1e-6) {
dir.init(1,0,0);
}
this.simplexSize = 0;
if(this.c1 != null) {
this.computeWitnessPoint1(true);
} else {
let v = this.w1[this.simplexSize];
v.x = this.tf1._positionX;
v.y = this.tf1._positionY;
v.z = this.tf1._positionZ;
}
this.computeWitnessPoint2(true);
let _this = this.s[this.simplexSize];
let v = this.w1[this.simplexSize];
_this.x = v.x;
_this.y = v.y;
_this.z = v.z;
let v1 = this.w2[this.simplexSize];
_this.x -= v1.x;
_this.y -= v1.y;
_this.z -= v1.z;
this.simplexSize = 1;
let count = 0;
let lambda = 0.0;
let rayX = this.rayX;
let rayR = this.rayR;
rayX.zero();
rayR.x = tl2.x;
rayR.y = tl2.y;
rayR.z = tl2.z;
rayR.x -= tl1.x;
rayR.y -= tl1.y;
rayR.z -= tl1.z;
while(count < 40) {
let v = 0;
switch(this.simplexSize) {
case 1:
let v1 = s[0];
closest.x = v1.x;
closest.y = v1.y;
closest.z = v1.z;
v = 1;
break;
case 2:
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
let v2 = s[0];
v1X = v2.x;
v1Y = v2.y;
v1Z = v2.z;
let v3 = s[1];
v2X = v3.x;
v2Y = v3.y;
v2Z = v3.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
v = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
v = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
v = 3;
}
break;
case 3:
let vec1 = s[0];
let vec2 = s[1];
let vec3 = s[2];
let v1X1;
let v1Y1;
let v1Z1;
let v2X1;
let v2Y1;
let v2Z1;
let v3X;
let v3Y;
let v3Z;
let v12X1;
let v12Y1;
let v12Z1;
let v23X;
let v23Y;
let v23Z;
let v31X;
let v31Y;
let v31Z;
v1X1 = vec1.x;
v1Y1 = vec1.y;
v1Z1 = vec1.z;
v2X1 = vec2.x;
v2Y1 = vec2.y;
v2Z1 = vec2.z;
v3X = vec3.x;
v3Y = vec3.y;
v3Z = vec3.z;
v12X1 = v2X1 - v1X1;
v12Y1 = v2Y1 - v1Y1;
v12Z1 = v2Z1 - v1Z1;
v23X = v3X - v2X1;
v23Y = v3Y - v2Y1;
v23Z = v3Z - v2Z1;
v31X = v1X1 - v3X;
v31Y = v1Y1 - v3Y;
v31Z = v1Z1 - v3Z;
let nX;
let nY;
let nZ;
nX = v12Y1 * v23Z - v12Z1 * v23Y;
nY = v12Z1 * v23X - v12X1 * v23Z;
nZ = v12X1 * v23Y - v12Y1 * v23X;
let n12X;
let n12Y;
let n12Z;
let n23X;
let n23Y;
let n23Z;
let n31X;
let n31Y;
let n31Z;
n12X = v12Y1 * nZ - v12Z1 * nY;
n12Y = v12Z1 * nX - v12X1 * nZ;
n12Z = v12X1 * nY - v12Y1 * nX;
n23X = v23Y * nZ - v23Z * nY;
n23Y = v23Z * nX - v23X * nZ;
n23Z = v23X * nY - v23Y * nX;
n31X = v31Y * nZ - v31Z * nY;
n31Y = v31Z * nX - v31X * nZ;
n31Z = v31X * nY - v31Y * nX;
let mind = -1;
let minvX;
let minvY;
let minvZ;
let mini = 0;
minvX = 0;
minvY = 0;
minvZ = 0;
if(v1X1 * n12X + v1Y1 * n12Y + v1Z1 * n12Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec1.x;
v1Y = vec1.y;
v1Z = vec1.z;
v2X = vec2.x;
v2Y = vec2.y;
v2Z = vec2.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
mini = b;
mind = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
if(v2X1 * n23X + v2Y1 * n23Y + v2Z1 * n23Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec2.x;
v1Y = vec2.y;
v1Z = vec2.z;
v2X = vec3.x;
v2Y = vec3.y;
v2Z = vec3.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
let d = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
if(mind < 0 || d < mind) {
mini = b << 1;
mind = d;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
}
if(v3X * n31X + v3Y * n31Y + v3Z * n31Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec1.x;
v1Y = vec1.y;
v1Z = vec1.z;
v2X = vec3.x;
v2Y = vec3.y;
v2Z = vec3.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
let d = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
if(mind < 0 || d < mind) {
mini = b & 1 | (b & 2) << 1;
mind = d;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
}
if(mind > 0) {
closest.x = minvX;
closest.y = minvY;
closest.z = minvZ;
v = mini;
} else {
let l = nX * nX + nY * nY + nZ * nZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
nX *= l;
nY *= l;
nZ *= l;
let l2 = nX * nX + nY * nY + nZ * nZ;
l2 = (v1X1 * nX + v1Y1 * nY + v1Z1 * nZ) / l2;
minvX = nX * l2;
minvY = nY * l2;
minvZ = nZ * l2;
closest.x = minvX;
closest.y = minvY;
closest.z = minvZ;
v = 7;
}
break;
case 4:
let vec11 = s[0];
let vec21 = s[1];
let vec31 = s[2];
let vec4 = s[3];
let v1X2;
let v1Y2;
let v1Z2;
let v2X2;
let v2Y2;
let v2Z2;
let v3X1;
let v3Y1;
let v3Z1;
let v4X;
let v4Y;
let v4Z;
let v12X2;
let v12Y2;
let v12Z2;
let v13X;
let v13Y;
let v13Z;
let v14X;
let v14Y;
let v14Z;
let v23X1;
let v23Y1;
let v23Z1;
let v24X;
let v24Y;
let v24Z;
v1X2 = vec11.x;
v1Y2 = vec11.y;
v1Z2 = vec11.z;
v2X2 = vec21.x;
v2Y2 = vec21.y;
v2Z2 = vec21.z;
v3X1 = vec31.x;
v3Y1 = vec31.y;
v3Z1 = vec31.z;
v4X = vec4.x;
v4Y = vec4.y;
v4Z = vec4.z;
v12X2 = v2X2 - v1X2;
v12Y2 = v2Y2 - v1Y2;
v12Z2 = v2Z2 - v1Z2;
v13X = v3X1 - v1X2;
v13Y = v3Y1 - v1Y2;
v13Z = v3Z1 - v1Z2;
v14X = v4X - v1X2;
v14Y = v4Y - v1Y2;
v14Z = v4Z - v1Z2;
v23X1 = v3X1 - v2X2;
v23Y1 = v3Y1 - v2Y2;
v23Z1 = v3Z1 - v2Z2;
v24X = v4X - v2X2;
v24Y = v4Y - v2Y2;
v24Z = v4Z - v2Z2;
let n123X;
let n123Y;
let n123Z;
let n134X;
let n134Y;
let n134Z;
let n142X;
let n142Y;
let n142Z;
let n243X;
let n243Y;
let n243Z;
n123X = v12Y2 * v13Z - v12Z2 * v13Y;
n123Y = v12Z2 * v13X - v12X2 * v13Z;
n123Z = v12X2 * v13Y - v12Y2 * v13X;
n134X = v13Y * v14Z - v13Z * v14Y;
n134Y = v13Z * v14X - v13X * v14Z;
n134Z = v13X * v14Y - v13Y * v14X;
n142X = v14Y * v12Z2 - v14Z * v12Y2;
n142Y = v14Z * v12X2 - v14X * v12Z2;
n142Z = v14X * v12Y2 - v14Y * v12X2;
n243X = v24Y * v23Z1 - v24Z * v23Y1;
n243Y = v24Z * v23X1 - v24X * v23Z1;
n243Z = v24X * v23Y1 - v24Y * v23X1;
let sign = v12X2 * n243X + v12Y2 * n243Y + v12Z2 * n243Z > 0 ? 1 : -1;
let mind1 = -1;
let minvX1;
let minvY1;
let minvZ1;
let mini1 = 0;
minvX1 = 0;
minvY1 = 0;
minvZ1 = 0;
if((v1X2 * n123X + v1Y2 * n123Y + v1Z2 * n123Z) * sign < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
let v3X;
let v3Y;
let v3Z;
let v12X;
let v12Y;
let v12Z;
let v23X;
let v23Y;
let v23Z;
let v31X;
let v31Y;
let v31Z;
v1X = vec11.x;
v1Y = vec11.y;
v1Z = vec11.z;
v2X = vec21.x;
v2Y = vec21.y;
v2Z = vec21.z;
v3X = vec31.x;
v3Y = vec31.y;
v3Z = vec31.z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
v23X = v3X - v2X;
v23Y = v3Y - v2Y;
v23Z = v3Z - v2Z;
v31X = v1X - v3X;
v31Y = v1Y - v3Y;
v31Z = v1Z - v3Z;
let nX;
let nY;
let nZ;
nX = v12Y * v23Z - v12Z * v23Y;
nY = v12Z * v23X - v12X * v23Z;
nZ = v12X * v23Y - v12Y * v23X;
let n12X;
let n12Y;
let n12Z;
let n23X;
let n23Y;
let n23Z;
let n31X;
let n31Y;
let n31Z;
n12X = v12Y * nZ - v12Z * nY;
n12Y = v12Z * nX - v12X * nZ;
n12Z = v12X * nY - v12Y * nX;
n23X = v23Y * nZ - v23Z * nY;
n23Y = v23Z * nX - v23X * nZ;
n23Z = v23X * nY - v23Y * nX;
n31X = v31Y * nZ - v31Z * nY;
n31Y = v31Z * nX - v31X * nZ;
n31Z = v31X * nY - v31Y * nX;
let mind = -1;
let minvX;
let minvY;
let minvZ;
let mini = 0;
minvX = 0;
minvY = 0;
minvZ = 0;
if(v1X * n12X + v1Y * n12Y + v1Z * n12Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec11.x;
v1Y = vec11.y;
v1Z = vec11.z;
v2X = vec21.x;
v2Y = vec21.y;
v2Z = vec21.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
mini = b;
mind = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
if(v2X * n23X + v2Y * n23Y + v2Z * n23Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec21.x;
v1Y = vec21.y;
v1Z = vec21.z;
v2X = vec31.x;
v2Y = vec31.y;
v2Z = vec31.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
let d = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
if(mind < 0 || d < mind) {
mini = b << 1;
mind = d;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
}
if(v3X * n31X + v3Y * n31Y + v3Z * n31Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec11.x;
v1Y = vec11.y;
v1Z = vec11.z;
v2X = vec31.x;
v2Y = vec31.y;
v2Z = vec31.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
let d = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
if(mind < 0 || d < mind) {
mini = b & 1 | (b & 2) << 1;
mind = d;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
}
let b;
if(mind > 0) {
closest.x = minvX;
closest.y = minvY;
closest.z = minvZ;
b = mini;
} else {
let l = nX * nX + nY * nY + nZ * nZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
nX *= l;
nY *= l;
nZ *= l;
let l2 = nX * nX + nY * nY + nZ * nZ;
l2 = (v1X * nX + v1Y * nY + v1Z * nZ) / l2;
minvX = nX * l2;
minvY = nY * l2;
minvZ = nZ * l2;
closest.x = minvX;
closest.y = minvY;
closest.z = minvZ;
b = 7;
}
mini1 = b;
mind1 = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
minvX1 = closest.x;
minvY1 = closest.y;
minvZ1 = closest.z;
}
if((v1X2 * n134X + v1Y2 * n134Y + v1Z2 * n134Z) * sign < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
let v3X;
let v3Y;
let v3Z;
let v12X;
let v12Y;
let v12Z;
let v23X;
let v23Y;
let v23Z;
let v31X;
let v31Y;
let v31Z;
v1X = vec11.x;
v1Y = vec11.y;
v1Z = vec11.z;
v2X = vec31.x;
v2Y = vec31.y;
v2Z = vec31.z;
v3X = vec4.x;
v3Y = vec4.y;
v3Z = vec4.z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
v23X = v3X - v2X;
v23Y = v3Y - v2Y;
v23Z = v3Z - v2Z;
v31X = v1X - v3X;
v31Y = v1Y - v3Y;
v31Z = v1Z - v3Z;
let nX;
let nY;
let nZ;
nX = v12Y * v23Z - v12Z * v23Y;
nY = v12Z * v23X - v12X * v23Z;
nZ = v12X * v23Y - v12Y * v23X;
let n12X;
let n12Y;
let n12Z;
let n23X;
let n23Y;
let n23Z;
let n31X;
let n31Y;
let n31Z;
n12X = v12Y * nZ - v12Z * nY;
n12Y = v12Z * nX - v12X * nZ;
n12Z = v12X * nY - v12Y * nX;
n23X = v23Y * nZ - v23Z * nY;
n23Y = v23Z * nX - v23X * nZ;
n23Z = v23X * nY - v23Y * nX;
n31X = v31Y * nZ - v31Z * nY;
n31Y = v31Z * nX - v31X * nZ;
n31Z = v31X * nY - v31Y * nX;
let mind = -1;
let minvX;
let minvY;
let minvZ;
let mini = 0;
minvX = 0;
minvY = 0;
minvZ = 0;
if(v1X * n12X + v1Y * n12Y + v1Z * n12Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec11.x;
v1Y = vec11.y;
v1Z = vec11.z;
v2X = vec31.x;
v2Y = vec31.y;
v2Z = vec31.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
mini = b;
mind = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
if(v2X * n23X + v2Y * n23Y + v2Z * n23Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec31.x;
v1Y = vec31.y;
v1Z = vec31.z;
v2X = vec4.x;
v2Y = vec4.y;
v2Z = vec4.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
let d = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
if(mind < 0 || d < mind) {
mini = b << 1;
mind = d;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
}
if(v3X * n31X + v3Y * n31Y + v3Z * n31Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec11.x;
v1Y = vec11.y;
v1Z = vec11.z;
v2X = vec4.x;
v2Y = vec4.y;
v2Z = vec4.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
let d = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
if(mind < 0 || d < mind) {
mini = b & 1 | (b & 2) << 1;
mind = d;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
}
let b;
if(mind > 0) {
closest.x = minvX;
closest.y = minvY;
closest.z = minvZ;
b = mini;
} else {
let l = nX * nX + nY * nY + nZ * nZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
nX *= l;
nY *= l;
nZ *= l;
let l2 = nX * nX + nY * nY + nZ * nZ;
l2 = (v1X * nX + v1Y * nY + v1Z * nZ) / l2;
minvX = nX * l2;
minvY = nY * l2;
minvZ = nZ * l2;
closest.x = minvX;
closest.y = minvY;
closest.z = minvZ;
b = 7;
}
let d = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
if(mind1 < 0 || d < mind1) {
mini1 = b & 1 | (b & 6) << 1;
mind1 = d;
minvX1 = closest.x;
minvY1 = closest.y;
minvZ1 = closest.z;
}
}
if((v1X2 * n142X + v1Y2 * n142Y + v1Z2 * n142Z) * sign < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
let v3X;
let v3Y;
let v3Z;
let v12X;
let v12Y;
let v12Z;
let v23X;
let v23Y;
let v23Z;
let v31X;
let v31Y;
let v31Z;
v1X = vec11.x;
v1Y = vec11.y;
v1Z = vec11.z;
v2X = vec21.x;
v2Y = vec21.y;
v2Z = vec21.z;
v3X = vec4.x;
v3Y = vec4.y;
v3Z = vec4.z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
v23X = v3X - v2X;
v23Y = v3Y - v2Y;
v23Z = v3Z - v2Z;
v31X = v1X - v3X;
v31Y = v1Y - v3Y;
v31Z = v1Z - v3Z;
let nX;
let nY;
let nZ;
nX = v12Y * v23Z - v12Z * v23Y;
nY = v12Z * v23X - v12X * v23Z;
nZ = v12X * v23Y - v12Y * v23X;
let n12X;
let n12Y;
let n12Z;
let n23X;
let n23Y;
let n23Z;
let n31X;
let n31Y;
let n31Z;
n12X = v12Y * nZ - v12Z * nY;
n12Y = v12Z * nX - v12X * nZ;
n12Z = v12X * nY - v12Y * nX;
n23X = v23Y * nZ - v23Z * nY;
n23Y = v23Z * nX - v23X * nZ;
n23Z = v23X * nY - v23Y * nX;
n31X = v31Y * nZ - v31Z * nY;
n31Y = v31Z * nX - v31X * nZ;
n31Z = v31X * nY - v31Y * nX;
let mind = -1;
let minvX;
let minvY;
let minvZ;
let mini = 0;
minvX = 0;
minvY = 0;
minvZ = 0;
if(v1X * n12X + v1Y * n12Y + v1Z * n12Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec11.x;
v1Y = vec11.y;
v1Z = vec11.z;
v2X = vec21.x;
v2Y = vec21.y;
v2Z = vec21.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
mini = b;
mind = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
if(v2X * n23X + v2Y * n23Y + v2Z * n23Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec21.x;
v1Y = vec21.y;
v1Z = vec21.z;
v2X = vec4.x;
v2Y = vec4.y;
v2Z = vec4.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
let d = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
if(mind < 0 || d < mind) {
mini = b << 1;
mind = d;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
}
if(v3X * n31X + v3Y * n31Y + v3Z * n31Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec11.x;
v1Y = vec11.y;
v1Z = vec11.z;
v2X = vec4.x;
v2Y = vec4.y;
v2Z = vec4.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
let d = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
if(mind < 0 || d < mind) {
mini = b & 1 | (b & 2) << 1;
mind = d;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
}
let b;
if(mind > 0) {
closest.x = minvX;
closest.y = minvY;
closest.z = minvZ;
b = mini;
} else {
let l = nX * nX + nY * nY + nZ * nZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
nX *= l;
nY *= l;
nZ *= l;
let l2 = nX * nX + nY * nY + nZ * nZ;
l2 = (v1X * nX + v1Y * nY + v1Z * nZ) / l2;
minvX = nX * l2;
minvY = nY * l2;
minvZ = nZ * l2;
closest.x = minvX;
closest.y = minvY;
closest.z = minvZ;
b = 7;
}
let d = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
if(mind1 < 0 || d < mind1) {
mini1 = b & 3 | (b & 4) << 1;
mind1 = d;
minvX1 = closest.x;
minvY1 = closest.y;
minvZ1 = closest.z;
}
}
if((v2X2 * n243X + v2Y2 * n243Y + v2Z2 * n243Z) * sign < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
let v3X;
let v3Y;
let v3Z;
let v12X;
let v12Y;
let v12Z;
let v23X;
let v23Y;
let v23Z;
let v31X;
let v31Y;
let v31Z;
v1X = vec21.x;
v1Y = vec21.y;
v1Z = vec21.z;
v2X = vec31.x;
v2Y = vec31.y;
v2Z = vec31.z;
v3X = vec4.x;
v3Y = vec4.y;
v3Z = vec4.z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
v23X = v3X - v2X;
v23Y = v3Y - v2Y;
v23Z = v3Z - v2Z;
v31X = v1X - v3X;
v31Y = v1Y - v3Y;
v31Z = v1Z - v3Z;
let nX;
let nY;
let nZ;
nX = v12Y * v23Z - v12Z * v23Y;
nY = v12Z * v23X - v12X * v23Z;
nZ = v12X * v23Y - v12Y * v23X;
let n12X;
let n12Y;
let n12Z;
let n23X;
let n23Y;
let n23Z;
let n31X;
let n31Y;
let n31Z;
n12X = v12Y * nZ - v12Z * nY;
n12Y = v12Z * nX - v12X * nZ;
n12Z = v12X * nY - v12Y * nX;
n23X = v23Y * nZ - v23Z * nY;
n23Y = v23Z * nX - v23X * nZ;
n23Z = v23X * nY - v23Y * nX;
n31X = v31Y * nZ - v31Z * nY;
n31Y = v31Z * nX - v31X * nZ;
n31Z = v31X * nY - v31Y * nX;
let mind = -1;
let minvX;
let minvY;
let minvZ;
let mini = 0;
minvX = 0;
minvY = 0;
minvZ = 0;
if(v1X * n12X + v1Y * n12Y + v1Z * n12Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec21.x;
v1Y = vec21.y;
v1Z = vec21.z;
v2X = vec31.x;
v2Y = vec31.y;
v2Z = vec31.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
mini = b;
mind = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
if(v2X * n23X + v2Y * n23Y + v2Z * n23Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec31.x;
v1Y = vec31.y;
v1Z = vec31.z;
v2X = vec4.x;
v2Y = vec4.y;
v2Z = vec4.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
let d = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
if(mind < 0 || d < mind) {
mini = b << 1;
mind = d;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
}
if(v3X * n31X + v3Y * n31Y + v3Z * n31Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec21.x;
v1Y = vec21.y;
v1Z = vec21.z;
v2X = vec4.x;
v2Y = vec4.y;
v2Z = vec4.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
closest.x = v1X;
closest.y = v1Y;
closest.z = v1Z;
b = 1;
} else if(t > 1) {
closest.x = v2X;
closest.y = v2Y;
closest.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
closest.x = pX;
closest.y = pY;
closest.z = pZ;
b = 3;
}
let d = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
if(mind < 0 || d < mind) {
mini = b & 1 | (b & 2) << 1;
mind = d;
minvX = closest.x;
minvY = closest.y;
minvZ = closest.z;
}
}
let b;
if(mind > 0) {
closest.x = minvX;
closest.y = minvY;
closest.z = minvZ;
b = mini;
} else {
let l = nX * nX + nY * nY + nZ * nZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
nX *= l;
nY *= l;
nZ *= l;
let l2 = nX * nX + nY * nY + nZ * nZ;
l2 = (v1X * nX + v1Y * nY + v1Z * nZ) / l2;
minvX = nX * l2;
minvY = nY * l2;
minvZ = nZ * l2;
closest.x = minvX;
closest.y = minvY;
closest.z = minvZ;
b = 7;
}
let d = closest.x * closest.x + closest.y * closest.y + closest.z * closest.z;
if(mind1 < 0 || d < mind1) {
mini1 = b << 1;
mind1 = d;
minvX1 = closest.x;
minvY1 = closest.y;
minvZ1 = closest.z;
}
}
if(mind1 > 0) {
closest.x = minvX1;
closest.y = minvY1;
closest.z = minvZ1;
v = mini1;
} else {
closest.zero();
v = 15;
}
break;
}
this.shrinkSimplex(v);
if(closest.x * closest.x + closest.y * closest.y + closest.z * closest.z < 1e-008) {
if(lambda == 0 || this.simplexSize == 4) {
hit.fraction = lambda;
return false;
}
this.interpolateClosestPoints();
hit.fraction = lambda;
let _this = hit.normal;
_this.x = dir.x;
_this.y = dir.y;
_this.z = dir.z;
let invLen = Math.sqrt(_this.x * _this.x + _this.y * _this.y + _this.z * _this.z);
if(invLen > 0) {
invLen = 1 / invLen;
}
_this.x *= invLen;
_this.y *= invLen;
_this.z *= invLen;
let _this1 = hit.position;
let v = this.closestPoint1;
_this1.x = v.x;
_this1.y = v.y;
_this1.z = v.z;
_this1.x += tl1.x * lambda;
_this1.y += tl1.y * lambda;
_this1.z += tl1.z * lambda;
return true;
}
dir.x = closest.x;
dir.y = closest.y;
dir.z = closest.z;
dir.x = -dir.x;
dir.y = -dir.y;
dir.z = -dir.z;
if(this.c1 != null) {
this.computeWitnessPoint1(true);
} else {
let v = this.w1[this.simplexSize];
v.x = this.tf1._positionX;
v.y = this.tf1._positionY;
v.z = this.tf1._positionZ;
}
this.computeWitnessPoint2(true);
let _this = this.s[this.simplexSize];
let v4 = this.w1[this.simplexSize];
_this.x = v4.x;
_this.y = v4.y;
_this.z = v4.z;
let v5 = this.w2[this.simplexSize];
_this.x -= v5.x;
_this.y -= v5.y;
_this.z -= v5.z;
let _this1 = s[this.simplexSize];
_this1.x -= rayX.x;
_this1.y -= rayX.y;
_this1.z -= rayX.z;
if(dir.x * dir.x + dir.y * dir.y + dir.z * dir.z < 1e-008) {
throw new Error("!?");
}
let p = s[this.simplexSize];
let pn = p.x * dir.x + p.y * dir.y + p.z * dir.z;
if(pn < 0) {
if(rayR.x * dir.x + rayR.y * dir.y + rayR.z * dir.z >= 0) {
return false;
}
let dLambda = pn / (rayR.x * dir.x + rayR.y * dir.y + rayR.z * dir.z);
lambda += dLambda;
if(lambda >= 1) {
return false;
}
rayX.x += rayR.x * dLambda;
rayX.y += rayR.y * dLambda;
rayX.z += rayR.z * dLambda;
let _g = 0;
let _g1 = this.simplexSize + 1;
while(_g < _g1) {
let _this = s[_g++];
let s1 = -dLambda;
_this.x += rayR.x * s1;
_this.y += rayR.y * s1;
_this.z += rayR.z * s1;
}
}
let duplicate = false;
let _g = 0;
let _g1 = this.simplexSize;
while(_g < _g1) {
let i = _g++;
let dx = s[i].x - s[this.simplexSize].x;
let dy = s[i].y - s[this.simplexSize].y;
let dz = s[i].z - s[this.simplexSize].z;
if(dx * dx + dy * dy + dz * dz < 1e-008) {
duplicate = true;
break;
}
}
if(!duplicate) {
this.simplexSize++;
}
++count;
}
return false;
}
interpolateClosestPoints() {
switch(this.simplexSize) {
case 1:
let _this = this.closestPoint1;
let v = this.w1[0];
_this.x = v.x;
_this.y = v.y;
_this.z = v.z;
let _this1 = this.closestPoint2;
let v1 = this.w2[0];
_this1.x = v1.x;
_this1.y = v1.y;
_this1.z = v1.z;
break;
case 2:
let cX;
let cY;
let cZ;
let v2 = this.closest;
cX = v2.x;
cY = v2.y;
cZ = v2.z;
let s0X;
let s0Y;
let s0Z;
let w10X;
let w10Y;
let w10Z;
let w20X;
let w20Y;
let w20Z;
let s1X;
let s1Y;
let s1Z;
let w11X;
let w11Y;
let w11Z;
let w21X;
let w21Y;
let w21Z;
let v3 = this.s[0];
s0X = v3.x;
s0Y = v3.y;
s0Z = v3.z;
let v4 = this.w1[0];
w10X = v4.x;
w10Y = v4.y;
w10Z = v4.z;
let v5 = this.w2[0];
w20X = v5.x;
w20Y = v5.y;
w20Z = v5.z;
let v6 = this.s[1];
s1X = v6.x;
s1Y = v6.y;
s1Z = v6.z;
let v7 = this.w1[1];
w11X = v7.x;
w11Y = v7.y;
w11Z = v7.z;
let v8 = this.w2[1];
w21X = v8.x;
w21Y = v8.y;
w21Z = v8.z;
let s01X;
let s01Y;
let s01Z;
s01X = s1X - s0X;
s01Y = s1Y - s0Y;
s01Z = s1Z - s0Z;
let invDet = s01X * s01X + s01Y * s01Y + s01Z * s01Z;
if(invDet != 0) {
invDet = 1 / invDet;
}
let s0cX;
let s0cY;
let s0cZ;
s0cX = cX - s0X;
s0cY = cY - s0Y;
s0cZ = cZ - s0Z;
let t = (s0cX * s01X + s0cY * s01Y + s0cZ * s01Z) * invDet;
let diffX;
let diffY;
let diffZ;
let cp1X;
let cp1Y;
let cp1Z;
let cp2X;
let cp2Y;
let cp2Z;
diffX = w11X - w10X;
diffY = w11Y - w10Y;
diffZ = w11Z - w10Z;
cp1X = w10X + diffX * t;
cp1Y = w10Y + diffY * t;
cp1Z = w10Z + diffZ * t;
diffX = w21X - w20X;
diffY = w21Y - w20Y;
diffZ = w21Z - w20Z;
cp2X = w20X + diffX * t;
cp2Y = w20Y + diffY * t;
cp2Z = w20Z + diffZ * t;
let v9 = this.closestPoint1;
v9.x = cp1X;
v9.y = cp1Y;
v9.z = cp1Z;
let v10 = this.closestPoint2;
v10.x = cp2X;
v10.y = cp2Y;
v10.z = cp2Z;
break;
case 3:
let cX1;
let cY1;
let cZ1;
let v11 = this.closest;
cX1 = v11.x;
cY1 = v11.y;
cZ1 = v11.z;
let s0X1;
let s0Y1;
let s0Z1;
let w10X1;
let w10Y1;
let w10Z1;
let w20X1;
let w20Y1;
let w20Z1;
let s1X1;
let s1Y1;
let s1Z1;
let w11X1;
let w11Y1;
let w11Z1;
let w21X1;
let w21Y1;
let w21Z1;
let s2X;
let s2Y;
let s2Z;
let w12X;
let w12Y;
let w12Z;
let w22X;
let w22Y;
let w22Z;
let v12 = this.s[0];
s0X1 = v12.x;
s0Y1 = v12.y;
s0Z1 = v12.z;
let v13 = this.w1[0];
w10X1 = v13.x;
w10Y1 = v13.y;
w10Z1 = v13.z;
let v14 = this.w2[0];
w20X1 = v14.x;
w20Y1 = v14.y;
w20Z1 = v14.z;
let v15 = this.s[1];
s1X1 = v15.x;
s1Y1 = v15.y;
s1Z1 = v15.z;
let v16 = this.w1[1];
w11X1 = v16.x;
w11Y1 = v16.y;
w11Z1 = v16.z;
let v17 = this.w2[1];
w21X1 = v17.x;
w21Y1 = v17.y;
w21Z1 = v17.z;
let v18 = this.s[2];
s2X = v18.x;
s2Y = v18.y;
s2Z = v18.z;
let v19 = this.w1[2];
w12X = v19.x;
w12Y = v19.y;
w12Z = v19.z;
let v20 = this.w2[2];
w22X = v20.x;
w22Y = v20.y;
w22Z = v20.z;
let s01X1;
let s01Y1;
let s01Z1;
let s02X;
let s02Y;
let s02Z;
let s0cX1;
let s0cY1;
let s0cZ1;
s01X1 = s1X1 - s0X1;
s01Y1 = s1Y1 - s0Y1;
s01Z1 = s1Z1 - s0Z1;
s02X = s2X - s0X1;
s02Y = s2Y - s0Y1;
s02Z = s2Z - s0Z1;
s0cX1 = cX1 - s0X1;
s0cY1 = cY1 - s0Y1;
s0cZ1 = cZ1 - s0Z1;
let d11 = s01X1 * s01X1 + s01Y1 * s01Y1 + s01Z1 * s01Z1;
let d12 = s01X1 * s02X + s01Y1 * s02Y + s01Z1 * s02Z;
let d22 = s02X * s02X + s02Y * s02Y + s02Z * s02Z;
let d1c = s01X1 * s0cX1 + s01Y1 * s0cY1 + s01Z1 * s0cZ1;
let d2c = s02X * s0cX1 + s02Y * s0cY1 + s02Z * s0cZ1;
let invDet1 = d11 * d22 - d12 * d12;
if(invDet1 != 0) {
invDet1 = 1 / invDet1;
}
let s = (d1c * d22 - d2c * d12) * invDet1;
let t1 = (-d1c * d12 + d2c * d11) * invDet1;
let diffX1;
let diffY1;
let diffZ1;
let cp1X1;
let cp1Y1;
let cp1Z1;
let cp2X1;
let cp2Y1;
let cp2Z1;
diffX1 = w11X1 - w10X1;
diffY1 = w11Y1 - w10Y1;
diffZ1 = w11Z1 - w10Z1;
cp1X1 = w10X1 + diffX1 * s;
cp1Y1 = w10Y1 + diffY1 * s;
cp1Z1 = w10Z1 + diffZ1 * s;
diffX1 = w12X - w10X1;
diffY1 = w12Y - w10Y1;
diffZ1 = w12Z - w10Z1;
cp1X1 += diffX1 * t1;
cp1Y1 += diffY1 * t1;
cp1Z1 += diffZ1 * t1;
diffX1 = w21X1 - w20X1;
diffY1 = w21Y1 - w20Y1;
diffZ1 = w21Z1 - w20Z1;
cp2X1 = w20X1 + diffX1 * s;
cp2Y1 = w20Y1 + diffY1 * s;
cp2Z1 = w20Z1 + diffZ1 * s;
diffX1 = w22X - w20X1;
diffY1 = w22Y - w20Y1;
diffZ1 = w22Z - w20Z1;
cp2X1 += diffX1 * t1;
cp2Y1 += diffY1 * t1;
cp2Z1 += diffZ1 * t1;
let v21 = this.closestPoint1;
v21.x = cp1X1;
v21.y = cp1Y1;
v21.z = cp1Z1;
let v22 = this.closestPoint2;
v22.x = cp2X1;
v22.y = cp2Y1;
v22.z = cp2Z1;
break;
default:
throw new Error("!?");
}
}
loadCache(gjkCache) {
let _this = this.dir;
let v = gjkCache.prevClosestDir;
_this.x = v.x;
_this.y = v.y;
_this.z = v.z;
}
saveCache(gjkCache) {
let _this = gjkCache.prevClosestDir;
let v = this.closest;
_this.x = v.x;
_this.y = v.y;
_this.z = v.z;
_this.x = -_this.x;
_this.y = -_this.y;
_this.z = -_this.z;
}
shrinkSimplex(vertexBits) {
this.simplexSize = vertexBits;
this.simplexSize = (this.simplexSize & 5) + (this.simplexSize >> 1 & 5);
this.simplexSize = (this.simplexSize & 3) + (this.simplexSize >> 2 & 3);
switch(vertexBits) {
case 2:
let _this = this.s[0];
let v = this.s[1];
_this.x = v.x;
_this.y = v.y;
_this.z = v.z;
let _this1 = this.w1[0];
let v1 = this.w1[1];
_this1.x = v1.x;
_this1.y = v1.y;
_this1.z = v1.z;
let _this2 = this.w2[0];
let v2 = this.w2[1];
_this2.x = v2.x;
_this2.y = v2.y;
_this2.z = v2.z;
break;
case 4:
let _this3 = this.s[0];
let v3 = this.s[2];
_this3.x = v3.x;
_this3.y = v3.y;
_this3.z = v3.z;
let _this4 = this.w1[0];
let v4 = this.w1[2];
_this4.x = v4.x;
_this4.y = v4.y;
_this4.z = v4.z;
let _this5 = this.w2[0];
let v5 = this.w2[2];
_this5.x = v5.x;
_this5.y = v5.y;
_this5.z = v5.z;
break;
case 5:
let _this6 = this.s[1];
let v6 = this.s[2];
_this6.x = v6.x;
_this6.y = v6.y;
_this6.z = v6.z;
let _this7 = this.w1[1];
let v7 = this.w1[2];
_this7.x = v7.x;
_this7.y = v7.y;
_this7.z = v7.z;
let _this8 = this.w2[1];
let v8 = this.w2[2];
_this8.x = v8.x;
_this8.y = v8.y;
_this8.z = v8.z;
break;
case 6:
let _this9 = this.s[0];
let v9 = this.s[2];
_this9.x = v9.x;
_this9.y = v9.y;
_this9.z = v9.z;
let _this10 = this.w1[0];
let v10 = this.w1[2];
_this10.x = v10.x;
_this10.y = v10.y;
_this10.z = v10.z;
let _this11 = this.w2[0];
let v11 = this.w2[2];
_this11.x = v11.x;
_this11.y = v11.y;
_this11.z = v11.z;
break;
case 8:
let _this12 = this.s[0];
let v12 = this.s[3];
_this12.x = v12.x;
_this12.y = v12.y;
_this12.z = v12.z;
let _this13 = this.w1[0];
let v13 = this.w1[3];
_this13.x = v13.x;
_this13.y = v13.y;
_this13.z = v13.z;
let _this14 = this.w2[0];
let v14 = this.w2[3];
_this14.x = v14.x;
_this14.y = v14.y;
_this14.z = v14.z;
break;
case 9:
let _this15 = this.s[1];
let v15 = this.s[3];
_this15.x = v15.x;
_this15.y = v15.y;
_this15.z = v15.z;
let _this16 = this.w1[1];
let v16 = this.w1[3];
_this16.x = v16.x;
_this16.y = v16.y;
_this16.z = v16.z;
let _this17 = this.w2[1];
let v17 = this.w2[3];
_this17.x = v17.x;
_this17.y = v17.y;
_this17.z = v17.z;
break;
case 10:
let _this18 = this.s[0];
let v18 = this.s[3];
_this18.x = v18.x;
_this18.y = v18.y;
_this18.z = v18.z;
let _this19 = this.w1[0];
let v19 = this.w1[3];
_this19.x = v19.x;
_this19.y = v19.y;
_this19.z = v19.z;
let _this20 = this.w2[0];
let v20 = this.w2[3];
_this20.x = v20.x;
_this20.y = v20.y;
_this20.z = v20.z;
break;
case 11:
let _this21 = this.s[2];
let v21 = this.s[3];
_this21.x = v21.x;
_this21.y = v21.y;
_this21.z = v21.z;
let _this22 = this.w1[2];
let v22 = this.w1[3];
_this22.x = v22.x;
_this22.y = v22.y;
_this22.z = v22.z;
let _this23 = this.w2[2];
let v23 = this.w2[3];
_this23.x = v23.x;
_this23.y = v23.y;
_this23.z = v23.z;
break;
case 12:
let _this24 = this.s[0];
let v24 = this.s[2];
_this24.x = v24.x;
_this24.y = v24.y;
_this24.z = v24.z;
let _this25 = this.w1[0];
let v25 = this.w1[2];
_this25.x = v25.x;
_this25.y = v25.y;
_this25.z = v25.z;
let _this26 = this.w2[0];
let v26 = this.w2[2];
_this26.x = v26.x;
_this26.y = v26.y;
_this26.z = v26.z;
let _this27 = this.s[1];
let v27 = this.s[3];
_this27.x = v27.x;
_this27.y = v27.y;
_this27.z = v27.z;
let _this28 = this.w1[1];
let v28 = this.w1[3];
_this28.x = v28.x;
_this28.y = v28.y;
_this28.z = v28.z;
let _this29 = this.w2[1];
let v29 = this.w2[3];
_this29.x = v29.x;
_this29.y = v29.y;
_this29.z = v29.z;
break;
case 13:
let _this30 = this.s[1];
let v30 = this.s[3];
_this30.x = v30.x;
_this30.y = v30.y;
_this30.z = v30.z;
let _this31 = this.w1[1];
let v31 = this.w1[3];
_this31.x = v31.x;
_this31.y = v31.y;
_this31.z = v31.z;
let _this32 = this.w2[1];
let v32 = this.w2[3];
_this32.x = v32.x;
_this32.y = v32.y;
_this32.z = v32.z;
break;
case 14:
let _this33 = this.s[0];
let v33 = this.s[3];
_this33.x = v33.x;
_this33.y = v33.y;
_this33.z = v33.z;
let _this34 = this.w1[0];
let v34 = this.w1[3];
_this34.x = v34.x;
_this34.y = v34.y;
_this34.z = v34.z;
let _this35 = this.w2[0];
let v35 = this.w2[3];
_this35.x = v35.x;
_this35.y = v35.y;
_this35.z = v35.z;
break;
}
}
computeWitnessPoint1(addMargin) {
let tmpX;
let tmpY;
let tmpZ;
let idirX;
let idirY;
let idirZ;
let v = this.dir;
idirX = v.x;
idirY = v.y;
idirZ = v.z;
let ldir1X;
let ldir1Y;
let ldir1Z;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = this.tf1._rotation00 * idirX + this.tf1._rotation10 * idirY + this.tf1._rotation20 * idirZ;
__tmp__Y = this.tf1._rotation01 * idirX + this.tf1._rotation11 * idirY + this.tf1._rotation21 * idirZ;
__tmp__Z = this.tf1._rotation02 * idirX + this.tf1._rotation12 * idirY + this.tf1._rotation22 * idirZ;
ldir1X = __tmp__X;
ldir1Y = __tmp__Y;
ldir1Z = __tmp__Z;
let iw1X;
let iw1Y;
let iw1Z;
let v1 = this.dir;
v1.x = ldir1X;
v1.y = ldir1Y;
v1.z = ldir1Z;
this.c1.computeLocalSupportingVertex(this.dir,this.w1[this.simplexSize]);
if(addMargin) {
let _this = this.dir;
let invLen = Math.sqrt(_this.x * _this.x + _this.y * _this.y + _this.z * _this.z);
if(invLen > 0) {
invLen = 1 / invLen;
}
_this.x *= invLen;
_this.y *= invLen;
_this.z *= invLen;
let _this1 = this.w1[this.simplexSize];
let v = this.dir;
let s = this.c1._gjkMargin;
_this1.x += v.x * s;
_this1.y += v.y * s;
_this1.z += v.z * s;
}
let v2 = this.w1[this.simplexSize];
tmpX = v2.x;
tmpY = v2.y;
tmpZ = v2.z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = this.tf1._rotation00 * tmpX + this.tf1._rotation01 * tmpY + this.tf1._rotation02 * tmpZ;
__tmp__Y1 = this.tf1._rotation10 * tmpX + this.tf1._rotation11 * tmpY + this.tf1._rotation12 * tmpZ;
__tmp__Z1 = this.tf1._rotation20 * tmpX + this.tf1._rotation21 * tmpY + this.tf1._rotation22 * tmpZ;
iw1X = __tmp__X1;
iw1Y = __tmp__Y1;
iw1Z = __tmp__Z1;
iw1X += this.tf1._positionX;
iw1Y += this.tf1._positionY;
iw1Z += this.tf1._positionZ;
let v3 = this.w1[this.simplexSize];
v3.x = iw1X;
v3.y = iw1Y;
v3.z = iw1Z;
let v4 = this.dir;
v4.x = idirX;
v4.y = idirY;
v4.z = idirZ;
}
computeWitnessPoint2(addMargin) {
let tmpX;
let tmpY;
let tmpZ;
let idirX;
let idirY;
let idirZ;
let v = this.dir;
idirX = v.x;
idirY = v.y;
idirZ = v.z;
let ldir2X;
let ldir2Y;
let ldir2Z;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = this.tf2._rotation00 * idirX + this.tf2._rotation10 * idirY + this.tf2._rotation20 * idirZ;
__tmp__Y = this.tf2._rotation01 * idirX + this.tf2._rotation11 * idirY + this.tf2._rotation21 * idirZ;
__tmp__Z = this.tf2._rotation02 * idirX + this.tf2._rotation12 * idirY + this.tf2._rotation22 * idirZ;
ldir2X = __tmp__X;
ldir2Y = __tmp__Y;
ldir2Z = __tmp__Z;
ldir2X = -ldir2X;
ldir2Y = -ldir2Y;
ldir2Z = -ldir2Z;
let iw2X;
let iw2Y;
let iw2Z;
let v1 = this.dir;
v1.x = ldir2X;
v1.y = ldir2Y;
v1.z = ldir2Z;
this.c2.computeLocalSupportingVertex(this.dir,this.w2[this.simplexSize]);
if(addMargin) {
let _this = this.dir;
let invLen = Math.sqrt(_this.x * _this.x + _this.y * _this.y + _this.z * _this.z);
if(invLen > 0) {
invLen = 1 / invLen;
}
_this.x *= invLen;
_this.y *= invLen;
_this.z *= invLen;
let _this1 = this.w2[this.simplexSize];
let v = this.dir;
let s = this.c2._gjkMargin;
_this1.x += v.x * s;
_this1.y += v.y * s;
_this1.z += v.z * s;
}
let v2 = this.w2[this.simplexSize];
tmpX = v2.x;
tmpY = v2.y;
tmpZ = v2.z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = this.tf2._rotation00 * tmpX + this.tf2._rotation01 * tmpY + this.tf2._rotation02 * tmpZ;
__tmp__Y1 = this.tf2._rotation10 * tmpX + this.tf2._rotation11 * tmpY + this.tf2._rotation12 * tmpZ;
__tmp__Z1 = this.tf2._rotation20 * tmpX + this.tf2._rotation21 * tmpY + this.tf2._rotation22 * tmpZ;
iw2X = __tmp__X1;
iw2Y = __tmp__Y1;
iw2Z = __tmp__Z1;
iw2X += this.tf2._positionX;
iw2Y += this.tf2._positionY;
iw2Z += this.tf2._positionZ;
let v3 = this.w2[this.simplexSize];
v3.x = iw2X;
v3.y = iw2Y;
v3.z = iw2Z;
let v4 = this.dir;
v4.x = idirX;
v4.y = idirY;
v4.z = idirZ;
}
pointToTetrahedron() {
let _g = 0;
while(_g < 3) {
let _this = this.dir;
let v = this.baseDirs[_g++];
_this.x = v.x;
_this.y = v.y;
_this.z = v.z;
this.computeWitnessPoint1(false);
this.computeWitnessPoint2(false);
let _this1 = this.s[this.simplexSize];
let v1 = this.w1[this.simplexSize];
_this1.x = v1.x;
_this1.y = v1.y;
_this1.z = v1.z;
let v2 = this.w2[this.simplexSize];
_this1.x -= v2.x;
_this1.y -= v2.y;
_this1.z -= v2.z;
this.simplexSize++;
this.lineToTetrahedron();
if(this.simplexSize == 4) {
break;
}
this.simplexSize--;
let _this2 = this.dir;
_this2.x = -_this2.x;
_this2.y = -_this2.y;
_this2.z = -_this2.z;
this.computeWitnessPoint1(false);
this.computeWitnessPoint2(false);
let _this3 = this.s[this.simplexSize];
let v3 = this.w1[this.simplexSize];
_this3.x = v3.x;
_this3.y = v3.y;
_this3.z = v3.z;
let v4 = this.w2[this.simplexSize];
_this3.x -= v4.x;
_this3.y -= v4.y;
_this3.z -= v4.z;
this.simplexSize++;
this.lineToTetrahedron();
if(this.simplexSize == 4) {
break;
}
this.simplexSize--;
}
}
lineToTetrahedron() {
let oldDirX;
let oldDirY;
let oldDirZ;
let v = this.dir;
oldDirX = v.x;
oldDirY = v.y;
oldDirZ = v.z;
let s0X;
let s0Y;
let s0Z;
let s1X;
let s1Y;
let s1Z;
let lineDirX;
let lineDirY;
let lineDirZ;
let v1 = this.s[0];
s0X = v1.x;
s0Y = v1.y;
s0Z = v1.z;
let v2 = this.s[1];
s1X = v2.x;
s1Y = v2.y;
s1Z = v2.z;
lineDirX = s0X - s1X;
lineDirY = s0Y - s1Y;
lineDirZ = s0Z - s1Z;
let _g = 0;
while(_g < 3) {
let baseDirX;
let baseDirY;
let baseDirZ;
let v = this.baseDirs[_g++];
baseDirX = v.x;
baseDirY = v.y;
baseDirZ = v.z;
let newDirX;
let newDirY;
let newDirZ;
newDirX = lineDirY * baseDirZ - lineDirZ * baseDirY;
newDirY = lineDirZ * baseDirX - lineDirX * baseDirZ;
newDirZ = lineDirX * baseDirY - lineDirY * baseDirX;
let v1 = this.dir;
v1.x = newDirX;
v1.y = newDirY;
v1.z = newDirZ;
this.computeWitnessPoint1(false);
this.computeWitnessPoint2(false);
let _this = this.s[this.simplexSize];
let v2 = this.w1[this.simplexSize];
_this.x = v2.x;
_this.y = v2.y;
_this.z = v2.z;
let v3 = this.w2[this.simplexSize];
_this.x -= v3.x;
_this.y -= v3.y;
_this.z -= v3.z;
this.simplexSize++;
this.triangleToTetrahedron();
if(this.simplexSize == 4) {
break;
}
this.simplexSize--;
let _this1 = this.dir;
_this1.x = -_this1.x;
_this1.y = -_this1.y;
_this1.z = -_this1.z;
this.computeWitnessPoint1(false);
this.computeWitnessPoint2(false);
let _this2 = this.s[this.simplexSize];
let v4 = this.w1[this.simplexSize];
_this2.x = v4.x;
_this2.y = v4.y;
_this2.z = v4.z;
let v5 = this.w2[this.simplexSize];
_this2.x -= v5.x;
_this2.y -= v5.y;
_this2.z -= v5.z;
this.simplexSize++;
this.triangleToTetrahedron();
if(this.simplexSize == 4) {
break;
}
this.simplexSize--;
}
let v3 = this.dir;
v3.x = oldDirX;
v3.y = oldDirY;
v3.z = oldDirZ;
}
triangleToTetrahedron() {
let oldDirX;
let oldDirY;
let oldDirZ;
let v = this.dir;
oldDirX = v.x;
oldDirY = v.y;
oldDirZ = v.z;
while(true) {
let s0X;
let s0Y;
let s0Z;
let s1X;
let s1Y;
let s1Z;
let s2X;
let s2Y;
let s2Z;
let s01X;
let s01Y;
let s01Z;
let s02X;
let s02Y;
let s02Z;
let v = this.s[0];
s0X = v.x;
s0Y = v.y;
s0Z = v.z;
let v1 = this.s[1];
s1X = v1.x;
s1Y = v1.y;
s1Z = v1.z;
let v2 = this.s[2];
s2X = v2.x;
s2Y = v2.y;
s2Z = v2.z;
s01X = s1X - s0X;
s01Y = s1Y - s0Y;
s01Z = s1Z - s0Z;
s02X = s2X - s0X;
s02Y = s2Y - s0Y;
s02Z = s2Z - s0Z;
let nX;
let nY;
let nZ;
nX = s01Y * s02Z - s01Z * s02Y;
nY = s01Z * s02X - s01X * s02Z;
nZ = s01X * s02Y - s01Y * s02X;
let v3 = this.dir;
v3.x = nX;
v3.y = nY;
v3.z = nZ;
this.computeWitnessPoint1(false);
this.computeWitnessPoint2(false);
let _this = this.s[this.simplexSize];
let v4 = this.w1[this.simplexSize];
_this.x = v4.x;
_this.y = v4.y;
_this.z = v4.z;
let v5 = this.w2[this.simplexSize];
_this.x -= v5.x;
_this.y -= v5.y;
_this.z -= v5.z;
this.simplexSize++;
if(this.isValidTetrahedron()) {
break;
}
this.simplexSize--;
let _this1 = this.dir;
_this1.x = -_this1.x;
_this1.y = -_this1.y;
_this1.z = -_this1.z;
this.computeWitnessPoint1(false);
this.computeWitnessPoint2(false);
let _this2 = this.s[this.simplexSize];
let v6 = this.w1[this.simplexSize];
_this2.x = v6.x;
_this2.y = v6.y;
_this2.z = v6.z;
let v7 = this.w2[this.simplexSize];
_this2.x -= v7.x;
_this2.y -= v7.y;
_this2.z -= v7.z;
this.simplexSize++;
if(this.isValidTetrahedron()) {
break;
}
this.simplexSize--;
break;
}
let v1 = this.dir;
v1.x = oldDirX;
v1.y = oldDirY;
v1.z = oldDirZ;
}
isValidTetrahedron() {
let e10 = this.s[2].x - this.s[0].x;
let e11 = this.s[2].y - this.s[0].y;
let e12 = this.s[2].z - this.s[0].z;
let e20 = this.s[3].x - this.s[0].x;
let e21 = this.s[3].y - this.s[0].y;
let e22 = this.s[3].z - this.s[0].z;
let det = (this.s[1].x - this.s[0].x) * (e11 * e22 - e12 * e21) - (this.s[1].y - this.s[0].y) * (e10 * e22 - e12 * e20) + (this.s[1].z - this.s[0].z) * (e10 * e21 - e11 * e20);
if(!(det > 1e-12)) {
return det < -1e-12;
} else {
return true;
}
}
computeDepth(convex1,convex2,tf1,tf2,initialPolyhedron,initialPolyhedron1,initialPolyhedron2) {
let _this = this.polyhedron;
while(_this._numTriangles > 0) {
let t = _this._triangleList;
_this._numTriangles--;
let prev = t._prev;
let next = t._next;
if(prev != null) {
prev._next = next;
}
if(next != null) {
next._prev = prev;
}
if(t == _this._triangleList) {
_this._triangleList = _this._triangleList._next;
}
if(t == _this._triangleListLast) {
_this._triangleListLast = _this._triangleListLast._prev;
}
t._next = null;
t._prev = null;
t.removeReferences();
t._next = _this._trianglePool;
_this._trianglePool = t;
}
while(_this._numVertices > 0) {
let v = _this._vertices[--_this._numVertices];
v.removeReferences();
v._next = _this._vertexPool;
_this._vertexPool = v;
}
let tmp = this.polyhedron;
let _this1 = this.polyhedron;
let first = _this1._vertexPool;
if(first != null) {
_this1._vertexPool = first._next;
first._next = null;
} else {
first = new oimo.collision.narrowphase.detector.gjkepa.EpaVertex();
}
let tmp1 = first.init(initialPolyhedron[0],initialPolyhedron1[0],initialPolyhedron2[0]);
let _this2 = this.polyhedron;
let first1 = _this2._vertexPool;
if(first1 != null) {
_this2._vertexPool = first1._next;
first1._next = null;
} else {
first1 = new oimo.collision.narrowphase.detector.gjkepa.EpaVertex();
}
let tmp2 = first1.init(initialPolyhedron[1],initialPolyhedron1[1],initialPolyhedron2[1]);
let _this3 = this.polyhedron;
let first2 = _this3._vertexPool;
if(first2 != null) {
_this3._vertexPool = first2._next;
first2._next = null;
} else {
first2 = new oimo.collision.narrowphase.detector.gjkepa.EpaVertex();
}
let tmp3 = first2.init(initialPolyhedron[2],initialPolyhedron1[2],initialPolyhedron2[2]);
let _this4 = this.polyhedron;
let first3 = _this4._vertexPool;
if(first3 != null) {
_this4._vertexPool = first3._next;
first3._next = null;
} else {
first3 = new oimo.collision.narrowphase.detector.gjkepa.EpaVertex();
}
if(!tmp._init(tmp1,tmp2,tmp3,first3.init(initialPolyhedron[3],initialPolyhedron1[3],initialPolyhedron2[3]))) {
return oimo.collision.narrowphase.detector.gjkepa.GjkEpaResultState.EPA_FAILED_TO_INIT;
}
this.simplexSize = 0;
let supportingVertex = this.s[0];
let witness1 = this.w1[0];
let witness2 = this.w2[0];
let count = 0;
while(count < 40) {
let f = this.polyhedron._triangleList;
let mind = 1e65536;
let minf = null;
while(f != null) {
if(f._distanceSq < mind) {
mind = f._distanceSq;
minf = f;
}
f = f._next;
}
let face = minf;
let _this = this.dir;
let v = face._normal;
_this.x = v.x;
_this.y = v.y;
_this.z = v.z;
let invLen = Math.sqrt(_this.x * _this.x + _this.y * _this.y + _this.z * _this.z);
if(invLen > 0) {
invLen = 1 / invLen;
}
_this.x *= invLen;
_this.y *= invLen;
_this.z *= invLen;
this.computeWitnessPoint1(false);
this.computeWitnessPoint2(false);
let _this1 = this.s[this.simplexSize];
let v1 = this.w1[this.simplexSize];
_this1.x = v1.x;
_this1.y = v1.y;
_this1.z = v1.z;
let v2 = this.w2[this.simplexSize];
_this1.x -= v2.x;
_this1.y -= v2.y;
_this1.z -= v2.z;
let v0 = face._vertices[0];
let v11 = face._vertices[1];
let v21 = face._vertices[2];
let _this2 = v0.v;
let v3 = this.dir;
let v4 = this.dir;
if(supportingVertex.x * v4.x + supportingVertex.y * v4.y + supportingVertex.z * v4.z - (_this2.x * v3.x + _this2.y * v3.y + _this2.z * v3.z) < 1e-6 || count == 39) {
let _this = this.closest;
let v = this.dir;
_this.x = v.x;
_this.y = v.y;
_this.z = v.z;
let _this1 = this.dir;
let v1 = v0.v;
let _this2 = this.dir;
let s = (_this1.x * v1.x + _this1.y * v1.y + _this1.z * v1.z) / (_this2.x * _this2.x + _this2.y * _this2.y + _this2.z * _this2.z);
_this.x *= s;
_this.y *= s;
_this.z *= s;
let cX;
let cY;
let cZ;
let v2 = this.closest;
cX = v2.x;
cY = v2.y;
cZ = v2.z;
let s0X;
let s0Y;
let s0Z;
let w10X;
let w10Y;
let w10Z;
let w20X;
let w20Y;
let w20Z;
let s1X;
let s1Y;
let s1Z;
let w11X;
let w11Y;
let w11Z;
let w21X;
let w21Y;
let w21Z;
let s2X;
let s2Y;
let s2Z;
let w12X;
let w12Y;
let w12Z;
let w22X;
let w22Y;
let w22Z;
let v3 = v0.v;
s0X = v3.x;
s0Y = v3.y;
s0Z = v3.z;
let v4 = v0.w1;
w10X = v4.x;
w10Y = v4.y;
w10Z = v4.z;
let v5 = v0.w2;
w20X = v5.x;
w20Y = v5.y;
w20Z = v5.z;
let v6 = v11.v;
s1X = v6.x;
s1Y = v6.y;
s1Z = v6.z;
let v7 = v11.w1;
w11X = v7.x;
w11Y = v7.y;
w11Z = v7.z;
let v8 = v11.w2;
w21X = v8.x;
w21Y = v8.y;
w21Z = v8.z;
let v9 = v21.v;
s2X = v9.x;
s2Y = v9.y;
s2Z = v9.z;
let v10 = v21.w1;
w12X = v10.x;
w12Y = v10.y;
w12Z = v10.z;
let v12 = v21.w2;
w22X = v12.x;
w22Y = v12.y;
w22Z = v12.z;
let s01X;
let s01Y;
let s01Z;
let s02X;
let s02Y;
let s02Z;
let s0cX;
let s0cY;
let s0cZ;
s01X = s1X - s0X;
s01Y = s1Y - s0Y;
s01Z = s1Z - s0Z;
s02X = s2X - s0X;
s02Y = s2Y - s0Y;
s02Z = s2Z - s0Z;
s0cX = cX - s0X;
s0cY = cY - s0Y;
s0cZ = cZ - s0Z;
let d11 = s01X * s01X + s01Y * s01Y + s01Z * s01Z;
let d12 = s01X * s02X + s01Y * s02Y + s01Z * s02Z;
let d22 = s02X * s02X + s02Y * s02Y + s02Z * s02Z;
let d1c = s01X * s0cX + s01Y * s0cY + s01Z * s0cZ;
let d2c = s02X * s0cX + s02Y * s0cY + s02Z * s0cZ;
let invDet = d11 * d22 - d12 * d12;
if(invDet != 0) {
invDet = 1 / invDet;
}
let s1 = (d1c * d22 - d2c * d12) * invDet;
let t = (-d1c * d12 + d2c * d11) * invDet;
let diffX;
let diffY;
let diffZ;
let cp1X;
let cp1Y;
let cp1Z;
let cp2X;
let cp2Y;
let cp2Z;
diffX = w11X - w10X;
diffY = w11Y - w10Y;
diffZ = w11Z - w10Z;
cp1X = w10X + diffX * s1;
cp1Y = w10Y + diffY * s1;
cp1Z = w10Z + diffZ * s1;
diffX = w12X - w10X;
diffY = w12Y - w10Y;
diffZ = w12Z - w10Z;
cp1X += diffX * t;
cp1Y += diffY * t;
cp1Z += diffZ * t;
diffX = w21X - w20X;
diffY = w21Y - w20Y;
diffZ = w21Z - w20Z;
cp2X = w20X + diffX * s1;
cp2Y = w20Y + diffY * s1;
cp2Z = w20Z + diffZ * s1;
diffX = w22X - w20X;
diffY = w22Y - w20Y;
diffZ = w22Z - w20Z;
cp2X += diffX * t;
cp2Y += diffY * t;
cp2Z += diffZ * t;
let v13 = this.closestPoint1;
v13.x = cp1X;
v13.y = cp1Y;
v13.z = cp1Z;
let v14 = this.closestPoint2;
v14.x = cp2X;
v14.y = cp2Y;
v14.z = cp2Z;
let _this3 = this.closest;
this.depth = Math.sqrt(_this3.x * _this3.x + _this3.y * _this3.y + _this3.z * _this3.z);
return oimo.collision.narrowphase.detector.gjkepa.GjkEpaResultState.SUCCEEDED;
}
let _this3 = this.polyhedron;
let first = _this3._vertexPool;
if(first != null) {
_this3._vertexPool = first._next;
first._next = null;
} else {
first = new oimo.collision.narrowphase.detector.gjkepa.EpaVertex();
}
let epaVertex = first.init(supportingVertex,witness1,witness2);
if(!this.polyhedron._addVertex(epaVertex,face)) {
return oimo.collision.narrowphase.detector.gjkepa.GjkEpaResultState.EPA_FAILED_TO_ADD_VERTEX;
}
++count;
}
return oimo.collision.narrowphase.detector.gjkepa.GjkEpaResultState.EPA_DID_NOT_CONVERGE;
}
computeClosestPoints(c1,c2,tf1,tf2,cache) {
return this.computeClosestPointsImpl(c1,c2,tf1,tf2,cache,true);
}
computeDistance(c1,c2,tf1,tf2,cache) {
return this.computeClosestPointsImpl(c1,c2,tf1,tf2,cache,false);
}
convexCast(c1,c2,tf1,tf2,tl1,tl2,hit) {
return this.convexCastImpl(c1,c2,tf1,tf2,tl1,tl2,hit);
}
rayCast(c,tf,begin,end,hit) {
let tf1 = this.tempTransform;
tf1._positionX = begin.x;
tf1._positionY = begin.y;
tf1._positionZ = begin.z;
let tl1 = this.tl1;
let tl2 = this.tl2;
tl1.x = end.x;
tl1.y = end.y;
tl1.z = end.z;
tl1.x -= begin.x;
tl1.y -= begin.y;
tl1.z -= begin.z;
tl2.zero();
return this.convexCastImpl(null,c,tf1,tf,tl1,tl2,hit);
}
static getInstance() {
return oimo.collision.narrowphase.detector.gjkepa.GjkEpa.instance;
}
}
oimo.collision.narrowphase.detector.gjkepa.GjkEpaLog = class oimo_collision_narrowphase_detector_gjkepa_GjkEpaLog {
}
oimo.collision.narrowphase.detector.gjkepa.GjkEpaResultState = class oimo_collision_narrowphase_detector_gjkepa_GjkEpaResultState {
}
oimo.collision.narrowphase.detector.gjkepa.SimplexUtil = class oimo_collision_narrowphase_detector_gjkepa_SimplexUtil {
static projectOrigin2(vec1,vec2,out) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec1.x;
v1Y = vec1.y;
v1Z = vec1.z;
v2X = vec2.x;
v2Y = vec2.y;
v2Z = vec2.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
if(t < 0) {
out.x = v1X;
out.y = v1Y;
out.z = v1Z;
return 1;
}
if(t > 1) {
out.x = v2X;
out.y = v2Y;
out.z = v2Z;
return 2;
}
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
out.x = pX;
out.y = pY;
out.z = pZ;
return 3;
}
static projectOrigin3(vec1,vec2,vec3,out) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
let v3X;
let v3Y;
let v3Z;
let v12X;
let v12Y;
let v12Z;
let v23X;
let v23Y;
let v23Z;
let v31X;
let v31Y;
let v31Z;
v1X = vec1.x;
v1Y = vec1.y;
v1Z = vec1.z;
v2X = vec2.x;
v2Y = vec2.y;
v2Z = vec2.z;
v3X = vec3.x;
v3Y = vec3.y;
v3Z = vec3.z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
v23X = v3X - v2X;
v23Y = v3Y - v2Y;
v23Z = v3Z - v2Z;
v31X = v1X - v3X;
v31Y = v1Y - v3Y;
v31Z = v1Z - v3Z;
let nX;
let nY;
let nZ;
nX = v12Y * v23Z - v12Z * v23Y;
nY = v12Z * v23X - v12X * v23Z;
nZ = v12X * v23Y - v12Y * v23X;
let n12X;
let n12Y;
let n12Z;
let n23X;
let n23Y;
let n23Z;
let n31X;
let n31Y;
let n31Z;
n12X = v12Y * nZ - v12Z * nY;
n12Y = v12Z * nX - v12X * nZ;
n12Z = v12X * nY - v12Y * nX;
n23X = v23Y * nZ - v23Z * nY;
n23Y = v23Z * nX - v23X * nZ;
n23Z = v23X * nY - v23Y * nX;
n31X = v31Y * nZ - v31Z * nY;
n31Y = v31Z * nX - v31X * nZ;
n31Z = v31X * nY - v31Y * nX;
let mind = -1;
let minvX;
let minvY;
let minvZ;
let mini = 0;
minvX = 0;
minvY = 0;
minvZ = 0;
if(v1X * n12X + v1Y * n12Y + v1Z * n12Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec1.x;
v1Y = vec1.y;
v1Z = vec1.z;
v2X = vec2.x;
v2Y = vec2.y;
v2Z = vec2.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
out.x = v1X;
out.y = v1Y;
out.z = v1Z;
b = 1;
} else if(t > 1) {
out.x = v2X;
out.y = v2Y;
out.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
out.x = pX;
out.y = pY;
out.z = pZ;
b = 3;
}
mini = b;
mind = out.x * out.x + out.y * out.y + out.z * out.z;
minvX = out.x;
minvY = out.y;
minvZ = out.z;
}
if(v2X * n23X + v2Y * n23Y + v2Z * n23Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec2.x;
v1Y = vec2.y;
v1Z = vec2.z;
v2X = vec3.x;
v2Y = vec3.y;
v2Z = vec3.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
out.x = v1X;
out.y = v1Y;
out.z = v1Z;
b = 1;
} else if(t > 1) {
out.x = v2X;
out.y = v2Y;
out.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
out.x = pX;
out.y = pY;
out.z = pZ;
b = 3;
}
let d = out.x * out.x + out.y * out.y + out.z * out.z;
if(mind < 0 || d < mind) {
mini = b << 1;
mind = d;
minvX = out.x;
minvY = out.y;
minvZ = out.z;
}
}
if(v3X * n31X + v3Y * n31Y + v3Z * n31Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec1.x;
v1Y = vec1.y;
v1Z = vec1.z;
v2X = vec3.x;
v2Y = vec3.y;
v2Z = vec3.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
out.x = v1X;
out.y = v1Y;
out.z = v1Z;
b = 1;
} else if(t > 1) {
out.x = v2X;
out.y = v2Y;
out.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
out.x = pX;
out.y = pY;
out.z = pZ;
b = 3;
}
let d = out.x * out.x + out.y * out.y + out.z * out.z;
if(mind < 0 || d < mind) {
mini = b & 1 | (b & 2) << 1;
mind = d;
minvX = out.x;
minvY = out.y;
minvZ = out.z;
}
}
if(mind > 0) {
out.x = minvX;
out.y = minvY;
out.z = minvZ;
return mini;
}
let l = nX * nX + nY * nY + nZ * nZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
nX *= l;
nY *= l;
nZ *= l;
let l2 = nX * nX + nY * nY + nZ * nZ;
l2 = (v1X * nX + v1Y * nY + v1Z * nZ) / l2;
minvX = nX * l2;
minvY = nY * l2;
minvZ = nZ * l2;
out.x = minvX;
out.y = minvY;
out.z = minvZ;
return 7;
}
static projectOrigin4(vec1,vec2,vec3,vec4,out) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
let v3X;
let v3Y;
let v3Z;
let v4X;
let v4Y;
let v4Z;
let v12X;
let v12Y;
let v12Z;
let v13X;
let v13Y;
let v13Z;
let v14X;
let v14Y;
let v14Z;
let v23X;
let v23Y;
let v23Z;
let v24X;
let v24Y;
let v24Z;
v1X = vec1.x;
v1Y = vec1.y;
v1Z = vec1.z;
v2X = vec2.x;
v2Y = vec2.y;
v2Z = vec2.z;
v3X = vec3.x;
v3Y = vec3.y;
v3Z = vec3.z;
v4X = vec4.x;
v4Y = vec4.y;
v4Z = vec4.z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
v13X = v3X - v1X;
v13Y = v3Y - v1Y;
v13Z = v3Z - v1Z;
v14X = v4X - v1X;
v14Y = v4Y - v1Y;
v14Z = v4Z - v1Z;
v23X = v3X - v2X;
v23Y = v3Y - v2Y;
v23Z = v3Z - v2Z;
v24X = v4X - v2X;
v24Y = v4Y - v2Y;
v24Z = v4Z - v2Z;
let n123X;
let n123Y;
let n123Z;
let n134X;
let n134Y;
let n134Z;
let n142X;
let n142Y;
let n142Z;
let n243X;
let n243Y;
let n243Z;
n123X = v12Y * v13Z - v12Z * v13Y;
n123Y = v12Z * v13X - v12X * v13Z;
n123Z = v12X * v13Y - v12Y * v13X;
n134X = v13Y * v14Z - v13Z * v14Y;
n134Y = v13Z * v14X - v13X * v14Z;
n134Z = v13X * v14Y - v13Y * v14X;
n142X = v14Y * v12Z - v14Z * v12Y;
n142Y = v14Z * v12X - v14X * v12Z;
n142Z = v14X * v12Y - v14Y * v12X;
n243X = v24Y * v23Z - v24Z * v23Y;
n243Y = v24Z * v23X - v24X * v23Z;
n243Z = v24X * v23Y - v24Y * v23X;
let sign = v12X * n243X + v12Y * n243Y + v12Z * n243Z > 0 ? 1 : -1;
let mind = -1;
let minvX;
let minvY;
let minvZ;
let mini = 0;
minvX = 0;
minvY = 0;
minvZ = 0;
if((v1X * n123X + v1Y * n123Y + v1Z * n123Z) * sign < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
let v3X;
let v3Y;
let v3Z;
let v12X;
let v12Y;
let v12Z;
let v23X;
let v23Y;
let v23Z;
let v31X;
let v31Y;
let v31Z;
v1X = vec1.x;
v1Y = vec1.y;
v1Z = vec1.z;
v2X = vec2.x;
v2Y = vec2.y;
v2Z = vec2.z;
v3X = vec3.x;
v3Y = vec3.y;
v3Z = vec3.z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
v23X = v3X - v2X;
v23Y = v3Y - v2Y;
v23Z = v3Z - v2Z;
v31X = v1X - v3X;
v31Y = v1Y - v3Y;
v31Z = v1Z - v3Z;
let nX;
let nY;
let nZ;
nX = v12Y * v23Z - v12Z * v23Y;
nY = v12Z * v23X - v12X * v23Z;
nZ = v12X * v23Y - v12Y * v23X;
let n12X;
let n12Y;
let n12Z;
let n23X;
let n23Y;
let n23Z;
let n31X;
let n31Y;
let n31Z;
n12X = v12Y * nZ - v12Z * nY;
n12Y = v12Z * nX - v12X * nZ;
n12Z = v12X * nY - v12Y * nX;
n23X = v23Y * nZ - v23Z * nY;
n23Y = v23Z * nX - v23X * nZ;
n23Z = v23X * nY - v23Y * nX;
n31X = v31Y * nZ - v31Z * nY;
n31Y = v31Z * nX - v31X * nZ;
n31Z = v31X * nY - v31Y * nX;
let mind1 = -1;
let minvX1;
let minvY1;
let minvZ1;
let mini1 = 0;
minvX1 = 0;
minvY1 = 0;
minvZ1 = 0;
if(v1X * n12X + v1Y * n12Y + v1Z * n12Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec1.x;
v1Y = vec1.y;
v1Z = vec1.z;
v2X = vec2.x;
v2Y = vec2.y;
v2Z = vec2.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
out.x = v1X;
out.y = v1Y;
out.z = v1Z;
b = 1;
} else if(t > 1) {
out.x = v2X;
out.y = v2Y;
out.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
out.x = pX;
out.y = pY;
out.z = pZ;
b = 3;
}
mini1 = b;
mind1 = out.x * out.x + out.y * out.y + out.z * out.z;
minvX1 = out.x;
minvY1 = out.y;
minvZ1 = out.z;
}
if(v2X * n23X + v2Y * n23Y + v2Z * n23Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec2.x;
v1Y = vec2.y;
v1Z = vec2.z;
v2X = vec3.x;
v2Y = vec3.y;
v2Z = vec3.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
out.x = v1X;
out.y = v1Y;
out.z = v1Z;
b = 1;
} else if(t > 1) {
out.x = v2X;
out.y = v2Y;
out.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
out.x = pX;
out.y = pY;
out.z = pZ;
b = 3;
}
let d = out.x * out.x + out.y * out.y + out.z * out.z;
if(mind1 < 0 || d < mind1) {
mini1 = b << 1;
mind1 = d;
minvX1 = out.x;
minvY1 = out.y;
minvZ1 = out.z;
}
}
if(v3X * n31X + v3Y * n31Y + v3Z * n31Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec1.x;
v1Y = vec1.y;
v1Z = vec1.z;
v2X = vec3.x;
v2Y = vec3.y;
v2Z = vec3.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
out.x = v1X;
out.y = v1Y;
out.z = v1Z;
b = 1;
} else if(t > 1) {
out.x = v2X;
out.y = v2Y;
out.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
out.x = pX;
out.y = pY;
out.z = pZ;
b = 3;
}
let d = out.x * out.x + out.y * out.y + out.z * out.z;
if(mind1 < 0 || d < mind1) {
mini1 = b & 1 | (b & 2) << 1;
mind1 = d;
minvX1 = out.x;
minvY1 = out.y;
minvZ1 = out.z;
}
}
let b;
if(mind1 > 0) {
out.x = minvX1;
out.y = minvY1;
out.z = minvZ1;
b = mini1;
} else {
let l = nX * nX + nY * nY + nZ * nZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
nX *= l;
nY *= l;
nZ *= l;
let l2 = nX * nX + nY * nY + nZ * nZ;
l2 = (v1X * nX + v1Y * nY + v1Z * nZ) / l2;
minvX1 = nX * l2;
minvY1 = nY * l2;
minvZ1 = nZ * l2;
out.x = minvX1;
out.y = minvY1;
out.z = minvZ1;
b = 7;
}
mini = b;
mind = out.x * out.x + out.y * out.y + out.z * out.z;
minvX = out.x;
minvY = out.y;
minvZ = out.z;
}
if((v1X * n134X + v1Y * n134Y + v1Z * n134Z) * sign < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
let v3X;
let v3Y;
let v3Z;
let v12X;
let v12Y;
let v12Z;
let v23X;
let v23Y;
let v23Z;
let v31X;
let v31Y;
let v31Z;
v1X = vec1.x;
v1Y = vec1.y;
v1Z = vec1.z;
v2X = vec3.x;
v2Y = vec3.y;
v2Z = vec3.z;
v3X = vec4.x;
v3Y = vec4.y;
v3Z = vec4.z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
v23X = v3X - v2X;
v23Y = v3Y - v2Y;
v23Z = v3Z - v2Z;
v31X = v1X - v3X;
v31Y = v1Y - v3Y;
v31Z = v1Z - v3Z;
let nX;
let nY;
let nZ;
nX = v12Y * v23Z - v12Z * v23Y;
nY = v12Z * v23X - v12X * v23Z;
nZ = v12X * v23Y - v12Y * v23X;
let n12X;
let n12Y;
let n12Z;
let n23X;
let n23Y;
let n23Z;
let n31X;
let n31Y;
let n31Z;
n12X = v12Y * nZ - v12Z * nY;
n12Y = v12Z * nX - v12X * nZ;
n12Z = v12X * nY - v12Y * nX;
n23X = v23Y * nZ - v23Z * nY;
n23Y = v23Z * nX - v23X * nZ;
n23Z = v23X * nY - v23Y * nX;
n31X = v31Y * nZ - v31Z * nY;
n31Y = v31Z * nX - v31X * nZ;
n31Z = v31X * nY - v31Y * nX;
let mind1 = -1;
let minvX1;
let minvY1;
let minvZ1;
let mini1 = 0;
minvX1 = 0;
minvY1 = 0;
minvZ1 = 0;
if(v1X * n12X + v1Y * n12Y + v1Z * n12Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec1.x;
v1Y = vec1.y;
v1Z = vec1.z;
v2X = vec3.x;
v2Y = vec3.y;
v2Z = vec3.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
out.x = v1X;
out.y = v1Y;
out.z = v1Z;
b = 1;
} else if(t > 1) {
out.x = v2X;
out.y = v2Y;
out.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
out.x = pX;
out.y = pY;
out.z = pZ;
b = 3;
}
mini1 = b;
mind1 = out.x * out.x + out.y * out.y + out.z * out.z;
minvX1 = out.x;
minvY1 = out.y;
minvZ1 = out.z;
}
if(v2X * n23X + v2Y * n23Y + v2Z * n23Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec3.x;
v1Y = vec3.y;
v1Z = vec3.z;
v2X = vec4.x;
v2Y = vec4.y;
v2Z = vec4.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
out.x = v1X;
out.y = v1Y;
out.z = v1Z;
b = 1;
} else if(t > 1) {
out.x = v2X;
out.y = v2Y;
out.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
out.x = pX;
out.y = pY;
out.z = pZ;
b = 3;
}
let d = out.x * out.x + out.y * out.y + out.z * out.z;
if(mind1 < 0 || d < mind1) {
mini1 = b << 1;
mind1 = d;
minvX1 = out.x;
minvY1 = out.y;
minvZ1 = out.z;
}
}
if(v3X * n31X + v3Y * n31Y + v3Z * n31Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec1.x;
v1Y = vec1.y;
v1Z = vec1.z;
v2X = vec4.x;
v2Y = vec4.y;
v2Z = vec4.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
out.x = v1X;
out.y = v1Y;
out.z = v1Z;
b = 1;
} else if(t > 1) {
out.x = v2X;
out.y = v2Y;
out.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
out.x = pX;
out.y = pY;
out.z = pZ;
b = 3;
}
let d = out.x * out.x + out.y * out.y + out.z * out.z;
if(mind1 < 0 || d < mind1) {
mini1 = b & 1 | (b & 2) << 1;
mind1 = d;
minvX1 = out.x;
minvY1 = out.y;
minvZ1 = out.z;
}
}
let b;
if(mind1 > 0) {
out.x = minvX1;
out.y = minvY1;
out.z = minvZ1;
b = mini1;
} else {
let l = nX * nX + nY * nY + nZ * nZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
nX *= l;
nY *= l;
nZ *= l;
let l2 = nX * nX + nY * nY + nZ * nZ;
l2 = (v1X * nX + v1Y * nY + v1Z * nZ) / l2;
minvX1 = nX * l2;
minvY1 = nY * l2;
minvZ1 = nZ * l2;
out.x = minvX1;
out.y = minvY1;
out.z = minvZ1;
b = 7;
}
let d = out.x * out.x + out.y * out.y + out.z * out.z;
if(mind < 0 || d < mind) {
mini = b & 1 | (b & 6) << 1;
mind = d;
minvX = out.x;
minvY = out.y;
minvZ = out.z;
}
}
if((v1X * n142X + v1Y * n142Y + v1Z * n142Z) * sign < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
let v3X;
let v3Y;
let v3Z;
let v12X;
let v12Y;
let v12Z;
let v23X;
let v23Y;
let v23Z;
let v31X;
let v31Y;
let v31Z;
v1X = vec1.x;
v1Y = vec1.y;
v1Z = vec1.z;
v2X = vec2.x;
v2Y = vec2.y;
v2Z = vec2.z;
v3X = vec4.x;
v3Y = vec4.y;
v3Z = vec4.z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
v23X = v3X - v2X;
v23Y = v3Y - v2Y;
v23Z = v3Z - v2Z;
v31X = v1X - v3X;
v31Y = v1Y - v3Y;
v31Z = v1Z - v3Z;
let nX;
let nY;
let nZ;
nX = v12Y * v23Z - v12Z * v23Y;
nY = v12Z * v23X - v12X * v23Z;
nZ = v12X * v23Y - v12Y * v23X;
let n12X;
let n12Y;
let n12Z;
let n23X;
let n23Y;
let n23Z;
let n31X;
let n31Y;
let n31Z;
n12X = v12Y * nZ - v12Z * nY;
n12Y = v12Z * nX - v12X * nZ;
n12Z = v12X * nY - v12Y * nX;
n23X = v23Y * nZ - v23Z * nY;
n23Y = v23Z * nX - v23X * nZ;
n23Z = v23X * nY - v23Y * nX;
n31X = v31Y * nZ - v31Z * nY;
n31Y = v31Z * nX - v31X * nZ;
n31Z = v31X * nY - v31Y * nX;
let mind1 = -1;
let minvX1;
let minvY1;
let minvZ1;
let mini1 = 0;
minvX1 = 0;
minvY1 = 0;
minvZ1 = 0;
if(v1X * n12X + v1Y * n12Y + v1Z * n12Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec1.x;
v1Y = vec1.y;
v1Z = vec1.z;
v2X = vec2.x;
v2Y = vec2.y;
v2Z = vec2.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
out.x = v1X;
out.y = v1Y;
out.z = v1Z;
b = 1;
} else if(t > 1) {
out.x = v2X;
out.y = v2Y;
out.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
out.x = pX;
out.y = pY;
out.z = pZ;
b = 3;
}
mini1 = b;
mind1 = out.x * out.x + out.y * out.y + out.z * out.z;
minvX1 = out.x;
minvY1 = out.y;
minvZ1 = out.z;
}
if(v2X * n23X + v2Y * n23Y + v2Z * n23Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec2.x;
v1Y = vec2.y;
v1Z = vec2.z;
v2X = vec4.x;
v2Y = vec4.y;
v2Z = vec4.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
out.x = v1X;
out.y = v1Y;
out.z = v1Z;
b = 1;
} else if(t > 1) {
out.x = v2X;
out.y = v2Y;
out.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
out.x = pX;
out.y = pY;
out.z = pZ;
b = 3;
}
let d = out.x * out.x + out.y * out.y + out.z * out.z;
if(mind1 < 0 || d < mind1) {
mini1 = b << 1;
mind1 = d;
minvX1 = out.x;
minvY1 = out.y;
minvZ1 = out.z;
}
}
if(v3X * n31X + v3Y * n31Y + v3Z * n31Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec1.x;
v1Y = vec1.y;
v1Z = vec1.z;
v2X = vec4.x;
v2Y = vec4.y;
v2Z = vec4.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
out.x = v1X;
out.y = v1Y;
out.z = v1Z;
b = 1;
} else if(t > 1) {
out.x = v2X;
out.y = v2Y;
out.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
out.x = pX;
out.y = pY;
out.z = pZ;
b = 3;
}
let d = out.x * out.x + out.y * out.y + out.z * out.z;
if(mind1 < 0 || d < mind1) {
mini1 = b & 1 | (b & 2) << 1;
mind1 = d;
minvX1 = out.x;
minvY1 = out.y;
minvZ1 = out.z;
}
}
let b;
if(mind1 > 0) {
out.x = minvX1;
out.y = minvY1;
out.z = minvZ1;
b = mini1;
} else {
let l = nX * nX + nY * nY + nZ * nZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
nX *= l;
nY *= l;
nZ *= l;
let l2 = nX * nX + nY * nY + nZ * nZ;
l2 = (v1X * nX + v1Y * nY + v1Z * nZ) / l2;
minvX1 = nX * l2;
minvY1 = nY * l2;
minvZ1 = nZ * l2;
out.x = minvX1;
out.y = minvY1;
out.z = minvZ1;
b = 7;
}
let d = out.x * out.x + out.y * out.y + out.z * out.z;
if(mind < 0 || d < mind) {
mini = b & 3 | (b & 4) << 1;
mind = d;
minvX = out.x;
minvY = out.y;
minvZ = out.z;
}
}
if((v2X * n243X + v2Y * n243Y + v2Z * n243Z) * sign < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
let v3X;
let v3Y;
let v3Z;
let v12X;
let v12Y;
let v12Z;
let v23X;
let v23Y;
let v23Z;
let v31X;
let v31Y;
let v31Z;
v1X = vec2.x;
v1Y = vec2.y;
v1Z = vec2.z;
v2X = vec3.x;
v2Y = vec3.y;
v2Z = vec3.z;
v3X = vec4.x;
v3Y = vec4.y;
v3Z = vec4.z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
v23X = v3X - v2X;
v23Y = v3Y - v2Y;
v23Z = v3Z - v2Z;
v31X = v1X - v3X;
v31Y = v1Y - v3Y;
v31Z = v1Z - v3Z;
let nX;
let nY;
let nZ;
nX = v12Y * v23Z - v12Z * v23Y;
nY = v12Z * v23X - v12X * v23Z;
nZ = v12X * v23Y - v12Y * v23X;
let n12X;
let n12Y;
let n12Z;
let n23X;
let n23Y;
let n23Z;
let n31X;
let n31Y;
let n31Z;
n12X = v12Y * nZ - v12Z * nY;
n12Y = v12Z * nX - v12X * nZ;
n12Z = v12X * nY - v12Y * nX;
n23X = v23Y * nZ - v23Z * nY;
n23Y = v23Z * nX - v23X * nZ;
n23Z = v23X * nY - v23Y * nX;
n31X = v31Y * nZ - v31Z * nY;
n31Y = v31Z * nX - v31X * nZ;
n31Z = v31X * nY - v31Y * nX;
let mind1 = -1;
let minvX1;
let minvY1;
let minvZ1;
let mini1 = 0;
minvX1 = 0;
minvY1 = 0;
minvZ1 = 0;
if(v1X * n12X + v1Y * n12Y + v1Z * n12Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec2.x;
v1Y = vec2.y;
v1Z = vec2.z;
v2X = vec3.x;
v2Y = vec3.y;
v2Z = vec3.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
out.x = v1X;
out.y = v1Y;
out.z = v1Z;
b = 1;
} else if(t > 1) {
out.x = v2X;
out.y = v2Y;
out.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
out.x = pX;
out.y = pY;
out.z = pZ;
b = 3;
}
mini1 = b;
mind1 = out.x * out.x + out.y * out.y + out.z * out.z;
minvX1 = out.x;
minvY1 = out.y;
minvZ1 = out.z;
}
if(v2X * n23X + v2Y * n23Y + v2Z * n23Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec3.x;
v1Y = vec3.y;
v1Z = vec3.z;
v2X = vec4.x;
v2Y = vec4.y;
v2Z = vec4.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
out.x = v1X;
out.y = v1Y;
out.z = v1Z;
b = 1;
} else if(t > 1) {
out.x = v2X;
out.y = v2Y;
out.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
out.x = pX;
out.y = pY;
out.z = pZ;
b = 3;
}
let d = out.x * out.x + out.y * out.y + out.z * out.z;
if(mind1 < 0 || d < mind1) {
mini1 = b << 1;
mind1 = d;
minvX1 = out.x;
minvY1 = out.y;
minvZ1 = out.z;
}
}
if(v3X * n31X + v3Y * n31Y + v3Z * n31Z < 0) {
let v1X;
let v1Y;
let v1Z;
let v2X;
let v2Y;
let v2Z;
v1X = vec2.x;
v1Y = vec2.y;
v1Z = vec2.z;
v2X = vec4.x;
v2Y = vec4.y;
v2Z = vec4.z;
let v12X;
let v12Y;
let v12Z;
v12X = v2X - v1X;
v12Y = v2Y - v1Y;
v12Z = v2Z - v1Z;
let t = v12X * v1X + v12Y * v1Y + v12Z * v1Z;
t = -t / (v12X * v12X + v12Y * v12Y + v12Z * v12Z);
let b;
if(t < 0) {
out.x = v1X;
out.y = v1Y;
out.z = v1Z;
b = 1;
} else if(t > 1) {
out.x = v2X;
out.y = v2Y;
out.z = v2Z;
b = 2;
} else {
let pX;
let pY;
let pZ;
pX = v1X + v12X * t;
pY = v1Y + v12Y * t;
pZ = v1Z + v12Z * t;
out.x = pX;
out.y = pY;
out.z = pZ;
b = 3;
}
let d = out.x * out.x + out.y * out.y + out.z * out.z;
if(mind1 < 0 || d < mind1) {
mini1 = b & 1 | (b & 2) << 1;
mind1 = d;
minvX1 = out.x;
minvY1 = out.y;
minvZ1 = out.z;
}
}
let b;
if(mind1 > 0) {
out.x = minvX1;
out.y = minvY1;
out.z = minvZ1;
b = mini1;
} else {
let l = nX * nX + nY * nY + nZ * nZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
nX *= l;
nY *= l;
nZ *= l;
let l2 = nX * nX + nY * nY + nZ * nZ;
l2 = (v1X * nX + v1Y * nY + v1Z * nZ) / l2;
minvX1 = nX * l2;
minvY1 = nY * l2;
minvZ1 = nZ * l2;
out.x = minvX1;
out.y = minvY1;
out.z = minvZ1;
b = 7;
}
let d = out.x * out.x + out.y * out.y + out.z * out.z;
if(mind < 0 || d < mind) {
mini = b << 1;
mind = d;
minvX = out.x;
minvY = out.y;
minvZ = out.z;
}
}
if(mind > 0) {
out.x = minvX;
out.y = minvY;
out.z = minvZ;
return mini;
}
out.zero();
return 15;
}
}
oimo.common.Mat3 = class oimo_common_Mat3 {
constructor(e00,e01,e02,e10,e11,e12,e20,e21,e22) {
if(e22 == null) {
e22 = 1;
}
if(e21 == null) {
e21 = 0;
}
if(e20 == null) {
e20 = 0;
}
if(e12 == null) {
e12 = 0;
}
if(e11 == null) {
e11 = 1;
}
if(e10 == null) {
e10 = 0;
}
if(e02 == null) {
e02 = 0;
}
if(e01 == null) {
e01 = 0;
}
if(e00 == null) {
e00 = 1;
}
this.e00 = e00;
this.e01 = e01;
this.e02 = e02;
this.e10 = e10;
this.e11 = e11;
this.e12 = e12;
this.e20 = e20;
this.e21 = e21;
this.e22 = e22;
oimo.common.Mat3.numCreations++;
}
init(e00,e01,e02,e10,e11,e12,e20,e21,e22) {
this.e00 = e00;
this.e01 = e01;
this.e02 = e02;
this.e10 = e10;
this.e11 = e11;
this.e12 = e12;
this.e20 = e20;
this.e21 = e21;
this.e22 = e22;
return this;
}
identity() {
this.e00 = 1;
this.e01 = 0;
this.e02 = 0;
this.e10 = 0;
this.e11 = 1;
this.e12 = 0;
this.e20 = 0;
this.e21 = 0;
this.e22 = 1;
return this;
}
add(m) {
return new oimo.common.Mat3(this.e00 + m.e00,this.e01 + m.e01,this.e02 + m.e02,this.e10 + m.e10,this.e11 + m.e11,this.e12 + m.e12,this.e20 + m.e20,this.e21 + m.e21,this.e22 + m.e22);
}
sub(m) {
return new oimo.common.Mat3(this.e00 - m.e00,this.e01 - m.e01,this.e02 - m.e02,this.e10 - m.e10,this.e11 - m.e11,this.e12 - m.e12,this.e20 - m.e20,this.e21 - m.e21,this.e22 - m.e22);
}
scale(s) {
return new oimo.common.Mat3(this.e00 * s,this.e01 * s,this.e02 * s,this.e10 * s,this.e11 * s,this.e12 * s,this.e20 * s,this.e21 * s,this.e22 * s);
}
mul(m) {
return new oimo.common.Mat3(this.e00 * m.e00 + this.e01 * m.e10 + this.e02 * m.e20,this.e00 * m.e01 + this.e01 * m.e11 + this.e02 * m.e21,this.e00 * m.e02 + this.e01 * m.e12 + this.e02 * m.e22,this.e10 * m.e00 + this.e11 * m.e10 + this.e12 * m.e20,this.e10 * m.e01 + this.e11 * m.e11 + this.e12 * m.e21,this.e10 * m.e02 + this.e11 * m.e12 + this.e12 * m.e22,this.e20 * m.e00 + this.e21 * m.e10 + this.e22 * m.e20,this.e20 * m.e01 + this.e21 * m.e11 + this.e22 * m.e21,this.e20 * m.e02 + this.e21 * m.e12 + this.e22 * m.e22);
}
addEq(m) {
this.e00 += m.e00;
this.e01 += m.e01;
this.e02 += m.e02;
this.e10 += m.e10;
this.e11 += m.e11;
this.e12 += m.e12;
this.e20 += m.e20;
this.e21 += m.e21;
this.e22 += m.e22;
return this;
}
subEq(m) {
this.e00 -= m.e00;
this.e01 -= m.e01;
this.e02 -= m.e02;
this.e10 -= m.e10;
this.e11 -= m.e11;
this.e12 -= m.e12;
this.e20 -= m.e20;
this.e21 -= m.e21;
this.e22 -= m.e22;
return this;
}
scaleEq(s) {
this.e00 *= s;
this.e01 *= s;
this.e02 *= s;
this.e10 *= s;
this.e11 *= s;
this.e12 *= s;
this.e20 *= s;
this.e21 *= s;
this.e22 *= s;
return this;
}
mulEq(m) {
let e01 = this.e00 * m.e01 + this.e01 * m.e11 + this.e02 * m.e21;
let e02 = this.e00 * m.e02 + this.e01 * m.e12 + this.e02 * m.e22;
let e10 = this.e10 * m.e00 + this.e11 * m.e10 + this.e12 * m.e20;
let e11 = this.e10 * m.e01 + this.e11 * m.e11 + this.e12 * m.e21;
let e12 = this.e10 * m.e02 + this.e11 * m.e12 + this.e12 * m.e22;
let e20 = this.e20 * m.e00 + this.e21 * m.e10 + this.e22 * m.e20;
let e21 = this.e20 * m.e01 + this.e21 * m.e11 + this.e22 * m.e21;
let e22 = this.e20 * m.e02 + this.e21 * m.e12 + this.e22 * m.e22;
this.e00 = this.e00 * m.e00 + this.e01 * m.e10 + this.e02 * m.e20;
this.e01 = e01;
this.e02 = e02;
this.e10 = e10;
this.e11 = e11;
this.e12 = e12;
this.e20 = e20;
this.e21 = e21;
this.e22 = e22;
return this;
}
prependScale(sx,sy,sz) {
return new oimo.common.Mat3(this.e00 * sx,this.e01 * sx,this.e02 * sx,this.e10 * sy,this.e11 * sy,this.e12 * sy,this.e20 * sz,this.e21 * sz,this.e22 * sz);
}
appendScale(sx,sy,sz) {
return new oimo.common.Mat3(this.e00 * sx,this.e01 * sy,this.e02 * sz,this.e10 * sx,this.e11 * sy,this.e12 * sz,this.e20 * sx,this.e21 * sy,this.e22 * sz);
}
prependRotation(rad,axisX,axisY,axisZ) {
let s = Math.sin(rad);
let c = Math.cos(rad);
let c1 = 1 - c;
let r00 = axisX * axisX * c1 + c;
let r01 = axisX * axisY * c1 - axisZ * s;
let r02 = axisX * axisZ * c1 + axisY * s;
let r10 = axisY * axisX * c1 + axisZ * s;
let r11 = axisY * axisY * c1 + c;
let r12 = axisY * axisZ * c1 - axisX * s;
let r20 = axisZ * axisX * c1 - axisY * s;
let r21 = axisZ * axisY * c1 + axisX * s;
let r22 = axisZ * axisZ * c1 + c;
return new oimo.common.Mat3(r00 * this.e00 + r01 * this.e10 + r02 * this.e20,r00 * this.e01 + r01 * this.e11 + r02 * this.e21,r00 * this.e02 + r01 * this.e12 + r02 * this.e22,r10 * this.e00 + r11 * this.e10 + r12 * this.e20,r10 * this.e01 + r11 * this.e11 + r12 * this.e21,r10 * this.e02 + r11 * this.e12 + r12 * this.e22,r20 * this.e00 + r21 * this.e10 + r22 * this.e20,r20 * this.e01 + r21 * this.e11 + r22 * this.e21,r20 * this.e02 + r21 * this.e12 + r22 * this.e22);
}
appendRotation(rad,axisX,axisY,axisZ) {
let s = Math.sin(rad);
let c = Math.cos(rad);
let c1 = 1 - c;
let r00 = axisX * axisX * c1 + c;
let r01 = axisX * axisY * c1 - axisZ * s;
let r02 = axisX * axisZ * c1 + axisY * s;
let r10 = axisY * axisX * c1 + axisZ * s;
let r11 = axisY * axisY * c1 + c;
let r12 = axisY * axisZ * c1 - axisX * s;
let r20 = axisZ * axisX * c1 - axisY * s;
let r21 = axisZ * axisY * c1 + axisX * s;
let r22 = axisZ * axisZ * c1 + c;
return new oimo.common.Mat3(this.e00 * r00 + this.e01 * r10 + this.e02 * r20,this.e00 * r01 + this.e01 * r11 + this.e02 * r21,this.e00 * r02 + this.e01 * r12 + this.e02 * r22,this.e10 * r00 + this.e11 * r10 + this.e12 * r20,this.e10 * r01 + this.e11 * r11 + this.e12 * r21,this.e10 * r02 + this.e11 * r12 + this.e12 * r22,this.e20 * r00 + this.e21 * r10 + this.e22 * r20,this.e20 * r01 + this.e21 * r11 + this.e22 * r21,this.e20 * r02 + this.e21 * r12 + this.e22 * r22);
}
prependScaleEq(sx,sy,sz) {
this.e00 *= sx;
this.e01 *= sx;
this.e02 *= sx;
this.e10 *= sy;
this.e11 *= sy;
this.e12 *= sy;
this.e20 *= sz;
this.e21 *= sz;
this.e22 *= sz;
return this;
}
appendScaleEq(sx,sy,sz) {
this.e00 *= sx;
this.e01 *= sy;
this.e02 *= sz;
this.e10 *= sx;
this.e11 *= sy;
this.e12 *= sz;
this.e20 *= sx;
this.e21 *= sy;
this.e22 *= sz;
return this;
}
prependRotationEq(rad,axisX,axisY,axisZ) {
let s = Math.sin(rad);
let c = Math.cos(rad);
let c1 = 1 - c;
let r00 = axisX * axisX * c1 + c;
let r01 = axisX * axisY * c1 - axisZ * s;
let r02 = axisX * axisZ * c1 + axisY * s;
let r10 = axisY * axisX * c1 + axisZ * s;
let r11 = axisY * axisY * c1 + c;
let r12 = axisY * axisZ * c1 - axisX * s;
let r20 = axisZ * axisX * c1 - axisY * s;
let r21 = axisZ * axisY * c1 + axisX * s;
let r22 = axisZ * axisZ * c1 + c;
let e10 = r10 * this.e00 + r11 * this.e10 + r12 * this.e20;
let e11 = r10 * this.e01 + r11 * this.e11 + r12 * this.e21;
let e12 = r10 * this.e02 + r11 * this.e12 + r12 * this.e22;
let e20 = r20 * this.e00 + r21 * this.e10 + r22 * this.e20;
let e21 = r20 * this.e01 + r21 * this.e11 + r22 * this.e21;
let e22 = r20 * this.e02 + r21 * this.e12 + r22 * this.e22;
this.e00 = r00 * this.e00 + r01 * this.e10 + r02 * this.e20;
this.e01 = r00 * this.e01 + r01 * this.e11 + r02 * this.e21;
this.e02 = r00 * this.e02 + r01 * this.e12 + r02 * this.e22;
this.e10 = e10;
this.e11 = e11;
this.e12 = e12;
this.e20 = e20;
this.e21 = e21;
this.e22 = e22;
return this;
}
appendRotationEq(rad,axisX,axisY,axisZ) {
let s = Math.sin(rad);
let c = Math.cos(rad);
let c1 = 1 - c;
let r00 = axisX * axisX * c1 + c;
let r01 = axisX * axisY * c1 - axisZ * s;
let r02 = axisX * axisZ * c1 + axisY * s;
let r10 = axisY * axisX * c1 + axisZ * s;
let r11 = axisY * axisY * c1 + c;
let r12 = axisY * axisZ * c1 - axisX * s;
let r20 = axisZ * axisX * c1 - axisY * s;
let r21 = axisZ * axisY * c1 + axisX * s;
let r22 = axisZ * axisZ * c1 + c;
let e01 = this.e00 * r01 + this.e01 * r11 + this.e02 * r21;
let e02 = this.e00 * r02 + this.e01 * r12 + this.e02 * r22;
let e11 = this.e10 * r01 + this.e11 * r11 + this.e12 * r21;
let e12 = this.e10 * r02 + this.e11 * r12 + this.e12 * r22;
let e21 = this.e20 * r01 + this.e21 * r11 + this.e22 * r21;
let e22 = this.e20 * r02 + this.e21 * r12 + this.e22 * r22;
this.e00 = this.e00 * r00 + this.e01 * r10 + this.e02 * r20;
this.e01 = e01;
this.e02 = e02;
this.e10 = this.e10 * r00 + this.e11 * r10 + this.e12 * r20;
this.e11 = e11;
this.e12 = e12;
this.e20 = this.e20 * r00 + this.e21 * r10 + this.e22 * r20;
this.e21 = e21;
this.e22 = e22;
return this;
}
transpose() {
return new oimo.common.Mat3(this.e00,this.e10,this.e20,this.e01,this.e11,this.e21,this.e02,this.e12,this.e22);
}
transposeEq() {
let e10 = this.e01;
let e20 = this.e02;
let e21 = this.e12;
this.e01 = this.e10;
this.e02 = this.e20;
this.e10 = e10;
this.e12 = this.e21;
this.e20 = e20;
this.e21 = e21;
return this;
}
determinant() {
return this.e00 * (this.e11 * this.e22 - this.e12 * this.e21) - this.e01 * (this.e10 * this.e22 - this.e12 * this.e20) + this.e02 * (this.e10 * this.e21 - this.e11 * this.e20);
}
trace() {
return this.e00 + this.e11 + this.e22;
}
inverse() {
let d00 = this.e11 * this.e22 - this.e12 * this.e21;
let d01 = this.e10 * this.e22 - this.e12 * this.e20;
let d02 = this.e10 * this.e21 - this.e11 * this.e20;
let invDet = this.e00 * d00 - this.e01 * d01 + this.e02 * d02;
if(invDet != 0) {
invDet = 1 / invDet;
}
return new oimo.common.Mat3(d00 * invDet,-(this.e01 * this.e22 - this.e02 * this.e21) * invDet,(this.e01 * this.e12 - this.e02 * this.e11) * invDet,-d01 * invDet,(this.e00 * this.e22 - this.e02 * this.e20) * invDet,-(this.e00 * this.e12 - this.e02 * this.e10) * invDet,d02 * invDet,-(this.e00 * this.e21 - this.e01 * this.e20) * invDet,(this.e00 * this.e11 - this.e01 * this.e10) * invDet);
}
inverseEq() {
let d00 = this.e11 * this.e22 - this.e12 * this.e21;
let d01 = this.e10 * this.e22 - this.e12 * this.e20;
let d02 = this.e10 * this.e21 - this.e11 * this.e20;
let invDet = this.e00 * d00 - this.e01 * d01 + this.e02 * d02;
if(invDet != 0) {
invDet = 1 / invDet;
}
let t02 = (this.e01 * this.e12 - this.e02 * this.e11) * invDet;
let t11 = (this.e00 * this.e22 - this.e02 * this.e20) * invDet;
let t12 = -(this.e00 * this.e12 - this.e02 * this.e10) * invDet;
let t21 = -(this.e00 * this.e21 - this.e01 * this.e20) * invDet;
let t22 = (this.e00 * this.e11 - this.e01 * this.e10) * invDet;
this.e00 = d00 * invDet;
this.e01 = -(this.e01 * this.e22 - this.e02 * this.e21) * invDet;
this.e02 = t02;
this.e10 = -d01 * invDet;
this.e11 = t11;
this.e12 = t12;
this.e20 = d02 * invDet;
this.e21 = t21;
this.e22 = t22;
return this;
}
toArray(columnMajor) {
if(columnMajor == null) {
columnMajor = false;
}
if(columnMajor) {
return [this.e00,this.e10,this.e20,this.e01,this.e11,this.e21,this.e02,this.e12,this.e22];
} else {
return [this.e00,this.e01,this.e02,this.e10,this.e11,this.e12,this.e20,this.e21,this.e22];
}
}
copyFrom(m) {
this.e00 = m.e00;
this.e01 = m.e01;
this.e02 = m.e02;
this.e10 = m.e10;
this.e11 = m.e11;
this.e12 = m.e12;
this.e20 = m.e20;
this.e21 = m.e21;
this.e22 = m.e22;
return this;
}
clone() {
return new oimo.common.Mat3(this.e00,this.e01,this.e02,this.e10,this.e11,this.e12,this.e20,this.e21,this.e22);
}
fromQuat(q) {
let x = q.x;
let y = q.y;
let z = q.z;
let w = q.w;
let x2 = 2 * x;
let y2 = 2 * y;
let z2 = 2 * z;
let xx = x * x2;
let yy = y * y2;
let zz = z * z2;
let xy = x * y2;
let yz = y * z2;
let xz = x * z2;
let wx = w * x2;
let wy = w * y2;
let wz = w * z2;
this.e00 = 1 - yy - zz;
this.e01 = xy - wz;
this.e02 = xz + wy;
this.e10 = xy + wz;
this.e11 = 1 - xx - zz;
this.e12 = yz - wx;
this.e20 = xz - wy;
this.e21 = yz + wx;
this.e22 = 1 - xx - yy;
return this;
}
toQuat() {
let _this = new oimo.common.Quat();
let e00 = this.e00;
let e11 = this.e11;
let e22 = this.e22;
let t = e00 + e11 + e22;
let s;
if(t > 0) {
s = Math.sqrt(t + 1);
_this.w = 0.5 * s;
s = 0.5 / s;
_this.x = (this.e21 - this.e12) * s;
_this.y = (this.e02 - this.e20) * s;
_this.z = (this.e10 - this.e01) * s;
} else if(e00 > e11) {
if(e00 > e22) {
s = Math.sqrt(e00 - e11 - e22 + 1);
_this.x = 0.5 * s;
s = 0.5 / s;
_this.y = (this.e01 + this.e10) * s;
_this.z = (this.e02 + this.e20) * s;
_this.w = (this.e21 - this.e12) * s;
} else {
s = Math.sqrt(e22 - e00 - e11 + 1);
_this.z = 0.5 * s;
s = 0.5 / s;
_this.x = (this.e02 + this.e20) * s;
_this.y = (this.e12 + this.e21) * s;
_this.w = (this.e10 - this.e01) * s;
}
} else if(e11 > e22) {
s = Math.sqrt(e11 - e22 - e00 + 1);
_this.y = 0.5 * s;
s = 0.5 / s;
_this.x = (this.e01 + this.e10) * s;
_this.z = (this.e12 + this.e21) * s;
_this.w = (this.e02 - this.e20) * s;
} else {
s = Math.sqrt(e22 - e00 - e11 + 1);
_this.z = 0.5 * s;
s = 0.5 / s;
_this.x = (this.e02 + this.e20) * s;
_this.y = (this.e12 + this.e21) * s;
_this.w = (this.e10 - this.e01) * s;
}
return _this;
}
fromEulerXyz(eulerAngles) {
let sx = Math.sin(eulerAngles.x);
let sy = Math.sin(eulerAngles.y);
let sz = Math.sin(eulerAngles.z);
let cx = Math.cos(eulerAngles.x);
let cy = Math.cos(eulerAngles.y);
let cz = Math.cos(eulerAngles.z);
this.e00 = cy * cz;
this.e01 = -cy * sz;
this.e02 = sy;
this.e10 = cx * sz + cz * sx * sy;
this.e11 = cx * cz - sx * sy * sz;
this.e12 = -cy * sx;
this.e20 = sx * sz - cx * cz * sy;
this.e21 = cz * sx + cx * sy * sz;
this.e22 = cx * cy;
return this;
}
toEulerXyz() {
let sy = this.e02;
if(sy <= -1) {
let xSubZ = Math.atan2(this.e21,this.e11);
return new oimo.common.Vec3(xSubZ * 0.5,-1.570796326794895,-xSubZ * 0.5);
}
if(sy >= 1) {
let xAddZ = Math.atan2(this.e21,this.e11);
return new oimo.common.Vec3(xAddZ * 0.5,1.570796326794895,xAddZ * 0.5);
}
return new oimo.common.Vec3(Math.atan2(-this.e12,this.e22),Math.asin(sy),Math.atan2(-this.e01,this.e00));
}
getRow(index) {
if(index == 0) {
return new oimo.common.Vec3(this.e00,this.e01,this.e02);
} else if(index == 1) {
return new oimo.common.Vec3(this.e10,this.e11,this.e12);
} else if(index == 2) {
return new oimo.common.Vec3(this.e20,this.e21,this.e22);
} else {
return null;
}
}
getCol(index) {
if(index == 0) {
return new oimo.common.Vec3(this.e00,this.e10,this.e20);
} else if(index == 1) {
return new oimo.common.Vec3(this.e01,this.e11,this.e21);
} else if(index == 2) {
return new oimo.common.Vec3(this.e02,this.e12,this.e22);
} else {
return null;
}
}
getRowTo(index,dst) {
if(index == 0) {
dst.init(this.e00,this.e01,this.e02);
} else if(index == 1) {
dst.init(this.e10,this.e11,this.e12);
} else if(index == 2) {
dst.init(this.e20,this.e21,this.e22);
} else {
dst.zero();
}
}
getColTo(index,dst) {
if(index == 0) {
dst.init(this.e00,this.e10,this.e20);
} else if(index == 1) {
dst.init(this.e01,this.e11,this.e21);
} else if(index == 2) {
dst.init(this.e02,this.e12,this.e22);
} else {
dst.zero();
}
}
fromRows(row0,row1,row2) {
this.e00 = row0.x;
this.e01 = row0.y;
this.e02 = row0.z;
this.e10 = row1.x;
this.e11 = row1.y;
this.e12 = row1.z;
this.e20 = row2.x;
this.e21 = row2.y;
this.e22 = row2.z;
return this;
}
fromCols(col0,col1,col2) {
this.e00 = col0.x;
this.e01 = col1.x;
this.e02 = col2.x;
this.e10 = col0.y;
this.e11 = col1.y;
this.e12 = col2.y;
this.e20 = col0.z;
this.e21 = col1.z;
this.e22 = col2.z;
return this;
}
toString() {
return "Mat3[" + (this.e00 > 0 ? (this.e00 * 10000000 + 0.5 | 0) / 10000000 : (this.e00 * 10000000 - 0.5 | 0) / 10000000) + ", " + (this.e01 > 0 ? (this.e01 * 10000000 + 0.5 | 0) / 10000000 : (this.e01 * 10000000 - 0.5 | 0) / 10000000) + ", " + (this.e02 > 0 ? (this.e02 * 10000000 + 0.5 | 0) / 10000000 : (this.e02 * 10000000 - 0.5 | 0) / 10000000) + ",\n" + " " + (this.e10 > 0 ? (this.e10 * 10000000 + 0.5 | 0) / 10000000 : (this.e10 * 10000000 - 0.5 | 0) / 10000000) + ", " + (this.e11 > 0 ? (this.e11 * 10000000 + 0.5 | 0) / 10000000 : (this.e11 * 10000000 - 0.5 | 0) / 10000000) + ", " + (this.e12 > 0 ? (this.e12 * 10000000 + 0.5 | 0) / 10000000 : (this.e12 * 10000000 - 0.5 | 0) / 10000000) + ",\n" + " " + (this.e20 > 0 ? (this.e20 * 10000000 + 0.5 | 0) / 10000000 : (this.e20 * 10000000 - 0.5 | 0) / 10000000) + ", " + (this.e21 > 0 ? (this.e21 * 10000000 + 0.5 | 0) / 10000000 : (this.e21 * 10000000 - 0.5 | 0) / 10000000) + ", " + (this.e22 > 0 ? (this.e22 * 10000000 + 0.5 | 0) / 10000000 : (this.e22 * 10000000 - 0.5 | 0) / 10000000) + "]";
}
}
oimo.common.Mat4 = class oimo_common_Mat4 {
constructor(e00,e01,e02,e03,e10,e11,e12,e13,e20,e21,e22,e23,e30,e31,e32,e33) {
if(e33 == null) {
e33 = 1;
}
if(e32 == null) {
e32 = 0;
}
if(e31 == null) {
e31 = 0;
}
if(e30 == null) {
e30 = 0;
}
if(e23 == null) {
e23 = 0;
}
if(e22 == null) {
e22 = 1;
}
if(e21 == null) {
e21 = 0;
}
if(e20 == null) {
e20 = 0;
}
if(e13 == null) {
e13 = 0;
}
if(e12 == null) {
e12 = 0;
}
if(e11 == null) {
e11 = 1;
}
if(e10 == null) {
e10 = 0;
}
if(e03 == null) {
e03 = 0;
}
if(e02 == null) {
e02 = 0;
}
if(e01 == null) {
e01 = 0;
}
if(e00 == null) {
e00 = 1;
}
this.e00 = e00;
this.e01 = e01;
this.e02 = e02;
this.e03 = e03;
this.e10 = e10;
this.e11 = e11;
this.e12 = e12;
this.e13 = e13;
this.e20 = e20;
this.e21 = e21;
this.e22 = e22;
this.e23 = e23;
this.e30 = e30;
this.e31 = e31;
this.e32 = e32;
this.e33 = e33;
oimo.common.Mat4.numCreations++;
}
init(e00,e01,e02,e03,e10,e11,e12,e13,e20,e21,e22,e23,e30,e31,e32,e33) {
this.e00 = e00;
this.e01 = e01;
this.e02 = e02;
this.e03 = e03;
this.e10 = e10;
this.e11 = e11;
this.e12 = e12;
this.e13 = e13;
this.e20 = e20;
this.e21 = e21;
this.e22 = e22;
this.e23 = e23;
this.e30 = e30;
this.e31 = e31;
this.e32 = e32;
this.e33 = e33;
return this;
}
identity() {
this.e00 = 1;
this.e01 = 0;
this.e02 = 0;
this.e03 = 0;
this.e10 = 0;
this.e11 = 1;
this.e12 = 0;
this.e13 = 0;
this.e20 = 0;
this.e21 = 0;
this.e22 = 1;
this.e23 = 0;
this.e30 = 0;
this.e31 = 0;
this.e32 = 0;
this.e33 = 1;
return this;
}
add(m) {
return new oimo.common.Mat4(this.e00 + m.e00,this.e01 + m.e01,this.e02 + m.e02,this.e03 + m.e03,this.e10 + m.e10,this.e11 + m.e11,this.e12 + m.e12,this.e13 + m.e13,this.e20 + m.e20,this.e21 + m.e21,this.e22 + m.e22,this.e23 + m.e23,this.e30 + m.e30,this.e31 + m.e31,this.e32 + m.e32,this.e33 + m.e33);
}
sub(m) {
return new oimo.common.Mat4(this.e00 - m.e00,this.e01 - m.e01,this.e02 - m.e02,this.e03 - m.e03,this.e10 - m.e10,this.e11 - m.e11,this.e12 - m.e12,this.e13 - m.e13,this.e20 - m.e20,this.e21 - m.e21,this.e22 - m.e22,this.e23 - m.e23,this.e30 - m.e30,this.e31 - m.e31,this.e32 - m.e32,this.e33 - m.e33);
}
scale(s) {
return new oimo.common.Mat4(this.e00 * s,this.e01 * s,this.e02 * s,this.e03 * s,this.e10 * s,this.e11 * s,this.e12 * s,this.e13 * s,this.e20 * s,this.e21 * s,this.e22 * s,this.e23 * s,this.e30 * s,this.e31 * s,this.e32 * s,this.e33 * s);
}
mul(m) {
return new oimo.common.Mat4(this.e00 * m.e00 + this.e01 * m.e10 + this.e02 * m.e20 + this.e03 * m.e30,this.e00 * m.e01 + this.e01 * m.e11 + this.e02 * m.e21 + this.e03 * m.e31,this.e00 * m.e02 + this.e01 * m.e12 + this.e02 * m.e22 + this.e03 * m.e32,this.e00 * m.e03 + this.e01 * m.e13 + this.e02 * m.e23 + this.e03 * m.e33,this.e10 * m.e00 + this.e11 * m.e10 + this.e12 * m.e20 + this.e13 * m.e30,this.e10 * m.e01 + this.e11 * m.e11 + this.e12 * m.e21 + this.e13 * m.e31,this.e10 * m.e02 + this.e11 * m.e12 + this.e12 * m.e22 + this.e13 * m.e32,this.e10 * m.e03 + this.e11 * m.e13 + this.e12 * m.e23 + this.e13 * m.e33,this.e20 * m.e00 + this.e21 * m.e10 + this.e22 * m.e20 + this.e23 * m.e30,this.e20 * m.e01 + this.e21 * m.e11 + this.e22 * m.e21 + this.e23 * m.e31,this.e20 * m.e02 + this.e21 * m.e12 + this.e22 * m.e22 + this.e23 * m.e32,this.e20 * m.e03 + this.e21 * m.e13 + this.e22 * m.e23 + this.e23 * m.e33,this.e30 * m.e00 + this.e31 * m.e10 + this.e32 * m.e20 + this.e33 * m.e30,this.e30 * m.e01 + this.e31 * m.e11 + this.e32 * m.e21 + this.e33 * m.e31,this.e30 * m.e02 + this.e31 * m.e12 + this.e32 * m.e22 + this.e33 * m.e32,this.e30 * m.e03 + this.e31 * m.e13 + this.e32 * m.e23 + this.e33 * m.e33);
}
addEq(m) {
this.e00 += m.e00;
this.e01 += m.e01;
this.e02 += m.e02;
this.e03 += m.e03;
this.e10 += m.e10;
this.e11 += m.e11;
this.e12 += m.e12;
this.e13 += m.e13;
this.e20 += m.e20;
this.e21 += m.e21;
this.e22 += m.e22;
this.e23 += m.e23;
this.e30 += m.e30;
this.e31 += m.e31;
this.e32 += m.e32;
this.e33 += m.e33;
return this;
}
subEq(m) {
this.e00 -= m.e00;
this.e01 -= m.e01;
this.e02 -= m.e02;
this.e03 -= m.e03;
this.e10 -= m.e10;
this.e11 -= m.e11;
this.e12 -= m.e12;
this.e13 -= m.e13;
this.e20 -= m.e20;
this.e21 -= m.e21;
this.e22 -= m.e22;
this.e23 -= m.e23;
this.e30 -= m.e30;
this.e31 -= m.e31;
this.e32 -= m.e32;
this.e33 -= m.e33;
return this;
}
scaleEq(s) {
this.e00 *= s;
this.e01 *= s;
this.e02 *= s;
this.e03 *= s;
this.e10 *= s;
this.e11 *= s;
this.e12 *= s;
this.e13 *= s;
this.e20 *= s;
this.e21 *= s;
this.e22 *= s;
this.e23 *= s;
this.e30 *= s;
this.e31 *= s;
this.e32 *= s;
this.e33 *= s;
return this;
}
mulEq(m) {
let e01 = this.e00 * m.e01 + this.e01 * m.e11 + this.e02 * m.e21 + this.e03 * m.e31;
let e02 = this.e00 * m.e02 + this.e01 * m.e12 + this.e02 * m.e22 + this.e03 * m.e32;
let e03 = this.e00 * m.e03 + this.e01 * m.e13 + this.e02 * m.e23 + this.e03 * m.e33;
let e10 = this.e10 * m.e00 + this.e11 * m.e10 + this.e12 * m.e20 + this.e13 * m.e30;
let e11 = this.e10 * m.e01 + this.e11 * m.e11 + this.e12 * m.e21 + this.e13 * m.e31;
let e12 = this.e10 * m.e02 + this.e11 * m.e12 + this.e12 * m.e22 + this.e13 * m.e32;
let e13 = this.e10 * m.e03 + this.e11 * m.e13 + this.e12 * m.e23 + this.e13 * m.e33;
let e20 = this.e20 * m.e00 + this.e21 * m.e10 + this.e22 * m.e20 + this.e23 * m.e30;
let e21 = this.e20 * m.e01 + this.e21 * m.e11 + this.e22 * m.e21 + this.e23 * m.e31;
let e22 = this.e20 * m.e02 + this.e21 * m.e12 + this.e22 * m.e22 + this.e23 * m.e32;
let e23 = this.e20 * m.e03 + this.e21 * m.e13 + this.e22 * m.e23 + this.e23 * m.e33;
let e30 = this.e30 * m.e00 + this.e31 * m.e10 + this.e32 * m.e20 + this.e33 * m.e30;
let e31 = this.e30 * m.e01 + this.e31 * m.e11 + this.e32 * m.e21 + this.e33 * m.e31;
let e32 = this.e30 * m.e02 + this.e31 * m.e12 + this.e32 * m.e22 + this.e33 * m.e32;
let e33 = this.e30 * m.e03 + this.e31 * m.e13 + this.e32 * m.e23 + this.e33 * m.e33;
this.e00 = this.e00 * m.e00 + this.e01 * m.e10 + this.e02 * m.e20 + this.e03 * m.e30;
this.e01 = e01;
this.e02 = e02;
this.e03 = e03;
this.e10 = e10;
this.e11 = e11;
this.e12 = e12;
this.e13 = e13;
this.e20 = e20;
this.e21 = e21;
this.e22 = e22;
this.e23 = e23;
this.e30 = e30;
this.e31 = e31;
this.e32 = e32;
this.e33 = e33;
return this;
}
prependScale(sx,sy,sz) {
return new oimo.common.Mat4(this.e00 * sx,this.e01 * sx,this.e02 * sx,this.e03 * sx,this.e10 * sy,this.e11 * sy,this.e12 * sy,this.e13 * sy,this.e20 * sz,this.e21 * sz,this.e22 * sz,this.e23 * sz,this.e30,this.e31,this.e32,this.e33);
}
appendScale(sx,sy,sz) {
return new oimo.common.Mat4(this.e00 * sx,this.e01 * sy,this.e02 * sz,this.e03,this.e10 * sx,this.e11 * sy,this.e12 * sz,this.e13,this.e20 * sx,this.e21 * sy,this.e22 * sz,this.e23,this.e30 * sx,this.e31 * sy,this.e32 * sz,this.e33);
}
prependRotation(rad,axisX,axisY,axisZ) {
let s = Math.sin(rad);
let c = Math.cos(rad);
let c1 = 1 - c;
let r00 = axisX * axisX * c1 + c;
let r01 = axisX * axisY * c1 - axisZ * s;
let r02 = axisX * axisZ * c1 + axisY * s;
let r10 = axisY * axisX * c1 + axisZ * s;
let r11 = axisY * axisY * c1 + c;
let r12 = axisY * axisZ * c1 - axisX * s;
let r20 = axisZ * axisX * c1 - axisY * s;
let r21 = axisZ * axisY * c1 + axisX * s;
let r22 = axisZ * axisZ * c1 + c;
return new oimo.common.Mat4(r00 * this.e00 + r01 * this.e10 + r02 * this.e20,r00 * this.e01 + r01 * this.e11 + r02 * this.e21,r00 * this.e02 + r01 * this.e12 + r02 * this.e22,r00 * this.e03 + r01 * this.e13 + r02 * this.e23,r10 * this.e00 + r11 * this.e10 + r12 * this.e20,r10 * this.e01 + r11 * this.e11 + r12 * this.e21,r10 * this.e02 + r11 * this.e12 + r12 * this.e22,r10 * this.e03 + r11 * this.e13 + r12 * this.e23,r20 * this.e00 + r21 * this.e10 + r22 * this.e20,r20 * this.e01 + r21 * this.e11 + r22 * this.e21,r20 * this.e02 + r21 * this.e12 + r22 * this.e22,r20 * this.e03 + r21 * this.e13 + r22 * this.e23,this.e30,this.e31,this.e32,this.e33);
}
appendRotation(rad,axisX,axisY,axisZ) {
let s = Math.sin(rad);
let c = Math.cos(rad);
let c1 = 1 - c;
let r00 = axisX * axisX * c1 + c;
let r01 = axisX * axisY * c1 - axisZ * s;
let r02 = axisX * axisZ * c1 + axisY * s;
let r10 = axisY * axisX * c1 + axisZ * s;
let r11 = axisY * axisY * c1 + c;
let r12 = axisY * axisZ * c1 - axisX * s;
let r20 = axisZ * axisX * c1 - axisY * s;
let r21 = axisZ * axisY * c1 + axisX * s;
let r22 = axisZ * axisZ * c1 + c;
return new oimo.common.Mat4(this.e00 * r00 + this.e01 * r10 + this.e02 * r20,this.e00 * r01 + this.e01 * r11 + this.e02 * r21,this.e00 * r02 + this.e01 * r12 + this.e02 * r22,this.e03,this.e10 * r00 + this.e11 * r10 + this.e12 * r20,this.e10 * r01 + this.e11 * r11 + this.e12 * r21,this.e10 * r02 + this.e11 * r12 + this.e12 * r22,this.e13,this.e20 * r00 + this.e21 * r10 + this.e22 * r20,this.e20 * r01 + this.e21 * r11 + this.e22 * r21,this.e20 * r02 + this.e21 * r12 + this.e22 * r22,this.e23,this.e30 * r00 + this.e31 * r10 + this.e32 * r20,this.e30 * r01 + this.e31 * r11 + this.e32 * r21,this.e30 * r02 + this.e31 * r12 + this.e32 * r22,this.e33);
}
prependTranslation(tx,ty,tz) {
return new oimo.common.Mat4(this.e00 + tx * this.e30,this.e01 + tx * this.e31,this.e02 + tx * this.e32,this.e03 + tx * this.e33,this.e10 + ty * this.e30,this.e11 + ty * this.e31,this.e12 + ty * this.e32,this.e13 + ty * this.e33,this.e20 + tz * this.e30,this.e21 + tz * this.e31,this.e22 + tz * this.e32,this.e23 + tz * this.e33,this.e30,this.e31,this.e32,this.e33);
}
appendTranslation(tx,ty,tz) {
return new oimo.common.Mat4(this.e00,this.e01,this.e02,this.e00 * tx + this.e01 * ty + this.e02 * tz + this.e03,this.e10,this.e11,this.e12,this.e10 * tx + this.e11 * ty + this.e12 * tz + this.e13,this.e20,this.e21,this.e22,this.e20 * tx + this.e21 * ty + this.e22 * tz + this.e23,this.e30,this.e31,this.e32,this.e30 * tx + this.e31 * ty + this.e32 * tz + this.e33);
}
prependScaleEq(sx,sy,sz) {
this.e00 *= sx;
this.e01 *= sx;
this.e02 *= sx;
this.e03 *= sx;
this.e10 *= sy;
this.e11 *= sy;
this.e12 *= sy;
this.e13 *= sy;
this.e20 *= sz;
this.e21 *= sz;
this.e22 *= sz;
this.e23 *= sz;
return this;
}
appendScaleEq(sx,sy,sz) {
this.e00 *= sx;
this.e01 *= sy;
this.e02 *= sz;
this.e10 *= sx;
this.e11 *= sy;
this.e12 *= sz;
this.e20 *= sx;
this.e21 *= sy;
this.e22 *= sz;
this.e30 *= sx;
this.e31 *= sy;
this.e32 *= sz;
return this;
}
prependRotationEq(rad,axisX,axisY,axisZ) {
let s = Math.sin(rad);
let c = Math.cos(rad);
let c1 = 1 - c;
let r00 = axisX * axisX * c1 + c;
let r01 = axisX * axisY * c1 - axisZ * s;
let r02 = axisX * axisZ * c1 + axisY * s;
let r10 = axisY * axisX * c1 + axisZ * s;
let r11 = axisY * axisY * c1 + c;
let r12 = axisY * axisZ * c1 - axisX * s;
let r20 = axisZ * axisX * c1 - axisY * s;
let r21 = axisZ * axisY * c1 + axisX * s;
let r22 = axisZ * axisZ * c1 + c;
let e10 = r10 * this.e00 + r11 * this.e10 + r12 * this.e20;
let e11 = r10 * this.e01 + r11 * this.e11 + r12 * this.e21;
let e12 = r10 * this.e02 + r11 * this.e12 + r12 * this.e22;
let e13 = r10 * this.e03 + r11 * this.e13 + r12 * this.e23;
let e20 = r20 * this.e00 + r21 * this.e10 + r22 * this.e20;
let e21 = r20 * this.e01 + r21 * this.e11 + r22 * this.e21;
let e22 = r20 * this.e02 + r21 * this.e12 + r22 * this.e22;
let e23 = r20 * this.e03 + r21 * this.e13 + r22 * this.e23;
this.e00 = r00 * this.e00 + r01 * this.e10 + r02 * this.e20;
this.e01 = r00 * this.e01 + r01 * this.e11 + r02 * this.e21;
this.e02 = r00 * this.e02 + r01 * this.e12 + r02 * this.e22;
this.e03 = r00 * this.e03 + r01 * this.e13 + r02 * this.e23;
this.e10 = e10;
this.e11 = e11;
this.e12 = e12;
this.e13 = e13;
this.e20 = e20;
this.e21 = e21;
this.e22 = e22;
this.e23 = e23;
return this;
}
appendRotationEq(rad,axisX,axisY,axisZ) {
let s = Math.sin(rad);
let c = Math.cos(rad);
let c1 = 1 - c;
let r00 = axisX * axisX * c1 + c;
let r01 = axisX * axisY * c1 - axisZ * s;
let r02 = axisX * axisZ * c1 + axisY * s;
let r10 = axisY * axisX * c1 + axisZ * s;
let r11 = axisY * axisY * c1 + c;
let r12 = axisY * axisZ * c1 - axisX * s;
let r20 = axisZ * axisX * c1 - axisY * s;
let r21 = axisZ * axisY * c1 + axisX * s;
let r22 = axisZ * axisZ * c1 + c;
let e01 = this.e00 * r01 + this.e01 * r11 + this.e02 * r21;
let e02 = this.e00 * r02 + this.e01 * r12 + this.e02 * r22;
let e11 = this.e10 * r01 + this.e11 * r11 + this.e12 * r21;
let e12 = this.e10 * r02 + this.e11 * r12 + this.e12 * r22;
let e21 = this.e20 * r01 + this.e21 * r11 + this.e22 * r21;
let e22 = this.e20 * r02 + this.e21 * r12 + this.e22 * r22;
let e31 = this.e30 * r01 + this.e31 * r11 + this.e32 * r21;
let e32 = this.e30 * r02 + this.e31 * r12 + this.e32 * r22;
this.e00 = this.e00 * r00 + this.e01 * r10 + this.e02 * r20;
this.e01 = e01;
this.e02 = e02;
this.e10 = this.e10 * r00 + this.e11 * r10 + this.e12 * r20;
this.e11 = e11;
this.e12 = e12;
this.e20 = this.e20 * r00 + this.e21 * r10 + this.e22 * r20;
this.e21 = e21;
this.e22 = e22;
this.e30 = this.e30 * r00 + this.e31 * r10 + this.e32 * r20;
this.e31 = e31;
this.e32 = e32;
return this;
}
prependTranslationEq(tx,ty,tz) {
this.e00 += tx * this.e30;
this.e01 += tx * this.e31;
this.e02 += tx * this.e32;
this.e03 += tx * this.e33;
this.e10 += ty * this.e30;
this.e11 += ty * this.e31;
this.e12 += ty * this.e32;
this.e13 += ty * this.e33;
this.e20 += tz * this.e30;
this.e21 += tz * this.e31;
this.e22 += tz * this.e32;
this.e23 += tz * this.e33;
return this;
}
appendTranslationEq(tx,ty,tz) {
let e03 = this.e00 * tx + this.e01 * ty + this.e02 * tz + this.e03;
let e13 = this.e10 * tx + this.e11 * ty + this.e12 * tz + this.e13;
let e23 = this.e20 * tx + this.e21 * ty + this.e22 * tz + this.e23;
let e33 = this.e30 * tx + this.e31 * ty + this.e32 * tz + this.e33;
this.e03 = e03;
this.e13 = e13;
this.e23 = e23;
this.e33 = e33;
return this;
}
transpose() {
return new oimo.common.Mat4(this.e00,this.e10,this.e20,this.e30,this.e01,this.e11,this.e21,this.e31,this.e02,this.e12,this.e22,this.e32,this.e03,this.e13,this.e23,this.e33);
}
transposeEq() {
let e10 = this.e01;
let e20 = this.e02;
let e21 = this.e12;
let e30 = this.e03;
let e31 = this.e13;
let e32 = this.e23;
this.e01 = this.e10;
this.e02 = this.e20;
this.e03 = this.e30;
this.e10 = e10;
this.e12 = this.e21;
this.e13 = this.e31;
this.e20 = e20;
this.e21 = e21;
this.e23 = this.e32;
this.e30 = e30;
this.e31 = e31;
this.e32 = e32;
return this;
}
determinant() {
let d23_01 = this.e20 * this.e31 - this.e21 * this.e30;
let d23_02 = this.e20 * this.e32 - this.e22 * this.e30;
let d23_03 = this.e20 * this.e33 - this.e23 * this.e30;
let d23_12 = this.e21 * this.e32 - this.e22 * this.e31;
let d23_13 = this.e21 * this.e33 - this.e23 * this.e31;
let d23_23 = this.e22 * this.e33 - this.e23 * this.e32;
return this.e00 * (this.e11 * d23_23 - this.e12 * d23_13 + this.e13 * d23_12) - this.e01 * (this.e10 * d23_23 - this.e12 * d23_03 + this.e13 * d23_02) + this.e02 * (this.e10 * d23_13 - this.e11 * d23_03 + this.e13 * d23_01) - this.e03 * (this.e10 * d23_12 - this.e11 * d23_02 + this.e12 * d23_01);
}
trace() {
return this.e00 + this.e11 + this.e22 + this.e33;
}
inverse() {
let d01_01 = this.e00 * this.e11 - this.e01 * this.e10;
let d01_02 = this.e00 * this.e12 - this.e02 * this.e10;
let d01_03 = this.e00 * this.e13 - this.e03 * this.e10;
let d01_12 = this.e01 * this.e12 - this.e02 * this.e11;
let d01_13 = this.e01 * this.e13 - this.e03 * this.e11;
let d01_23 = this.e02 * this.e13 - this.e03 * this.e12;
let d23_01 = this.e20 * this.e31 - this.e21 * this.e30;
let d23_02 = this.e20 * this.e32 - this.e22 * this.e30;
let d23_03 = this.e20 * this.e33 - this.e23 * this.e30;
let d23_12 = this.e21 * this.e32 - this.e22 * this.e31;
let d23_13 = this.e21 * this.e33 - this.e23 * this.e31;
let d23_23 = this.e22 * this.e33 - this.e23 * this.e32;
let d00 = this.e11 * d23_23 - this.e12 * d23_13 + this.e13 * d23_12;
let d01 = this.e10 * d23_23 - this.e12 * d23_03 + this.e13 * d23_02;
let d02 = this.e10 * d23_13 - this.e11 * d23_03 + this.e13 * d23_01;
let d03 = this.e10 * d23_12 - this.e11 * d23_02 + this.e12 * d23_01;
let invDet = this.e00 * d00 - this.e01 * d01 + this.e02 * d02 - this.e03 * d03;
if(invDet != 0) {
invDet = 1 / invDet;
}
return new oimo.common.Mat4(d00 * invDet,-(this.e01 * d23_23 - this.e02 * d23_13 + this.e03 * d23_12) * invDet,(this.e31 * d01_23 - this.e32 * d01_13 + this.e33 * d01_12) * invDet,-(this.e21 * d01_23 - this.e22 * d01_13 + this.e23 * d01_12) * invDet,-d01 * invDet,(this.e00 * d23_23 - this.e02 * d23_03 + this.e03 * d23_02) * invDet,-(this.e30 * d01_23 - this.e32 * d01_03 + this.e33 * d01_02) * invDet,(this.e20 * d01_23 - this.e22 * d01_03 + this.e23 * d01_02) * invDet,d02 * invDet,-(this.e00 * d23_13 - this.e01 * d23_03 + this.e03 * d23_01) * invDet,(this.e30 * d01_13 - this.e31 * d01_03 + this.e33 * d01_01) * invDet,-(this.e20 * d01_13 - this.e21 * d01_03 + this.e23 * d01_01) * invDet,-d03 * invDet,(this.e00 * d23_12 - this.e01 * d23_02 + this.e02 * d23_01) * invDet,-(this.e30 * d01_12 - this.e31 * d01_02 + this.e32 * d01_01) * invDet,(this.e20 * d01_12 - this.e21 * d01_02 + this.e22 * d01_01) * invDet);
}
inverseEq() {
let d01_01 = this.e00 * this.e11 - this.e01 * this.e10;
let d01_02 = this.e00 * this.e12 - this.e02 * this.e10;
let d01_03 = this.e00 * this.e13 - this.e03 * this.e10;
let d01_12 = this.e01 * this.e12 - this.e02 * this.e11;
let d01_13 = this.e01 * this.e13 - this.e03 * this.e11;
let d01_23 = this.e02 * this.e13 - this.e03 * this.e12;
let d23_01 = this.e20 * this.e31 - this.e21 * this.e30;
let d23_02 = this.e20 * this.e32 - this.e22 * this.e30;
let d23_03 = this.e20 * this.e33 - this.e23 * this.e30;
let d23_12 = this.e21 * this.e32 - this.e22 * this.e31;
let d23_13 = this.e21 * this.e33 - this.e23 * this.e31;
let d23_23 = this.e22 * this.e33 - this.e23 * this.e32;
let d00 = this.e11 * d23_23 - this.e12 * d23_13 + this.e13 * d23_12;
let d01 = this.e10 * d23_23 - this.e12 * d23_03 + this.e13 * d23_02;
let d02 = this.e10 * d23_13 - this.e11 * d23_03 + this.e13 * d23_01;
let d03 = this.e10 * d23_12 - this.e11 * d23_02 + this.e12 * d23_01;
let invDet = this.e00 * d00 - this.e01 * d01 + this.e02 * d02 - this.e03 * d03;
if(invDet != 0) {
invDet = 1 / invDet;
}
let t11 = (this.e00 * d23_23 - this.e02 * d23_03 + this.e03 * d23_02) * invDet;
let t21 = -(this.e00 * d23_13 - this.e01 * d23_03 + this.e03 * d23_01) * invDet;
let t23 = -(this.e20 * d01_13 - this.e21 * d01_03 + this.e23 * d01_01) * invDet;
let t31 = (this.e00 * d23_12 - this.e01 * d23_02 + this.e02 * d23_01) * invDet;
let t32 = -(this.e30 * d01_12 - this.e31 * d01_02 + this.e32 * d01_01) * invDet;
let t33 = (this.e20 * d01_12 - this.e21 * d01_02 + this.e22 * d01_01) * invDet;
this.e00 = d00 * invDet;
this.e01 = -(this.e01 * d23_23 - this.e02 * d23_13 + this.e03 * d23_12) * invDet;
this.e02 = (this.e31 * d01_23 - this.e32 * d01_13 + this.e33 * d01_12) * invDet;
this.e03 = -(this.e21 * d01_23 - this.e22 * d01_13 + this.e23 * d01_12) * invDet;
this.e10 = -d01 * invDet;
this.e11 = t11;
this.e12 = -(this.e30 * d01_23 - this.e32 * d01_03 + this.e33 * d01_02) * invDet;
this.e13 = (this.e20 * d01_23 - this.e22 * d01_03 + this.e23 * d01_02) * invDet;
this.e20 = d02 * invDet;
this.e21 = t21;
this.e22 = (this.e30 * d01_13 - this.e31 * d01_03 + this.e33 * d01_01) * invDet;
this.e23 = t23;
this.e30 = -d03 * invDet;
this.e31 = t31;
this.e32 = t32;
this.e33 = t33;
return this;
}
lookAt(eyeX,eyeY,eyeZ,atX,atY,atZ,upX,upY,upZ) {
let zx = eyeX - atX;
let zy = eyeY - atY;
let zz = eyeZ - atZ;
let tmp = 1 / Math.sqrt(zx * zx + zy * zy + zz * zz);
zx *= tmp;
zy *= tmp;
zz *= tmp;
let xx = upY * zz - upZ * zy;
let xy = upZ * zx - upX * zz;
let xz = upX * zy - upY * zx;
tmp = 1 / Math.sqrt(xx * xx + xy * xy + xz * xz);
xx *= tmp;
xy *= tmp;
xz *= tmp;
let yx = zy * xz - zz * xy;
let yy = zz * xx - zx * xz;
let yz = zx * xy - zy * xx;
this.e00 = xx;
this.e01 = xy;
this.e02 = xz;
this.e03 = -(xx * eyeX + xy * eyeY + xz * eyeZ);
this.e10 = yx;
this.e11 = yy;
this.e12 = yz;
this.e13 = -(yx * eyeX + yy * eyeY + yz * eyeZ);
this.e20 = zx;
this.e21 = zy;
this.e22 = zz;
this.e23 = -(zx * eyeX + zy * eyeY + zz * eyeZ);
this.e30 = 0;
this.e31 = 0;
this.e32 = 0;
this.e33 = 1;
return this;
}
perspective(fovY,aspect,near,far) {
let h = 1 / Math.tan(fovY * 0.5);
let fnf = far / (near - far);
this.e00 = h / aspect;
this.e01 = 0;
this.e02 = 0;
this.e03 = 0;
this.e10 = 0;
this.e11 = h;
this.e12 = 0;
this.e13 = 0;
this.e20 = 0;
this.e21 = 0;
this.e22 = fnf;
this.e23 = near * fnf;
this.e30 = 0;
this.e31 = 0;
this.e32 = -1;
this.e33 = 0;
return this;
}
ortho(width,height,near,far) {
let nf = 1 / (near - far);
this.e00 = 2 / width;
this.e01 = 0;
this.e02 = 0;
this.e03 = 0;
this.e10 = 0;
this.e11 = 2 / height;
this.e12 = 0;
this.e13 = 0;
this.e20 = 0;
this.e21 = 0;
this.e22 = nf;
this.e23 = near * nf;
this.e30 = 0;
this.e31 = 0;
this.e32 = 0;
this.e33 = 1;
return this;
}
toArray(columnMajor) {
if(columnMajor == null) {
columnMajor = false;
}
if(columnMajor) {
return [this.e00,this.e10,this.e20,this.e30,this.e01,this.e11,this.e21,this.e31,this.e02,this.e12,this.e22,this.e32,this.e03,this.e13,this.e23,this.e33];
} else {
return [this.e00,this.e01,this.e02,this.e03,this.e10,this.e11,this.e12,this.e13,this.e20,this.e21,this.e22,this.e23,this.e30,this.e31,this.e32,this.e33];
}
}
copyFrom(m) {
this.e00 = m.e00;
this.e01 = m.e01;
this.e02 = m.e02;
this.e03 = m.e03;
this.e10 = m.e10;
this.e11 = m.e11;
this.e12 = m.e12;
this.e13 = m.e13;
this.e20 = m.e20;
this.e21 = m.e21;
this.e22 = m.e22;
this.e23 = m.e23;
this.e30 = m.e30;
this.e31 = m.e31;
this.e32 = m.e32;
this.e33 = m.e33;
return this;
}
fromMat3(m) {
this.e00 = m.e00;
this.e01 = m.e01;
this.e02 = m.e02;
this.e03 = 0;
this.e10 = m.e10;
this.e11 = m.e11;
this.e12 = m.e12;
this.e13 = 0;
this.e20 = m.e20;
this.e21 = m.e21;
this.e22 = m.e22;
this.e23 = 0;
this.e30 = 0;
this.e31 = 0;
this.e32 = 0;
this.e33 = 1;
return this;
}
fromTransform(transform) {
this.e00 = transform._rotation00;
this.e01 = transform._rotation01;
this.e02 = transform._rotation02;
this.e10 = transform._rotation10;
this.e11 = transform._rotation11;
this.e12 = transform._rotation12;
this.e20 = transform._rotation20;
this.e21 = transform._rotation21;
this.e22 = transform._rotation22;
this.e03 = transform._positionX;
this.e13 = transform._positionY;
this.e23 = transform._positionZ;
this.e30 = 0;
this.e31 = 0;
this.e32 = 0;
this.e33 = 1;
return this;
}
clone() {
return new oimo.common.Mat4(this.e00,this.e01,this.e02,this.e03,this.e10,this.e11,this.e12,this.e13,this.e20,this.e21,this.e22,this.e23,this.e30,this.e31,this.e32,this.e33);
}
toString() {
return "Mat4[" + (this.e00 > 0 ? (this.e00 * 10000000 + 0.5 | 0) / 10000000 : (this.e00 * 10000000 - 0.5 | 0) / 10000000) + ", " + (this.e01 > 0 ? (this.e01 * 10000000 + 0.5 | 0) / 10000000 : (this.e01 * 10000000 - 0.5 | 0) / 10000000) + ", " + (this.e02 > 0 ? (this.e02 * 10000000 + 0.5 | 0) / 10000000 : (this.e02 * 10000000 - 0.5 | 0) / 10000000) + ", " + (this.e03 > 0 ? (this.e03 * 10000000 + 0.5 | 0) / 10000000 : (this.e03 * 10000000 - 0.5 | 0) / 10000000) + ",\n" + " " + (this.e10 > 0 ? (this.e10 * 10000000 + 0.5 | 0) / 10000000 : (this.e10 * 10000000 - 0.5 | 0) / 10000000) + ", " + (this.e11 > 0 ? (this.e11 * 10000000 + 0.5 | 0) / 10000000 : (this.e11 * 10000000 - 0.5 | 0) / 10000000) + ", " + (this.e12 > 0 ? (this.e12 * 10000000 + 0.5 | 0) / 10000000 : (this.e12 * 10000000 - 0.5 | 0) / 10000000) + ", " + (this.e13 > 0 ? (this.e13 * 10000000 + 0.5 | 0) / 10000000 : (this.e13 * 10000000 - 0.5 | 0) / 10000000) + ",\n" + " " + (this.e20 > 0 ? (this.e20 * 10000000 + 0.5 | 0) / 10000000 : (this.e20 * 10000000 - 0.5 | 0) / 10000000) + ", " + (this.e21 > 0 ? (this.e21 * 10000000 + 0.5 | 0) / 10000000 : (this.e21 * 10000000 - 0.5 | 0) / 10000000) + ", " + (this.e22 > 0 ? (this.e22 * 10000000 + 0.5 | 0) / 10000000 : (this.e22 * 10000000 - 0.5 | 0) / 10000000) + ", " + (this.e23 > 0 ? (this.e23 * 10000000 + 0.5 | 0) / 10000000 : (this.e23 * 10000000 - 0.5 | 0) / 10000000) + ",\n" + " " + (this.e30 > 0 ? (this.e30 * 10000000 + 0.5 | 0) / 10000000 : (this.e30 * 10000000 - 0.5 | 0) / 10000000) + ", " + (this.e31 > 0 ? (this.e31 * 10000000 + 0.5 | 0) / 10000000 : (this.e31 * 10000000 - 0.5 | 0) / 10000000) + ", " + (this.e32 > 0 ? (this.e32 * 10000000 + 0.5 | 0) / 10000000 : (this.e32 * 10000000 - 0.5 | 0) / 10000000) + ", " + (this.e33 > 0 ? (this.e33 * 10000000 + 0.5 | 0) / 10000000 : (this.e33 * 10000000 - 0.5 | 0) / 10000000) + "]";
}
}
oimo.common.MathUtil = class oimo_common_MathUtil {
static abs(x) {
if(x > 0) {
return x;
} else {
return -x;
}
}
static sin(x) {
return Math.sin(x);
}
static cos(x) {
return Math.cos(x);
}
static tan(x) {
return Math.tan(x);
}
static asin(x) {
return Math.asin(x);
}
static acos(x) {
return Math.acos(x);
}
static atan(x) {
return Math.atan(x);
}
static safeAsin(x) {
if(x <= -1) {
return -1.570796326794895;
}
if(x >= 1) {
return 1.570796326794895;
}
return Math.asin(x);
}
static safeAcos(x) {
if(x <= -1) {
return 3.14159265358979;
}
if(x >= 1) {
return 0;
}
return Math.acos(x);
}
static atan2(y,x) {
return Math.atan2(y,x);
}
static sqrt(x) {
return Math.sqrt(x);
}
static clamp(x,min,max) {
if(x < min) {
return min;
} else if(x > max) {
return max;
} else {
return x;
}
}
static rand() {
return Math.random();
}
static randIn(min,max) {
return min + Math.random() * (max - min);
}
static randVec3In(min,max) {
return new oimo.common.Vec3(min + Math.random() * (max - min),min + Math.random() * (max - min),min + Math.random() * (max - min));
}
static randVec3() {
return new oimo.common.Vec3(-1 + Math.random() * 2,-1 + Math.random() * 2,-1 + Math.random() * 2);
}
}
oimo.common.Pool = class oimo_common_Pool {
constructor() {
this.stackVec3 = new Array(256);
this.sizeVec3 = 0;
this.stackMat3 = new Array(256);
this.sizeMat3 = 0;
this.stackMat4 = new Array(256);
this.sizeMat4 = 0;
this.stackQuat = new Array(256);
this.sizeQuat = 0;
}
vec3() {
if(this.sizeVec3 == 0) {
return new oimo.common.Vec3();
} else {
return this.stackVec3[--this.sizeVec3];
}
}
mat3() {
if(this.sizeMat3 == 0) {
return new oimo.common.Mat3();
} else {
return this.stackMat3[--this.sizeMat3];
}
}
mat4() {
if(this.sizeMat4 == 0) {
return new oimo.common.Mat4();
} else {
return this.stackMat4[--this.sizeMat4];
}
}
quat() {
if(this.sizeQuat == 0) {
return new oimo.common.Quat();
} else {
return this.stackQuat[--this.sizeQuat];
}
}
dispose(vec3,mat3,mat4,quat) {
if(vec3 != null) {
vec3.zero();
if(this.sizeVec3 == this.stackVec3.length) {
let newArray = new Array(this.sizeVec3 << 1);
let _g = 0;
let _g1 = this.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = this.stackVec3[i];
this.stackVec3[i] = null;
}
this.stackVec3 = newArray;
}
this.stackVec3[this.sizeVec3++] = vec3;
}
if(mat3 != null) {
mat3.e00 = 1;
mat3.e01 = 0;
mat3.e02 = 0;
mat3.e10 = 0;
mat3.e11 = 1;
mat3.e12 = 0;
mat3.e20 = 0;
mat3.e21 = 0;
mat3.e22 = 1;
if(this.sizeMat3 == this.stackMat3.length) {
let newArray = new Array(this.sizeMat3 << 1);
let _g = 0;
let _g1 = this.sizeMat3;
while(_g < _g1) {
let i = _g++;
newArray[i] = this.stackMat3[i];
this.stackMat3[i] = null;
}
this.stackMat3 = newArray;
}
this.stackMat3[this.sizeMat3++] = mat3;
}
if(mat4 != null) {
mat4.e00 = 1;
mat4.e01 = 0;
mat4.e02 = 0;
mat4.e03 = 0;
mat4.e10 = 0;
mat4.e11 = 1;
mat4.e12 = 0;
mat4.e13 = 0;
mat4.e20 = 0;
mat4.e21 = 0;
mat4.e22 = 1;
mat4.e23 = 0;
mat4.e30 = 0;
mat4.e31 = 0;
mat4.e32 = 0;
mat4.e33 = 1;
if(this.sizeMat4 == this.stackMat4.length) {
let newArray = new Array(this.sizeMat4 << 1);
let _g = 0;
let _g1 = this.sizeMat4;
while(_g < _g1) {
let i = _g++;
newArray[i] = this.stackMat4[i];
this.stackMat4[i] = null;
}
this.stackMat4 = newArray;
}
this.stackMat4[this.sizeMat4++] = mat4;
}
if(quat != null) {
quat.x = 0;
quat.y = 0;
quat.z = 0;
quat.w = 1;
if(this.sizeQuat == this.stackQuat.length) {
let newArray = new Array(this.sizeQuat << 1);
let _g = 0;
let _g1 = this.sizeQuat;
while(_g < _g1) {
let i = _g++;
newArray[i] = this.stackQuat[i];
this.stackQuat[i] = null;
}
this.stackQuat = newArray;
}
this.stackQuat[this.sizeQuat++] = quat;
}
}
disposeVec3(v) {
v.zero();
if(this.sizeVec3 == this.stackVec3.length) {
let newArray = new Array(this.sizeVec3 << 1);
let _g = 0;
let _g1 = this.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = this.stackVec3[i];
this.stackVec3[i] = null;
}
this.stackVec3 = newArray;
}
this.stackVec3[this.sizeVec3++] = v;
}
disposeMat3(m) {
m.e00 = 1;
m.e01 = 0;
m.e02 = 0;
m.e10 = 0;
m.e11 = 1;
m.e12 = 0;
m.e20 = 0;
m.e21 = 0;
m.e22 = 1;
if(this.sizeMat3 == this.stackMat3.length) {
let newArray = new Array(this.sizeMat3 << 1);
let _g = 0;
let _g1 = this.sizeMat3;
while(_g < _g1) {
let i = _g++;
newArray[i] = this.stackMat3[i];
this.stackMat3[i] = null;
}
this.stackMat3 = newArray;
}
this.stackMat3[this.sizeMat3++] = m;
}
disposeMat4(m) {
m.e00 = 1;
m.e01 = 0;
m.e02 = 0;
m.e03 = 0;
m.e10 = 0;
m.e11 = 1;
m.e12 = 0;
m.e13 = 0;
m.e20 = 0;
m.e21 = 0;
m.e22 = 1;
m.e23 = 0;
m.e30 = 0;
m.e31 = 0;
m.e32 = 0;
m.e33 = 1;
if(this.sizeMat4 == this.stackMat4.length) {
let newArray = new Array(this.sizeMat4 << 1);
let _g = 0;
let _g1 = this.sizeMat4;
while(_g < _g1) {
let i = _g++;
newArray[i] = this.stackMat4[i];
this.stackMat4[i] = null;
}
this.stackMat4 = newArray;
}
this.stackMat4[this.sizeMat4++] = m;
}
disposeQuat(q) {
q.x = 0;
q.y = 0;
q.z = 0;
q.w = 1;
if(this.sizeQuat == this.stackQuat.length) {
let newArray = new Array(this.sizeQuat << 1);
let _g = 0;
let _g1 = this.sizeQuat;
while(_g < _g1) {
let i = _g++;
newArray[i] = this.stackQuat[i];
this.stackQuat[i] = null;
}
this.stackQuat = newArray;
}
this.stackQuat[this.sizeQuat++] = q;
}
}
oimo.common.Quat = class oimo_common_Quat {
constructor(x,y,z,w) {
if(w == null) {
w = 1;
}
if(z == null) {
z = 0;
}
if(y == null) {
y = 0;
}
if(x == null) {
x = 0;
}
this.x = x;
this.y = y;
this.z = z;
this.w = w;
oimo.common.Quat.numCreations++;
}
identity() {
this.x = 0;
this.y = 0;
this.z = 0;
this.w = 1;
return this;
}
init(x,y,z,w) {
this.x = x;
this.y = y;
this.z = z;
this.w = w;
return this;
}
add(q) {
return new oimo.common.Quat(this.x + q.x,this.y + q.y,this.z + q.z,this.w + q.w);
}
sub(q) {
return new oimo.common.Quat(this.x - q.x,this.y - q.y,this.z - q.z,this.w - q.w);
}
scale(s) {
return new oimo.common.Quat(this.x * s,this.y * s,this.z * s,this.w * s);
}
addEq(q) {
this.x += q.x;
this.y += q.y;
this.z += q.z;
this.w += q.w;
return this;
}
subEq(q) {
this.x -= q.x;
this.y -= q.y;
this.z -= q.z;
this.w -= q.w;
return this;
}
scaleEq(s) {
this.x *= s;
this.y *= s;
this.z *= s;
this.w *= s;
return this;
}
length() {
return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);
}
lengthSq() {
return this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w;
}
dot(q) {
return this.x * q.x + this.y * q.y + this.z * q.z + this.w * q.w;
}
normalized() {
let invLen = Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);
if(invLen > 0) {
invLen = 1 / invLen;
}
return new oimo.common.Quat(this.x * invLen,this.y * invLen,this.z * invLen,this.w * invLen);
}
normalize() {
let invLen = Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);
if(invLen > 0) {
invLen = 1 / invLen;
}
this.x *= invLen;
this.y *= invLen;
this.z *= invLen;
this.w *= invLen;
return this;
}
setArc(v1,v2) {
let x1 = v1.x;
let y1 = v1.y;
let z1 = v1.z;
let x2 = v2.x;
let y2 = v2.y;
let z2 = v2.z;
let d = x1 * x2 + y1 * y2 + z1 * z2;
this.w = Math.sqrt((1 + d) * 0.5);
if(this.w == 0) {
x2 = x1 * x1;
y2 = y1 * y1;
z2 = z1 * z1;
if(x2 < y2) {
if(x2 < z2) {
d = 1 / Math.sqrt(y2 + z2);
this.x = 0;
this.y = z1 * d;
this.z = -y1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
this.z = 0;
this.x = y1 * d;
this.y = -x1 * d;
}
} else if(y2 < z2) {
d = 1 / Math.sqrt(z2 + x2);
this.y = 0;
this.z = x1 * d;
this.x = -z1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
this.z = 0;
this.x = y1 * d;
this.y = -x1 * d;
}
return this;
}
d = 0.5 / this.w;
this.x = (y1 * z2 - z1 * y2) * d;
this.y = (z1 * x2 - x1 * z2) * d;
this.z = (x1 * y2 - y1 * x2) * d;
return this;
}
slerp(q,t) {
let qx;
let qy;
let qz;
let qw;
let d = this.x * q.x + this.y * q.y + this.z * q.z + this.w * q.w;
if(d < 0) {
d = -d;
qx = -q.x;
qy = -q.y;
qz = -q.z;
qw = -q.w;
} else {
qx = q.x;
qy = q.y;
qz = q.z;
qw = q.w;
}
if(d > 0.999999) {
let _this = new oimo.common.Quat(this.x + (qx - this.x) * t,this.y + (qy - this.y) * t,this.z + (qz - this.z) * t,this.w + (qw - this.w) * t);
let invLen = Math.sqrt(_this.x * _this.x + _this.y * _this.y + _this.z * _this.z + _this.w * _this.w);
if(invLen > 0) {
invLen = 1 / invLen;
}
_this.x *= invLen;
_this.y *= invLen;
_this.z *= invLen;
_this.w *= invLen;
return _this;
}
let theta = t * Math.acos(d);
qx -= this.x * d;
qy -= this.y * d;
qz -= this.z * d;
qw -= this.w * d;
let invLen = 1 / Math.sqrt(qx * qx + qy * qy + qz * qz + qw * qw);
qx *= invLen;
qy *= invLen;
qz *= invLen;
qw *= invLen;
let sin = Math.sin(theta);
let cos = Math.cos(theta);
return new oimo.common.Quat(this.x * cos + qx * sin,this.y * cos + qy * sin,this.z * cos + qz * sin,this.w * cos + qw * sin);
}
copyFrom(q) {
this.x = q.x;
this.y = q.y;
this.z = q.z;
this.w = q.w;
return this;
}
clone() {
return new oimo.common.Quat(this.x,this.y,this.z,this.w);
}
fromMat3(m) {
let e00 = m.e00;
let e11 = m.e11;
let e22 = m.e22;
let t = e00 + e11 + e22;
let s;
if(t > 0) {
s = Math.sqrt(t + 1);
this.w = 0.5 * s;
s = 0.5 / s;
this.x = (m.e21 - m.e12) * s;
this.y = (m.e02 - m.e20) * s;
this.z = (m.e10 - m.e01) * s;
} else if(e00 > e11) {
if(e00 > e22) {
s = Math.sqrt(e00 - e11 - e22 + 1);
this.x = 0.5 * s;
s = 0.5 / s;
this.y = (m.e01 + m.e10) * s;
this.z = (m.e02 + m.e20) * s;
this.w = (m.e21 - m.e12) * s;
} else {
s = Math.sqrt(e22 - e00 - e11 + 1);
this.z = 0.5 * s;
s = 0.5 / s;
this.x = (m.e02 + m.e20) * s;
this.y = (m.e12 + m.e21) * s;
this.w = (m.e10 - m.e01) * s;
}
} else if(e11 > e22) {
s = Math.sqrt(e11 - e22 - e00 + 1);
this.y = 0.5 * s;
s = 0.5 / s;
this.x = (m.e01 + m.e10) * s;
this.z = (m.e12 + m.e21) * s;
this.w = (m.e02 - m.e20) * s;
} else {
s = Math.sqrt(e22 - e00 - e11 + 1);
this.z = 0.5 * s;
s = 0.5 / s;
this.x = (m.e02 + m.e20) * s;
this.y = (m.e12 + m.e21) * s;
this.w = (m.e10 - m.e01) * s;
}
return this;
}
toMat3() {
let _this = new oimo.common.Mat3();
let x = this.x;
let y = this.y;
let z = this.z;
let w = this.w;
let x2 = 2 * x;
let y2 = 2 * y;
let z2 = 2 * z;
let xx = x * x2;
let yy = y * y2;
let zz = z * z2;
let xy = x * y2;
let yz = y * z2;
let xz = x * z2;
let wx = w * x2;
let wy = w * y2;
let wz = w * z2;
_this.e00 = 1 - yy - zz;
_this.e01 = xy - wz;
_this.e02 = xz + wy;
_this.e10 = xy + wz;
_this.e11 = 1 - xx - zz;
_this.e12 = yz - wx;
_this.e20 = xz - wy;
_this.e21 = yz + wx;
_this.e22 = 1 - xx - yy;
return _this;
}
toString() {
return "Quat[" + (this.x > 0 ? (this.x * 10000000 + 0.5 | 0) / 10000000 : (this.x * 10000000 - 0.5 | 0) / 10000000) + " i,\n" + " " + (this.y > 0 ? (this.y * 10000000 + 0.5 | 0) / 10000000 : (this.y * 10000000 - 0.5 | 0) / 10000000) + " j,\n" + " " + (this.z > 0 ? (this.z * 10000000 + 0.5 | 0) / 10000000 : (this.z * 10000000 - 0.5 | 0) / 10000000) + " k,\n" + " " + (this.w > 0 ? (this.w * 10000000 + 0.5 | 0) / 10000000 : (this.w * 10000000 - 0.5 | 0) / 10000000) + "]";
}
}
if(!oimo.dynamics) oimo.dynamics = {};
oimo.dynamics.Contact = class oimo_dynamics_Contact {
constructor() {
this._next = null;
this._prev = null;
this._link1 = new oimo.dynamics.ContactLink();
this._link2 = new oimo.dynamics.ContactLink();
this._s1 = null;
this._s2 = null;
this._b1 = null;
this._b2 = null;
this._detector = null;
this._cachedDetectorData = new oimo.collision.narrowphase.detector.CachedDetectorData();
this._detectorResult = new oimo.collision.narrowphase.DetectorResult();
this._latest = false;
this._shouldBeSkipped = false;
this._manifold = new oimo.dynamics.constraint.contact.Manifold();
this._updater = new oimo.dynamics.constraint.contact.ManifoldUpdater(this._manifold);
this._contactConstraint = new oimo.dynamics.constraint.contact.ContactConstraint(this._manifold);
this._touching = false;
}
_updateManifold() {
if(this._detector == null) {
return;
}
let ptouching = this._touching;
let result = this._detectorResult;
this._detector.detect(result,this._s1._geom,this._s2._geom,this._s1._transform,this._s2._transform,this._cachedDetectorData);
this._touching = result.numPoints > 0;
if(this._touching) {
this._manifold._buildBasis(result.normal);
if(result.getMaxDepth() > oimo.common.Setting.contactUseAlternativePositionCorrectionAlgorithmDepthThreshold) {
this._contactConstraint._positionCorrectionAlgorithm = oimo.common.Setting.alternativeContactPositionCorrectionAlgorithm;
} else {
this._contactConstraint._positionCorrectionAlgorithm = oimo.common.Setting.defaultContactPositionCorrectionAlgorithm;
}
if(result.incremental) {
this._updater.incrementalUpdate(result,this._b1._transform,this._b2._transform);
} else {
this._updater.totalUpdate(result,this._b1._transform,this._b2._transform);
}
} else {
this._manifold._clear();
}
if(this._touching && !ptouching) {
let cc1 = this._s1._contactCallback;
let cc2 = this._s2._contactCallback;
if(cc1 == cc2) {
cc2 = null;
}
if(cc1 != null) {
cc1.beginContact(this);
}
if(cc2 != null) {
cc2.beginContact(this);
}
}
if(!this._touching && ptouching) {
let cc1 = this._s1._contactCallback;
let cc2 = this._s2._contactCallback;
if(cc1 == cc2) {
cc2 = null;
}
if(cc1 != null) {
cc1.endContact(this);
}
if(cc2 != null) {
cc2.endContact(this);
}
}
if(this._touching) {
let cc1 = this._s1._contactCallback;
let cc2 = this._s2._contactCallback;
if(cc1 == cc2) {
cc2 = null;
}
if(cc1 != null) {
cc1.preSolve(this);
}
if(cc2 != null) {
cc2.preSolve(this);
}
}
}
_postSolve() {
let cc1 = this._s1._contactCallback;
let cc2 = this._s2._contactCallback;
if(cc1 == cc2) {
cc2 = null;
}
if(cc1 != null) {
cc1.postSolve(this);
}
if(cc2 != null) {
cc2.postSolve(this);
}
}
getShape1() {
return this._s1;
}
getShape2() {
return this._s2;
}
isTouching() {
return this._touching;
}
getManifold() {
return this._manifold;
}
getContactConstraint() {
return this._contactConstraint;
}
getPrev() {
return this._prev;
}
getNext() {
return this._next;
}
}
oimo.dynamics.ContactLink = class oimo_dynamics_ContactLink {
constructor() {
this._prev = null;
this._next = null;
this._contact = null;
this._other = null;
}
getContact() {
return this._contact;
}
getOther() {
return this._other;
}
getPrev() {
return this._prev;
}
getNext() {
return this._next;
}
}
oimo.dynamics.ContactManager = class oimo_dynamics_ContactManager {
constructor(broadPhase) {
this._broadPhase = broadPhase;
this._collisionMatrix = new oimo.collision.narrowphase.CollisionMatrix();
this._numContacts = 0;
}
createContacts() {
let pp = this._broadPhase._proxyPairList;
while(pp != null) {
let n = pp._next;
while(true) {
let s1;
let s2;
if(pp._p1._id < pp._p2._id) {
s1 = pp._p1.userData;
s2 = pp._p2.userData;
} else {
s1 = pp._p2.userData;
s2 = pp._p1.userData;
}
if(!this.shouldCollide(s1,s2)) {
break;
}
let b1 = s1._rigidBody;
let b2 = s2._rigidBody;
let l;
if(b1._numContactLinks < b2._numContactLinks) {
l = b1._contactLinkList;
} else {
l = b2._contactLinkList;
}
let id1 = s1._id;
let id2 = s2._id;
let found = false;
while(l != null) {
let c = l._contact;
if(c._s1._id == id1 && c._s2._id == id2) {
c._latest = true;
found = true;
break;
}
l = l._next;
}
if(!found) {
let first = this._contactPool;
if(first != null) {
this._contactPool = first._next;
first._next = null;
} else {
first = new oimo.dynamics.Contact();
}
let c = first;
if(this._contactList == null) {
this._contactList = c;
this._contactListLast = c;
} else {
this._contactListLast._next = c;
c._prev = this._contactListLast;
this._contactListLast = c;
}
c._latest = true;
let detector = this._collisionMatrix.detectors[s1._geom._type][s2._geom._type];
c._s1 = s1;
c._s2 = s2;
c._b1 = s1._rigidBody;
c._b2 = s2._rigidBody;
c._touching = false;
if(c._b1._contactLinkList == null) {
c._b1._contactLinkList = c._link1;
c._b1._contactLinkListLast = c._link1;
} else {
c._b1._contactLinkListLast._next = c._link1;
c._link1._prev = c._b1._contactLinkListLast;
c._b1._contactLinkListLast = c._link1;
}
if(c._b2._contactLinkList == null) {
c._b2._contactLinkList = c._link2;
c._b2._contactLinkListLast = c._link2;
} else {
c._b2._contactLinkListLast._next = c._link2;
c._link2._prev = c._b2._contactLinkListLast;
c._b2._contactLinkListLast = c._link2;
}
c._b1._numContactLinks++;
c._b2._numContactLinks++;
c._link1._other = c._b2;
c._link2._other = c._b1;
c._link1._contact = c;
c._link2._contact = c;
c._detector = detector;
let _this = c._contactConstraint;
_this._s1 = s1;
_this._s2 = s2;
_this._b1 = _this._s1._rigidBody;
_this._b2 = _this._s2._rigidBody;
_this._tf1 = _this._b1._transform;
_this._tf2 = _this._b2._transform;
this._numContacts++;
}
break;
}
pp = n;
}
}
destroyOutdatedContacts() {
let incremental = this._broadPhase._incremental;
let c = this._contactList;
while(c != null) {
let n = c._next;
while(true) {
if(c._latest) {
c._latest = false;
c._shouldBeSkipped = false;
break;
}
if(!incremental) {
let prev = c._prev;
let next = c._next;
if(prev != null) {
prev._next = next;
}
if(next != null) {
next._prev = prev;
}
if(c == this._contactList) {
this._contactList = this._contactList._next;
}
if(c == this._contactListLast) {
this._contactListLast = this._contactListLast._prev;
}
c._next = null;
c._prev = null;
if(c._touching) {
let cc1 = c._s1._contactCallback;
let cc2 = c._s2._contactCallback;
if(cc1 == cc2) {
cc2 = null;
}
if(cc1 != null) {
cc1.endContact(c);
}
if(cc2 != null) {
cc2.endContact(c);
}
}
let prev1 = c._link1._prev;
let next1 = c._link1._next;
if(prev1 != null) {
prev1._next = next1;
}
if(next1 != null) {
next1._prev = prev1;
}
if(c._link1 == c._b1._contactLinkList) {
c._b1._contactLinkList = c._b1._contactLinkList._next;
}
if(c._link1 == c._b1._contactLinkListLast) {
c._b1._contactLinkListLast = c._b1._contactLinkListLast._prev;
}
c._link1._next = null;
c._link1._prev = null;
let prev2 = c._link2._prev;
let next2 = c._link2._next;
if(prev2 != null) {
prev2._next = next2;
}
if(next2 != null) {
next2._prev = prev2;
}
if(c._link2 == c._b2._contactLinkList) {
c._b2._contactLinkList = c._b2._contactLinkList._next;
}
if(c._link2 == c._b2._contactLinkListLast) {
c._b2._contactLinkListLast = c._b2._contactLinkListLast._prev;
}
c._link2._next = null;
c._link2._prev = null;
c._b1._numContactLinks--;
c._b2._numContactLinks--;
c._link1._other = null;
c._link2._other = null;
c._link1._contact = null;
c._link2._contact = null;
c._s1 = null;
c._s2 = null;
c._b1 = null;
c._b2 = null;
c._touching = false;
c._cachedDetectorData._clear();
c._manifold._clear();
c._detector = null;
let _this = c._contactConstraint;
_this._s1 = null;
_this._s2 = null;
_this._b1 = null;
_this._b2 = null;
_this._tf1 = null;
_this._tf2 = null;
c._next = this._contactPool;
this._contactPool = c;
this._numContacts--;
break;
}
let s1 = c._s1;
let s2 = c._s2;
let r1 = s1._rigidBody;
let r2 = s2._rigidBody;
if(!(!r1._sleeping && r1._type != 1) && !(!r2._sleeping && r2._type != 1)) {
c._shouldBeSkipped = true;
break;
}
let aabb1 = s1._aabb;
let aabb2 = s2._aabb;
let proxy1 = s1._proxy;
let proxy2 = s2._proxy;
if(!(proxy1._aabbMinX < proxy2._aabbMaxX && proxy1._aabbMaxX > proxy2._aabbMinX && proxy1._aabbMinY < proxy2._aabbMaxY && proxy1._aabbMaxY > proxy2._aabbMinY && proxy1._aabbMinZ < proxy2._aabbMaxZ && proxy1._aabbMaxZ > proxy2._aabbMinZ) || !this.shouldCollide(s1,s2)) {
let prev = c._prev;
let next = c._next;
if(prev != null) {
prev._next = next;
}
if(next != null) {
next._prev = prev;
}
if(c == this._contactList) {
this._contactList = this._contactList._next;
}
if(c == this._contactListLast) {
this._contactListLast = this._contactListLast._prev;
}
c._next = null;
c._prev = null;
if(c._touching) {
let cc1 = c._s1._contactCallback;
let cc2 = c._s2._contactCallback;
if(cc1 == cc2) {
cc2 = null;
}
if(cc1 != null) {
cc1.endContact(c);
}
if(cc2 != null) {
cc2.endContact(c);
}
}
let prev1 = c._link1._prev;
let next1 = c._link1._next;
if(prev1 != null) {
prev1._next = next1;
}
if(next1 != null) {
next1._prev = prev1;
}
if(c._link1 == c._b1._contactLinkList) {
c._b1._contactLinkList = c._b1._contactLinkList._next;
}
if(c._link1 == c._b1._contactLinkListLast) {
c._b1._contactLinkListLast = c._b1._contactLinkListLast._prev;
}
c._link1._next = null;
c._link1._prev = null;
let prev2 = c._link2._prev;
let next2 = c._link2._next;
if(prev2 != null) {
prev2._next = next2;
}
if(next2 != null) {
next2._prev = prev2;
}
if(c._link2 == c._b2._contactLinkList) {
c._b2._contactLinkList = c._b2._contactLinkList._next;
}
if(c._link2 == c._b2._contactLinkListLast) {
c._b2._contactLinkListLast = c._b2._contactLinkListLast._prev;
}
c._link2._next = null;
c._link2._prev = null;
c._b1._numContactLinks--;
c._b2._numContactLinks--;
c._link1._other = null;
c._link2._other = null;
c._link1._contact = null;
c._link2._contact = null;
c._s1 = null;
c._s2 = null;
c._b1 = null;
c._b2 = null;
c._touching = false;
c._cachedDetectorData._clear();
c._manifold._clear();
c._detector = null;
let _this = c._contactConstraint;
_this._s1 = null;
_this._s2 = null;
_this._b1 = null;
_this._b2 = null;
_this._tf1 = null;
_this._tf2 = null;
c._next = this._contactPool;
this._contactPool = c;
this._numContacts--;
break;
}
c._shouldBeSkipped = !(aabb1._minX < aabb2._maxX && aabb1._maxX > aabb2._minX && aabb1._minY < aabb2._maxY && aabb1._maxY > aabb2._minY && aabb1._minZ < aabb2._maxZ && aabb1._maxZ > aabb2._minZ);
break;
}
c = n;
}
}
shouldCollide(s1,s2) {
let r1 = s1._rigidBody;
let r2 = s2._rigidBody;
if(r1 == r2) {
return false;
}
if(r1._type != 0 && r2._type != 0) {
return false;
}
if((s1._collisionGroup & s2._collisionMask) == 0 || (s2._collisionGroup & s1._collisionMask) == 0) {
return false;
}
let jl;
let other;
if(r1._numJointLinks < r2._numJointLinks) {
jl = r1._jointLinkList;
other = r2;
} else {
jl = r2._jointLinkList;
other = r1;
}
while(jl != null) {
if(jl._other == other && !jl._joint._allowCollision) {
return false;
}
jl = jl._next;
}
return true;
}
_updateContacts() {
this._broadPhase.collectPairs();
this.createContacts();
this.destroyOutdatedContacts();
}
_postSolve() {
let c = this._contactList;
while(c != null) {
let n = c._next;
if(c._touching) {
c._postSolve();
}
c = n;
}
}
getNumContacts() {
return this._numContacts;
}
getContactList() {
return this._contactList;
}
}
oimo.dynamics.Island = class oimo_dynamics_Island {
constructor() {
this.rigidBodies = new Array(oimo.common.Setting.islandInitialRigidBodyArraySize);
this.solvers = new Array(oimo.common.Setting.islandInitialConstraintArraySize);
this.solversSi = new Array(oimo.common.Setting.islandInitialConstraintArraySize);
this.solversNgs = new Array(oimo.common.Setting.islandInitialConstraintArraySize);
this.numRigidBodies = 0;
this.numSolvers = 0;
this.numSolversSi = 0;
this.numSolversNgs = 0;
}
_clear() {
while(this.numRigidBodies > 0) this.rigidBodies[--this.numRigidBodies] = null;
while(this.numSolvers > 0) this.solvers[--this.numSolvers] = null;
while(this.numSolversSi > 0) this.solversSi[--this.numSolversSi] = null;
while(this.numSolversNgs > 0) this.solversNgs[--this.numSolversNgs] = null;
}
_addRigidBody(rigidBody) {
if(this.numRigidBodies == this.rigidBodies.length) {
let newArray = new Array(this.numRigidBodies << 1);
let _g = 0;
let _g1 = this.numRigidBodies;
while(_g < _g1) {
let i = _g++;
newArray[i] = this.rigidBodies[i];
this.rigidBodies[i] = null;
}
this.rigidBodies = newArray;
}
rigidBody._addedToIsland = true;
this.rigidBodies[this.numRigidBodies++] = rigidBody;
}
_addConstraintSolver(solver,positionCorrection) {
if(this.numSolvers == this.solvers.length) {
let newArray = new Array(this.numSolvers << 1);
let _g = 0;
let _g1 = this.numSolvers;
while(_g < _g1) {
let i = _g++;
newArray[i] = this.solvers[i];
this.solvers[i] = null;
}
this.solvers = newArray;
}
solver._addedToIsland = true;
this.solvers[this.numSolvers++] = solver;
if(positionCorrection == oimo.dynamics.constraint.PositionCorrectionAlgorithm.SPLIT_IMPULSE) {
if(this.numSolversSi == this.solversSi.length) {
let newArray = new Array(this.numSolversSi << 1);
let _g = 0;
let _g1 = this.numSolversSi;
while(_g < _g1) {
let i = _g++;
newArray[i] = this.solversSi[i];
this.solversSi[i] = null;
}
this.solversSi = newArray;
}
this.solversSi[this.numSolversSi++] = solver;
}
if(positionCorrection == oimo.dynamics.constraint.PositionCorrectionAlgorithm.NGS) {
if(this.numSolversNgs == this.solversNgs.length) {
let newArray = new Array(this.numSolversNgs << 1);
let _g = 0;
let _g1 = this.numSolversNgs;
while(_g < _g1) {
let i = _g++;
newArray[i] = this.solversNgs[i];
this.solversNgs[i] = null;
}
this.solversNgs = newArray;
}
this.solversNgs[this.numSolversNgs++] = solver;
}
}
_stepSingleRigidBody(timeStep,rb) {
let dt = timeStep.dt;
let dst = rb._ptransform;
let src = rb._transform;
dst._positionX = src._positionX;
dst._positionY = src._positionY;
dst._positionZ = src._positionZ;
dst._rotation00 = src._rotation00;
dst._rotation01 = src._rotation01;
dst._rotation02 = src._rotation02;
dst._rotation10 = src._rotation10;
dst._rotation11 = src._rotation11;
dst._rotation12 = src._rotation12;
dst._rotation20 = src._rotation20;
dst._rotation21 = src._rotation21;
dst._rotation22 = src._rotation22;
rb._linearContactImpulseX = 0;
rb._linearContactImpulseY = 0;
rb._linearContactImpulseZ = 0;
rb._angularContactImpulseX = 0;
rb._angularContactImpulseY = 0;
rb._angularContactImpulseZ = 0;
if(rb._autoSleep && rb._velX * rb._velX + rb._velY * rb._velY + rb._velZ * rb._velZ < oimo.common.Setting.sleepingVelocityThreshold * oimo.common.Setting.sleepingVelocityThreshold && rb._angVelX * rb._angVelX + rb._angVelY * rb._angVelY + rb._angVelZ * rb._angVelZ < oimo.common.Setting.sleepingAngularVelocityThreshold * oimo.common.Setting.sleepingAngularVelocityThreshold) {
rb._sleepTime += dt;
if(rb._sleepTime > oimo.common.Setting.sleepingTimeThreshold) {
rb._sleeping = true;
rb._sleepTime = 0;
}
} else {
rb._sleepTime = 0;
}
if(!rb._sleeping) {
if(rb._type == 0) {
let x = dt * rb._linearDamping;
let x2 = x * x;
let linScale = 1 / (1 + x + x2 * (0.5 + x * 0.16666666666666666 + x2 * 0.041666666666666664));
let x1 = dt * rb._angularDamping;
let x21 = x1 * x1;
let angScale = 1 / (1 + x1 + x21 * (0.5 + x1 * 0.16666666666666666 + x21 * 0.041666666666666664));
let linAccX;
let linAccY;
let linAccZ;
let angAccX;
let angAccY;
let angAccZ;
linAccX = this.gravityX * rb._gravityScale;
linAccY = this.gravityY * rb._gravityScale;
linAccZ = this.gravityZ * rb._gravityScale;
linAccX += rb._forceX * rb._invMass;
linAccY += rb._forceY * rb._invMass;
linAccZ += rb._forceZ * rb._invMass;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = rb._invInertia00 * rb._torqueX + rb._invInertia01 * rb._torqueY + rb._invInertia02 * rb._torqueZ;
__tmp__Y = rb._invInertia10 * rb._torqueX + rb._invInertia11 * rb._torqueY + rb._invInertia12 * rb._torqueZ;
__tmp__Z = rb._invInertia20 * rb._torqueX + rb._invInertia21 * rb._torqueY + rb._invInertia22 * rb._torqueZ;
angAccX = __tmp__X;
angAccY = __tmp__Y;
angAccZ = __tmp__Z;
rb._velX += linAccX * dt;
rb._velY += linAccY * dt;
rb._velZ += linAccZ * dt;
rb._velX *= linScale;
rb._velY *= linScale;
rb._velZ *= linScale;
rb._angVelX += angAccX * dt;
rb._angVelY += angAccY * dt;
rb._angVelZ += angAccZ * dt;
rb._angVelX *= angScale;
rb._angVelY *= angScale;
rb._angVelZ *= angScale;
}
rb._integrate(dt);
let s = rb._shapeList;
while(s != null) {
let n = s._next;
let tf1 = rb._ptransform;
let tf2 = rb._transform;
let dst = s._ptransform;
let src1 = s._localTransform;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = tf1._rotation00 * src1._rotation00 + tf1._rotation01 * src1._rotation10 + tf1._rotation02 * src1._rotation20;
__tmp__01 = tf1._rotation00 * src1._rotation01 + tf1._rotation01 * src1._rotation11 + tf1._rotation02 * src1._rotation21;
__tmp__02 = tf1._rotation00 * src1._rotation02 + tf1._rotation01 * src1._rotation12 + tf1._rotation02 * src1._rotation22;
__tmp__10 = tf1._rotation10 * src1._rotation00 + tf1._rotation11 * src1._rotation10 + tf1._rotation12 * src1._rotation20;
__tmp__11 = tf1._rotation10 * src1._rotation01 + tf1._rotation11 * src1._rotation11 + tf1._rotation12 * src1._rotation21;
__tmp__12 = tf1._rotation10 * src1._rotation02 + tf1._rotation11 * src1._rotation12 + tf1._rotation12 * src1._rotation22;
__tmp__20 = tf1._rotation20 * src1._rotation00 + tf1._rotation21 * src1._rotation10 + tf1._rotation22 * src1._rotation20;
__tmp__21 = tf1._rotation20 * src1._rotation01 + tf1._rotation21 * src1._rotation11 + tf1._rotation22 * src1._rotation21;
__tmp__22 = tf1._rotation20 * src1._rotation02 + tf1._rotation21 * src1._rotation12 + tf1._rotation22 * src1._rotation22;
dst._rotation00 = __tmp__00;
dst._rotation01 = __tmp__01;
dst._rotation02 = __tmp__02;
dst._rotation10 = __tmp__10;
dst._rotation11 = __tmp__11;
dst._rotation12 = __tmp__12;
dst._rotation20 = __tmp__20;
dst._rotation21 = __tmp__21;
dst._rotation22 = __tmp__22;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = tf1._rotation00 * src1._positionX + tf1._rotation01 * src1._positionY + tf1._rotation02 * src1._positionZ;
__tmp__Y = tf1._rotation10 * src1._positionX + tf1._rotation11 * src1._positionY + tf1._rotation12 * src1._positionZ;
__tmp__Z = tf1._rotation20 * src1._positionX + tf1._rotation21 * src1._positionY + tf1._rotation22 * src1._positionZ;
dst._positionX = __tmp__X;
dst._positionY = __tmp__Y;
dst._positionZ = __tmp__Z;
dst._positionX += tf1._positionX;
dst._positionY += tf1._positionY;
dst._positionZ += tf1._positionZ;
let dst1 = s._transform;
let src11 = s._localTransform;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = tf2._rotation00 * src11._rotation00 + tf2._rotation01 * src11._rotation10 + tf2._rotation02 * src11._rotation20;
__tmp__011 = tf2._rotation00 * src11._rotation01 + tf2._rotation01 * src11._rotation11 + tf2._rotation02 * src11._rotation21;
__tmp__021 = tf2._rotation00 * src11._rotation02 + tf2._rotation01 * src11._rotation12 + tf2._rotation02 * src11._rotation22;
__tmp__101 = tf2._rotation10 * src11._rotation00 + tf2._rotation11 * src11._rotation10 + tf2._rotation12 * src11._rotation20;
__tmp__111 = tf2._rotation10 * src11._rotation01 + tf2._rotation11 * src11._rotation11 + tf2._rotation12 * src11._rotation21;
__tmp__121 = tf2._rotation10 * src11._rotation02 + tf2._rotation11 * src11._rotation12 + tf2._rotation12 * src11._rotation22;
__tmp__201 = tf2._rotation20 * src11._rotation00 + tf2._rotation21 * src11._rotation10 + tf2._rotation22 * src11._rotation20;
__tmp__211 = tf2._rotation20 * src11._rotation01 + tf2._rotation21 * src11._rotation11 + tf2._rotation22 * src11._rotation21;
__tmp__221 = tf2._rotation20 * src11._rotation02 + tf2._rotation21 * src11._rotation12 + tf2._rotation22 * src11._rotation22;
dst1._rotation00 = __tmp__001;
dst1._rotation01 = __tmp__011;
dst1._rotation02 = __tmp__021;
dst1._rotation10 = __tmp__101;
dst1._rotation11 = __tmp__111;
dst1._rotation12 = __tmp__121;
dst1._rotation20 = __tmp__201;
dst1._rotation21 = __tmp__211;
dst1._rotation22 = __tmp__221;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = tf2._rotation00 * src11._positionX + tf2._rotation01 * src11._positionY + tf2._rotation02 * src11._positionZ;
__tmp__Y1 = tf2._rotation10 * src11._positionX + tf2._rotation11 * src11._positionY + tf2._rotation12 * src11._positionZ;
__tmp__Z1 = tf2._rotation20 * src11._positionX + tf2._rotation21 * src11._positionY + tf2._rotation22 * src11._positionZ;
dst1._positionX = __tmp__X1;
dst1._positionY = __tmp__Y1;
dst1._positionZ = __tmp__Z1;
dst1._positionX += tf2._positionX;
dst1._positionY += tf2._positionY;
dst1._positionZ += tf2._positionZ;
let minX;
let minY;
let minZ;
let maxX;
let maxY;
let maxZ;
s._geom._computeAabb(s._aabb,s._ptransform);
minX = s._aabb._minX;
minY = s._aabb._minY;
minZ = s._aabb._minZ;
maxX = s._aabb._maxX;
maxY = s._aabb._maxY;
maxZ = s._aabb._maxZ;
s._geom._computeAabb(s._aabb,s._transform);
s._aabb._minX = minX < s._aabb._minX ? minX : s._aabb._minX;
s._aabb._minY = minY < s._aabb._minY ? minY : s._aabb._minY;
s._aabb._minZ = minZ < s._aabb._minZ ? minZ : s._aabb._minZ;
s._aabb._maxX = maxX > s._aabb._maxX ? maxX : s._aabb._maxX;
s._aabb._maxY = maxY > s._aabb._maxY ? maxY : s._aabb._maxY;
s._aabb._maxZ = maxZ > s._aabb._maxZ ? maxZ : s._aabb._maxZ;
if(s._proxy != null) {
let dX;
let dY;
let dZ;
dX = s._transform._positionX - s._ptransform._positionX;
dY = s._transform._positionY - s._ptransform._positionY;
dZ = s._transform._positionZ - s._ptransform._positionZ;
let v = s.displacement;
v.x = dX;
v.y = dY;
v.z = dZ;
s._rigidBody._world._broadPhase.moveProxy(s._proxy,s._aabb,s.displacement);
}
s = n;
}
}
}
_step(timeStep,numVelocityIterations,numPositionIterations) {
let dt = timeStep.dt;
let sleepIsland = true;
let _g = 0;
let _g1 = this.numRigidBodies;
while(_g < _g1) {
let rb = this.rigidBodies[_g++];
let dst = rb._ptransform;
let src = rb._transform;
dst._positionX = src._positionX;
dst._positionY = src._positionY;
dst._positionZ = src._positionZ;
dst._rotation00 = src._rotation00;
dst._rotation01 = src._rotation01;
dst._rotation02 = src._rotation02;
dst._rotation10 = src._rotation10;
dst._rotation11 = src._rotation11;
dst._rotation12 = src._rotation12;
dst._rotation20 = src._rotation20;
dst._rotation21 = src._rotation21;
dst._rotation22 = src._rotation22;
rb._linearContactImpulseX = 0;
rb._linearContactImpulseY = 0;
rb._linearContactImpulseZ = 0;
rb._angularContactImpulseX = 0;
rb._angularContactImpulseY = 0;
rb._angularContactImpulseZ = 0;
rb._sleeping = false;
if(rb._autoSleep && rb._velX * rb._velX + rb._velY * rb._velY + rb._velZ * rb._velZ < oimo.common.Setting.sleepingVelocityThreshold * oimo.common.Setting.sleepingVelocityThreshold && rb._angVelX * rb._angVelX + rb._angVelY * rb._angVelY + rb._angVelZ * rb._angVelZ < oimo.common.Setting.sleepingAngularVelocityThreshold * oimo.common.Setting.sleepingAngularVelocityThreshold) {
rb._sleepTime += dt;
} else {
rb._sleepTime = 0;
}
if(rb._sleepTime < oimo.common.Setting.sleepingTimeThreshold) {
sleepIsland = false;
}
if(rb._type == 0) {
let x = dt * rb._linearDamping;
let x2 = x * x;
let linScale = 1 / (1 + x + x2 * (0.5 + x * 0.16666666666666666 + x2 * 0.041666666666666664));
let x1 = dt * rb._angularDamping;
let x21 = x1 * x1;
let angScale = 1 / (1 + x1 + x21 * (0.5 + x1 * 0.16666666666666666 + x21 * 0.041666666666666664));
let linAccX;
let linAccY;
let linAccZ;
let angAccX;
let angAccY;
let angAccZ;
linAccX = this.gravityX * rb._gravityScale;
linAccY = this.gravityY * rb._gravityScale;
linAccZ = this.gravityZ * rb._gravityScale;
linAccX += rb._forceX * rb._invMass;
linAccY += rb._forceY * rb._invMass;
linAccZ += rb._forceZ * rb._invMass;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = rb._invInertia00 * rb._torqueX + rb._invInertia01 * rb._torqueY + rb._invInertia02 * rb._torqueZ;
__tmp__Y = rb._invInertia10 * rb._torqueX + rb._invInertia11 * rb._torqueY + rb._invInertia12 * rb._torqueZ;
__tmp__Z = rb._invInertia20 * rb._torqueX + rb._invInertia21 * rb._torqueY + rb._invInertia22 * rb._torqueZ;
angAccX = __tmp__X;
angAccY = __tmp__Y;
angAccZ = __tmp__Z;
rb._velX += linAccX * dt;
rb._velY += linAccY * dt;
rb._velZ += linAccZ * dt;
rb._velX *= linScale;
rb._velY *= linScale;
rb._velZ *= linScale;
rb._angVelX += angAccX * dt;
rb._angVelY += angAccY * dt;
rb._angVelZ += angAccZ * dt;
rb._angVelX *= angScale;
rb._angVelY *= angScale;
rb._angVelZ *= angScale;
}
}
if(sleepIsland) {
let _g = 0;
let _g1 = this.numRigidBodies;
while(_g < _g1) {
let rb = this.rigidBodies[_g++];
rb._sleeping = true;
rb._sleepTime = 0;
}
return;
}
let _g2 = 0;
let _g3 = this.numSolvers;
while(_g2 < _g3) this.solvers[_g2++].preSolveVelocity(timeStep);
let _g4 = 0;
let _g5 = this.numSolvers;
while(_g4 < _g5) this.solvers[_g4++].warmStart(timeStep);
let _g6 = 0;
while(_g6 < numVelocityIterations) {
++_g6;
let _g = 0;
let _g1 = this.numSolvers;
while(_g < _g1) this.solvers[_g++].solveVelocity();
}
let _g7 = 0;
let _g8 = this.numSolvers;
while(_g7 < _g8) this.solvers[_g7++].postSolveVelocity(timeStep);
let _g9 = 0;
let _g10 = this.numRigidBodies;
while(_g9 < _g10) this.rigidBodies[_g9++]._integrate(dt);
let _g11 = 0;
let _g12 = this.numSolversSi;
while(_g11 < _g12) this.solversSi[_g11++].preSolvePosition(timeStep);
let _g13 = 0;
while(_g13 < numPositionIterations) {
++_g13;
let _g = 0;
let _g1 = this.numSolversSi;
while(_g < _g1) this.solversSi[_g++].solvePositionSplitImpulse();
}
let _g14 = 0;
let _g15 = this.numRigidBodies;
while(_g14 < _g15) this.rigidBodies[_g14++]._integratePseudoVelocity();
let _g16 = 0;
let _g17 = this.numSolversNgs;
while(_g16 < _g17) this.solversNgs[_g16++].preSolvePosition(timeStep);
let _g18 = 0;
while(_g18 < numPositionIterations) {
++_g18;
let _g = 0;
let _g1 = this.numSolversNgs;
while(_g < _g1) this.solversNgs[_g++].solvePositionNgs(timeStep);
}
let _g19 = 0;
let _g20 = this.numSolvers;
while(_g19 < _g20) this.solvers[_g19++].postSolve();
let _g21 = 0;
let _g22 = this.numRigidBodies;
while(_g21 < _g22) {
let rb = this.rigidBodies[_g21++];
let s = rb._shapeList;
while(s != null) {
let n = s._next;
let tf1 = rb._ptransform;
let tf2 = rb._transform;
let dst = s._ptransform;
let src1 = s._localTransform;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = tf1._rotation00 * src1._rotation00 + tf1._rotation01 * src1._rotation10 + tf1._rotation02 * src1._rotation20;
__tmp__01 = tf1._rotation00 * src1._rotation01 + tf1._rotation01 * src1._rotation11 + tf1._rotation02 * src1._rotation21;
__tmp__02 = tf1._rotation00 * src1._rotation02 + tf1._rotation01 * src1._rotation12 + tf1._rotation02 * src1._rotation22;
__tmp__10 = tf1._rotation10 * src1._rotation00 + tf1._rotation11 * src1._rotation10 + tf1._rotation12 * src1._rotation20;
__tmp__11 = tf1._rotation10 * src1._rotation01 + tf1._rotation11 * src1._rotation11 + tf1._rotation12 * src1._rotation21;
__tmp__12 = tf1._rotation10 * src1._rotation02 + tf1._rotation11 * src1._rotation12 + tf1._rotation12 * src1._rotation22;
__tmp__20 = tf1._rotation20 * src1._rotation00 + tf1._rotation21 * src1._rotation10 + tf1._rotation22 * src1._rotation20;
__tmp__21 = tf1._rotation20 * src1._rotation01 + tf1._rotation21 * src1._rotation11 + tf1._rotation22 * src1._rotation21;
__tmp__22 = tf1._rotation20 * src1._rotation02 + tf1._rotation21 * src1._rotation12 + tf1._rotation22 * src1._rotation22;
dst._rotation00 = __tmp__00;
dst._rotation01 = __tmp__01;
dst._rotation02 = __tmp__02;
dst._rotation10 = __tmp__10;
dst._rotation11 = __tmp__11;
dst._rotation12 = __tmp__12;
dst._rotation20 = __tmp__20;
dst._rotation21 = __tmp__21;
dst._rotation22 = __tmp__22;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = tf1._rotation00 * src1._positionX + tf1._rotation01 * src1._positionY + tf1._rotation02 * src1._positionZ;
__tmp__Y = tf1._rotation10 * src1._positionX + tf1._rotation11 * src1._positionY + tf1._rotation12 * src1._positionZ;
__tmp__Z = tf1._rotation20 * src1._positionX + tf1._rotation21 * src1._positionY + tf1._rotation22 * src1._positionZ;
dst._positionX = __tmp__X;
dst._positionY = __tmp__Y;
dst._positionZ = __tmp__Z;
dst._positionX += tf1._positionX;
dst._positionY += tf1._positionY;
dst._positionZ += tf1._positionZ;
let dst1 = s._transform;
let src11 = s._localTransform;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = tf2._rotation00 * src11._rotation00 + tf2._rotation01 * src11._rotation10 + tf2._rotation02 * src11._rotation20;
__tmp__011 = tf2._rotation00 * src11._rotation01 + tf2._rotation01 * src11._rotation11 + tf2._rotation02 * src11._rotation21;
__tmp__021 = tf2._rotation00 * src11._rotation02 + tf2._rotation01 * src11._rotation12 + tf2._rotation02 * src11._rotation22;
__tmp__101 = tf2._rotation10 * src11._rotation00 + tf2._rotation11 * src11._rotation10 + tf2._rotation12 * src11._rotation20;
__tmp__111 = tf2._rotation10 * src11._rotation01 + tf2._rotation11 * src11._rotation11 + tf2._rotation12 * src11._rotation21;
__tmp__121 = tf2._rotation10 * src11._rotation02 + tf2._rotation11 * src11._rotation12 + tf2._rotation12 * src11._rotation22;
__tmp__201 = tf2._rotation20 * src11._rotation00 + tf2._rotation21 * src11._rotation10 + tf2._rotation22 * src11._rotation20;
__tmp__211 = tf2._rotation20 * src11._rotation01 + tf2._rotation21 * src11._rotation11 + tf2._rotation22 * src11._rotation21;
__tmp__221 = tf2._rotation20 * src11._rotation02 + tf2._rotation21 * src11._rotation12 + tf2._rotation22 * src11._rotation22;
dst1._rotation00 = __tmp__001;
dst1._rotation01 = __tmp__011;
dst1._rotation02 = __tmp__021;
dst1._rotation10 = __tmp__101;
dst1._rotation11 = __tmp__111;
dst1._rotation12 = __tmp__121;
dst1._rotation20 = __tmp__201;
dst1._rotation21 = __tmp__211;
dst1._rotation22 = __tmp__221;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = tf2._rotation00 * src11._positionX + tf2._rotation01 * src11._positionY + tf2._rotation02 * src11._positionZ;
__tmp__Y1 = tf2._rotation10 * src11._positionX + tf2._rotation11 * src11._positionY + tf2._rotation12 * src11._positionZ;
__tmp__Z1 = tf2._rotation20 * src11._positionX + tf2._rotation21 * src11._positionY + tf2._rotation22 * src11._positionZ;
dst1._positionX = __tmp__X1;
dst1._positionY = __tmp__Y1;
dst1._positionZ = __tmp__Z1;
dst1._positionX += tf2._positionX;
dst1._positionY += tf2._positionY;
dst1._positionZ += tf2._positionZ;
let minX;
let minY;
let minZ;
let maxX;
let maxY;
let maxZ;
s._geom._computeAabb(s._aabb,s._ptransform);
minX = s._aabb._minX;
minY = s._aabb._minY;
minZ = s._aabb._minZ;
maxX = s._aabb._maxX;
maxY = s._aabb._maxY;
maxZ = s._aabb._maxZ;
s._geom._computeAabb(s._aabb,s._transform);
s._aabb._minX = minX < s._aabb._minX ? minX : s._aabb._minX;
s._aabb._minY = minY < s._aabb._minY ? minY : s._aabb._minY;
s._aabb._minZ = minZ < s._aabb._minZ ? minZ : s._aabb._minZ;
s._aabb._maxX = maxX > s._aabb._maxX ? maxX : s._aabb._maxX;
s._aabb._maxY = maxY > s._aabb._maxY ? maxY : s._aabb._maxY;
s._aabb._maxZ = maxZ > s._aabb._maxZ ? maxZ : s._aabb._maxZ;
if(s._proxy != null) {
let dX;
let dY;
let dZ;
dX = s._transform._positionX - s._ptransform._positionX;
dY = s._transform._positionY - s._ptransform._positionY;
dZ = s._transform._positionZ - s._ptransform._positionZ;
let v = s.displacement;
v.x = dX;
v.y = dY;
v.z = dZ;
s._rigidBody._world._broadPhase.moveProxy(s._proxy,s._aabb,s.displacement);
}
s = n;
}
}
}
}
oimo.dynamics.TimeStep = class oimo_dynamics_TimeStep {
constructor() {
this.dt = 0;
this.invDt = 0;
this.dtRatio = 1;
}
}
oimo.dynamics.World = class oimo_dynamics_World {
constructor(broadPhaseType,gravity) {
if(broadPhaseType == null) {
broadPhaseType = 2;
}
switch(broadPhaseType) {
case 1:
this._broadPhase = new oimo.collision.broadphase.bruteforce.BruteForceBroadPhase();
break;
case 2:
this._broadPhase = new oimo.collision.broadphase.bvh.BvhBroadPhase();
break;
}
this._contactManager = new oimo.dynamics.ContactManager(this._broadPhase);
if(gravity == null) {
gravity = new oimo.common.Vec3(0,-9.80665,0);
}
this._gravity = new oimo.common.Vec3(gravity.x,gravity.y,gravity.z);
this._rigidBodyList = null;
this._rigidBodyListLast = null;
this._jointList = null;
this._jointListLast = null;
this._numRigidBodies = 0;
this._numShapes = 0;
this._numJoints = 0;
this._numIslands = 0;
this._numVelocityIterations = 10;
this._numPositionIterations = 5;
this._rayCastWrapper = new oimo.dynamics._World.RayCastWrapper();
this._convexCastWrapper = new oimo.dynamics._World.ConvexCastWrapper();
this._aabbTestWrapper = new oimo.dynamics._World.AabbTestWrapper();
this._island = new oimo.dynamics.Island();
this._solversInIslands = new Array(oimo.common.Setting.islandInitialConstraintArraySize);
this._rigidBodyStack = new Array(oimo.common.Setting.islandInitialRigidBodyArraySize);
this._timeStep = new oimo.dynamics.TimeStep();
this._pool = new oimo.common.Pool();
this._shapeIdCount = 0;
}
_updateContacts() {
let st = Date.now() / 1000;
this._contactManager._updateContacts();
oimo.dynamics.common.Performance.broadPhaseCollisionTime = (Date.now() / 1000 - st) * 1000;
let st1 = Date.now() / 1000;
let c = this._contactManager._contactList;
while(c != null) {
let n = c._next;
if(!c._shouldBeSkipped) {
c._updateManifold();
}
c = n;
}
oimo.dynamics.common.Performance.narrowPhaseCollisionTime = (Date.now() / 1000 - st1) * 1000;
}
_solveIslands() {
let st = Date.now() / 1000;
if(oimo.common.Setting.disableSleeping) {
let b = this._rigidBodyList;
while(b != null) {
b._sleeping = false;
b._sleepTime = 0;
b = b._next;
}
}
if(this._rigidBodyStack.length < this._numRigidBodies) {
let newStackSize = this._rigidBodyStack.length << 1;
while(newStackSize < this._numRigidBodies) newStackSize <<= 1;
this._rigidBodyStack = new Array(newStackSize);
}
this._numIslands = 0;
let _this = this._island;
let gravity = this._gravity;
_this.gravityX = gravity.x;
_this.gravityY = gravity.y;
_this.gravityZ = gravity.z;
let b = this._rigidBodyList;
this._numSolversInIslands = 0;
while(b != null) {
let n = b._next;
while(!(b._addedToIsland || b._sleeping || b._type == 1)) {
if(b._numContactLinks == 0 && b._numJointLinks == 0) {
this._island._stepSingleRigidBody(this._timeStep,b);
this._numIslands++;
break;
}
this.buildIsland(b);
this._island._step(this._timeStep,this._numVelocityIterations,this._numPositionIterations);
this._island._clear();
this._numIslands++;
break;
}
b = n;
}
this._contactManager._postSolve();
b = this._rigidBodyList;
while(b != null) {
b._addedToIsland = false;
b = b._next;
}
b = this._rigidBodyList;
while(b != null) {
b._forceX = 0;
b._forceY = 0;
b._forceZ = 0;
b._torqueX = 0;
b._torqueY = 0;
b._torqueZ = 0;
b = b._next;
}
while(this._numSolversInIslands > 0) {
this._solversInIslands[--this._numSolversInIslands]._addedToIsland = false;
this._solversInIslands[this._numSolversInIslands] = null;
}
oimo.dynamics.common.Performance.dynamicsTime = (Date.now() / 1000 - st) * 1000;
}
buildIsland(base) {
let stackCount = 1;
this._island._addRigidBody(base);
this._rigidBodyStack[0] = base;
while(stackCount > 0) {
let rb = this._rigidBodyStack[--stackCount];
this._rigidBodyStack[stackCount] = null;
if(rb._type == 1) {
continue;
}
let cl = rb._contactLinkList;
while(cl != null) {
let n = cl._next;
let cc = cl._contact._contactConstraint;
let ccs = cl._contact._contactConstraint._solver;
if(cc.isTouching() && !ccs._addedToIsland) {
if(this._solversInIslands.length == this._numSolversInIslands) {
let newArray = new Array(this._numSolversInIslands << 1);
let _g = 0;
let _g1 = this._numSolversInIslands;
while(_g < _g1) {
let i = _g++;
newArray[i] = this._solversInIslands[i];
this._solversInIslands[i] = null;
}
this._solversInIslands = newArray;
}
this._solversInIslands[this._numSolversInIslands++] = ccs;
this._island._addConstraintSolver(ccs,cc._positionCorrectionAlgorithm);
let other = cl._other;
if(!other._addedToIsland) {
this._island._addRigidBody(other);
this._rigidBodyStack[stackCount++] = other;
}
}
cl = n;
}
let jl = rb._jointLinkList;
while(jl != null) {
let n = jl._next;
let j = jl._joint;
let js1 = j._solver;
if(!js1._addedToIsland) {
if(this._solversInIslands.length == this._numSolversInIslands) {
let newArray = new Array(this._numSolversInIslands << 1);
let _g = 0;
let _g1 = this._numSolversInIslands;
while(_g < _g1) {
let i = _g++;
newArray[i] = this._solversInIslands[i];
this._solversInIslands[i] = null;
}
this._solversInIslands = newArray;
}
this._solversInIslands[this._numSolversInIslands++] = js1;
this._island._addConstraintSolver(js1,j._positionCorrectionAlgorithm);
let other = jl._other;
if(!other._addedToIsland) {
this._island._addRigidBody(other);
this._rigidBodyStack[stackCount++] = other;
}
}
jl = n;
}
}
}
_drawBvh(d,tree) {
if(d.drawBvh) {
this._drawBvhNode(d,tree._root,0,d.style.bvhNodeColor);
}
}
_drawBvhNode(d,node,level,color) {
if(node == null) {
return;
}
if(level >= d.drawBvhMinLevel && level <= d.drawBvhMaxLevel) {
let _this = this._pool;
let min = _this.sizeVec3 == 0 ? new oimo.common.Vec3() : _this.stackVec3[--_this.sizeVec3];
let _this1 = this._pool;
let max = _this1.sizeVec3 == 0 ? new oimo.common.Vec3() : _this1.stackVec3[--_this1.sizeVec3];
let v = min;
v.x = node._aabbMinX;
v.y = node._aabbMinY;
v.z = node._aabbMinZ;
let v1 = max;
v1.x = node._aabbMaxX;
v1.y = node._aabbMaxY;
v1.z = node._aabbMaxZ;
d.aabb(min,max,color);
let _this2 = this._pool;
if(min != null) {
min.zero();
if(_this2.sizeVec3 == _this2.stackVec3.length) {
let newArray = new Array(_this2.sizeVec3 << 1);
let _g = 0;
let _g1 = _this2.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this2.stackVec3[i];
_this2.stackVec3[i] = null;
}
_this2.stackVec3 = newArray;
}
_this2.stackVec3[_this2.sizeVec3++] = min;
}
let _this3 = this._pool;
if(max != null) {
max.zero();
if(_this3.sizeVec3 == _this3.stackVec3.length) {
let newArray = new Array(_this3.sizeVec3 << 1);
let _g = 0;
let _g1 = _this3.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this3.stackVec3[i];
_this3.stackVec3[i] = null;
}
_this3.stackVec3 = newArray;
}
_this3.stackVec3[_this3.sizeVec3++] = max;
}
}
this._drawBvhNode(d,node._children[0],level + 1,color);
this._drawBvhNode(d,node._children[1],level + 1,color);
}
_drawRigidBodies(d) {
let style = d.style;
let r = this._rigidBodyList;
while(r != null) {
let n = r._next;
if(d.drawBases) {
let style = d.style;
d.basis(r._transform,style.basisLength,style.basisColorX,style.basisColorY,style.basisColorZ);
}
let shapeColor = null;
let isDynamic = r._type == 0;
if(!isDynamic) {
shapeColor = r._type == 2 ? style.kinematicShapeColor : style.staticShapeColor;
}
let s = r._shapeList;
while(s != null) {
let n = s._next;
if(isDynamic) {
if((s._id & 1) == 0) {
shapeColor = r._sleeping ? style.sleepingShapeColor1 : r._sleepTime > oimo.common.Setting.sleepingTimeThreshold ? style.sleepyShapeColor1 : style.shapeColor1;
} else {
shapeColor = r._sleeping ? style.sleepingShapeColor2 : r._sleepTime > oimo.common.Setting.sleepingTimeThreshold ? style.sleepyShapeColor2 : style.shapeColor2;
}
}
if(d.drawShapes) {
let geom = s._geom;
let tf = s._transform;
switch(geom._type) {
case 0:
d.sphere(tf,geom._radius,shapeColor);
break;
case 1:
let g = geom;
let _this = this._pool;
let hx = _this.sizeVec3 == 0 ? new oimo.common.Vec3() : _this.stackVec3[--_this.sizeVec3];
let v = hx;
v.x = g._halfExtentsX;
v.y = g._halfExtentsY;
v.z = g._halfExtentsZ;
d.box(tf,hx,shapeColor);
let _this1 = this._pool;
if(hx != null) {
hx.zero();
if(_this1.sizeVec3 == _this1.stackVec3.length) {
let newArray = new Array(_this1.sizeVec3 << 1);
let _g = 0;
let _g1 = _this1.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this1.stackVec3[i];
_this1.stackVec3[i] = null;
}
_this1.stackVec3 = newArray;
}
_this1.stackVec3[_this1.sizeVec3++] = hx;
}
break;
case 2:
let g1 = geom;
d.cylinder(tf,g1._radius,g1._halfHeight,shapeColor);
break;
case 3:
let g2 = geom;
d.cone(tf,g2._radius,g2._halfHeight,shapeColor);
break;
case 4:
let g3 = geom;
d.capsule(tf,g3._radius,g3._halfHeight,shapeColor);
break;
case 5:
let g4 = geom;
let n = g4._numVertices;
let _this2 = this._pool;
let v1 = _this2.sizeVec3 == 0 ? new oimo.common.Vec3() : _this2.stackVec3[--_this2.sizeVec3];
let _this3 = this._pool;
let v2 = _this3.sizeVec3 == 0 ? new oimo.common.Vec3() : _this3.stackVec3[--_this3.sizeVec3];
let _this4 = this._pool;
let v3 = _this4.sizeVec3 == 0 ? new oimo.common.Vec3() : _this4.stackVec3[--_this4.sizeVec3];
let _this5 = this._pool;
let v12 = _this5.sizeVec3 == 0 ? new oimo.common.Vec3() : _this5.stackVec3[--_this5.sizeVec3];
let _this6 = this._pool;
let v13 = _this6.sizeVec3 == 0 ? new oimo.common.Vec3() : _this6.stackVec3[--_this6.sizeVec3];
let _this7 = this._pool;
let normal = _this7.sizeVec3 == 0 ? new oimo.common.Vec3() : _this7.stackVec3[--_this7.sizeVec3];
let _this8 = this._pool;
let m = _this8.sizeMat3 == 0 ? new oimo.common.Mat3() : _this8.stackMat3[--_this8.sizeMat3];
let _this9 = this._pool;
let o = _this9.sizeVec3 == 0 ? new oimo.common.Vec3() : _this9.stackVec3[--_this9.sizeVec3];
let m1 = m;
m1.e00 = tf._rotation00;
m1.e01 = tf._rotation01;
m1.e02 = tf._rotation02;
m1.e10 = tf._rotation10;
m1.e11 = tf._rotation11;
m1.e12 = tf._rotation12;
m1.e20 = tf._rotation20;
m1.e21 = tf._rotation21;
m1.e22 = tf._rotation22;
let v4 = o;
v4.x = tf._positionX;
v4.y = tf._positionY;
v4.z = tf._positionZ;
let _g = 0;
while(_g < n) {
let i = _g++;
let _this = g4._tmpVertices[i];
let v = g4._vertices[i];
_this.x = v.x;
_this.y = v.y;
_this.z = v.z;
let y = _this.x * m.e10 + _this.y * m.e11 + _this.z * m.e12;
let z = _this.x * m.e20 + _this.y * m.e21 + _this.z * m.e22;
_this.x = _this.x * m.e00 + _this.y * m.e01 + _this.z * m.e02;
_this.y = y;
_this.z = z;
_this.x += o.x;
_this.y += o.y;
_this.z += o.z;
}
if(n > 30) {
let _g = 0;
while(_g < n) {
let i = _g++;
let v = g4._tmpVertices[i];
v1.x = v.x;
v1.y = v.y;
v1.z = v.z;
let v3 = g4._tmpVertices[(i + 1) % n];
v2.x = v3.x;
v2.y = v3.y;
v2.z = v3.z;
d.line(v1,v2,shapeColor);
}
} else if(this._debugDraw.wireframe || n > 10) {
let _g = 0;
while(_g < n) {
let i = _g++;
let v = g4._tmpVertices[i];
v1.x = v.x;
v1.y = v.y;
v1.z = v.z;
let _g1 = 0;
while(_g1 < i) {
let v = g4._tmpVertices[_g1++];
v2.x = v.x;
v2.y = v.y;
v2.z = v.z;
d.line(v1,v2,shapeColor);
}
}
} else {
let _g = 0;
while(_g < n) {
let i = _g++;
let v = g4._tmpVertices[i];
v1.x = v.x;
v1.y = v.y;
v1.z = v.z;
let _g1 = 0;
while(_g1 < i) {
let j = _g1++;
let v = g4._tmpVertices[j];
v2.x = v.x;
v2.y = v.y;
v2.z = v.z;
let _g = 0;
while(_g < j) {
let v = g4._tmpVertices[_g++];
v3.x = v.x;
v3.y = v.y;
v3.z = v.z;
v12.x = v2.x;
v12.y = v2.y;
v12.z = v2.z;
let _this = v12;
_this.x -= v1.x;
_this.y -= v1.y;
_this.z -= v1.z;
v13.x = v3.x;
v13.y = v3.y;
v13.z = v3.z;
let _this1 = v13;
_this1.x -= v1.x;
_this1.y -= v1.y;
_this1.z -= v1.z;
normal.x = v12.x;
normal.y = v12.y;
normal.z = v12.z;
let _this2 = normal;
let y = _this2.z * v13.x - _this2.x * v13.z;
let z = _this2.x * v13.y - _this2.y * v13.x;
_this2.x = _this2.y * v13.z - _this2.z * v13.y;
_this2.y = y;
_this2.z = z;
let invLen = Math.sqrt(_this2.x * _this2.x + _this2.y * _this2.y + _this2.z * _this2.z);
if(invLen > 0) {
invLen = 1 / invLen;
}
_this2.x *= invLen;
_this2.y *= invLen;
_this2.z *= invLen;
d.triangle(v1,v2,v3,normal,normal,normal,shapeColor);
normal.x = -normal.x;
normal.y = -normal.y;
normal.z = -normal.z;
d.triangle(v1,v3,v2,normal,normal,normal,shapeColor);
}
}
}
}
let _this10 = this._pool;
if(v1 != null) {
v1.zero();
if(_this10.sizeVec3 == _this10.stackVec3.length) {
let newArray = new Array(_this10.sizeVec3 << 1);
let _g = 0;
let _g1 = _this10.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this10.stackVec3[i];
_this10.stackVec3[i] = null;
}
_this10.stackVec3 = newArray;
}
_this10.stackVec3[_this10.sizeVec3++] = v1;
}
let _this11 = this._pool;
if(v2 != null) {
v2.zero();
if(_this11.sizeVec3 == _this11.stackVec3.length) {
let newArray = new Array(_this11.sizeVec3 << 1);
let _g = 0;
let _g1 = _this11.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this11.stackVec3[i];
_this11.stackVec3[i] = null;
}
_this11.stackVec3 = newArray;
}
_this11.stackVec3[_this11.sizeVec3++] = v2;
}
let _this12 = this._pool;
if(v3 != null) {
v3.zero();
if(_this12.sizeVec3 == _this12.stackVec3.length) {
let newArray = new Array(_this12.sizeVec3 << 1);
let _g = 0;
let _g1 = _this12.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this12.stackVec3[i];
_this12.stackVec3[i] = null;
}
_this12.stackVec3 = newArray;
}
_this12.stackVec3[_this12.sizeVec3++] = v3;
}
let _this13 = this._pool;
if(v12 != null) {
v12.zero();
if(_this13.sizeVec3 == _this13.stackVec3.length) {
let newArray = new Array(_this13.sizeVec3 << 1);
let _g = 0;
let _g1 = _this13.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this13.stackVec3[i];
_this13.stackVec3[i] = null;
}
_this13.stackVec3 = newArray;
}
_this13.stackVec3[_this13.sizeVec3++] = v12;
}
let _this14 = this._pool;
if(v13 != null) {
v13.zero();
if(_this14.sizeVec3 == _this14.stackVec3.length) {
let newArray = new Array(_this14.sizeVec3 << 1);
let _g = 0;
let _g1 = _this14.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this14.stackVec3[i];
_this14.stackVec3[i] = null;
}
_this14.stackVec3 = newArray;
}
_this14.stackVec3[_this14.sizeVec3++] = v13;
}
let _this15 = this._pool;
if(normal != null) {
normal.zero();
if(_this15.sizeVec3 == _this15.stackVec3.length) {
let newArray = new Array(_this15.sizeVec3 << 1);
let _g = 0;
let _g1 = _this15.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this15.stackVec3[i];
_this15.stackVec3[i] = null;
}
_this15.stackVec3 = newArray;
}
_this15.stackVec3[_this15.sizeVec3++] = normal;
}
let _this16 = this._pool;
if(m != null) {
m.e00 = 1;
m.e01 = 0;
m.e02 = 0;
m.e10 = 0;
m.e11 = 1;
m.e12 = 0;
m.e20 = 0;
m.e21 = 0;
m.e22 = 1;
if(_this16.sizeMat3 == _this16.stackMat3.length) {
let newArray = new Array(_this16.sizeMat3 << 1);
let _g = 0;
let _g1 = _this16.sizeMat3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this16.stackMat3[i];
_this16.stackMat3[i] = null;
}
_this16.stackMat3 = newArray;
}
_this16.stackMat3[_this16.sizeMat3++] = m;
}
let _this17 = this._pool;
if(o != null) {
o.zero();
if(_this17.sizeVec3 == _this17.stackVec3.length) {
let newArray = new Array(_this17.sizeVec3 << 1);
let _g = 0;
let _g1 = _this17.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this17.stackVec3[i];
_this17.stackVec3[i] = null;
}
_this17.stackVec3 = newArray;
}
_this17.stackVec3[_this17.sizeVec3++] = o;
}
break;
}
}
if(d.drawAabbs) {
let aabb = s._aabb;
let color = style.aabbColor;
let _this = this._pool;
let min = _this.sizeVec3 == 0 ? new oimo.common.Vec3() : _this.stackVec3[--_this.sizeVec3];
let _this1 = this._pool;
let max = _this1.sizeVec3 == 0 ? new oimo.common.Vec3() : _this1.stackVec3[--_this1.sizeVec3];
let v = min;
v.x = aabb._minX;
v.y = aabb._minY;
v.z = aabb._minZ;
let v1 = max;
v1.x = aabb._maxX;
v1.y = aabb._maxY;
v1.z = aabb._maxZ;
d.aabb(min,max,color);
let _this2 = this._pool;
if(min != null) {
min.zero();
if(_this2.sizeVec3 == _this2.stackVec3.length) {
let newArray = new Array(_this2.sizeVec3 << 1);
let _g = 0;
let _g1 = _this2.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this2.stackVec3[i];
_this2.stackVec3[i] = null;
}
_this2.stackVec3 = newArray;
}
_this2.stackVec3[_this2.sizeVec3++] = min;
}
let _this3 = this._pool;
if(max != null) {
max.zero();
if(_this3.sizeVec3 == _this3.stackVec3.length) {
let newArray = new Array(_this3.sizeVec3 << 1);
let _g = 0;
let _g1 = _this3.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this3.stackVec3[i];
_this3.stackVec3[i] = null;
}
_this3.stackVec3 = newArray;
}
_this3.stackVec3[_this3.sizeVec3++] = max;
}
}
s = n;
}
r = n;
}
}
_drawConstraints(d) {
let style = d.style;
if(d.drawPairs || d.drawContacts) {
let c = this._contactManager._contactList;
while(c != null) {
let n = c._next;
if(d.drawPairs) {
let color = style.pairColor;
let _this = this._pool;
let v1 = _this.sizeVec3 == 0 ? new oimo.common.Vec3() : _this.stackVec3[--_this.sizeVec3];
let _this1 = this._pool;
let v2 = _this1.sizeVec3 == 0 ? new oimo.common.Vec3() : _this1.stackVec3[--_this1.sizeVec3];
let v = v1;
v.x = c._s1._transform._positionX;
v.y = c._s1._transform._positionY;
v.z = c._s1._transform._positionZ;
let v3 = v2;
v3.x = c._s2._transform._positionX;
v3.y = c._s2._transform._positionY;
v3.z = c._s2._transform._positionZ;
d.line(v1,v2,color);
let _this2 = this._pool;
if(v1 != null) {
v1.zero();
if(_this2.sizeVec3 == _this2.stackVec3.length) {
let newArray = new Array(_this2.sizeVec3 << 1);
let _g = 0;
let _g1 = _this2.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this2.stackVec3[i];
_this2.stackVec3[i] = null;
}
_this2.stackVec3 = newArray;
}
_this2.stackVec3[_this2.sizeVec3++] = v1;
}
let _this3 = this._pool;
if(v2 != null) {
v2.zero();
if(_this3.sizeVec3 == _this3.stackVec3.length) {
let newArray = new Array(_this3.sizeVec3 << 1);
let _g = 0;
let _g1 = _this3.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this3.stackVec3[i];
_this3.stackVec3[i] = null;
}
_this3.stackVec3 = newArray;
}
_this3.stackVec3[_this3.sizeVec3++] = v2;
}
}
if(d.drawContacts) {
let cc = c._contactConstraint;
let ps = c._contactConstraint._manifold._points;
let _g = 0;
let _g1 = c._contactConstraint._manifold._numPoints;
while(_g < _g1) {
let p = ps[_g++];
let style = d.style;
let _this = this._pool;
let pos1 = _this.sizeVec3 == 0 ? new oimo.common.Vec3() : _this.stackVec3[--_this.sizeVec3];
let _this1 = this._pool;
let pos2 = _this1.sizeVec3 == 0 ? new oimo.common.Vec3() : _this1.stackVec3[--_this1.sizeVec3];
let _this2 = this._pool;
let normal = _this2.sizeVec3 == 0 ? new oimo.common.Vec3() : _this2.stackVec3[--_this2.sizeVec3];
let _this3 = this._pool;
let tangent = _this3.sizeVec3 == 0 ? new oimo.common.Vec3() : _this3.stackVec3[--_this3.sizeVec3];
let _this4 = this._pool;
let binormal = _this4.sizeVec3 == 0 ? new oimo.common.Vec3() : _this4.stackVec3[--_this4.sizeVec3];
let v = pos1;
v.x = p._pos1X;
v.y = p._pos1Y;
v.z = p._pos1Z;
let v1 = pos2;
v1.x = p._pos2X;
v1.y = p._pos2Y;
v1.z = p._pos2Z;
let v2 = normal;
v2.x = cc._manifold._normalX;
v2.y = cc._manifold._normalY;
v2.z = cc._manifold._normalZ;
let v3 = tangent;
v3.x = cc._manifold._tangentX;
v3.y = cc._manifold._tangentY;
v3.z = cc._manifold._tangentZ;
let v4 = binormal;
v4.x = cc._manifold._binormalX;
v4.y = cc._manifold._binormalY;
v4.z = cc._manifold._binormalZ;
if(p._disabled) {
d.point(pos1,style.disabledContactColor);
d.point(pos2,style.disabledContactColor);
d.line(pos1,pos2,style.disabledContactColor);
} else if(p._warmStarted) {
let color;
switch(p._id & 3) {
case 0:
color = style.contactColor;
break;
case 1:
color = style.contactColor2;
break;
case 2:
color = style.contactColor3;
break;
default:
color = style.contactColor4;
}
d.point(pos1,color);
d.point(pos2,color);
d.line(pos1,pos2,style.contactColor);
} else {
d.point(pos1,style.newContactColor);
d.point(pos2,style.newContactColor);
d.line(pos1,pos2,style.newContactColor);
}
pos2.x = pos1.x;
pos2.y = pos1.y;
pos2.z = pos1.z;
let _this5 = pos2;
let s = style.contactNormalLength;
_this5.x += normal.x * s;
_this5.y += normal.y * s;
_this5.z += normal.z * s;
d.line(pos1,pos2,style.contactNormalColor);
if(d.drawContactBases) {
pos2.x = pos1.x;
pos2.y = pos1.y;
pos2.z = pos1.z;
let _this = pos2;
let s = style.contactTangentLength;
_this.x += tangent.x * s;
_this.y += tangent.y * s;
_this.z += tangent.z * s;
d.line(pos1,pos2,style.contactTangentColor);
pos2.x = pos1.x;
pos2.y = pos1.y;
pos2.z = pos1.z;
let _this1 = pos2;
let s1 = style.contactBinormalLength;
_this1.x += binormal.x * s1;
_this1.y += binormal.y * s1;
_this1.z += binormal.z * s1;
d.line(pos1,pos2,style.contactBinormalColor);
}
let _this6 = this._pool;
if(pos1 != null) {
pos1.zero();
if(_this6.sizeVec3 == _this6.stackVec3.length) {
let newArray = new Array(_this6.sizeVec3 << 1);
let _g = 0;
let _g1 = _this6.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this6.stackVec3[i];
_this6.stackVec3[i] = null;
}
_this6.stackVec3 = newArray;
}
_this6.stackVec3[_this6.sizeVec3++] = pos1;
}
let _this7 = this._pool;
if(pos2 != null) {
pos2.zero();
if(_this7.sizeVec3 == _this7.stackVec3.length) {
let newArray = new Array(_this7.sizeVec3 << 1);
let _g = 0;
let _g1 = _this7.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this7.stackVec3[i];
_this7.stackVec3[i] = null;
}
_this7.stackVec3 = newArray;
}
_this7.stackVec3[_this7.sizeVec3++] = pos2;
}
let _this8 = this._pool;
if(normal != null) {
normal.zero();
if(_this8.sizeVec3 == _this8.stackVec3.length) {
let newArray = new Array(_this8.sizeVec3 << 1);
let _g = 0;
let _g1 = _this8.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this8.stackVec3[i];
_this8.stackVec3[i] = null;
}
_this8.stackVec3 = newArray;
}
_this8.stackVec3[_this8.sizeVec3++] = normal;
}
let _this9 = this._pool;
if(tangent != null) {
tangent.zero();
if(_this9.sizeVec3 == _this9.stackVec3.length) {
let newArray = new Array(_this9.sizeVec3 << 1);
let _g = 0;
let _g1 = _this9.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this9.stackVec3[i];
_this9.stackVec3[i] = null;
}
_this9.stackVec3 = newArray;
}
_this9.stackVec3[_this9.sizeVec3++] = tangent;
}
let _this10 = this._pool;
if(binormal != null) {
binormal.zero();
if(_this10.sizeVec3 == _this10.stackVec3.length) {
let newArray = new Array(_this10.sizeVec3 << 1);
let _g = 0;
let _g1 = _this10.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this10.stackVec3[i];
_this10.stackVec3[i] = null;
}
_this10.stackVec3 = newArray;
}
_this10.stackVec3[_this10.sizeVec3++] = binormal;
}
}
}
c = n;
}
}
if(d.drawJoints) {
let j = this._jointList;
while(j != null) {
let n = j._next;
let _this = this._pool;
let p1 = _this.sizeVec3 == 0 ? new oimo.common.Vec3() : _this.stackVec3[--_this.sizeVec3];
let _this1 = this._pool;
let p2 = _this1.sizeVec3 == 0 ? new oimo.common.Vec3() : _this1.stackVec3[--_this1.sizeVec3];
let v = p1;
v.x = j._b1._transform._positionX;
v.y = j._b1._transform._positionY;
v.z = j._b1._transform._positionZ;
let v1 = p2;
v1.x = j._b2._transform._positionX;
v1.y = j._b2._transform._positionY;
v1.z = j._b2._transform._positionZ;
let _this2 = this._pool;
let anchor1 = _this2.sizeVec3 == 0 ? new oimo.common.Vec3() : _this2.stackVec3[--_this2.sizeVec3];
let _this3 = this._pool;
let anchor2 = _this3.sizeVec3 == 0 ? new oimo.common.Vec3() : _this3.stackVec3[--_this3.sizeVec3];
let _this4 = this._pool;
let basisX1 = _this4.sizeVec3 == 0 ? new oimo.common.Vec3() : _this4.stackVec3[--_this4.sizeVec3];
let _this5 = this._pool;
let basisY1 = _this5.sizeVec3 == 0 ? new oimo.common.Vec3() : _this5.stackVec3[--_this5.sizeVec3];
let _this6 = this._pool;
let basisZ1 = _this6.sizeVec3 == 0 ? new oimo.common.Vec3() : _this6.stackVec3[--_this6.sizeVec3];
let _this7 = this._pool;
let basisX2 = _this7.sizeVec3 == 0 ? new oimo.common.Vec3() : _this7.stackVec3[--_this7.sizeVec3];
let _this8 = this._pool;
let basisY2 = _this8.sizeVec3 == 0 ? new oimo.common.Vec3() : _this8.stackVec3[--_this8.sizeVec3];
let _this9 = this._pool;
let basisZ2 = _this9.sizeVec3 == 0 ? new oimo.common.Vec3() : _this9.stackVec3[--_this9.sizeVec3];
let v2 = anchor1;
v2.x = j._anchor1X;
v2.y = j._anchor1Y;
v2.z = j._anchor1Z;
let v3 = anchor2;
v3.x = j._anchor2X;
v3.y = j._anchor2Y;
v3.z = j._anchor2Z;
let v4 = basisX1;
v4.x = j._basisX1X;
v4.y = j._basisX1Y;
v4.z = j._basisX1Z;
let v5 = basisY1;
v5.x = j._basisY1X;
v5.y = j._basisY1Y;
v5.z = j._basisY1Z;
let v6 = basisZ1;
v6.x = j._basisZ1X;
v6.y = j._basisZ1Y;
v6.z = j._basisZ1Z;
let v7 = basisX2;
v7.x = j._basisX2X;
v7.y = j._basisX2Y;
v7.z = j._basisX2Z;
let v8 = basisY2;
v8.x = j._basisY2X;
v8.y = j._basisY2Y;
v8.z = j._basisY2Z;
let v9 = basisZ2;
v9.x = j._basisZ2X;
v9.y = j._basisZ2Y;
v9.z = j._basisZ2Z;
d.line(p1,anchor1,d.style.jointLineColor);
d.line(p2,anchor2,d.style.jointLineColor);
if(d.drawJointLimits) {
switch(j._type) {
case 0:
break;
case 1:
let lm = j._lm;
this._drawRotationalLimit(d,anchor1,basisY1,basisZ1,basisY2,d.style.jointRotationalConstraintRadius,lm.lowerLimit,lm.upperLimit,d.style.jointLineColor);
break;
case 2:
let j1 = j;
let color = d.style.jointLineColor;
let rlm = j1._rotLm;
let tlm = j1._translLm;
this._drawRotationalLimit(d,anchor2,basisY1,basisZ1,basisY2,d.style.jointRotationalConstraintRadius,rlm.lowerLimit,rlm.upperLimit,color);
this._drawTranslationalLimit(d,anchor1,basisX1,tlm.lowerLimit,tlm.upperLimit,color);
break;
case 3:
let lm1 = j._lm;
this._drawTranslationalLimit(d,anchor1,basisX1,lm1.lowerLimit,lm1.upperLimit,d.style.jointLineColor);
break;
case 4:
let j2 = j;
let radius = d.style.jointRotationalConstraintRadius;
let color1 = d.style.jointLineColor;
let lm11 = j2._lm1;
let lm2 = j2._lm2;
this._drawRotationalLimit(d,anchor1,basisY1,basisZ1,basisY1,radius,j2._angleX - lm11.upperLimit,j2._angleX - lm11.lowerLimit,color1);
this._drawRotationalLimit(d,anchor2,basisX2,basisY2,basisX2,radius,lm2.lowerLimit - j2._angleZ,lm2.upperLimit - j2._angleZ,color1);
break;
case 5:
let j3 = j;
let radius1 = d.style.jointRotationalConstraintRadius;
let color2 = d.style.jointLineColor;
let lm3 = j3._twistLm;
this._drawRotationalLimit(d,anchor2,basisY2,basisZ2,basisY2,radius1,lm3.lowerLimit - j3._twistAngle,lm3.upperLimit - j3._twistAngle,color2);
this._drawEllipseOnSphere(d,anchor1,basisX1,basisY1,basisZ1,j3._maxSwingAngle1,j3._maxSwingAngle2,radius1,color2);
let _this10 = this._pool;
let _this11 = _this10.sizeVec3 == 0 ? new oimo.common.Vec3() : _this10.stackVec3[--_this10.sizeVec3];
_this11.x = anchor2.x;
_this11.y = anchor2.y;
_this11.z = anchor2.z;
let _this12 = _this11;
_this12.x += basisX2.x * radius1;
_this12.y += basisX2.y * radius1;
_this12.z += basisX2.z * radius1;
d.line(anchor2,_this12,color2);
let _this13 = this._pool;
if(_this12 != null) {
_this12.zero();
if(_this13.sizeVec3 == _this13.stackVec3.length) {
let newArray = new Array(_this13.sizeVec3 << 1);
let _g = 0;
let _g1 = _this13.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this13.stackVec3[i];
_this13.stackVec3[i] = null;
}
_this13.stackVec3 = newArray;
}
_this13.stackVec3[_this13.sizeVec3++] = _this12;
}
break;
case 6:
let j4 = j;
let radius2 = d.style.jointRotationalConstraintRadius;
let color3 = d.style.jointLineColor;
let rxlm = j4._rotLms[0];
let rylm = j4._rotLms[1];
let rzlm = j4._rotLms[2];
this._drawTranslationalLimit3D(d,anchor1,basisX1,basisY1,basisZ1,j4._translLms[0],j4._translLms[1],j4._translLms[2],color3);
let _this14 = this._pool;
let rotYAxis = _this14.sizeVec3 == 0 ? new oimo.common.Vec3() : _this14.stackVec3[--_this14.sizeVec3];
let v10 = rotYAxis;
v10.x = j4._axisYX;
v10.y = j4._axisYY;
v10.z = j4._axisYZ;
let _this15 = this._pool;
let _this16 = _this15.sizeVec3 == 0 ? new oimo.common.Vec3() : _this15.stackVec3[--_this15.sizeVec3];
_this16.x = basisX1.x;
_this16.y = basisX1.y;
_this16.z = basisX1.z;
let rotYBasisX = _this16;
let _this17 = this._pool;
let _this18 = _this17.sizeVec3 == 0 ? new oimo.common.Vec3() : _this17.stackVec3[--_this17.sizeVec3];
_this18.x = basisX1.x;
_this18.y = basisX1.y;
_this18.z = basisX1.z;
let _this19 = _this18;
let y = _this19.z * rotYAxis.x - _this19.x * rotYAxis.z;
let z = _this19.x * rotYAxis.y - _this19.y * rotYAxis.x;
_this19.x = _this19.y * rotYAxis.z - _this19.z * rotYAxis.y;
_this19.y = y;
_this19.z = z;
this._drawRotationalLimit(d,anchor2,basisY1,basisZ1,basisY1,radius2,j4._angleX - rxlm.upperLimit,j4._angleX - rxlm.lowerLimit,color3);
this._drawRotationalLimit(d,anchor2,rotYBasisX,_this19,rotYBasisX,radius2,rylm.lowerLimit - j4._angleY,rylm.upperLimit - j4._angleY,color3);
this._drawRotationalLimit(d,anchor2,basisX2,basisY2,basisX2,radius2,rzlm.lowerLimit - j4._angleZ,rzlm.upperLimit - j4._angleZ,color3);
break;
}
}
d.line(anchor1,anchor2,d.style.jointErrorColor);
let _this20 = this._pool;
if(p1 != null) {
p1.zero();
if(_this20.sizeVec3 == _this20.stackVec3.length) {
let newArray = new Array(_this20.sizeVec3 << 1);
let _g = 0;
let _g1 = _this20.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this20.stackVec3[i];
_this20.stackVec3[i] = null;
}
_this20.stackVec3 = newArray;
}
_this20.stackVec3[_this20.sizeVec3++] = p1;
}
let _this21 = this._pool;
if(p2 != null) {
p2.zero();
if(_this21.sizeVec3 == _this21.stackVec3.length) {
let newArray = new Array(_this21.sizeVec3 << 1);
let _g = 0;
let _g1 = _this21.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this21.stackVec3[i];
_this21.stackVec3[i] = null;
}
_this21.stackVec3 = newArray;
}
_this21.stackVec3[_this21.sizeVec3++] = p2;
}
let _this22 = this._pool;
if(anchor1 != null) {
anchor1.zero();
if(_this22.sizeVec3 == _this22.stackVec3.length) {
let newArray = new Array(_this22.sizeVec3 << 1);
let _g = 0;
let _g1 = _this22.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this22.stackVec3[i];
_this22.stackVec3[i] = null;
}
_this22.stackVec3 = newArray;
}
_this22.stackVec3[_this22.sizeVec3++] = anchor1;
}
let _this23 = this._pool;
if(anchor2 != null) {
anchor2.zero();
if(_this23.sizeVec3 == _this23.stackVec3.length) {
let newArray = new Array(_this23.sizeVec3 << 1);
let _g = 0;
let _g1 = _this23.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this23.stackVec3[i];
_this23.stackVec3[i] = null;
}
_this23.stackVec3 = newArray;
}
_this23.stackVec3[_this23.sizeVec3++] = anchor2;
}
let _this24 = this._pool;
if(basisX1 != null) {
basisX1.zero();
if(_this24.sizeVec3 == _this24.stackVec3.length) {
let newArray = new Array(_this24.sizeVec3 << 1);
let _g = 0;
let _g1 = _this24.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this24.stackVec3[i];
_this24.stackVec3[i] = null;
}
_this24.stackVec3 = newArray;
}
_this24.stackVec3[_this24.sizeVec3++] = basisX1;
}
let _this25 = this._pool;
if(basisY1 != null) {
basisY1.zero();
if(_this25.sizeVec3 == _this25.stackVec3.length) {
let newArray = new Array(_this25.sizeVec3 << 1);
let _g = 0;
let _g1 = _this25.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this25.stackVec3[i];
_this25.stackVec3[i] = null;
}
_this25.stackVec3 = newArray;
}
_this25.stackVec3[_this25.sizeVec3++] = basisY1;
}
let _this26 = this._pool;
if(basisZ1 != null) {
basisZ1.zero();
if(_this26.sizeVec3 == _this26.stackVec3.length) {
let newArray = new Array(_this26.sizeVec3 << 1);
let _g = 0;
let _g1 = _this26.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this26.stackVec3[i];
_this26.stackVec3[i] = null;
}
_this26.stackVec3 = newArray;
}
_this26.stackVec3[_this26.sizeVec3++] = basisZ1;
}
let _this27 = this._pool;
if(basisX2 != null) {
basisX2.zero();
if(_this27.sizeVec3 == _this27.stackVec3.length) {
let newArray = new Array(_this27.sizeVec3 << 1);
let _g = 0;
let _g1 = _this27.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this27.stackVec3[i];
_this27.stackVec3[i] = null;
}
_this27.stackVec3 = newArray;
}
_this27.stackVec3[_this27.sizeVec3++] = basisX2;
}
let _this28 = this._pool;
if(basisY2 != null) {
basisY2.zero();
if(_this28.sizeVec3 == _this28.stackVec3.length) {
let newArray = new Array(_this28.sizeVec3 << 1);
let _g = 0;
let _g1 = _this28.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this28.stackVec3[i];
_this28.stackVec3[i] = null;
}
_this28.stackVec3 = newArray;
}
_this28.stackVec3[_this28.sizeVec3++] = basisY2;
}
let _this29 = this._pool;
if(basisZ2 != null) {
basisZ2.zero();
if(_this29.sizeVec3 == _this29.stackVec3.length) {
let newArray = new Array(_this29.sizeVec3 << 1);
let _g = 0;
let _g1 = _this29.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this29.stackVec3[i];
_this29.stackVec3[i] = null;
}
_this29.stackVec3 = newArray;
}
_this29.stackVec3[_this29.sizeVec3++] = basisZ2;
}
j = n;
}
}
}
_drawRotationalLimit(d,center,ex,ey,needle,radius,min,max,color) {
if(min != max) {
let _this = this._pool;
let _this1 = _this.sizeVec3 == 0 ? new oimo.common.Vec3() : _this.stackVec3[--_this.sizeVec3];
_this1.x = center.x;
_this1.y = center.y;
_this1.z = center.z;
let _this2 = _this1;
_this2.x += needle.x * radius;
_this2.y += needle.y * radius;
_this2.z += needle.z * radius;
d.line(center,_this2,color);
let _this3 = this._pool;
if(_this2 != null) {
_this2.zero();
if(_this3.sizeVec3 == _this3.stackVec3.length) {
let newArray = new Array(_this3.sizeVec3 << 1);
let _g = 0;
let _g1 = _this3.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this3.stackVec3[i];
_this3.stackVec3[i] = null;
}
_this3.stackVec3 = newArray;
}
_this3.stackVec3[_this3.sizeVec3++] = _this2;
}
if(min > max) {
d.ellipse(center,ex,ey,radius,radius,color);
} else {
d.arc(center,ex,ey,radius,radius,min,max,true,color);
}
}
}
_drawTranslationalLimit(d,center,ex,min,max,color) {
if(min < max) {
let _this = this._pool;
let _this1 = _this.sizeVec3 == 0 ? new oimo.common.Vec3() : _this.stackVec3[--_this.sizeVec3];
_this1.x = center.x;
_this1.y = center.y;
_this1.z = center.z;
let _this2 = _this1;
_this2.x += ex.x * min;
_this2.y += ex.y * min;
_this2.z += ex.z * min;
let _this3 = this._pool;
let _this4 = _this3.sizeVec3 == 0 ? new oimo.common.Vec3() : _this3.stackVec3[--_this3.sizeVec3];
_this4.x = center.x;
_this4.y = center.y;
_this4.z = center.z;
let _this5 = _this4;
_this5.x += ex.x * max;
_this5.y += ex.y * max;
_this5.z += ex.z * max;
d.line(_this2,_this5,color);
let _this6 = this._pool;
if(_this2 != null) {
_this2.zero();
if(_this6.sizeVec3 == _this6.stackVec3.length) {
let newArray = new Array(_this6.sizeVec3 << 1);
let _g = 0;
let _g1 = _this6.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this6.stackVec3[i];
_this6.stackVec3[i] = null;
}
_this6.stackVec3 = newArray;
}
_this6.stackVec3[_this6.sizeVec3++] = _this2;
}
let _this7 = this._pool;
if(_this5 != null) {
_this5.zero();
if(_this7.sizeVec3 == _this7.stackVec3.length) {
let newArray = new Array(_this7.sizeVec3 << 1);
let _g = 0;
let _g1 = _this7.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this7.stackVec3[i];
_this7.stackVec3[i] = null;
}
_this7.stackVec3 = newArray;
}
_this7.stackVec3[_this7.sizeVec3++] = _this5;
}
}
}
_drawTranslationalLimit3D(d,center,ex,ey,ez,xlm,ylm,zlm,color) {
let minx = xlm.lowerLimit;
let maxx = xlm.upperLimit;
let miny = ylm.lowerLimit;
let maxy = ylm.upperLimit;
let minz = zlm.lowerLimit;
let maxz = zlm.upperLimit;
let _this = this._pool;
if(_this.sizeVec3 == 0) {
new oimo.common.Vec3();
} else {
--_this.sizeVec3;
}
let _this1 = this._pool;
if(_this1.sizeVec3 == 0) {
new oimo.common.Vec3();
} else {
--_this1.sizeVec3;
}
let _this2 = this._pool;
let _this3 = _this2.sizeVec3 == 0 ? new oimo.common.Vec3() : _this2.stackVec3[--_this2.sizeVec3];
_this3.x = center.x;
_this3.y = center.y;
_this3.z = center.z;
let _this4 = _this3;
_this4.x += ex.x * minx;
_this4.y += ex.y * minx;
_this4.z += ex.z * minx;
_this4.x += ey.x * miny;
_this4.y += ey.y * miny;
_this4.z += ey.z * miny;
_this4.x += ez.x * minz;
_this4.y += ez.y * minz;
_this4.z += ez.z * minz;
let _this5 = this._pool;
let _this6 = _this5.sizeVec3 == 0 ? new oimo.common.Vec3() : _this5.stackVec3[--_this5.sizeVec3];
_this6.x = center.x;
_this6.y = center.y;
_this6.z = center.z;
let _this7 = _this6;
_this7.x += ex.x * minx;
_this7.y += ex.y * minx;
_this7.z += ex.z * minx;
_this7.x += ey.x * miny;
_this7.y += ey.y * miny;
_this7.z += ey.z * miny;
_this7.x += ez.x * maxz;
_this7.y += ez.y * maxz;
_this7.z += ez.z * maxz;
let _this8 = this._pool;
let _this9 = _this8.sizeVec3 == 0 ? new oimo.common.Vec3() : _this8.stackVec3[--_this8.sizeVec3];
_this9.x = center.x;
_this9.y = center.y;
_this9.z = center.z;
let _this10 = _this9;
_this10.x += ex.x * minx;
_this10.y += ex.y * minx;
_this10.z += ex.z * minx;
_this10.x += ey.x * maxy;
_this10.y += ey.y * maxy;
_this10.z += ey.z * maxy;
_this10.x += ez.x * minz;
_this10.y += ez.y * minz;
_this10.z += ez.z * minz;
let _this11 = this._pool;
let _this12 = _this11.sizeVec3 == 0 ? new oimo.common.Vec3() : _this11.stackVec3[--_this11.sizeVec3];
_this12.x = center.x;
_this12.y = center.y;
_this12.z = center.z;
let _this13 = _this12;
_this13.x += ex.x * minx;
_this13.y += ex.y * minx;
_this13.z += ex.z * minx;
_this13.x += ey.x * maxy;
_this13.y += ey.y * maxy;
_this13.z += ey.z * maxy;
_this13.x += ez.x * maxz;
_this13.y += ez.y * maxz;
_this13.z += ez.z * maxz;
let _this14 = this._pool;
let _this15 = _this14.sizeVec3 == 0 ? new oimo.common.Vec3() : _this14.stackVec3[--_this14.sizeVec3];
_this15.x = center.x;
_this15.y = center.y;
_this15.z = center.z;
let _this16 = _this15;
_this16.x += ex.x * maxx;
_this16.y += ex.y * maxx;
_this16.z += ex.z * maxx;
_this16.x += ey.x * miny;
_this16.y += ey.y * miny;
_this16.z += ey.z * miny;
_this16.x += ez.x * minz;
_this16.y += ez.y * minz;
_this16.z += ez.z * minz;
let _this17 = this._pool;
let _this18 = _this17.sizeVec3 == 0 ? new oimo.common.Vec3() : _this17.stackVec3[--_this17.sizeVec3];
_this18.x = center.x;
_this18.y = center.y;
_this18.z = center.z;
let _this19 = _this18;
_this19.x += ex.x * maxx;
_this19.y += ex.y * maxx;
_this19.z += ex.z * maxx;
_this19.x += ey.x * miny;
_this19.y += ey.y * miny;
_this19.z += ey.z * miny;
_this19.x += ez.x * maxz;
_this19.y += ez.y * maxz;
_this19.z += ez.z * maxz;
let _this20 = this._pool;
let _this21 = _this20.sizeVec3 == 0 ? new oimo.common.Vec3() : _this20.stackVec3[--_this20.sizeVec3];
_this21.x = center.x;
_this21.y = center.y;
_this21.z = center.z;
let _this22 = _this21;
_this22.x += ex.x * maxx;
_this22.y += ex.y * maxx;
_this22.z += ex.z * maxx;
_this22.x += ey.x * maxy;
_this22.y += ey.y * maxy;
_this22.z += ey.z * maxy;
_this22.x += ez.x * minz;
_this22.y += ez.y * minz;
_this22.z += ez.z * minz;
let _this23 = this._pool;
let _this24 = _this23.sizeVec3 == 0 ? new oimo.common.Vec3() : _this23.stackVec3[--_this23.sizeVec3];
_this24.x = center.x;
_this24.y = center.y;
_this24.z = center.z;
let _this25 = _this24;
_this25.x += ex.x * maxx;
_this25.y += ex.y * maxx;
_this25.z += ex.z * maxx;
_this25.x += ey.x * maxy;
_this25.y += ey.y * maxy;
_this25.z += ey.z * maxy;
_this25.x += ez.x * maxz;
_this25.y += ez.y * maxz;
_this25.z += ez.z * maxz;
d.line(_this4,_this16,color);
d.line(_this10,_this22,color);
d.line(_this7,_this19,color);
d.line(_this13,_this25,color);
d.line(_this4,_this10,color);
d.line(_this16,_this22,color);
d.line(_this7,_this13,color);
d.line(_this19,_this25,color);
d.line(_this4,_this7,color);
d.line(_this16,_this19,color);
d.line(_this10,_this13,color);
d.line(_this22,_this25,color);
let _this26 = this._pool;
if(_this4 != null) {
_this4.zero();
if(_this26.sizeVec3 == _this26.stackVec3.length) {
let newArray = new Array(_this26.sizeVec3 << 1);
let _g = 0;
let _g1 = _this26.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this26.stackVec3[i];
_this26.stackVec3[i] = null;
}
_this26.stackVec3 = newArray;
}
_this26.stackVec3[_this26.sizeVec3++] = _this4;
}
let _this27 = this._pool;
if(_this7 != null) {
_this7.zero();
if(_this27.sizeVec3 == _this27.stackVec3.length) {
let newArray = new Array(_this27.sizeVec3 << 1);
let _g = 0;
let _g1 = _this27.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this27.stackVec3[i];
_this27.stackVec3[i] = null;
}
_this27.stackVec3 = newArray;
}
_this27.stackVec3[_this27.sizeVec3++] = _this7;
}
let _this28 = this._pool;
if(_this10 != null) {
_this10.zero();
if(_this28.sizeVec3 == _this28.stackVec3.length) {
let newArray = new Array(_this28.sizeVec3 << 1);
let _g = 0;
let _g1 = _this28.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this28.stackVec3[i];
_this28.stackVec3[i] = null;
}
_this28.stackVec3 = newArray;
}
_this28.stackVec3[_this28.sizeVec3++] = _this10;
}
let _this29 = this._pool;
if(_this13 != null) {
_this13.zero();
if(_this29.sizeVec3 == _this29.stackVec3.length) {
let newArray = new Array(_this29.sizeVec3 << 1);
let _g = 0;
let _g1 = _this29.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this29.stackVec3[i];
_this29.stackVec3[i] = null;
}
_this29.stackVec3 = newArray;
}
_this29.stackVec3[_this29.sizeVec3++] = _this13;
}
let _this30 = this._pool;
if(_this16 != null) {
_this16.zero();
if(_this30.sizeVec3 == _this30.stackVec3.length) {
let newArray = new Array(_this30.sizeVec3 << 1);
let _g = 0;
let _g1 = _this30.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this30.stackVec3[i];
_this30.stackVec3[i] = null;
}
_this30.stackVec3 = newArray;
}
_this30.stackVec3[_this30.sizeVec3++] = _this16;
}
let _this31 = this._pool;
if(_this19 != null) {
_this19.zero();
if(_this31.sizeVec3 == _this31.stackVec3.length) {
let newArray = new Array(_this31.sizeVec3 << 1);
let _g = 0;
let _g1 = _this31.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this31.stackVec3[i];
_this31.stackVec3[i] = null;
}
_this31.stackVec3 = newArray;
}
_this31.stackVec3[_this31.sizeVec3++] = _this19;
}
let _this32 = this._pool;
if(_this22 != null) {
_this22.zero();
if(_this32.sizeVec3 == _this32.stackVec3.length) {
let newArray = new Array(_this32.sizeVec3 << 1);
let _g = 0;
let _g1 = _this32.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this32.stackVec3[i];
_this32.stackVec3[i] = null;
}
_this32.stackVec3 = newArray;
}
_this32.stackVec3[_this32.sizeVec3++] = _this22;
}
let _this33 = this._pool;
if(_this25 != null) {
_this25.zero();
if(_this33.sizeVec3 == _this33.stackVec3.length) {
let newArray = new Array(_this33.sizeVec3 << 1);
let _g = 0;
let _g1 = _this33.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this33.stackVec3[i];
_this33.stackVec3[i] = null;
}
_this33.stackVec3 = newArray;
}
_this33.stackVec3[_this33.sizeVec3++] = _this25;
}
}
_drawEllipseOnSphere(d,center,normal,x,y,radiansX,radiansY,radius,color) {
let theta = 0;
let _this = this._pool;
let rotVec = _this.sizeVec3 == 0 ? new oimo.common.Vec3() : _this.stackVec3[--_this.sizeVec3];
let _this1 = this._pool;
let rotQ = _this1.sizeQuat == 0 ? new oimo.common.Quat() : _this1.stackQuat[--_this1.sizeQuat];
let _this2 = this._pool;
let rotM = _this2.sizeMat3 == 0 ? new oimo.common.Mat3() : _this2.stackMat3[--_this2.sizeMat3];
let _this3 = this._pool;
let prevV = _this3.sizeVec3 == 0 ? new oimo.common.Vec3() : _this3.stackVec3[--_this3.sizeVec3];
let _g = 0;
while(_g < 17) {
let i = _g++;
let rx = Math.cos(theta) * radiansX;
let ry = Math.sin(theta) * radiansY;
let halfRotAng = Math.sqrt(rx * rx + ry * ry);
let rotSin = Math.sin(halfRotAng * 0.5);
let rotCos = Math.cos(halfRotAng * 0.5);
let _this = rotVec.zero();
_this.x += x.x * rx;
_this.y += x.y * rx;
_this.z += x.z * rx;
_this.x += y.x * ry;
_this.y += y.y * ry;
_this.z += y.z * ry;
let s = 1 / halfRotAng * rotSin;
rotVec.x *= s;
rotVec.y *= s;
rotVec.z *= s;
rotQ.x = rotVec.x;
rotQ.y = rotVec.y;
rotQ.z = rotVec.z;
rotQ.w = rotCos;
let x1 = rotQ.x;
let y1 = rotQ.y;
let z = rotQ.z;
let w = rotQ.w;
let x2 = 2 * x1;
let y2 = 2 * y1;
let z2 = 2 * z;
let xx = x1 * x2;
let yy = y1 * y2;
let zz = z * z2;
let xy = x1 * y2;
let yz = y1 * z2;
let xz = x1 * z2;
let wx = w * x2;
let wy = w * y2;
let wz = w * z2;
rotM.e00 = 1 - yy - zz;
rotM.e01 = xy - wz;
rotM.e02 = xz + wy;
rotM.e10 = xy + wz;
rotM.e11 = 1 - xx - zz;
rotM.e12 = yz - wx;
rotM.e20 = xz - wy;
rotM.e21 = yz + wx;
rotM.e22 = 1 - xx - yy;
let _this1 = this._pool;
let _this2 = _this1.sizeVec3 == 0 ? new oimo.common.Vec3() : _this1.stackVec3[--_this1.sizeVec3];
_this2.x += normal.x * radius;
_this2.y += normal.y * radius;
_this2.z += normal.z * radius;
let v = _this2;
let y3 = v.x * rotM.e10 + v.y * rotM.e11 + v.z * rotM.e12;
let z1 = v.x * rotM.e20 + v.y * rotM.e21 + v.z * rotM.e22;
v.x = v.x * rotM.e00 + v.y * rotM.e01 + v.z * rotM.e02;
v.y = y3;
v.z = z1;
v.x += center.x;
v.y += center.y;
v.z += center.z;
if(i >= 1) {
d.line(prevV,v,color);
}
let _this3 = this._pool;
if(prevV != null) {
prevV.zero();
if(_this3.sizeVec3 == _this3.stackVec3.length) {
let newArray = new Array(_this3.sizeVec3 << 1);
let _g = 0;
let _g1 = _this3.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this3.stackVec3[i];
_this3.stackVec3[i] = null;
}
_this3.stackVec3 = newArray;
}
_this3.stackVec3[_this3.sizeVec3++] = prevV;
}
prevV = v;
theta += 0.39269908169872375;
}
let _this4 = this._pool;
if(rotVec != null) {
rotVec.zero();
if(_this4.sizeVec3 == _this4.stackVec3.length) {
let newArray = new Array(_this4.sizeVec3 << 1);
let _g = 0;
let _g1 = _this4.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this4.stackVec3[i];
_this4.stackVec3[i] = null;
}
_this4.stackVec3 = newArray;
}
_this4.stackVec3[_this4.sizeVec3++] = rotVec;
}
let _this5 = this._pool;
if(rotQ != null) {
rotQ.x = 0;
rotQ.y = 0;
rotQ.z = 0;
rotQ.w = 1;
if(_this5.sizeQuat == _this5.stackQuat.length) {
let newArray = new Array(_this5.sizeQuat << 1);
let _g = 0;
let _g1 = _this5.sizeQuat;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this5.stackQuat[i];
_this5.stackQuat[i] = null;
}
_this5.stackQuat = newArray;
}
_this5.stackQuat[_this5.sizeQuat++] = rotQ;
}
let _this6 = this._pool;
if(rotM != null) {
rotM.e00 = 1;
rotM.e01 = 0;
rotM.e02 = 0;
rotM.e10 = 0;
rotM.e11 = 1;
rotM.e12 = 0;
rotM.e20 = 0;
rotM.e21 = 0;
rotM.e22 = 1;
if(_this6.sizeMat3 == _this6.stackMat3.length) {
let newArray = new Array(_this6.sizeMat3 << 1);
let _g = 0;
let _g1 = _this6.sizeMat3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this6.stackMat3[i];
_this6.stackMat3[i] = null;
}
_this6.stackMat3 = newArray;
}
_this6.stackMat3[_this6.sizeMat3++] = rotM;
}
let _this7 = this._pool;
if(prevV != null) {
prevV.zero();
if(_this7.sizeVec3 == _this7.stackVec3.length) {
let newArray = new Array(_this7.sizeVec3 << 1);
let _g = 0;
let _g1 = _this7.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this7.stackVec3[i];
_this7.stackVec3[i] = null;
}
_this7.stackVec3 = newArray;
}
_this7.stackVec3[_this7.sizeVec3++] = prevV;
}
}
step(timeStep) {
if(this._timeStep.dt > 0) {
this._timeStep.dtRatio = timeStep / this._timeStep.dt;
}
this._timeStep.dt = timeStep;
this._timeStep.invDt = 1 / timeStep;
let st = Date.now() / 1000;
this._updateContacts();
this._solveIslands();
oimo.dynamics.common.Performance.totalTime = (Date.now() / 1000 - st) * 1000;
}
addRigidBody(rigidBody) {
if(rigidBody._world != null) {
throw new Error("A rigid body cannot belong to multiple worlds.");
}
if(this._rigidBodyList == null) {
this._rigidBodyList = rigidBody;
this._rigidBodyListLast = rigidBody;
} else {
this._rigidBodyListLast._next = rigidBody;
rigidBody._prev = this._rigidBodyListLast;
this._rigidBodyListLast = rigidBody;
}
rigidBody._world = this;
let s = rigidBody._shapeList;
while(s != null) {
let n = s._next;
s._proxy = this._broadPhase.createProxy(s,s._aabb);
s._id = this._shapeIdCount++;
this._numShapes++;
s = n;
}
this._numRigidBodies++;
}
removeRigidBody(rigidBody) {
if(rigidBody._world != this) {
throw new Error("The rigid body doesn't belong to the world.");
}
let prev = rigidBody._prev;
let next = rigidBody._next;
if(prev != null) {
prev._next = next;
}
if(next != null) {
next._prev = prev;
}
if(rigidBody == this._rigidBodyList) {
this._rigidBodyList = this._rigidBodyList._next;
}
if(rigidBody == this._rigidBodyListLast) {
this._rigidBodyListLast = this._rigidBodyListLast._prev;
}
rigidBody._next = null;
rigidBody._prev = null;
rigidBody._world = null;
let s = rigidBody._shapeList;
while(s != null) {
let n = s._next;
this._broadPhase.destroyProxy(s._proxy);
s._proxy = null;
s._id = -1;
let cl = s._rigidBody._contactLinkList;
while(cl != null) {
let n = cl._next;
let c = cl._contact;
if(c._s1 == s || c._s2 == s) {
let _this = cl._other;
_this._sleeping = false;
_this._sleepTime = 0;
let _this1 = this._contactManager;
let prev = c._prev;
let next = c._next;
if(prev != null) {
prev._next = next;
}
if(next != null) {
next._prev = prev;
}
if(c == _this1._contactList) {
_this1._contactList = _this1._contactList._next;
}
if(c == _this1._contactListLast) {
_this1._contactListLast = _this1._contactListLast._prev;
}
c._next = null;
c._prev = null;
if(c._touching) {
let cc1 = c._s1._contactCallback;
let cc2 = c._s2._contactCallback;
if(cc1 == cc2) {
cc2 = null;
}
if(cc1 != null) {
cc1.endContact(c);
}
if(cc2 != null) {
cc2.endContact(c);
}
}
let prev1 = c._link1._prev;
let next1 = c._link1._next;
if(prev1 != null) {
prev1._next = next1;
}
if(next1 != null) {
next1._prev = prev1;
}
if(c._link1 == c._b1._contactLinkList) {
c._b1._contactLinkList = c._b1._contactLinkList._next;
}
if(c._link1 == c._b1._contactLinkListLast) {
c._b1._contactLinkListLast = c._b1._contactLinkListLast._prev;
}
c._link1._next = null;
c._link1._prev = null;
let prev2 = c._link2._prev;
let next2 = c._link2._next;
if(prev2 != null) {
prev2._next = next2;
}
if(next2 != null) {
next2._prev = prev2;
}
if(c._link2 == c._b2._contactLinkList) {
c._b2._contactLinkList = c._b2._contactLinkList._next;
}
if(c._link2 == c._b2._contactLinkListLast) {
c._b2._contactLinkListLast = c._b2._contactLinkListLast._prev;
}
c._link2._next = null;
c._link2._prev = null;
c._b1._numContactLinks--;
c._b2._numContactLinks--;
c._link1._other = null;
c._link2._other = null;
c._link1._contact = null;
c._link2._contact = null;
c._s1 = null;
c._s2 = null;
c._b1 = null;
c._b2 = null;
c._touching = false;
c._cachedDetectorData._clear();
c._manifold._clear();
c._detector = null;
let _this2 = c._contactConstraint;
_this2._s1 = null;
_this2._s2 = null;
_this2._b1 = null;
_this2._b2 = null;
_this2._tf1 = null;
_this2._tf2 = null;
c._next = _this1._contactPool;
_this1._contactPool = c;
_this1._numContacts--;
}
cl = n;
}
this._numShapes--;
s = n;
}
this._numRigidBodies--;
}
addJoint(joint) {
if(joint._world != null) {
throw new Error("A joint cannot belong to multiple worlds.");
}
if(this._jointList == null) {
this._jointList = joint;
this._jointListLast = joint;
} else {
this._jointListLast._next = joint;
joint._prev = this._jointListLast;
this._jointListLast = joint;
}
joint._world = this;
joint._link1._other = joint._b2;
joint._link2._other = joint._b1;
if(joint._b1._jointLinkList == null) {
joint._b1._jointLinkList = joint._link1;
joint._b1._jointLinkListLast = joint._link1;
} else {
joint._b1._jointLinkListLast._next = joint._link1;
joint._link1._prev = joint._b1._jointLinkListLast;
joint._b1._jointLinkListLast = joint._link1;
}
if(joint._b2._jointLinkList == null) {
joint._b2._jointLinkList = joint._link2;
joint._b2._jointLinkListLast = joint._link2;
} else {
joint._b2._jointLinkListLast._next = joint._link2;
joint._link2._prev = joint._b2._jointLinkListLast;
joint._b2._jointLinkListLast = joint._link2;
}
joint._b1._numJointLinks++;
joint._b2._numJointLinks++;
let _this = joint._b1;
_this._sleeping = false;
_this._sleepTime = 0;
let _this1 = joint._b2;
_this1._sleeping = false;
_this1._sleepTime = 0;
joint._syncAnchors();
this._numJoints++;
}
removeJoint(joint) {
if(joint._world != this) {
throw new Error("The joint doesn't belong to the world.");
}
let prev = joint._prev;
let next = joint._next;
if(prev != null) {
prev._next = next;
}
if(next != null) {
next._prev = prev;
}
if(joint == this._jointList) {
this._jointList = this._jointList._next;
}
if(joint == this._jointListLast) {
this._jointListLast = this._jointListLast._prev;
}
joint._next = null;
joint._prev = null;
joint._world = null;
let prev1 = joint._link1._prev;
let next1 = joint._link1._next;
if(prev1 != null) {
prev1._next = next1;
}
if(next1 != null) {
next1._prev = prev1;
}
if(joint._link1 == joint._b1._jointLinkList) {
joint._b1._jointLinkList = joint._b1._jointLinkList._next;
}
if(joint._link1 == joint._b1._jointLinkListLast) {
joint._b1._jointLinkListLast = joint._b1._jointLinkListLast._prev;
}
joint._link1._next = null;
joint._link1._prev = null;
let prev2 = joint._link2._prev;
let next2 = joint._link2._next;
if(prev2 != null) {
prev2._next = next2;
}
if(next2 != null) {
next2._prev = prev2;
}
if(joint._link2 == joint._b2._jointLinkList) {
joint._b2._jointLinkList = joint._b2._jointLinkList._next;
}
if(joint._link2 == joint._b2._jointLinkListLast) {
joint._b2._jointLinkListLast = joint._b2._jointLinkListLast._prev;
}
joint._link2._next = null;
joint._link2._prev = null;
joint._link1._other = null;
joint._link2._other = null;
joint._b1._numJointLinks--;
joint._b2._numJointLinks--;
let _this = joint._b1;
_this._sleeping = false;
_this._sleepTime = 0;
let _this1 = joint._b2;
_this1._sleeping = false;
_this1._sleepTime = 0;
this._numJoints--;
}
setDebugDraw(debugDraw) {
this._debugDraw = debugDraw;
}
getDebugDraw() {
return this._debugDraw;
}
debugDraw() {
if(this._debugDraw != null) {
if(this._broadPhase._type == 2) {
this._drawBvh(this._debugDraw,this._broadPhase._tree);
}
this._drawRigidBodies(this._debugDraw);
this._drawConstraints(this._debugDraw);
}
}
rayCast(begin,end,callback) {
let _this = this._rayCastWrapper.begin;
_this.x = begin.x;
_this.y = begin.y;
_this.z = begin.z;
let _this1 = this._rayCastWrapper.end;
_this1.x = end.x;
_this1.y = end.y;
_this1.z = end.z;
this._rayCastWrapper.callback = callback;
this._broadPhase.rayCast(begin,end,this._rayCastWrapper);
}
convexCast(convex,begin,translation,callback) {
this._convexCastWrapper.convex = convex;
let _this = this._convexCastWrapper.begin;
_this._positionX = begin._positionX;
_this._positionY = begin._positionY;
_this._positionZ = begin._positionZ;
_this._rotation00 = begin._rotation00;
_this._rotation01 = begin._rotation01;
_this._rotation02 = begin._rotation02;
_this._rotation10 = begin._rotation10;
_this._rotation11 = begin._rotation11;
_this._rotation12 = begin._rotation12;
_this._rotation20 = begin._rotation20;
_this._rotation21 = begin._rotation21;
_this._rotation22 = begin._rotation22;
let _this1 = this._convexCastWrapper.translation;
_this1.x = translation.x;
_this1.y = translation.y;
_this1.z = translation.z;
this._convexCastWrapper.callback = callback;
this._broadPhase.convexCast(convex,begin,translation,this._convexCastWrapper);
}
aabbTest(aabb,callback) {
this._aabbTestWrapper._aabb.copyFrom(aabb);
this._aabbTestWrapper._callback = callback;
this._broadPhase.aabbTest(aabb,this._aabbTestWrapper);
}
getRigidBodyList() {
return this._rigidBodyList;
}
getJointList() {
return this._jointList;
}
getBroadPhase() {
return this._broadPhase;
}
getContactManager() {
return this._contactManager;
}
getNumRigidBodies() {
return this._numRigidBodies;
}
getNumJoints() {
return this._numJoints;
}
getNumShapes() {
return this._numShapes;
}
getNumIslands() {
return this._numIslands;
}
getNumVelocityIterations() {
return this._numVelocityIterations;
}
setNumVelocityIterations(numVelocityIterations) {
this._numVelocityIterations = numVelocityIterations;
}
getNumPositionIterations() {
return this._numPositionIterations;
}
setNumPositionIterations(numPositionIterations) {
this._numPositionIterations = numPositionIterations;
}
getGravity() {
return this._gravity;
}
setGravity(gravity) {
let _this = this._gravity;
_this.x = gravity.x;
_this.y = gravity.y;
_this.z = gravity.z;
}
}
if(!oimo.dynamics._World) oimo.dynamics._World = {};
oimo.dynamics._World.RayCastWrapper = class oimo_dynamics__$World_RayCastWrapper extends oimo.collision.broadphase.BroadPhaseProxyCallback {
constructor() {
super();
this.rayCastHit = new oimo.collision.geometry.RayCastHit();
this.begin = new oimo.common.Vec3();
this.end = new oimo.common.Vec3();
this.callback = null;
}
process(proxy) {
let shape = proxy.userData;
if(shape._geom.rayCast(this.begin,this.end,shape._transform,this.rayCastHit)) {
this.callback.process(shape,this.rayCastHit);
}
}
}
oimo.dynamics._World.ConvexCastWrapper = class oimo_dynamics__$World_ConvexCastWrapper extends oimo.collision.broadphase.BroadPhaseProxyCallback {
constructor() {
super();
this.rayCastHit = new oimo.collision.geometry.RayCastHit();
this.begin = new oimo.common.Transform();
this.translation = new oimo.common.Vec3();
this.zero = new oimo.common.Vec3();
this.callback = null;
this.convex = null;
}
process(proxy) {
let shape = proxy.userData;
let type = shape._geom._type;
if(type < 0 || type > 5) {
return;
}
if(oimo.collision.narrowphase.detector.gjkepa.GjkEpa.instance.convexCast(this.convex,shape._geom,this.begin,shape._transform,this.translation,this.zero,this.rayCastHit)) {
this.callback.process(shape,this.rayCastHit);
}
}
}
oimo.dynamics._World.AabbTestWrapper = class oimo_dynamics__$World_AabbTestWrapper extends oimo.collision.broadphase.BroadPhaseProxyCallback {
constructor() {
super();
this._aabb = new oimo.collision.geometry.Aabb();
this._callback = null;
}
process(proxy) {
let shape = proxy.userData;
let shapeAabb = shape._aabb;
if(shapeAabb._minX < this._aabb._maxX && shapeAabb._maxX > this._aabb._minX && shapeAabb._minY < this._aabb._maxY && shapeAabb._maxY > this._aabb._minY && shapeAabb._minZ < this._aabb._maxZ && shapeAabb._maxZ > this._aabb._minZ) {
this._callback.process(shape);
}
}
}
if(!oimo.dynamics.callback) oimo.dynamics.callback = {};
oimo.dynamics.callback.AabbTestCallback = class oimo_dynamics_callback_AabbTestCallback {
constructor() {
}
process(shape) {
}
}
oimo.dynamics.callback.ContactCallback = class oimo_dynamics_callback_ContactCallback {
constructor() {
}
beginContact(c) {
}
preSolve(c) {
}
postSolve(c) {
}
endContact(c) {
}
}
oimo.dynamics.callback.RayCastCallback = class oimo_dynamics_callback_RayCastCallback {
constructor() {
}
process(shape,hit) {
}
}
oimo.dynamics.callback.RayCastClosest = class oimo_dynamics_callback_RayCastClosest extends oimo.dynamics.callback.RayCastCallback {
constructor() {
super();
this.position = new oimo.common.Vec3();
this.normal = new oimo.common.Vec3();
this.shape = null;
this.fraction = 1;
this.position.zero();
this.normal.zero();
this.hit = false;
}
clear() {
this.shape = null;
this.fraction = 1;
this.position.zero();
this.normal.zero();
this.hit = false;
}
process(shape,hit) {
if(hit.fraction < this.fraction) {
this.shape = shape;
this.hit = true;
this.fraction = hit.fraction;
let _this = this.position;
let v = hit.position;
_this.x = v.x;
_this.y = v.y;
_this.z = v.z;
let _this1 = this.normal;
let v1 = hit.normal;
_this1.x = v1.x;
_this1.y = v1.y;
_this1.z = v1.z;
}
}
}
if(!oimo.dynamics.common) oimo.dynamics.common = {};
oimo.dynamics.common.DebugDraw = class oimo_dynamics_common_DebugDraw {
constructor() {
this.p = new oimo.common.Pool();
this.wireframe = false;
this.drawShapes = true;
this.drawBvh = false;
this.drawBvhMinLevel = 0;
this.drawBvhMaxLevel = 65536;
this.drawAabbs = false;
this.drawBases = false;
this.drawPairs = false;
this.drawContacts = false;
this.drawJoints = true;
this.drawJointLimits = false;
this.sphereCoords = new Array(5);
this.tmpSphereVerts = new Array(5);
this.tmpSphereNorms = new Array(5);
let _g = 0;
while(_g < 5) {
let i = _g++;
let num = i == 0 || i == 4 ? 1 : 8;
this.sphereCoords[i] = new Array(num);
this.tmpSphereVerts[i] = new Array(num);
this.tmpSphereNorms[i] = new Array(num);
let _g1 = 0;
while(_g1 < 8) {
let j = _g1++;
let theta = i * 0.7853981633974475;
let phi = j * 0.7853981633974475;
this.sphereCoords[i][j] = new oimo.common.Vec3(Math.sin(theta) * Math.cos(phi),Math.cos(theta),-Math.sin(theta) * Math.sin(phi));
this.tmpSphereVerts[i][j] = new oimo.common.Vec3();
this.tmpSphereNorms[i][j] = new oimo.common.Vec3();
}
}
this.circleCoords = new Array(8);
this.circleCoordsShift = new Array(8);
this.tmpCircleVerts1 = new Array(8);
this.tmpCircleVerts2 = new Array(8);
this.tmpCircleNorms = new Array(8);
let _g1 = 0;
while(_g1 < 8) {
let i = _g1++;
this.circleCoords[i] = new oimo.common.Vec3(Math.cos(i * 0.7853981633974475),0,-Math.sin(i * 0.7853981633974475));
this.circleCoordsShift[i] = new oimo.common.Vec3(Math.cos((i + 0.5) * 0.7853981633974475),0,-Math.sin((i + 0.5) * 0.7853981633974475));
this.tmpCircleVerts1[i] = new oimo.common.Vec3();
this.tmpCircleVerts2[i] = new oimo.common.Vec3();
this.tmpCircleNorms[i] = new oimo.common.Vec3();
}
this.style = new oimo.dynamics.common.DebugDrawStyle();
}
aabb(min,max,color) {
let _this = this.p;
let v1 = (_this.sizeVec3 == 0 ? new oimo.common.Vec3() : _this.stackVec3[--_this.sizeVec3]).init(min.x,min.y,min.z);
let _this1 = this.p;
let v2 = (_this1.sizeVec3 == 0 ? new oimo.common.Vec3() : _this1.stackVec3[--_this1.sizeVec3]).init(min.x,min.y,max.z);
let _this2 = this.p;
let v3 = (_this2.sizeVec3 == 0 ? new oimo.common.Vec3() : _this2.stackVec3[--_this2.sizeVec3]).init(min.x,max.y,min.z);
let _this3 = this.p;
let v4 = (_this3.sizeVec3 == 0 ? new oimo.common.Vec3() : _this3.stackVec3[--_this3.sizeVec3]).init(min.x,max.y,max.z);
let _this4 = this.p;
let v5 = (_this4.sizeVec3 == 0 ? new oimo.common.Vec3() : _this4.stackVec3[--_this4.sizeVec3]).init(max.x,min.y,min.z);
let _this5 = this.p;
let v6 = (_this5.sizeVec3 == 0 ? new oimo.common.Vec3() : _this5.stackVec3[--_this5.sizeVec3]).init(max.x,min.y,max.z);
let _this6 = this.p;
let v7 = (_this6.sizeVec3 == 0 ? new oimo.common.Vec3() : _this6.stackVec3[--_this6.sizeVec3]).init(max.x,max.y,min.z);
let _this7 = this.p;
let v8 = (_this7.sizeVec3 == 0 ? new oimo.common.Vec3() : _this7.stackVec3[--_this7.sizeVec3]).init(max.x,max.y,max.z);
this.line(v1,v2,color);
this.line(v3,v4,color);
this.line(v5,v6,color);
this.line(v7,v8,color);
this.line(v1,v3,color);
this.line(v2,v4,color);
this.line(v5,v7,color);
this.line(v6,v8,color);
this.line(v1,v5,color);
this.line(v2,v6,color);
this.line(v3,v7,color);
this.line(v4,v8,color);
let _this8 = this.p;
if(v1 != null) {
v1.zero();
if(_this8.sizeVec3 == _this8.stackVec3.length) {
let newArray = new Array(_this8.sizeVec3 << 1);
let _g = 0;
let _g1 = _this8.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this8.stackVec3[i];
_this8.stackVec3[i] = null;
}
_this8.stackVec3 = newArray;
}
_this8.stackVec3[_this8.sizeVec3++] = v1;
}
let _this9 = this.p;
if(v2 != null) {
v2.zero();
if(_this9.sizeVec3 == _this9.stackVec3.length) {
let newArray = new Array(_this9.sizeVec3 << 1);
let _g = 0;
let _g1 = _this9.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this9.stackVec3[i];
_this9.stackVec3[i] = null;
}
_this9.stackVec3 = newArray;
}
_this9.stackVec3[_this9.sizeVec3++] = v2;
}
let _this10 = this.p;
if(v3 != null) {
v3.zero();
if(_this10.sizeVec3 == _this10.stackVec3.length) {
let newArray = new Array(_this10.sizeVec3 << 1);
let _g = 0;
let _g1 = _this10.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this10.stackVec3[i];
_this10.stackVec3[i] = null;
}
_this10.stackVec3 = newArray;
}
_this10.stackVec3[_this10.sizeVec3++] = v3;
}
let _this11 = this.p;
if(v4 != null) {
v4.zero();
if(_this11.sizeVec3 == _this11.stackVec3.length) {
let newArray = new Array(_this11.sizeVec3 << 1);
let _g = 0;
let _g1 = _this11.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this11.stackVec3[i];
_this11.stackVec3[i] = null;
}
_this11.stackVec3 = newArray;
}
_this11.stackVec3[_this11.sizeVec3++] = v4;
}
let _this12 = this.p;
if(v5 != null) {
v5.zero();
if(_this12.sizeVec3 == _this12.stackVec3.length) {
let newArray = new Array(_this12.sizeVec3 << 1);
let _g = 0;
let _g1 = _this12.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this12.stackVec3[i];
_this12.stackVec3[i] = null;
}
_this12.stackVec3 = newArray;
}
_this12.stackVec3[_this12.sizeVec3++] = v5;
}
let _this13 = this.p;
if(v6 != null) {
v6.zero();
if(_this13.sizeVec3 == _this13.stackVec3.length) {
let newArray = new Array(_this13.sizeVec3 << 1);
let _g = 0;
let _g1 = _this13.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this13.stackVec3[i];
_this13.stackVec3[i] = null;
}
_this13.stackVec3 = newArray;
}
_this13.stackVec3[_this13.sizeVec3++] = v6;
}
let _this14 = this.p;
if(v7 != null) {
v7.zero();
if(_this14.sizeVec3 == _this14.stackVec3.length) {
let newArray = new Array(_this14.sizeVec3 << 1);
let _g = 0;
let _g1 = _this14.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this14.stackVec3[i];
_this14.stackVec3[i] = null;
}
_this14.stackVec3 = newArray;
}
_this14.stackVec3[_this14.sizeVec3++] = v7;
}
let _this15 = this.p;
if(v8 != null) {
v8.zero();
if(_this15.sizeVec3 == _this15.stackVec3.length) {
let newArray = new Array(_this15.sizeVec3 << 1);
let _g = 0;
let _g1 = _this15.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this15.stackVec3[i];
_this15.stackVec3[i] = null;
}
_this15.stackVec3 = newArray;
}
_this15.stackVec3[_this15.sizeVec3++] = v8;
}
}
basis(transform,length,colorX,colorY,colorZ) {
let _this = this.p;
let pos = _this.sizeVec3 == 0 ? new oimo.common.Vec3() : _this.stackVec3[--_this.sizeVec3];
let _this1 = this.p;
let rot = _this1.sizeMat3 == 0 ? new oimo.common.Mat3() : _this1.stackMat3[--_this1.sizeMat3];
let _this2 = this.p;
let ex = _this2.sizeVec3 == 0 ? new oimo.common.Vec3() : _this2.stackVec3[--_this2.sizeVec3];
let _this3 = this.p;
let ey = _this3.sizeVec3 == 0 ? new oimo.common.Vec3() : _this3.stackVec3[--_this3.sizeVec3];
let _this4 = this.p;
let ez = _this4.sizeVec3 == 0 ? new oimo.common.Vec3() : _this4.stackVec3[--_this4.sizeVec3];
let v = pos;
v.x = transform._positionX;
v.y = transform._positionY;
v.z = transform._positionZ;
let m = rot;
m.e00 = transform._rotation00;
m.e01 = transform._rotation01;
m.e02 = transform._rotation02;
m.e10 = transform._rotation10;
m.e11 = transform._rotation11;
m.e12 = transform._rotation12;
m.e20 = transform._rotation20;
m.e21 = transform._rotation21;
m.e22 = transform._rotation22;
ex.init(rot.e00,rot.e10,rot.e20);
ey.init(rot.e01,rot.e11,rot.e21);
ez.init(rot.e02,rot.e12,rot.e22);
ex.x *= length;
ex.y *= length;
ex.z *= length;
let _this5 = ex;
_this5.x += pos.x;
_this5.y += pos.y;
_this5.z += pos.z;
ey.x *= length;
ey.y *= length;
ey.z *= length;
let _this6 = ey;
_this6.x += pos.x;
_this6.y += pos.y;
_this6.z += pos.z;
ez.x *= length;
ez.y *= length;
ez.z *= length;
let _this7 = ez;
_this7.x += pos.x;
_this7.y += pos.y;
_this7.z += pos.z;
this.line(pos,ex,colorX);
this.line(pos,ey,colorY);
this.line(pos,ez,colorZ);
let _this8 = this.p;
if(pos != null) {
pos.zero();
if(_this8.sizeVec3 == _this8.stackVec3.length) {
let newArray = new Array(_this8.sizeVec3 << 1);
let _g = 0;
let _g1 = _this8.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this8.stackVec3[i];
_this8.stackVec3[i] = null;
}
_this8.stackVec3 = newArray;
}
_this8.stackVec3[_this8.sizeVec3++] = pos;
}
let _this9 = this.p;
if(rot != null) {
rot.e00 = 1;
rot.e01 = 0;
rot.e02 = 0;
rot.e10 = 0;
rot.e11 = 1;
rot.e12 = 0;
rot.e20 = 0;
rot.e21 = 0;
rot.e22 = 1;
if(_this9.sizeMat3 == _this9.stackMat3.length) {
let newArray = new Array(_this9.sizeMat3 << 1);
let _g = 0;
let _g1 = _this9.sizeMat3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this9.stackMat3[i];
_this9.stackMat3[i] = null;
}
_this9.stackMat3 = newArray;
}
_this9.stackMat3[_this9.sizeMat3++] = rot;
}
let _this10 = this.p;
if(ex != null) {
ex.zero();
if(_this10.sizeVec3 == _this10.stackVec3.length) {
let newArray = new Array(_this10.sizeVec3 << 1);
let _g = 0;
let _g1 = _this10.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this10.stackVec3[i];
_this10.stackVec3[i] = null;
}
_this10.stackVec3 = newArray;
}
_this10.stackVec3[_this10.sizeVec3++] = ex;
}
let _this11 = this.p;
if(ey != null) {
ey.zero();
if(_this11.sizeVec3 == _this11.stackVec3.length) {
let newArray = new Array(_this11.sizeVec3 << 1);
let _g = 0;
let _g1 = _this11.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this11.stackVec3[i];
_this11.stackVec3[i] = null;
}
_this11.stackVec3 = newArray;
}
_this11.stackVec3[_this11.sizeVec3++] = ey;
}
let _this12 = this.p;
if(ez != null) {
ez.zero();
if(_this12.sizeVec3 == _this12.stackVec3.length) {
let newArray = new Array(_this12.sizeVec3 << 1);
let _g = 0;
let _g1 = _this12.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this12.stackVec3[i];
_this12.stackVec3[i] = null;
}
_this12.stackVec3 = newArray;
}
_this12.stackVec3[_this12.sizeVec3++] = ez;
}
}
ellipse(center,ex,ey,radiusX,radiusY,color) {
this.arc(center,ex,ey,radiusX,radiusY,0,6.28318530717958,false,color);
}
arc(center,ex,ey,radiusX,radiusY,startAngle,endAngle,drawSector,color) {
let _this = this.p;
let _this1 = _this.sizeVec3 == 0 ? new oimo.common.Vec3() : _this.stackVec3[--_this.sizeVec3];
_this1.x = ex.x;
_this1.y = ex.y;
_this1.z = ex.z;
let _this2 = _this1;
_this2.x *= radiusX;
_this2.y *= radiusX;
_this2.z *= radiusX;
let _this3 = this.p;
let _this4 = _this3.sizeVec3 == 0 ? new oimo.common.Vec3() : _this3.stackVec3[--_this3.sizeVec3];
_this4.x = ey.x;
_this4.y = ey.y;
_this4.z = ey.z;
let _this5 = _this4;
_this5.x *= radiusY;
_this5.y *= radiusY;
_this5.z *= radiusY;
let angDiff = endAngle - startAngle;
if(angDiff < 0) {
angDiff = -angDiff;
}
let n = angDiff / 0.52359877559829837 + 0.5 | 0;
if(n == 0) {
n = 1;
}
let theta = startAngle;
let dt = (endAngle - startAngle) / n;
let _this6 = this.p;
let _this7 = _this6.sizeVec3 == 0 ? new oimo.common.Vec3() : _this6.stackVec3[--_this6.sizeVec3];
_this7.x = center.x;
_this7.y = center.y;
_this7.z = center.z;
let _this8 = _this7;
let s = Math.cos(startAngle);
_this8.x += _this2.x * s;
_this8.y += _this2.y * s;
_this8.z += _this2.z * s;
let s1 = Math.sin(startAngle);
_this8.x += _this5.x * s1;
_this8.y += _this5.y * s1;
_this8.z += _this5.z * s1;
let prevV = _this8;
if(drawSector) {
this.line(center,_this8,color);
}
let _g = 0;
let _g1 = n;
while(_g < _g1) {
++_g;
theta += dt;
let _this = this.p;
let _this1 = _this.sizeVec3 == 0 ? new oimo.common.Vec3() : _this.stackVec3[--_this.sizeVec3];
_this1.x = center.x;
_this1.y = center.y;
_this1.z = center.z;
let _this3 = _this1;
let s = Math.cos(theta);
_this3.x += _this2.x * s;
_this3.y += _this2.y * s;
_this3.z += _this2.z * s;
let s1 = Math.sin(theta);
_this3.x += _this5.x * s1;
_this3.y += _this5.y * s1;
_this3.z += _this5.z * s1;
this.line(prevV,_this3,color);
let _this4 = this.p;
if(prevV != null) {
prevV.zero();
if(_this4.sizeVec3 == _this4.stackVec3.length) {
let newArray = new Array(_this4.sizeVec3 << 1);
let _g = 0;
let _g1 = _this4.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this4.stackVec3[i];
_this4.stackVec3[i] = null;
}
_this4.stackVec3 = newArray;
}
_this4.stackVec3[_this4.sizeVec3++] = prevV;
}
prevV = _this3;
}
if(drawSector) {
this.line(center,prevV,color);
}
let _this9 = this.p;
if(prevV != null) {
prevV.zero();
if(_this9.sizeVec3 == _this9.stackVec3.length) {
let newArray = new Array(_this9.sizeVec3 << 1);
let _g = 0;
let _g1 = _this9.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this9.stackVec3[i];
_this9.stackVec3[i] = null;
}
_this9.stackVec3 = newArray;
}
_this9.stackVec3[_this9.sizeVec3++] = prevV;
}
let _this10 = this.p;
if(_this2 != null) {
_this2.zero();
if(_this10.sizeVec3 == _this10.stackVec3.length) {
let newArray = new Array(_this10.sizeVec3 << 1);
let _g = 0;
let _g1 = _this10.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this10.stackVec3[i];
_this10.stackVec3[i] = null;
}
_this10.stackVec3 = newArray;
}
_this10.stackVec3[_this10.sizeVec3++] = _this2;
}
let _this11 = this.p;
if(_this5 != null) {
_this5.zero();
if(_this11.sizeVec3 == _this11.stackVec3.length) {
let newArray = new Array(_this11.sizeVec3 << 1);
let _g = 0;
let _g1 = _this11.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this11.stackVec3[i];
_this11.stackVec3[i] = null;
}
_this11.stackVec3 = newArray;
}
_this11.stackVec3[_this11.sizeVec3++] = _this5;
}
}
cone(tf,radius,halfHeight,color) {
let _this = this.p;
let ex = _this.sizeVec3 == 0 ? new oimo.common.Vec3() : _this.stackVec3[--_this.sizeVec3];
let _this1 = this.p;
let ey = _this1.sizeVec3 == 0 ? new oimo.common.Vec3() : _this1.stackVec3[--_this1.sizeVec3];
let _this2 = this.p;
let ez = _this2.sizeVec3 == 0 ? new oimo.common.Vec3() : _this2.stackVec3[--_this2.sizeVec3];
let _this3 = this.p;
let o = _this3.sizeVec3 == 0 ? new oimo.common.Vec3() : _this3.stackVec3[--_this3.sizeVec3];
let _this4 = this.p;
let m = _this4.sizeMat3 == 0 ? new oimo.common.Mat3() : _this4.stackMat3[--_this4.sizeMat3];
let v = o;
v.x = tf._positionX;
v.y = tf._positionY;
v.z = tf._positionZ;
let m1 = m;
m1.e00 = tf._rotation00;
m1.e01 = tf._rotation01;
m1.e02 = tf._rotation02;
m1.e10 = tf._rotation10;
m1.e11 = tf._rotation11;
m1.e12 = tf._rotation12;
m1.e20 = tf._rotation20;
m1.e21 = tf._rotation21;
m1.e22 = tf._rotation22;
ex.init(m.e00,m.e10,m.e20);
ey.init(m.e01,m.e11,m.e21);
ez.init(m.e02,m.e12,m.e22);
let _this5 = this.p;
let _this6 = _this5.sizeVec3 == 0 ? new oimo.common.Vec3() : _this5.stackVec3[--_this5.sizeVec3];
_this6.x = o.x;
_this6.y = o.y;
_this6.z = o.z;
let _this7 = _this6;
_this7.x += ey.x * halfHeight;
_this7.y += ey.y * halfHeight;
_this7.z += ey.z * halfHeight;
let _this8 = this.p;
let _this9 = _this8.sizeVec3 == 0 ? new oimo.common.Vec3() : _this8.stackVec3[--_this8.sizeVec3];
_this9.x = o.x;
_this9.y = o.y;
_this9.z = o.z;
let _this10 = _this9;
let s = -halfHeight;
_this10.x += ey.x * s;
_this10.y += ey.y * s;
_this10.z += ey.z * s;
if(this.wireframe) {
let _this = this.p;
let _this1 = _this.sizeVec3 == 0 ? new oimo.common.Vec3() : _this.stackVec3[--_this.sizeVec3];
_this1.x = _this10.x;
_this1.y = _this10.y;
_this1.z = _this10.z;
let _this2 = _this1;
let s = -radius;
_this2.x += ex.x * s;
_this2.y += ex.y * s;
_this2.z += ex.z * s;
_this2.x += ez.x * 0;
_this2.y += ez.y * 0;
_this2.z += ez.z * 0;
let _this3 = this.p;
let _this4 = _this3.sizeVec3 == 0 ? new oimo.common.Vec3() : _this3.stackVec3[--_this3.sizeVec3];
_this4.x = _this10.x;
_this4.y = _this10.y;
_this4.z = _this10.z;
let _this5 = _this4;
_this5.x += ex.x * radius;
_this5.y += ex.y * radius;
_this5.z += ex.z * radius;
_this5.x += ez.x * 0;
_this5.y += ez.y * 0;
_this5.z += ez.z * 0;
let _this6 = this.p;
let _this8 = _this6.sizeVec3 == 0 ? new oimo.common.Vec3() : _this6.stackVec3[--_this6.sizeVec3];
_this8.x = _this10.x;
_this8.y = _this10.y;
_this8.z = _this10.z;
let _this9 = _this8;
_this9.x += ex.x * 0;
_this9.y += ex.y * 0;
_this9.z += ex.z * 0;
let s1 = -radius;
_this9.x += ez.x * s1;
_this9.y += ez.y * s1;
_this9.z += ez.z * s1;
let _this11 = this.p;
let _this12 = _this11.sizeVec3 == 0 ? new oimo.common.Vec3() : _this11.stackVec3[--_this11.sizeVec3];
_this12.x = _this10.x;
_this12.y = _this10.y;
_this12.z = _this10.z;
let _this13 = _this12;
_this13.x += ex.x * 0;
_this13.y += ex.y * 0;
_this13.z += ex.z * 0;
_this13.x += ez.x * radius;
_this13.y += ez.y * radius;
_this13.z += ez.z * radius;
this.ellipse(_this10,ex,ez,radius,radius,color);
this.line(_this7,_this2,color);
this.line(_this7,_this5,color);
this.line(_this7,_this9,color);
this.line(_this7,_this13,color);
let _this14 = this.p;
if(_this2 != null) {
_this2.zero();
if(_this14.sizeVec3 == _this14.stackVec3.length) {
let newArray = new Array(_this14.sizeVec3 << 1);
let _g = 0;
let _g1 = _this14.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this14.stackVec3[i];
_this14.stackVec3[i] = null;
}
_this14.stackVec3 = newArray;
}
_this14.stackVec3[_this14.sizeVec3++] = _this2;
}
let _this15 = this.p;
if(_this5 != null) {
_this5.zero();
if(_this15.sizeVec3 == _this15.stackVec3.length) {
let newArray = new Array(_this15.sizeVec3 << 1);
let _g = 0;
let _g1 = _this15.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this15.stackVec3[i];
_this15.stackVec3[i] = null;
}
_this15.stackVec3 = newArray;
}
_this15.stackVec3[_this15.sizeVec3++] = _this5;
}
let _this16 = this.p;
if(_this9 != null) {
_this9.zero();
if(_this16.sizeVec3 == _this16.stackVec3.length) {
let newArray = new Array(_this16.sizeVec3 << 1);
let _g = 0;
let _g1 = _this16.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this16.stackVec3[i];
_this16.stackVec3[i] = null;
}
_this16.stackVec3 = newArray;
}
_this16.stackVec3[_this16.sizeVec3++] = _this9;
}
let _this17 = this.p;
if(_this13 != null) {
_this13.zero();
if(_this17.sizeVec3 == _this17.stackVec3.length) {
let newArray = new Array(_this17.sizeVec3 << 1);
let _g = 0;
let _g1 = _this17.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this17.stackVec3[i];
_this17.stackVec3[i] = null;
}
_this17.stackVec3 = newArray;
}
_this17.stackVec3[_this17.sizeVec3++] = _this13;
}
} else {
let invDenom = 1 / Math.sqrt(radius * radius + 4 * halfHeight * halfHeight);
let cos = 2 * halfHeight * invDenom;
let sin = radius * invDenom;
let _g = 0;
while(_g < 8) {
let i = _g++;
let _this = this.tmpCircleNorms[i];
let v = this.circleCoords[i];
_this.x = v.x;
_this.y = v.y;
_this.z = v.z;
_this.x *= cos;
_this.y *= cos;
_this.z *= cos;
_this.y += sin;
let _this1 = this.tmpCircleNorms[i];
let y = _this1.x * m.e10 + _this1.y * m.e11 + _this1.z * m.e12;
let z = _this1.x * m.e20 + _this1.y * m.e21 + _this1.z * m.e22;
_this1.x = _this1.x * m.e00 + _this1.y * m.e01 + _this1.z * m.e02;
_this1.y = y;
_this1.z = z;
let _this2 = this.tmpCircleVerts1[i];
let v1 = this.circleCoordsShift[i];
_this2.x = v1.x;
_this2.y = v1.y;
_this2.z = v1.z;
_this2.x *= cos;
_this2.y *= cos;
_this2.z *= cos;
_this2.y += sin;
let _this3 = this.tmpCircleVerts1[i];
let y1 = _this3.x * m.e10 + _this3.y * m.e11 + _this3.z * m.e12;
let z1 = _this3.x * m.e20 + _this3.y * m.e21 + _this3.z * m.e22;
_this3.x = _this3.x * m.e00 + _this3.y * m.e01 + _this3.z * m.e02;
_this3.y = y1;
_this3.z = z1;
let _this4 = this.tmpCircleVerts2[i];
let v2 = this.circleCoords[i];
_this4.x = v2.x;
_this4.y = v2.y;
_this4.z = v2.z;
let y2 = _this4.x * m.e10 + _this4.y * m.e11 + _this4.z * m.e12;
let z2 = _this4.x * m.e20 + _this4.y * m.e21 + _this4.z * m.e22;
_this4.x = _this4.x * m.e00 + _this4.y * m.e01 + _this4.z * m.e02;
_this4.y = y2;
_this4.z = z2;
_this4.x *= radius;
_this4.y *= radius;
_this4.z *= radius;
_this4.x += o.x;
_this4.y += o.y;
_this4.z += o.z;
let _this5 = this.tmpCircleVerts2[i];
let s = -halfHeight;
_this5.x += ey.x * s;
_this5.y += ey.y * s;
_this5.z += ey.z * s;
}
let _g1 = 0;
while(_g1 < 8) {
let i = _g1++;
let v2 = this.tmpCircleVerts2[i];
let v3 = this.tmpCircleVerts2[(i + 1) % 8];
let n1 = this.tmpCircleVerts1[i];
this.triangle(_this7,v2,v3,n1,this.tmpCircleNorms[i],this.tmpCircleNorms[(i + 1) % 8],color);
v2 = this.tmpCircleVerts2[(i + 1) % 8];
v3 = this.tmpCircleVerts2[i];
let _this = this.p;
let _this1 = _this.sizeVec3 == 0 ? new oimo.common.Vec3() : _this.stackVec3[--_this.sizeVec3];
_this1.x = ey.x;
_this1.y = ey.y;
_this1.z = ey.z;
let _this2 = _this1;
_this2.x = -_this2.x;
_this2.y = -_this2.y;
_this2.z = -_this2.z;
this.triangle(_this10,v2,v3,_this2,_this2,_this2,color);
let _this3 = this.p;
if(_this2 != null) {
_this2.zero();
if(_this3.sizeVec3 == _this3.stackVec3.length) {
let newArray = new Array(_this3.sizeVec3 << 1);
let _g = 0;
let _g1 = _this3.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this3.stackVec3[i];
_this3.stackVec3[i] = null;
}
_this3.stackVec3 = newArray;
}
_this3.stackVec3[_this3.sizeVec3++] = _this2;
}
}
}
let _this11 = this.p;
if(_this7 != null) {
_this7.zero();
if(_this11.sizeVec3 == _this11.stackVec3.length) {
let newArray = new Array(_this11.sizeVec3 << 1);
let _g = 0;
let _g1 = _this11.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this11.stackVec3[i];
_this11.stackVec3[i] = null;
}
_this11.stackVec3 = newArray;
}
_this11.stackVec3[_this11.sizeVec3++] = _this7;
}
let _this12 = this.p;
if(_this10 != null) {
_this10.zero();
if(_this12.sizeVec3 == _this12.stackVec3.length) {
let newArray = new Array(_this12.sizeVec3 << 1);
let _g = 0;
let _g1 = _this12.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this12.stackVec3[i];
_this12.stackVec3[i] = null;
}
_this12.stackVec3 = newArray;
}
_this12.stackVec3[_this12.sizeVec3++] = _this10;
}
let _this13 = this.p;
if(o != null) {
o.zero();
if(_this13.sizeVec3 == _this13.stackVec3.length) {
let newArray = new Array(_this13.sizeVec3 << 1);
let _g = 0;
let _g1 = _this13.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this13.stackVec3[i];
_this13.stackVec3[i] = null;
}
_this13.stackVec3 = newArray;
}
_this13.stackVec3[_this13.sizeVec3++] = o;
}
let _this14 = this.p;
if(m != null) {
m.e00 = 1;
m.e01 = 0;
m.e02 = 0;
m.e10 = 0;
m.e11 = 1;
m.e12 = 0;
m.e20 = 0;
m.e21 = 0;
m.e22 = 1;
if(_this14.sizeMat3 == _this14.stackMat3.length) {
let newArray = new Array(_this14.sizeMat3 << 1);
let _g = 0;
let _g1 = _this14.sizeMat3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this14.stackMat3[i];
_this14.stackMat3[i] = null;
}
_this14.stackMat3 = newArray;
}
_this14.stackMat3[_this14.sizeMat3++] = m;
}
let _this15 = this.p;
if(ex != null) {
ex.zero();
if(_this15.sizeVec3 == _this15.stackVec3.length) {
let newArray = new Array(_this15.sizeVec3 << 1);
let _g = 0;
let _g1 = _this15.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this15.stackVec3[i];
_this15.stackVec3[i] = null;
}
_this15.stackVec3 = newArray;
}
_this15.stackVec3[_this15.sizeVec3++] = ex;
}
let _this16 = this.p;
if(ey != null) {
ey.zero();
if(_this16.sizeVec3 == _this16.stackVec3.length) {
let newArray = new Array(_this16.sizeVec3 << 1);
let _g = 0;
let _g1 = _this16.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this16.stackVec3[i];
_this16.stackVec3[i] = null;
}
_this16.stackVec3 = newArray;
}
_this16.stackVec3[_this16.sizeVec3++] = ey;
}
let _this17 = this.p;
if(ez != null) {
ez.zero();
if(_this17.sizeVec3 == _this17.stackVec3.length) {
let newArray = new Array(_this17.sizeVec3 << 1);
let _g = 0;
let _g1 = _this17.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this17.stackVec3[i];
_this17.stackVec3[i] = null;
}
_this17.stackVec3 = newArray;
}
_this17.stackVec3[_this17.sizeVec3++] = ez;
}
}
cylinder(tf,radius,halfHeight,color) {
let _this = this.p;
let ex = _this.sizeVec3 == 0 ? new oimo.common.Vec3() : _this.stackVec3[--_this.sizeVec3];
let _this1 = this.p;
let ey = _this1.sizeVec3 == 0 ? new oimo.common.Vec3() : _this1.stackVec3[--_this1.sizeVec3];
let _this2 = this.p;
let ez = _this2.sizeVec3 == 0 ? new oimo.common.Vec3() : _this2.stackVec3[--_this2.sizeVec3];
let _this3 = this.p;
let o = _this3.sizeVec3 == 0 ? new oimo.common.Vec3() : _this3.stackVec3[--_this3.sizeVec3];
let _this4 = this.p;
let m = _this4.sizeMat3 == 0 ? new oimo.common.Mat3() : _this4.stackMat3[--_this4.sizeMat3];
let v = o;
v.x = tf._positionX;
v.y = tf._positionY;
v.z = tf._positionZ;
let m1 = m;
m1.e00 = tf._rotation00;
m1.e01 = tf._rotation01;
m1.e02 = tf._rotation02;
m1.e10 = tf._rotation10;
m1.e11 = tf._rotation11;
m1.e12 = tf._rotation12;
m1.e20 = tf._rotation20;
m1.e21 = tf._rotation21;
m1.e22 = tf._rotation22;
ex.init(m.e00,m.e10,m.e20);
ey.init(m.e01,m.e11,m.e21);
ez.init(m.e02,m.e12,m.e22);
let _this5 = this.p;
let _this6 = _this5.sizeVec3 == 0 ? new oimo.common.Vec3() : _this5.stackVec3[--_this5.sizeVec3];
_this6.x = o.x;
_this6.y = o.y;
_this6.z = o.z;
let _this7 = _this6;
_this7.x += ey.x * halfHeight;
_this7.y += ey.y * halfHeight;
_this7.z += ey.z * halfHeight;
let _this8 = this.p;
let _this9 = _this8.sizeVec3 == 0 ? new oimo.common.Vec3() : _this8.stackVec3[--_this8.sizeVec3];
_this9.x = o.x;
_this9.y = o.y;
_this9.z = o.z;
let _this10 = _this9;
let s = -halfHeight;
_this10.x += ey.x * s;
_this10.y += ey.y * s;
_this10.z += ey.z * s;
if(this.wireframe) {
let _this = this.p;
let _this1 = _this.sizeVec3 == 0 ? new oimo.common.Vec3() : _this.stackVec3[--_this.sizeVec3];
_this1.x = _this7.x;
_this1.y = _this7.y;
_this1.z = _this7.z;
let _this2 = _this1;
let s = -radius;
_this2.x += ex.x * s;
_this2.y += ex.y * s;
_this2.z += ex.z * s;
_this2.x += ez.x * 0;
_this2.y += ez.y * 0;
_this2.z += ez.z * 0;
let _this3 = this.p;
let _this4 = _this3.sizeVec3 == 0 ? new oimo.common.Vec3() : _this3.stackVec3[--_this3.sizeVec3];
_this4.x = _this7.x;
_this4.y = _this7.y;
_this4.z = _this7.z;
let _this5 = _this4;
_this5.x += ex.x * radius;
_this5.y += ex.y * radius;
_this5.z += ex.z * radius;
_this5.x += ez.x * 0;
_this5.y += ez.y * 0;
_this5.z += ez.z * 0;
let _this6 = this.p;
let _this8 = _this6.sizeVec3 == 0 ? new oimo.common.Vec3() : _this6.stackVec3[--_this6.sizeVec3];
_this8.x = _this7.x;
_this8.y = _this7.y;
_this8.z = _this7.z;
let _this9 = _this8;
_this9.x += ex.x * 0;
_this9.y += ex.y * 0;
_this9.z += ex.z * 0;
let s1 = -radius;
_this9.x += ez.x * s1;
_this9.y += ez.y * s1;
_this9.z += ez.z * s1;
let _this11 = this.p;
let _this12 = _this11.sizeVec3 == 0 ? new oimo.common.Vec3() : _this11.stackVec3[--_this11.sizeVec3];
_this12.x = _this7.x;
_this12.y = _this7.y;
_this12.z = _this7.z;
let _this13 = _this12;
_this13.x += ex.x * 0;
_this13.y += ex.y * 0;
_this13.z += ex.z * 0;
_this13.x += ez.x * radius;
_this13.y += ez.y * radius;
_this13.z += ez.z * radius;
let _this14 = this.p;
let _this15 = _this14.sizeVec3 == 0 ? new oimo.common.Vec3() : _this14.stackVec3[--_this14.sizeVec3];
_this15.x = _this10.x;
_this15.y = _this10.y;
_this15.z = _this10.z;
let _this16 = _this15;
let s2 = -radius;
_this16.x += ex.x * s2;
_this16.y += ex.y * s2;
_this16.z += ex.z * s2;
_this16.x += ez.x * 0;
_this16.y += ez.y * 0;
_this16.z += ez.z * 0;
let _this17 = this.p;
let _this18 = _this17.sizeVec3 == 0 ? new oimo.common.Vec3() : _this17.stackVec3[--_this17.sizeVec3];
_this18.x = _this10.x;
_this18.y = _this10.y;
_this18.z = _this10.z;
let _this19 = _this18;
_this19.x += ex.x * radius;
_this19.y += ex.y * radius;
_this19.z += ex.z * radius;
_this19.x += ez.x * 0;
_this19.y += ez.y * 0;
_this19.z += ez.z * 0;
let _this20 = this.p;
let _this21 = _this20.sizeVec3 == 0 ? new oimo.common.Vec3() : _this20.stackVec3[--_this20.sizeVec3];
_this21.x = _this10.x;
_this21.y = _this10.y;
_this21.z = _this10.z;
let _this22 = _this21;
_this22.x += ex.x * 0;
_this22.y += ex.y * 0;
_this22.z += ex.z * 0;
let s3 = -radius;
_this22.x += ez.x * s3;
_this22.y += ez.y * s3;
_this22.z += ez.z * s3;
let _this23 = this.p;
let _this24 = _this23.sizeVec3 == 0 ? new oimo.common.Vec3() : _this23.stackVec3[--_this23.sizeVec3];
_this24.x = _this10.x;
_this24.y = _this10.y;
_this24.z = _this10.z;
let _this25 = _this24;
_this25.x += ex.x * 0;
_this25.y += ex.y * 0;
_this25.z += ex.z * 0;
_this25.x += ez.x * radius;
_this25.y += ez.y * radius;
_this25.z += ez.z * radius;
this.ellipse(_this7,ex,ez,radius,radius,color);
this.ellipse(_this10,ex,ez,radius,radius,color);
this.line(_this2,_this16,color);
this.line(_this5,_this19,color);
this.line(_this9,_this22,color);
this.line(_this13,_this25,color);
let _this26 = this.p;
if(_this2 != null) {
_this2.zero();
if(_this26.sizeVec3 == _this26.stackVec3.length) {
let newArray = new Array(_this26.sizeVec3 << 1);
let _g = 0;
let _g1 = _this26.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this26.stackVec3[i];
_this26.stackVec3[i] = null;
}
_this26.stackVec3 = newArray;
}
_this26.stackVec3[_this26.sizeVec3++] = _this2;
}
let _this27 = this.p;
if(_this5 != null) {
_this5.zero();
if(_this27.sizeVec3 == _this27.stackVec3.length) {
let newArray = new Array(_this27.sizeVec3 << 1);
let _g = 0;
let _g1 = _this27.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this27.stackVec3[i];
_this27.stackVec3[i] = null;
}
_this27.stackVec3 = newArray;
}
_this27.stackVec3[_this27.sizeVec3++] = _this5;
}
let _this28 = this.p;
if(_this9 != null) {
_this9.zero();
if(_this28.sizeVec3 == _this28.stackVec3.length) {
let newArray = new Array(_this28.sizeVec3 << 1);
let _g = 0;
let _g1 = _this28.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this28.stackVec3[i];
_this28.stackVec3[i] = null;
}
_this28.stackVec3 = newArray;
}
_this28.stackVec3[_this28.sizeVec3++] = _this9;
}
let _this29 = this.p;
if(_this13 != null) {
_this13.zero();
if(_this29.sizeVec3 == _this29.stackVec3.length) {
let newArray = new Array(_this29.sizeVec3 << 1);
let _g = 0;
let _g1 = _this29.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this29.stackVec3[i];
_this29.stackVec3[i] = null;
}
_this29.stackVec3 = newArray;
}
_this29.stackVec3[_this29.sizeVec3++] = _this13;
}
let _this30 = this.p;
if(_this16 != null) {
_this16.zero();
if(_this30.sizeVec3 == _this30.stackVec3.length) {
let newArray = new Array(_this30.sizeVec3 << 1);
let _g = 0;
let _g1 = _this30.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this30.stackVec3[i];
_this30.stackVec3[i] = null;
}
_this30.stackVec3 = newArray;
}
_this30.stackVec3[_this30.sizeVec3++] = _this16;
}
let _this31 = this.p;
if(_this19 != null) {
_this19.zero();
if(_this31.sizeVec3 == _this31.stackVec3.length) {
let newArray = new Array(_this31.sizeVec3 << 1);
let _g = 0;
let _g1 = _this31.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this31.stackVec3[i];
_this31.stackVec3[i] = null;
}
_this31.stackVec3 = newArray;
}
_this31.stackVec3[_this31.sizeVec3++] = _this19;
}
let _this32 = this.p;
if(_this22 != null) {
_this22.zero();
if(_this32.sizeVec3 == _this32.stackVec3.length) {
let newArray = new Array(_this32.sizeVec3 << 1);
let _g = 0;
let _g1 = _this32.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this32.stackVec3[i];
_this32.stackVec3[i] = null;
}
_this32.stackVec3 = newArray;
}
_this32.stackVec3[_this32.sizeVec3++] = _this22;
}
let _this33 = this.p;
if(_this25 != null) {
_this25.zero();
if(_this33.sizeVec3 == _this33.stackVec3.length) {
let newArray = new Array(_this33.sizeVec3 << 1);
let _g = 0;
let _g1 = _this33.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this33.stackVec3[i];
_this33.stackVec3[i] = null;
}
_this33.stackVec3 = newArray;
}
_this33.stackVec3[_this33.sizeVec3++] = _this25;
}
} else {
let _g = 0;
while(_g < 8) {
let i = _g++;
let _this = this.tmpCircleNorms[i];
let v = this.circleCoords[i];
_this.x = v.x;
_this.y = v.y;
_this.z = v.z;
let y = _this.x * m.e10 + _this.y * m.e11 + _this.z * m.e12;
let z = _this.x * m.e20 + _this.y * m.e21 + _this.z * m.e22;
_this.x = _this.x * m.e00 + _this.y * m.e01 + _this.z * m.e02;
_this.y = y;
_this.z = z;
let _this1 = this.tmpCircleVerts1[i];
let v1 = this.tmpCircleNorms[i];
_this1.x = v1.x;
_this1.y = v1.y;
_this1.z = v1.z;
_this1.x *= radius;
_this1.y *= radius;
_this1.z *= radius;
_this1.x += o.x;
_this1.y += o.y;
_this1.z += o.z;
let _this2 = this.tmpCircleVerts2[i];
let v2 = this.tmpCircleVerts1[i];
_this2.x = v2.x;
_this2.y = v2.y;
_this2.z = v2.z;
let _this3 = this.tmpCircleVerts1[i];
_this3.x += ey.x * halfHeight;
_this3.y += ey.y * halfHeight;
_this3.z += ey.z * halfHeight;
let _this4 = this.tmpCircleVerts2[i];
let s = -halfHeight;
_this4.x += ey.x * s;
_this4.y += ey.y * s;
_this4.z += ey.z * s;
}
let _g1 = 0;
while(_g1 < 8) {
let i = _g1++;
let v1;
let v2 = this.tmpCircleVerts1[i];
let v3 = this.tmpCircleVerts1[(i + 1) % 8];
let n1 = ey;
this.triangle(_this7,v2,v3,n1,n1,n1,color);
v2 = this.tmpCircleVerts2[(i + 1) % 8];
v3 = this.tmpCircleVerts2[i];
let _this = this.p;
let _this1 = _this.sizeVec3 == 0 ? new oimo.common.Vec3() : _this.stackVec3[--_this.sizeVec3];
_this1.x = ey.x;
_this1.y = ey.y;
_this1.z = ey.z;
let _this2 = _this1;
_this2.x = -_this2.x;
_this2.y = -_this2.y;
_this2.z = -_this2.z;
this.triangle(_this10,v2,v3,_this2,_this2,_this2,color);
let _this3 = this.p;
if(_this2 != null) {
_this2.zero();
if(_this3.sizeVec3 == _this3.stackVec3.length) {
let newArray = new Array(_this3.sizeVec3 << 1);
let _g = 0;
let _g1 = _this3.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this3.stackVec3[i];
_this3.stackVec3[i] = null;
}
_this3.stackVec3 = newArray;
}
_this3.stackVec3[_this3.sizeVec3++] = _this2;
}
v1 = this.tmpCircleVerts1[i];
v2 = this.tmpCircleVerts2[i];
v3 = this.tmpCircleVerts2[(i + 1) % 8];
n1 = this.tmpCircleNorms[i];
let n2 = this.tmpCircleNorms[(i + 1) % 8];
this.rect(v1,v2,v3,this.tmpCircleVerts1[(i + 1) % 8],n1,n1,n2,n2,color);
}
}
let _this11 = this.p;
if(_this7 != null) {
_this7.zero();
if(_this11.sizeVec3 == _this11.stackVec3.length) {
let newArray = new Array(_this11.sizeVec3 << 1);
let _g = 0;
let _g1 = _this11.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this11.stackVec3[i];
_this11.stackVec3[i] = null;
}
_this11.stackVec3 = newArray;
}
_this11.stackVec3[_this11.sizeVec3++] = _this7;
}
let _this12 = this.p;
if(_this10 != null) {
_this10.zero();
if(_this12.sizeVec3 == _this12.stackVec3.length) {
let newArray = new Array(_this12.sizeVec3 << 1);
let _g = 0;
let _g1 = _this12.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this12.stackVec3[i];
_this12.stackVec3[i] = null;
}
_this12.stackVec3 = newArray;
}
_this12.stackVec3[_this12.sizeVec3++] = _this10;
}
let _this13 = this.p;
if(o != null) {
o.zero();
if(_this13.sizeVec3 == _this13.stackVec3.length) {
let newArray = new Array(_this13.sizeVec3 << 1);
let _g = 0;
let _g1 = _this13.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this13.stackVec3[i];
_this13.stackVec3[i] = null;
}
_this13.stackVec3 = newArray;
}
_this13.stackVec3[_this13.sizeVec3++] = o;
}
let _this14 = this.p;
if(m != null) {
m.e00 = 1;
m.e01 = 0;
m.e02 = 0;
m.e10 = 0;
m.e11 = 1;
m.e12 = 0;
m.e20 = 0;
m.e21 = 0;
m.e22 = 1;
if(_this14.sizeMat3 == _this14.stackMat3.length) {
let newArray = new Array(_this14.sizeMat3 << 1);
let _g = 0;
let _g1 = _this14.sizeMat3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this14.stackMat3[i];
_this14.stackMat3[i] = null;
}
_this14.stackMat3 = newArray;
}
_this14.stackMat3[_this14.sizeMat3++] = m;
}
let _this15 = this.p;
if(ex != null) {
ex.zero();
if(_this15.sizeVec3 == _this15.stackVec3.length) {
let newArray = new Array(_this15.sizeVec3 << 1);
let _g = 0;
let _g1 = _this15.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this15.stackVec3[i];
_this15.stackVec3[i] = null;
}
_this15.stackVec3 = newArray;
}
_this15.stackVec3[_this15.sizeVec3++] = ex;
}
let _this16 = this.p;
if(ey != null) {
ey.zero();
if(_this16.sizeVec3 == _this16.stackVec3.length) {
let newArray = new Array(_this16.sizeVec3 << 1);
let _g = 0;
let _g1 = _this16.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this16.stackVec3[i];
_this16.stackVec3[i] = null;
}
_this16.stackVec3 = newArray;
}
_this16.stackVec3[_this16.sizeVec3++] = ey;
}
let _this17 = this.p;
if(ez != null) {
ez.zero();
if(_this17.sizeVec3 == _this17.stackVec3.length) {
let newArray = new Array(_this17.sizeVec3 << 1);
let _g = 0;
let _g1 = _this17.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this17.stackVec3[i];
_this17.stackVec3[i] = null;
}
_this17.stackVec3 = newArray;
}
_this17.stackVec3[_this17.sizeVec3++] = ez;
}
}
capsule(tf,radius,halfHeight,color) {
let _this = this.p;
let ex = _this.sizeVec3 == 0 ? new oimo.common.Vec3() : _this.stackVec3[--_this.sizeVec3];
let _this1 = this.p;
let ey = _this1.sizeVec3 == 0 ? new oimo.common.Vec3() : _this1.stackVec3[--_this1.sizeVec3];
let _this2 = this.p;
let ez = _this2.sizeVec3 == 0 ? new oimo.common.Vec3() : _this2.stackVec3[--_this2.sizeVec3];
let _this3 = this.p;
let o = _this3.sizeVec3 == 0 ? new oimo.common.Vec3() : _this3.stackVec3[--_this3.sizeVec3];
let _this4 = this.p;
let m = _this4.sizeMat3 == 0 ? new oimo.common.Mat3() : _this4.stackMat3[--_this4.sizeMat3];
let v = o;
v.x = tf._positionX;
v.y = tf._positionY;
v.z = tf._positionZ;
let m1 = m;
m1.e00 = tf._rotation00;
m1.e01 = tf._rotation01;
m1.e02 = tf._rotation02;
m1.e10 = tf._rotation10;
m1.e11 = tf._rotation11;
m1.e12 = tf._rotation12;
m1.e20 = tf._rotation20;
m1.e21 = tf._rotation21;
m1.e22 = tf._rotation22;
ex.init(m.e00,m.e10,m.e20);
ey.init(m.e01,m.e11,m.e21);
ez.init(m.e02,m.e12,m.e22);
let vs = this.tmpSphereVerts;
let ns = this.tmpSphereNorms;
let _g = 0;
while(_g < 5) {
let i2 = _g++;
let n = this.tmpSphereVerts[i2].length;
let _g1 = 0;
while(_g1 < n) {
let j2 = _g1++;
let _this = ns[i2][j2];
let v = this.sphereCoords[i2][j2];
_this.x = v.x;
_this.y = v.y;
_this.z = v.z;
let y = _this.x * m.e10 + _this.y * m.e11 + _this.z * m.e12;
let z = _this.x * m.e20 + _this.y * m.e21 + _this.z * m.e22;
_this.x = _this.x * m.e00 + _this.y * m.e01 + _this.z * m.e02;
_this.y = y;
_this.z = z;
}
}
let _g1 = 0;
while(_g1 < 4) {
let i = _g1++;
if(i == 0) {
let _g = 0;
while(_g < 3) {
let i2 = _g++;
let n = this.tmpSphereVerts[i2].length;
let _g1 = 0;
while(_g1 < n) {
let j2 = _g1++;
let _this = vs[i2][j2];
let v = ns[i2][j2];
_this.x = v.x;
_this.y = v.y;
_this.z = v.z;
_this.x *= radius;
_this.y *= radius;
_this.z *= radius;
_this.x += o.x;
_this.y += o.y;
_this.z += o.z;
_this.x += ey.x * halfHeight;
_this.y += ey.y * halfHeight;
_this.z += ey.z * halfHeight;
}
}
}
if(i == 2) {
let _g = 2;
while(_g < 5) {
let i2 = _g++;
let n = this.tmpSphereVerts[i2].length;
let _g1 = 0;
while(_g1 < n) {
let j2 = _g1++;
let _this = vs[i2][j2];
let v = ns[i2][j2];
_this.x = v.x;
_this.y = v.y;
_this.z = v.z;
_this.x *= radius;
_this.y *= radius;
_this.z *= radius;
_this.x += o.x;
_this.y += o.y;
_this.z += o.z;
let s = -halfHeight;
_this.x += ey.x * s;
_this.y += ey.y * s;
_this.z += ey.z * s;
}
}
}
let _g = 0;
while(_g < 8) {
let j = _g++;
let v1;
let v2;
let v3;
let v4;
let n1;
let n2;
let n3;
let n4;
if(i == 0) {
if(this.wireframe) {
v1 = vs[0][0];
v2 = vs[1][j];
this.line(v1,v2,color);
} else {
v1 = vs[0][0];
v2 = vs[1][j];
v3 = vs[1][(j + 1) % 8];
n1 = ns[0][0];
n2 = ns[1][j];
n3 = ns[1][(j + 1) % 8];
this.triangle(v1,v2,v3,n1,n2,n3,color);
}
} else if(i == 3) {
if(this.wireframe) {
v1 = vs[4][0];
v2 = vs[i][(j + 1) % 8];
v3 = vs[i][j];
this.line(v1,v2,color);
this.line(v2,v3,color);
} else {
v1 = vs[4][0];
v2 = vs[i][(j + 1) % 8];
v3 = vs[i][j];
n1 = ns[4][0];
n2 = ns[i][(j + 1) % 8];
n3 = ns[i][j];
this.triangle(v1,v2,v3,n1,n2,n3,color);
}
} else if(this.wireframe) {
v1 = vs[i][j];
v2 = vs[i][(j + 1) % 8];
v3 = vs[i + 1][j];
this.line(v1,v2,color);
this.line(v1,v3,color);
} else {
v1 = vs[i][j];
v2 = vs[i][(j + 1) % 8];
v3 = vs[i + 1][j];
v4 = vs[i + 1][(j + 1) % 8];
n1 = ns[i][j];
n2 = ns[i][(j + 1) % 8];
n3 = ns[i + 1][j];
n4 = ns[i + 1][(j + 1) % 8];
this.rect(v1,v3,v4,v2,n1,n3,n4,n2,color);
}
}
}
let _this5 = this.p;
let _this6 = _this5.sizeVec3 == 0 ? new oimo.common.Vec3() : _this5.stackVec3[--_this5.sizeVec3];
_this6.x = o.x;
_this6.y = o.y;
_this6.z = o.z;
let _this7 = _this6;
_this7.x += ey.x * halfHeight;
_this7.y += ey.y * halfHeight;
_this7.z += ey.z * halfHeight;
let _this8 = this.p;
let _this9 = _this8.sizeVec3 == 0 ? new oimo.common.Vec3() : _this8.stackVec3[--_this8.sizeVec3];
_this9.x = o.x;
_this9.y = o.y;
_this9.z = o.z;
let _this10 = _this9;
let s = -halfHeight;
_this10.x += ey.x * s;
_this10.y += ey.y * s;
_this10.z += ey.z * s;
if(this.wireframe) {
let _this = this.p;
let _this1 = _this.sizeVec3 == 0 ? new oimo.common.Vec3() : _this.stackVec3[--_this.sizeVec3];
_this1.x = _this7.x;
_this1.y = _this7.y;
_this1.z = _this7.z;
let _this2 = _this1;
let s = -radius;
_this2.x += ex.x * s;
_this2.y += ex.y * s;
_this2.z += ex.z * s;
_this2.x += ez.x * 0;
_this2.y += ez.y * 0;
_this2.z += ez.z * 0;
let _this3 = this.p;
let _this4 = _this3.sizeVec3 == 0 ? new oimo.common.Vec3() : _this3.stackVec3[--_this3.sizeVec3];
_this4.x = _this7.x;
_this4.y = _this7.y;
_this4.z = _this7.z;
let _this5 = _this4;
_this5.x += ex.x * radius;
_this5.y += ex.y * radius;
_this5.z += ex.z * radius;
_this5.x += ez.x * 0;
_this5.y += ez.y * 0;
_this5.z += ez.z * 0;
let _this6 = this.p;
let _this8 = _this6.sizeVec3 == 0 ? new oimo.common.Vec3() : _this6.stackVec3[--_this6.sizeVec3];
_this8.x = _this7.x;
_this8.y = _this7.y;
_this8.z = _this7.z;
let _this9 = _this8;
_this9.x += ex.x * 0;
_this9.y += ex.y * 0;
_this9.z += ex.z * 0;
let s1 = -radius;
_this9.x += ez.x * s1;
_this9.y += ez.y * s1;
_this9.z += ez.z * s1;
let _this11 = this.p;
let _this12 = _this11.sizeVec3 == 0 ? new oimo.common.Vec3() : _this11.stackVec3[--_this11.sizeVec3];
_this12.x = _this7.x;
_this12.y = _this7.y;
_this12.z = _this7.z;
let _this13 = _this12;
_this13.x += ex.x * 0;
_this13.y += ex.y * 0;
_this13.z += ex.z * 0;
_this13.x += ez.x * radius;
_this13.y += ez.y * radius;
_this13.z += ez.z * radius;
let _this14 = this.p;
let _this15 = _this14.sizeVec3 == 0 ? new oimo.common.Vec3() : _this14.stackVec3[--_this14.sizeVec3];
_this15.x = _this10.x;
_this15.y = _this10.y;
_this15.z = _this10.z;
let _this16 = _this15;
let s2 = -radius;
_this16.x += ex.x * s2;
_this16.y += ex.y * s2;
_this16.z += ex.z * s2;
_this16.x += ez.x * 0;
_this16.y += ez.y * 0;
_this16.z += ez.z * 0;
let _this17 = this.p;
let _this18 = _this17.sizeVec3 == 0 ? new oimo.common.Vec3() : _this17.stackVec3[--_this17.sizeVec3];
_this18.x = _this10.x;
_this18.y = _this10.y;
_this18.z = _this10.z;
let _this19 = _this18;
_this19.x += ex.x * radius;
_this19.y += ex.y * radius;
_this19.z += ex.z * radius;
_this19.x += ez.x * 0;
_this19.y += ez.y * 0;
_this19.z += ez.z * 0;
let _this20 = this.p;
let _this21 = _this20.sizeVec3 == 0 ? new oimo.common.Vec3() : _this20.stackVec3[--_this20.sizeVec3];
_this21.x = _this10.x;
_this21.y = _this10.y;
_this21.z = _this10.z;
let _this22 = _this21;
_this22.x += ex.x * 0;
_this22.y += ex.y * 0;
_this22.z += ex.z * 0;
let s3 = -radius;
_this22.x += ez.x * s3;
_this22.y += ez.y * s3;
_this22.z += ez.z * s3;
let _this23 = this.p;
let _this24 = _this23.sizeVec3 == 0 ? new oimo.common.Vec3() : _this23.stackVec3[--_this23.sizeVec3];
_this24.x = _this10.x;
_this24.y = _this10.y;
_this24.z = _this10.z;
let _this25 = _this24;
_this25.x += ex.x * 0;
_this25.y += ex.y * 0;
_this25.z += ex.z * 0;
_this25.x += ez.x * radius;
_this25.y += ez.y * radius;
_this25.z += ez.z * radius;
this.ellipse(_this7,ex,ez,radius,radius,color);
this.ellipse(_this10,ex,ez,radius,radius,color);
this.line(_this2,_this16,color);
this.line(_this5,_this19,color);
this.line(_this9,_this22,color);
this.line(_this13,_this25,color);
let _this26 = this.p;
if(_this2 != null) {
_this2.zero();
if(_this26.sizeVec3 == _this26.stackVec3.length) {
let newArray = new Array(_this26.sizeVec3 << 1);
let _g = 0;
let _g1 = _this26.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this26.stackVec3[i];
_this26.stackVec3[i] = null;
}
_this26.stackVec3 = newArray;
}
_this26.stackVec3[_this26.sizeVec3++] = _this2;
}
let _this27 = this.p;
if(_this5 != null) {
_this5.zero();
if(_this27.sizeVec3 == _this27.stackVec3.length) {
let newArray = new Array(_this27.sizeVec3 << 1);
let _g = 0;
let _g1 = _this27.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this27.stackVec3[i];
_this27.stackVec3[i] = null;
}
_this27.stackVec3 = newArray;
}
_this27.stackVec3[_this27.sizeVec3++] = _this5;
}
let _this28 = this.p;
if(_this9 != null) {
_this9.zero();
if(_this28.sizeVec3 == _this28.stackVec3.length) {
let newArray = new Array(_this28.sizeVec3 << 1);
let _g = 0;
let _g1 = _this28.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this28.stackVec3[i];
_this28.stackVec3[i] = null;
}
_this28.stackVec3 = newArray;
}
_this28.stackVec3[_this28.sizeVec3++] = _this9;
}
let _this29 = this.p;
if(_this13 != null) {
_this13.zero();
if(_this29.sizeVec3 == _this29.stackVec3.length) {
let newArray = new Array(_this29.sizeVec3 << 1);
let _g = 0;
let _g1 = _this29.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this29.stackVec3[i];
_this29.stackVec3[i] = null;
}
_this29.stackVec3 = newArray;
}
_this29.stackVec3[_this29.sizeVec3++] = _this13;
}
let _this30 = this.p;
if(_this16 != null) {
_this16.zero();
if(_this30.sizeVec3 == _this30.stackVec3.length) {
let newArray = new Array(_this30.sizeVec3 << 1);
let _g = 0;
let _g1 = _this30.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this30.stackVec3[i];
_this30.stackVec3[i] = null;
}
_this30.stackVec3 = newArray;
}
_this30.stackVec3[_this30.sizeVec3++] = _this16;
}
let _this31 = this.p;
if(_this19 != null) {
_this19.zero();
if(_this31.sizeVec3 == _this31.stackVec3.length) {
let newArray = new Array(_this31.sizeVec3 << 1);
let _g = 0;
let _g1 = _this31.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this31.stackVec3[i];
_this31.stackVec3[i] = null;
}
_this31.stackVec3 = newArray;
}
_this31.stackVec3[_this31.sizeVec3++] = _this19;
}
let _this32 = this.p;
if(_this22 != null) {
_this22.zero();
if(_this32.sizeVec3 == _this32.stackVec3.length) {
let newArray = new Array(_this32.sizeVec3 << 1);
let _g = 0;
let _g1 = _this32.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this32.stackVec3[i];
_this32.stackVec3[i] = null;
}
_this32.stackVec3 = newArray;
}
_this32.stackVec3[_this32.sizeVec3++] = _this22;
}
let _this33 = this.p;
if(_this25 != null) {
_this25.zero();
if(_this33.sizeVec3 == _this33.stackVec3.length) {
let newArray = new Array(_this33.sizeVec3 << 1);
let _g = 0;
let _g1 = _this33.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this33.stackVec3[i];
_this33.stackVec3[i] = null;
}
_this33.stackVec3 = newArray;
}
_this33.stackVec3[_this33.sizeVec3++] = _this25;
}
} else {
let _g = 0;
while(_g < 8) {
let i = _g++;
let _this = this.tmpCircleNorms[i];
let v = this.circleCoords[i];
_this.x = v.x;
_this.y = v.y;
_this.z = v.z;
let y = _this.x * m.e10 + _this.y * m.e11 + _this.z * m.e12;
let z = _this.x * m.e20 + _this.y * m.e21 + _this.z * m.e22;
_this.x = _this.x * m.e00 + _this.y * m.e01 + _this.z * m.e02;
_this.y = y;
_this.z = z;
let _this1 = this.tmpCircleVerts1[i];
let v1 = this.tmpCircleNorms[i];
_this1.x = v1.x;
_this1.y = v1.y;
_this1.z = v1.z;
_this1.x *= radius;
_this1.y *= radius;
_this1.z *= radius;
_this1.x += o.x;
_this1.y += o.y;
_this1.z += o.z;
let _this2 = this.tmpCircleVerts2[i];
let v2 = this.tmpCircleVerts1[i];
_this2.x = v2.x;
_this2.y = v2.y;
_this2.z = v2.z;
let _this3 = this.tmpCircleVerts1[i];
_this3.x += ey.x * halfHeight;
_this3.y += ey.y * halfHeight;
_this3.z += ey.z * halfHeight;
let _this4 = this.tmpCircleVerts2[i];
let s = -halfHeight;
_this4.x += ey.x * s;
_this4.y += ey.y * s;
_this4.z += ey.z * s;
}
let _g1 = 0;
while(_g1 < 8) {
let i = _g1++;
let n1 = this.tmpCircleNorms[i];
let n2 = this.tmpCircleNorms[(i + 1) % 8];
this.rect(this.tmpCircleVerts1[i],this.tmpCircleVerts2[i],this.tmpCircleVerts2[(i + 1) % 8],this.tmpCircleVerts1[(i + 1) % 8],n1,n1,n2,n2,color);
}
}
let _this11 = this.p;
if(_this7 != null) {
_this7.zero();
if(_this11.sizeVec3 == _this11.stackVec3.length) {
let newArray = new Array(_this11.sizeVec3 << 1);
let _g = 0;
let _g1 = _this11.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this11.stackVec3[i];
_this11.stackVec3[i] = null;
}
_this11.stackVec3 = newArray;
}
_this11.stackVec3[_this11.sizeVec3++] = _this7;
}
let _this12 = this.p;
if(_this10 != null) {
_this10.zero();
if(_this12.sizeVec3 == _this12.stackVec3.length) {
let newArray = new Array(_this12.sizeVec3 << 1);
let _g = 0;
let _g1 = _this12.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this12.stackVec3[i];
_this12.stackVec3[i] = null;
}
_this12.stackVec3 = newArray;
}
_this12.stackVec3[_this12.sizeVec3++] = _this10;
}
let _this13 = this.p;
if(o != null) {
o.zero();
if(_this13.sizeVec3 == _this13.stackVec3.length) {
let newArray = new Array(_this13.sizeVec3 << 1);
let _g = 0;
let _g1 = _this13.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this13.stackVec3[i];
_this13.stackVec3[i] = null;
}
_this13.stackVec3 = newArray;
}
_this13.stackVec3[_this13.sizeVec3++] = o;
}
let _this14 = this.p;
if(m != null) {
m.e00 = 1;
m.e01 = 0;
m.e02 = 0;
m.e10 = 0;
m.e11 = 1;
m.e12 = 0;
m.e20 = 0;
m.e21 = 0;
m.e22 = 1;
if(_this14.sizeMat3 == _this14.stackMat3.length) {
let newArray = new Array(_this14.sizeMat3 << 1);
let _g = 0;
let _g1 = _this14.sizeMat3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this14.stackMat3[i];
_this14.stackMat3[i] = null;
}
_this14.stackMat3 = newArray;
}
_this14.stackMat3[_this14.sizeMat3++] = m;
}
let _this15 = this.p;
if(ex != null) {
ex.zero();
if(_this15.sizeVec3 == _this15.stackVec3.length) {
let newArray = new Array(_this15.sizeVec3 << 1);
let _g = 0;
let _g1 = _this15.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this15.stackVec3[i];
_this15.stackVec3[i] = null;
}
_this15.stackVec3 = newArray;
}
_this15.stackVec3[_this15.sizeVec3++] = ex;
}
let _this16 = this.p;
if(ey != null) {
ey.zero();
if(_this16.sizeVec3 == _this16.stackVec3.length) {
let newArray = new Array(_this16.sizeVec3 << 1);
let _g = 0;
let _g1 = _this16.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this16.stackVec3[i];
_this16.stackVec3[i] = null;
}
_this16.stackVec3 = newArray;
}
_this16.stackVec3[_this16.sizeVec3++] = ey;
}
let _this17 = this.p;
if(ez != null) {
ez.zero();
if(_this17.sizeVec3 == _this17.stackVec3.length) {
let newArray = new Array(_this17.sizeVec3 << 1);
let _g = 0;
let _g1 = _this17.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this17.stackVec3[i];
_this17.stackVec3[i] = null;
}
_this17.stackVec3 = newArray;
}
_this17.stackVec3[_this17.sizeVec3++] = ez;
}
}
sphere(tf,radius,color) {
let _this = this.p;
let o = _this.sizeVec3 == 0 ? new oimo.common.Vec3() : _this.stackVec3[--_this.sizeVec3];
let _this1 = this.p;
let m = _this1.sizeMat3 == 0 ? new oimo.common.Mat3() : _this1.stackMat3[--_this1.sizeMat3];
let v = o;
v.x = tf._positionX;
v.y = tf._positionY;
v.z = tf._positionZ;
let m1 = m;
m1.e00 = tf._rotation00;
m1.e01 = tf._rotation01;
m1.e02 = tf._rotation02;
m1.e10 = tf._rotation10;
m1.e11 = tf._rotation11;
m1.e12 = tf._rotation12;
m1.e20 = tf._rotation20;
m1.e21 = tf._rotation21;
m1.e22 = tf._rotation22;
let vs = this.tmpSphereVerts;
let ns = this.tmpSphereNorms;
let _g = 0;
while(_g < 5) {
let i = _g++;
let n = this.tmpSphereVerts[i].length;
let _g1 = 0;
while(_g1 < n) {
let j = _g1++;
let _this = ns[i][j];
let v = this.sphereCoords[i][j];
_this.x = v.x;
_this.y = v.y;
_this.z = v.z;
let y = _this.x * m.e10 + _this.y * m.e11 + _this.z * m.e12;
let z = _this.x * m.e20 + _this.y * m.e21 + _this.z * m.e22;
_this.x = _this.x * m.e00 + _this.y * m.e01 + _this.z * m.e02;
_this.y = y;
_this.z = z;
let _this1 = vs[i][j];
let v1 = ns[i][j];
_this1.x = v1.x;
_this1.y = v1.y;
_this1.z = v1.z;
_this1.x *= radius;
_this1.y *= radius;
_this1.z *= radius;
_this1.x += o.x;
_this1.y += o.y;
_this1.z += o.z;
}
}
let _g1 = 0;
while(_g1 < 4) {
let i = _g1++;
let _g = 0;
while(_g < 8) {
let j = _g++;
let v1;
let v2;
let v3;
let v4;
let n1;
let n2;
let n3;
let n4;
if(i == 0) {
if(this.wireframe) {
v1 = vs[0][0];
v2 = vs[1][j];
this.line(v1,v2,color);
} else {
v1 = vs[0][0];
v2 = vs[1][j];
v3 = vs[1][(j + 1) % 8];
n1 = ns[0][0];
n2 = ns[1][j];
n3 = ns[1][(j + 1) % 8];
this.triangle(v1,v2,v3,n1,n2,n3,color);
}
} else if(i == 3) {
if(this.wireframe) {
v1 = vs[4][0];
v2 = vs[i][(j + 1) % 8];
v3 = vs[i][j];
this.line(v1,v2,color);
this.line(v2,v3,color);
} else {
v1 = vs[4][0];
v2 = vs[i][(j + 1) % 8];
v3 = vs[i][j];
n1 = ns[4][0];
n2 = ns[i][(j + 1) % 8];
n3 = ns[i][j];
this.triangle(v1,v2,v3,n1,n2,n3,color);
}
} else if(this.wireframe) {
v1 = vs[i][j];
v2 = vs[i][(j + 1) % 8];
v3 = vs[i + 1][j];
this.line(v1,v2,color);
this.line(v1,v3,color);
} else {
v1 = vs[i][j];
v2 = vs[i][(j + 1) % 8];
v3 = vs[i + 1][j];
v4 = vs[i + 1][(j + 1) % 8];
n1 = ns[i][j];
n2 = ns[i][(j + 1) % 8];
n3 = ns[i + 1][j];
n4 = ns[i + 1][(j + 1) % 8];
this.rect(v1,v3,v4,v2,n1,n3,n4,n2,color);
}
}
}
let _this2 = this.p;
if(o != null) {
o.zero();
if(_this2.sizeVec3 == _this2.stackVec3.length) {
let newArray = new Array(_this2.sizeVec3 << 1);
let _g = 0;
let _g1 = _this2.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this2.stackVec3[i];
_this2.stackVec3[i] = null;
}
_this2.stackVec3 = newArray;
}
_this2.stackVec3[_this2.sizeVec3++] = o;
}
let _this3 = this.p;
if(m != null) {
m.e00 = 1;
m.e01 = 0;
m.e02 = 0;
m.e10 = 0;
m.e11 = 1;
m.e12 = 0;
m.e20 = 0;
m.e21 = 0;
m.e22 = 1;
if(_this3.sizeMat3 == _this3.stackMat3.length) {
let newArray = new Array(_this3.sizeMat3 << 1);
let _g = 0;
let _g1 = _this3.sizeMat3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this3.stackMat3[i];
_this3.stackMat3[i] = null;
}
_this3.stackMat3 = newArray;
}
_this3.stackMat3[_this3.sizeMat3++] = m;
}
}
box(tf,halfExtents,color) {
let _this = this.p;
let ex = _this.sizeVec3 == 0 ? new oimo.common.Vec3() : _this.stackVec3[--_this.sizeVec3];
let _this1 = this.p;
let ey = _this1.sizeVec3 == 0 ? new oimo.common.Vec3() : _this1.stackVec3[--_this1.sizeVec3];
let _this2 = this.p;
let ez = _this2.sizeVec3 == 0 ? new oimo.common.Vec3() : _this2.stackVec3[--_this2.sizeVec3];
let _this3 = this.p;
let o = _this3.sizeVec3 == 0 ? new oimo.common.Vec3() : _this3.stackVec3[--_this3.sizeVec3];
let _this4 = this.p;
let m = _this4.sizeMat3 == 0 ? new oimo.common.Mat3() : _this4.stackMat3[--_this4.sizeMat3];
let v = o;
v.x = tf._positionX;
v.y = tf._positionY;
v.z = tf._positionZ;
let m1 = m;
m1.e00 = tf._rotation00;
m1.e01 = tf._rotation01;
m1.e02 = tf._rotation02;
m1.e10 = tf._rotation10;
m1.e11 = tf._rotation11;
m1.e12 = tf._rotation12;
m1.e20 = tf._rotation20;
m1.e21 = tf._rotation21;
m1.e22 = tf._rotation22;
ex.init(m.e00,m.e10,m.e20);
ey.init(m.e01,m.e11,m.e21);
ez.init(m.e02,m.e12,m.e22);
let hx = halfExtents.x;
let hy = halfExtents.y;
let hz = halfExtents.z;
let _this5 = this.p;
let _this6 = _this5.sizeVec3 == 0 ? new oimo.common.Vec3() : _this5.stackVec3[--_this5.sizeVec3];
_this6.x = o.x;
_this6.y = o.y;
_this6.z = o.z;
let _this7 = _this6;
let s = -hx;
_this7.x += ex.x * s;
_this7.y += ex.y * s;
_this7.z += ex.z * s;
let s1 = -hy;
_this7.x += ey.x * s1;
_this7.y += ey.y * s1;
_this7.z += ey.z * s1;
let s2 = -hz;
_this7.x += ez.x * s2;
_this7.y += ez.y * s2;
_this7.z += ez.z * s2;
let _this8 = this.p;
let _this9 = _this8.sizeVec3 == 0 ? new oimo.common.Vec3() : _this8.stackVec3[--_this8.sizeVec3];
_this9.x = o.x;
_this9.y = o.y;
_this9.z = o.z;
let _this10 = _this9;
let s3 = -hx;
_this10.x += ex.x * s3;
_this10.y += ex.y * s3;
_this10.z += ex.z * s3;
let s4 = -hy;
_this10.x += ey.x * s4;
_this10.y += ey.y * s4;
_this10.z += ey.z * s4;
_this10.x += ez.x * hz;
_this10.y += ez.y * hz;
_this10.z += ez.z * hz;
let _this11 = this.p;
let _this12 = _this11.sizeVec3 == 0 ? new oimo.common.Vec3() : _this11.stackVec3[--_this11.sizeVec3];
_this12.x = o.x;
_this12.y = o.y;
_this12.z = o.z;
let _this13 = _this12;
let s5 = -hx;
_this13.x += ex.x * s5;
_this13.y += ex.y * s5;
_this13.z += ex.z * s5;
_this13.x += ey.x * hy;
_this13.y += ey.y * hy;
_this13.z += ey.z * hy;
let s6 = -hz;
_this13.x += ez.x * s6;
_this13.y += ez.y * s6;
_this13.z += ez.z * s6;
let _this14 = this.p;
let _this15 = _this14.sizeVec3 == 0 ? new oimo.common.Vec3() : _this14.stackVec3[--_this14.sizeVec3];
_this15.x = o.x;
_this15.y = o.y;
_this15.z = o.z;
let _this16 = _this15;
let s7 = -hx;
_this16.x += ex.x * s7;
_this16.y += ex.y * s7;
_this16.z += ex.z * s7;
_this16.x += ey.x * hy;
_this16.y += ey.y * hy;
_this16.z += ey.z * hy;
_this16.x += ez.x * hz;
_this16.y += ez.y * hz;
_this16.z += ez.z * hz;
let _this17 = this.p;
let _this18 = _this17.sizeVec3 == 0 ? new oimo.common.Vec3() : _this17.stackVec3[--_this17.sizeVec3];
_this18.x = o.x;
_this18.y = o.y;
_this18.z = o.z;
let _this19 = _this18;
_this19.x += ex.x * hx;
_this19.y += ex.y * hx;
_this19.z += ex.z * hx;
let s8 = -hy;
_this19.x += ey.x * s8;
_this19.y += ey.y * s8;
_this19.z += ey.z * s8;
let s9 = -hz;
_this19.x += ez.x * s9;
_this19.y += ez.y * s9;
_this19.z += ez.z * s9;
let _this20 = this.p;
let _this21 = _this20.sizeVec3 == 0 ? new oimo.common.Vec3() : _this20.stackVec3[--_this20.sizeVec3];
_this21.x = o.x;
_this21.y = o.y;
_this21.z = o.z;
let _this22 = _this21;
_this22.x += ex.x * hx;
_this22.y += ex.y * hx;
_this22.z += ex.z * hx;
let s10 = -hy;
_this22.x += ey.x * s10;
_this22.y += ey.y * s10;
_this22.z += ey.z * s10;
_this22.x += ez.x * hz;
_this22.y += ez.y * hz;
_this22.z += ez.z * hz;
let _this23 = this.p;
let _this24 = _this23.sizeVec3 == 0 ? new oimo.common.Vec3() : _this23.stackVec3[--_this23.sizeVec3];
_this24.x = o.x;
_this24.y = o.y;
_this24.z = o.z;
let _this25 = _this24;
_this25.x += ex.x * hx;
_this25.y += ex.y * hx;
_this25.z += ex.z * hx;
_this25.x += ey.x * hy;
_this25.y += ey.y * hy;
_this25.z += ey.z * hy;
let s11 = -hz;
_this25.x += ez.x * s11;
_this25.y += ez.y * s11;
_this25.z += ez.z * s11;
let _this26 = this.p;
let _this27 = _this26.sizeVec3 == 0 ? new oimo.common.Vec3() : _this26.stackVec3[--_this26.sizeVec3];
_this27.x = o.x;
_this27.y = o.y;
_this27.z = o.z;
let _this28 = _this27;
_this28.x += ex.x * hx;
_this28.y += ex.y * hx;
_this28.z += ex.z * hx;
_this28.x += ey.x * hy;
_this28.y += ey.y * hy;
_this28.z += ey.z * hy;
_this28.x += ez.x * hz;
_this28.y += ez.y * hz;
_this28.z += ez.z * hz;
if(this.wireframe) {
this.line(_this7,_this10,color);
this.line(_this13,_this16,color);
this.line(_this19,_this22,color);
this.line(_this25,_this28,color);
this.line(_this7,_this13,color);
this.line(_this10,_this16,color);
this.line(_this19,_this25,color);
this.line(_this22,_this28,color);
this.line(_this7,_this19,color);
this.line(_this10,_this22,color);
this.line(_this13,_this25,color);
this.line(_this16,_this28,color);
} else {
let _this = this.p;
let _this1 = _this.sizeVec3 == 0 ? new oimo.common.Vec3() : _this.stackVec3[--_this.sizeVec3];
_this1.x = ex.x;
_this1.y = ex.y;
_this1.z = ex.z;
let _this2 = _this1;
_this2.x = -_this2.x;
_this2.y = -_this2.y;
_this2.z = -_this2.z;
let _this3 = this.p;
let _this4 = _this3.sizeVec3 == 0 ? new oimo.common.Vec3() : _this3.stackVec3[--_this3.sizeVec3];
_this4.x = ey.x;
_this4.y = ey.y;
_this4.z = ey.z;
let _this5 = _this4;
_this5.x = -_this5.x;
_this5.y = -_this5.y;
_this5.z = -_this5.z;
let _this6 = this.p;
let _this8 = _this6.sizeVec3 == 0 ? new oimo.common.Vec3() : _this6.stackVec3[--_this6.sizeVec3];
_this8.x = ez.x;
_this8.y = ez.y;
_this8.z = ez.z;
let _this9 = _this8;
_this9.x = -_this9.x;
_this9.y = -_this9.y;
_this9.z = -_this9.z;
this.rect(_this7,_this10,_this16,_this13,_this2,_this2,_this2,_this2,color);
this.rect(_this19,_this25,_this28,_this22,ex,ex,ex,ex,color);
this.rect(_this7,_this19,_this22,_this10,_this5,_this5,_this5,_this5,color);
this.rect(_this13,_this16,_this28,_this25,ey,ey,ey,ey,color);
this.rect(_this7,_this13,_this25,_this19,_this9,_this9,_this9,_this9,color);
this.rect(_this10,_this22,_this28,_this16,ez,ez,ez,ez,color);
let _this11 = this.p;
if(_this2 != null) {
_this2.zero();
if(_this11.sizeVec3 == _this11.stackVec3.length) {
let newArray = new Array(_this11.sizeVec3 << 1);
let _g = 0;
let _g1 = _this11.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this11.stackVec3[i];
_this11.stackVec3[i] = null;
}
_this11.stackVec3 = newArray;
}
_this11.stackVec3[_this11.sizeVec3++] = _this2;
}
let _this12 = this.p;
if(_this5 != null) {
_this5.zero();
if(_this12.sizeVec3 == _this12.stackVec3.length) {
let newArray = new Array(_this12.sizeVec3 << 1);
let _g = 0;
let _g1 = _this12.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this12.stackVec3[i];
_this12.stackVec3[i] = null;
}
_this12.stackVec3 = newArray;
}
_this12.stackVec3[_this12.sizeVec3++] = _this5;
}
let _this14 = this.p;
if(_this9 != null) {
_this9.zero();
if(_this14.sizeVec3 == _this14.stackVec3.length) {
let newArray = new Array(_this14.sizeVec3 << 1);
let _g = 0;
let _g1 = _this14.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this14.stackVec3[i];
_this14.stackVec3[i] = null;
}
_this14.stackVec3 = newArray;
}
_this14.stackVec3[_this14.sizeVec3++] = _this9;
}
}
let _this29 = this.p;
if(_this7 != null) {
_this7.zero();
if(_this29.sizeVec3 == _this29.stackVec3.length) {
let newArray = new Array(_this29.sizeVec3 << 1);
let _g = 0;
let _g1 = _this29.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this29.stackVec3[i];
_this29.stackVec3[i] = null;
}
_this29.stackVec3 = newArray;
}
_this29.stackVec3[_this29.sizeVec3++] = _this7;
}
let _this30 = this.p;
if(_this10 != null) {
_this10.zero();
if(_this30.sizeVec3 == _this30.stackVec3.length) {
let newArray = new Array(_this30.sizeVec3 << 1);
let _g = 0;
let _g1 = _this30.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this30.stackVec3[i];
_this30.stackVec3[i] = null;
}
_this30.stackVec3 = newArray;
}
_this30.stackVec3[_this30.sizeVec3++] = _this10;
}
let _this31 = this.p;
if(_this13 != null) {
_this13.zero();
if(_this31.sizeVec3 == _this31.stackVec3.length) {
let newArray = new Array(_this31.sizeVec3 << 1);
let _g = 0;
let _g1 = _this31.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this31.stackVec3[i];
_this31.stackVec3[i] = null;
}
_this31.stackVec3 = newArray;
}
_this31.stackVec3[_this31.sizeVec3++] = _this13;
}
let _this32 = this.p;
if(_this16 != null) {
_this16.zero();
if(_this32.sizeVec3 == _this32.stackVec3.length) {
let newArray = new Array(_this32.sizeVec3 << 1);
let _g = 0;
let _g1 = _this32.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this32.stackVec3[i];
_this32.stackVec3[i] = null;
}
_this32.stackVec3 = newArray;
}
_this32.stackVec3[_this32.sizeVec3++] = _this16;
}
let _this33 = this.p;
if(_this19 != null) {
_this19.zero();
if(_this33.sizeVec3 == _this33.stackVec3.length) {
let newArray = new Array(_this33.sizeVec3 << 1);
let _g = 0;
let _g1 = _this33.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this33.stackVec3[i];
_this33.stackVec3[i] = null;
}
_this33.stackVec3 = newArray;
}
_this33.stackVec3[_this33.sizeVec3++] = _this19;
}
let _this34 = this.p;
if(_this22 != null) {
_this22.zero();
if(_this34.sizeVec3 == _this34.stackVec3.length) {
let newArray = new Array(_this34.sizeVec3 << 1);
let _g = 0;
let _g1 = _this34.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this34.stackVec3[i];
_this34.stackVec3[i] = null;
}
_this34.stackVec3 = newArray;
}
_this34.stackVec3[_this34.sizeVec3++] = _this22;
}
let _this35 = this.p;
if(_this25 != null) {
_this25.zero();
if(_this35.sizeVec3 == _this35.stackVec3.length) {
let newArray = new Array(_this35.sizeVec3 << 1);
let _g = 0;
let _g1 = _this35.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this35.stackVec3[i];
_this35.stackVec3[i] = null;
}
_this35.stackVec3 = newArray;
}
_this35.stackVec3[_this35.sizeVec3++] = _this25;
}
let _this36 = this.p;
if(_this28 != null) {
_this28.zero();
if(_this36.sizeVec3 == _this36.stackVec3.length) {
let newArray = new Array(_this36.sizeVec3 << 1);
let _g = 0;
let _g1 = _this36.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this36.stackVec3[i];
_this36.stackVec3[i] = null;
}
_this36.stackVec3 = newArray;
}
_this36.stackVec3[_this36.sizeVec3++] = _this28;
}
let _this37 = this.p;
if(o != null) {
o.zero();
if(_this37.sizeVec3 == _this37.stackVec3.length) {
let newArray = new Array(_this37.sizeVec3 << 1);
let _g = 0;
let _g1 = _this37.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this37.stackVec3[i];
_this37.stackVec3[i] = null;
}
_this37.stackVec3 = newArray;
}
_this37.stackVec3[_this37.sizeVec3++] = o;
}
let _this38 = this.p;
if(m != null) {
m.e00 = 1;
m.e01 = 0;
m.e02 = 0;
m.e10 = 0;
m.e11 = 1;
m.e12 = 0;
m.e20 = 0;
m.e21 = 0;
m.e22 = 1;
if(_this38.sizeMat3 == _this38.stackMat3.length) {
let newArray = new Array(_this38.sizeMat3 << 1);
let _g = 0;
let _g1 = _this38.sizeMat3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this38.stackMat3[i];
_this38.stackMat3[i] = null;
}
_this38.stackMat3 = newArray;
}
_this38.stackMat3[_this38.sizeMat3++] = m;
}
let _this39 = this.p;
if(ex != null) {
ex.zero();
if(_this39.sizeVec3 == _this39.stackVec3.length) {
let newArray = new Array(_this39.sizeVec3 << 1);
let _g = 0;
let _g1 = _this39.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this39.stackVec3[i];
_this39.stackVec3[i] = null;
}
_this39.stackVec3 = newArray;
}
_this39.stackVec3[_this39.sizeVec3++] = ex;
}
let _this40 = this.p;
if(ey != null) {
ey.zero();
if(_this40.sizeVec3 == _this40.stackVec3.length) {
let newArray = new Array(_this40.sizeVec3 << 1);
let _g = 0;
let _g1 = _this40.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this40.stackVec3[i];
_this40.stackVec3[i] = null;
}
_this40.stackVec3 = newArray;
}
_this40.stackVec3[_this40.sizeVec3++] = ey;
}
let _this41 = this.p;
if(ez != null) {
ez.zero();
if(_this41.sizeVec3 == _this41.stackVec3.length) {
let newArray = new Array(_this41.sizeVec3 << 1);
let _g = 0;
let _g1 = _this41.sizeVec3;
while(_g < _g1) {
let i = _g++;
newArray[i] = _this41.stackVec3[i];
_this41.stackVec3[i] = null;
}
_this41.stackVec3 = newArray;
}
_this41.stackVec3[_this41.sizeVec3++] = ez;
}
}
rect(v1,v2,v3,v4,n1,n2,n3,n4,color) {
this.triangle(v1,v2,v3,n1,n2,n3,color);
this.triangle(v1,v3,v4,n1,n3,n4,color);
}
point(v,color) {
}
triangle(v1,v2,v3,n1,n2,n3,color) {
}
line(v1,v2,color) {
}
}
oimo.dynamics.common.DebugDrawStyle = class oimo_dynamics_common_DebugDrawStyle {
constructor() {
this.basisColorZ = new oimo.common.Vec3(0.0,0.0,1.0);
this.basisColorY = new oimo.common.Vec3(0.0,1.0,0.0);
this.basisColorX = new oimo.common.Vec3(1.0,0.0,0.0);
this.basisLength = 0.5;
this.jointRotationalConstraintRadius = 0.3;
this.jointErrorColor = new oimo.common.Vec3(1.0,0.1,0.1);
this.jointLineColor = new oimo.common.Vec3(0.8,0.8,0.8);
this.contactBinormalLength = 0.5;
this.contactTangentLength = 0.5;
this.contactNormalLength = 0.5;
this.contactBinormalColor = new oimo.common.Vec3(0.2,0.2,1.0);
this.contactTangentColor = new oimo.common.Vec3(0.1,0.8,0.1);
this.contactNormalColor = new oimo.common.Vec3(1.0,0.1,0.1);
this.disabledContactColor = new oimo.common.Vec3(0.5,0.1,0.1);
this.newContactColor = new oimo.common.Vec3(1.0,1.0,0.1);
this.contactColor4 = new oimo.common.Vec3(0.8,0.1,1.0);
this.contactColor3 = new oimo.common.Vec3(0.1,0.8,0.6);
this.contactColor2 = new oimo.common.Vec3(1.0,0.6,0.1);
this.contactColor = new oimo.common.Vec3(1.0,0.1,0.1);
this.pairColor = new oimo.common.Vec3(1.0,1.0,0.1);
this.bvhNodeColor = new oimo.common.Vec3(0.4,0.4,0.4);
this.aabbColor = new oimo.common.Vec3(1.0,0.1,0.1);
this.kinematicShapeColor = new oimo.common.Vec3(1.0,0.5,0.1);
this.staticShapeColor = new oimo.common.Vec3(0.7,0.7,0.7);
this.sleepingShapeColor2 = new oimo.common.Vec3(0.2,0.8,0.5);
this.sleepingShapeColor1 = new oimo.common.Vec3(0.3,0.3,0.8);
this.sleepyShapeColor2 = new oimo.common.Vec3(0.6,0.8,0.3);
this.sleepyShapeColor1 = new oimo.common.Vec3(0.5,0.25,0.6);
this.shapeColor2 = new oimo.common.Vec3(1.0,0.8,0.1);
this.shapeColor1 = new oimo.common.Vec3(0.7,0.2,0.4);
}
}
oimo.dynamics.common.Performance = class oimo_dynamics_common_Performance {
}
if(!oimo.dynamics.constraint) oimo.dynamics.constraint = {};
oimo.dynamics.constraint.ConstraintSolver = class oimo_dynamics_constraint_ConstraintSolver {
constructor() {
this._b1 = null;
this._b2 = null;
this._addedToIsland = false;
}
preSolveVelocity(timeStep) {
}
warmStart(timeStep) {
}
solveVelocity() {
}
postSolveVelocity(timeStep) {
}
preSolvePosition(timeStep) {
}
solvePositionSplitImpulse() {
}
solvePositionNgs(timeStep) {
}
postSolve() {
}
}
oimo.dynamics.constraint.PositionCorrectionAlgorithm = class oimo_dynamics_constraint_PositionCorrectionAlgorithm {
}
if(!oimo.dynamics.constraint.contact) oimo.dynamics.constraint.contact = {};
oimo.dynamics.constraint.contact.ContactConstraint = class oimo_dynamics_constraint_contact_ContactConstraint {
constructor(manifold) {
this._solver = new oimo.dynamics.constraint.solver.pgs.PgsContactConstraintSolver(this);
this._manifold = manifold;
}
_getVelocitySolverInfo(timeStep,info) {
info.b1 = this._b1;
info.b2 = this._b2;
let normalX;
let normalY;
let normalZ;
let tangentX;
let tangentY;
let tangentZ;
let binormalX;
let binormalY;
let binormalZ;
normalX = this._manifold._normalX;
normalY = this._manifold._normalY;
normalZ = this._manifold._normalZ;
tangentX = this._manifold._tangentX;
tangentY = this._manifold._tangentY;
tangentZ = this._manifold._tangentZ;
binormalX = this._manifold._binormalX;
binormalY = this._manifold._binormalY;
binormalZ = this._manifold._binormalZ;
let friction = Math.sqrt(this._s1._friction * this._s2._friction);
let restitution = Math.sqrt(this._s1._restitution * this._s2._restitution);
let num = this._manifold._numPoints;
info.numRows = 0;
let _g = 0;
while(_g < num) {
let p = this._manifold._points[_g++];
if(p._depth < 0) {
p._disabled = true;
let _this = p._impulse;
_this.impulseN = 0;
_this.impulseT = 0;
_this.impulseB = 0;
_this.impulseP = 0;
_this.impulseLX = 0;
_this.impulseLY = 0;
_this.impulseLZ = 0;
continue;
} else {
p._disabled = false;
}
let row = info.rows[info.numRows++];
row.friction = friction;
row.cfm = 0;
let j = row.jacobianN;
j.lin1X = normalX;
j.lin1Y = normalY;
j.lin1Z = normalZ;
j.lin2X = normalX;
j.lin2Y = normalY;
j.lin2Z = normalZ;
j.ang1X = p._relPos1Y * normalZ - p._relPos1Z * normalY;
j.ang1Y = p._relPos1Z * normalX - p._relPos1X * normalZ;
j.ang1Z = p._relPos1X * normalY - p._relPos1Y * normalX;
j.ang2X = p._relPos2Y * normalZ - p._relPos2Z * normalY;
j.ang2Y = p._relPos2Z * normalX - p._relPos2X * normalZ;
j.ang2Z = p._relPos2X * normalY - p._relPos2Y * normalX;
j = row.jacobianT;
j.lin1X = tangentX;
j.lin1Y = tangentY;
j.lin1Z = tangentZ;
j.lin2X = tangentX;
j.lin2Y = tangentY;
j.lin2Z = tangentZ;
j.ang1X = p._relPos1Y * tangentZ - p._relPos1Z * tangentY;
j.ang1Y = p._relPos1Z * tangentX - p._relPos1X * tangentZ;
j.ang1Z = p._relPos1X * tangentY - p._relPos1Y * tangentX;
j.ang2X = p._relPos2Y * tangentZ - p._relPos2Z * tangentY;
j.ang2Y = p._relPos2Z * tangentX - p._relPos2X * tangentZ;
j.ang2Z = p._relPos2X * tangentY - p._relPos2Y * tangentX;
j = row.jacobianB;
j.lin1X = binormalX;
j.lin1Y = binormalY;
j.lin1Z = binormalZ;
j.lin2X = binormalX;
j.lin2Y = binormalY;
j.lin2Z = binormalZ;
j.ang1X = p._relPos1Y * binormalZ - p._relPos1Z * binormalY;
j.ang1Y = p._relPos1Z * binormalX - p._relPos1X * binormalZ;
j.ang1Z = p._relPos1X * binormalY - p._relPos1Y * binormalX;
j.ang2X = p._relPos2Y * binormalZ - p._relPos2Z * binormalY;
j.ang2Y = p._relPos2Z * binormalX - p._relPos2X * binormalZ;
j.ang2Z = p._relPos2X * binormalY - p._relPos2Y * binormalX;
j = row.jacobianN;
let rvn = j.lin1X * this._b1._velX + j.lin1Y * this._b1._velY + j.lin1Z * this._b1._velZ + (j.ang1X * this._b1._angVelX + j.ang1Y * this._b1._angVelY + j.ang1Z * this._b1._angVelZ) - (j.lin2X * this._b2._velX + j.lin2Y * this._b2._velY + j.lin2Z * this._b2._velZ + (j.ang2X * this._b2._angVelX + j.ang2Y * this._b2._angVelY + j.ang2Z * this._b2._angVelZ));
if(rvn < -oimo.common.Setting.contactEnableBounceThreshold && !p._warmStarted) {
row.rhs = -rvn * restitution;
} else {
row.rhs = 0;
}
if(this._positionCorrectionAlgorithm == oimo.dynamics.constraint.PositionCorrectionAlgorithm.BAUMGARTE) {
if(p._depth > oimo.common.Setting.linearSlop) {
let minRhs = (p._depth - oimo.common.Setting.linearSlop) * oimo.common.Setting.velocityBaumgarte * timeStep.invDt;
if(row.rhs < minRhs) {
row.rhs = minRhs;
}
}
}
if(!p._warmStarted) {
let _this = p._impulse;
_this.impulseN = 0;
_this.impulseT = 0;
_this.impulseB = 0;
_this.impulseP = 0;
_this.impulseLX = 0;
_this.impulseLY = 0;
_this.impulseLZ = 0;
}
row.impulse = p._impulse;
}
}
_getPositionSolverInfo(info) {
info.b1 = this._b1;
info.b2 = this._b2;
let normalX;
let normalY;
let normalZ;
normalX = this._manifold._normalX;
normalY = this._manifold._normalY;
normalZ = this._manifold._normalZ;
let num = this._manifold._numPoints;
info.numRows = 0;
let _g = 0;
while(_g < num) {
let p = this._manifold._points[_g++];
if(p._disabled) {
continue;
}
let row = info.rows[info.numRows++];
let j = row.jacobianN;
j.lin1X = normalX;
j.lin1Y = normalY;
j.lin1Z = normalZ;
j.lin2X = normalX;
j.lin2Y = normalY;
j.lin2Z = normalZ;
j.ang1X = p._relPos1Y * normalZ - p._relPos1Z * normalY;
j.ang1Y = p._relPos1Z * normalX - p._relPos1X * normalZ;
j.ang1Z = p._relPos1X * normalY - p._relPos1Y * normalX;
j.ang2X = p._relPos2Y * normalZ - p._relPos2Z * normalY;
j.ang2Y = p._relPos2Z * normalX - p._relPos2X * normalZ;
j.ang2Z = p._relPos2X * normalY - p._relPos2Y * normalX;
row.rhs = p._depth - oimo.common.Setting.linearSlop;
if(row.rhs < 0) {
row.rhs = 0;
}
row.impulse = p._impulse;
}
}
_syncManifold() {
this._manifold._updateDepthsAndPositions(this._tf1,this._tf2);
}
getShape1() {
return this._s1;
}
getShape2() {
return this._s2;
}
getManifold() {
return this._manifold;
}
isTouching() {
let _g = 0;
let _g1 = this._manifold._numPoints;
while(_g < _g1) if(this._manifold._points[_g++]._depth >= 0) {
return true;
}
return false;
}
}
oimo.dynamics.constraint.contact.ContactImpulse = class oimo_dynamics_constraint_contact_ContactImpulse {
constructor() {
this.impulseN = 0;
this.impulseT = 0;
this.impulseB = 0;
this.impulseP = 0;
this.impulseLX = 0;
this.impulseLY = 0;
this.impulseLZ = 0;
}
copyFrom(imp) {
this.impulseN = imp.impulseN;
this.impulseT = imp.impulseT;
this.impulseB = imp.impulseB;
this.impulseLX = imp.impulseLX;
this.impulseLY = imp.impulseLY;
this.impulseLZ = imp.impulseLZ;
}
}
oimo.dynamics.constraint.contact.Manifold = class oimo_dynamics_constraint_contact_Manifold {
constructor() {
this._normalX = 0;
this._normalY = 0;
this._normalZ = 0;
this._tangentX = 0;
this._tangentY = 0;
this._tangentZ = 0;
this._binormalX = 0;
this._binormalY = 0;
this._binormalZ = 0;
this._numPoints = 0;
this._points = new Array(oimo.common.Setting.maxManifoldPoints);
let _g = 0;
let _g1 = oimo.common.Setting.maxManifoldPoints;
while(_g < _g1) this._points[_g++] = new oimo.dynamics.constraint.contact.ManifoldPoint();
}
_clear() {
let _g = 0;
let _g1 = this._numPoints;
while(_g < _g1) {
let _this = this._points[_g++];
_this._localPos1X = 0;
_this._localPos1Y = 0;
_this._localPos1Z = 0;
_this._localPos2X = 0;
_this._localPos2Y = 0;
_this._localPos2Z = 0;
_this._relPos1X = 0;
_this._relPos1Y = 0;
_this._relPos1Z = 0;
_this._relPos2X = 0;
_this._relPos2Y = 0;
_this._relPos2Z = 0;
_this._pos1X = 0;
_this._pos1Y = 0;
_this._pos1Z = 0;
_this._pos2X = 0;
_this._pos2Y = 0;
_this._pos2Z = 0;
_this._depth = 0;
let _this1 = _this._impulse;
_this1.impulseN = 0;
_this1.impulseT = 0;
_this1.impulseB = 0;
_this1.impulseP = 0;
_this1.impulseLX = 0;
_this1.impulseLY = 0;
_this1.impulseLZ = 0;
_this._warmStarted = false;
_this._disabled = false;
_this._id = -1;
}
this._numPoints = 0;
}
_buildBasis(normal) {
this._normalX = normal.x;
this._normalY = normal.y;
this._normalZ = normal.z;
let nx = normal.x;
let ny = normal.y;
let nz = normal.z;
let nx2 = nx * nx;
let ny2 = ny * ny;
let nz2 = nz * nz;
let tx;
let ty;
let tz;
let bx;
let by;
let bz;
if(nx2 < ny2) {
if(nx2 < nz2) {
let invL = 1 / Math.sqrt(ny2 + nz2);
tx = 0;
ty = -nz * invL;
tz = ny * invL;
bx = ny * tz - nz * ty;
by = -nx * tz;
bz = nx * ty;
} else {
let invL = 1 / Math.sqrt(nx2 + ny2);
tx = -ny * invL;
ty = nx * invL;
tz = 0;
bx = -nz * ty;
by = nz * tx;
bz = nx * ty - ny * tx;
}
} else if(ny2 < nz2) {
let invL = 1 / Math.sqrt(nx2 + nz2);
tx = nz * invL;
ty = 0;
tz = -nx * invL;
bx = ny * tz;
by = nz * tx - nx * tz;
bz = -ny * tx;
} else {
let invL = 1 / Math.sqrt(nx2 + ny2);
tx = -ny * invL;
ty = nx * invL;
tz = 0;
bx = -nz * ty;
by = nz * tx;
bz = nx * ty - ny * tx;
}
this._tangentX = tx;
this._tangentY = ty;
this._tangentZ = tz;
this._binormalX = bx;
this._binormalY = by;
this._binormalZ = bz;
}
_updateDepthsAndPositions(tf1,tf2) {
let _g = 0;
let _g1 = this._numPoints;
while(_g < _g1) {
let p = this._points[_g++];
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = tf1._rotation00 * p._localPos1X + tf1._rotation01 * p._localPos1Y + tf1._rotation02 * p._localPos1Z;
__tmp__Y = tf1._rotation10 * p._localPos1X + tf1._rotation11 * p._localPos1Y + tf1._rotation12 * p._localPos1Z;
__tmp__Z = tf1._rotation20 * p._localPos1X + tf1._rotation21 * p._localPos1Y + tf1._rotation22 * p._localPos1Z;
p._relPos1X = __tmp__X;
p._relPos1Y = __tmp__Y;
p._relPos1Z = __tmp__Z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = tf2._rotation00 * p._localPos2X + tf2._rotation01 * p._localPos2Y + tf2._rotation02 * p._localPos2Z;
__tmp__Y1 = tf2._rotation10 * p._localPos2X + tf2._rotation11 * p._localPos2Y + tf2._rotation12 * p._localPos2Z;
__tmp__Z1 = tf2._rotation20 * p._localPos2X + tf2._rotation21 * p._localPos2Y + tf2._rotation22 * p._localPos2Z;
p._relPos2X = __tmp__X1;
p._relPos2Y = __tmp__Y1;
p._relPos2Z = __tmp__Z1;
p._pos1X = p._relPos1X + tf1._positionX;
p._pos1Y = p._relPos1Y + tf1._positionY;
p._pos1Z = p._relPos1Z + tf1._positionZ;
p._pos2X = p._relPos2X + tf2._positionX;
p._pos2Y = p._relPos2Y + tf2._positionY;
p._pos2Z = p._relPos2Z + tf2._positionZ;
let diffX;
let diffY;
let diffZ;
diffX = p._pos1X - p._pos2X;
diffY = p._pos1Y - p._pos2Y;
diffZ = p._pos1Z - p._pos2Z;
p._depth = -(diffX * this._normalX + diffY * this._normalY + diffZ * this._normalZ);
}
}
getNormal() {
let v = new oimo.common.Vec3();
v.x = this._normalX;
v.y = this._normalY;
v.z = this._normalZ;
return v;
}
getNormalTo(normal) {
normal.x = this._normalX;
normal.y = this._normalY;
normal.z = this._normalZ;
}
getTangent() {
let v = new oimo.common.Vec3();
v.x = this._tangentX;
v.y = this._tangentY;
v.z = this._tangentZ;
return v;
}
getTangentTo(tangent) {
tangent.x = this._tangentX;
tangent.y = this._tangentY;
tangent.z = this._tangentZ;
}
getBinormal() {
let v = new oimo.common.Vec3();
v.x = this._binormalX;
v.y = this._binormalY;
v.z = this._binormalZ;
return v;
}
getBinormalTo(binormal) {
binormal.x = this._binormalX;
binormal.y = this._binormalY;
binormal.z = this._binormalZ;
}
getPoints() {
return this._points;
}
getNumPoints() {
return this._numPoints;
}
}
oimo.dynamics.constraint.contact.ManifoldPoint = class oimo_dynamics_constraint_contact_ManifoldPoint {
constructor() {
this._localPos1X = 0;
this._localPos1Y = 0;
this._localPos1Z = 0;
this._localPos2X = 0;
this._localPos2Y = 0;
this._localPos2Z = 0;
this._relPos1X = 0;
this._relPos1Y = 0;
this._relPos1Z = 0;
this._relPos2X = 0;
this._relPos2Y = 0;
this._relPos2Z = 0;
this._pos1X = 0;
this._pos1Y = 0;
this._pos1Z = 0;
this._pos2X = 0;
this._pos2Y = 0;
this._pos2Z = 0;
this._depth = 0;
this._impulse = new oimo.dynamics.constraint.contact.ContactImpulse();
this._warmStarted = false;
this._disabled = false;
this._id = -1;
}
getPosition1() {
let v = new oimo.common.Vec3();
v.x = this._pos1X;
v.y = this._pos1Y;
v.z = this._pos1Z;
return v;
}
getPosition1To(position) {
position.x = this._pos1X;
position.y = this._pos1Y;
position.z = this._pos1Z;
}
getPosition2() {
let v = new oimo.common.Vec3();
v.x = this._pos2X;
v.y = this._pos2Y;
v.z = this._pos2Z;
return v;
}
getPosition2To(position) {
position.x = this._pos2X;
position.y = this._pos2Y;
position.z = this._pos2Z;
}
getDepth() {
return this._depth;
}
isWarmStarted() {
return this._warmStarted;
}
getNormalImpulse() {
return this._impulse.impulseN;
}
getTangentImpulse() {
return this._impulse.impulseT;
}
getBinormalImpulse() {
return this._impulse.impulseB;
}
isEnabled() {
return !this._disabled;
}
}
oimo.dynamics.constraint.contact.ManifoldUpdater = class oimo_dynamics_constraint_contact_ManifoldUpdater {
constructor(manifold) {
this._manifold = manifold;
this.numOldPoints = 0;
this.oldPoints = new Array(oimo.common.Setting.maxManifoldPoints);
let _g = 0;
let _g1 = oimo.common.Setting.maxManifoldPoints;
while(_g < _g1) this.oldPoints[_g++] = new oimo.dynamics.constraint.contact.ManifoldPoint();
}
removeOutdatedPoints() {
let index = this._manifold._numPoints;
while(--index >= 0) {
let p = this._manifold._points[index];
let diffX;
let diffY;
let diffZ;
diffX = p._pos1X - p._pos2X;
diffY = p._pos1Y - p._pos2Y;
diffZ = p._pos1Z - p._pos2Z;
let dotN = this._manifold._normalX * diffX + this._manifold._normalY * diffY + this._manifold._normalZ * diffZ;
if(dotN > oimo.common.Setting.contactPersistenceThreshold) {
this.removeManifoldPoint(index);
continue;
}
diffX += this._manifold._normalX * -dotN;
diffY += this._manifold._normalY * -dotN;
diffZ += this._manifold._normalZ * -dotN;
if(diffX * diffX + diffY * diffY + diffZ * diffZ > oimo.common.Setting.contactPersistenceThreshold * oimo.common.Setting.contactPersistenceThreshold) {
this.removeManifoldPoint(index);
continue;
}
}
}
removeManifoldPoint(index) {
let lastIndex = --this._manifold._numPoints;
if(index != lastIndex) {
let tmp = this._manifold._points[index];
this._manifold._points[index] = this._manifold._points[lastIndex];
this._manifold._points[lastIndex] = tmp;
}
let _this = this._manifold._points[lastIndex];
_this._localPos1X = 0;
_this._localPos1Y = 0;
_this._localPos1Z = 0;
_this._localPos2X = 0;
_this._localPos2Y = 0;
_this._localPos2Z = 0;
_this._relPos1X = 0;
_this._relPos1Y = 0;
_this._relPos1Z = 0;
_this._relPos2X = 0;
_this._relPos2Y = 0;
_this._relPos2Z = 0;
_this._pos1X = 0;
_this._pos1Y = 0;
_this._pos1Z = 0;
_this._pos2X = 0;
_this._pos2Y = 0;
_this._pos2Z = 0;
_this._depth = 0;
let _this1 = _this._impulse;
_this1.impulseN = 0;
_this1.impulseT = 0;
_this1.impulseB = 0;
_this1.impulseP = 0;
_this1.impulseLX = 0;
_this1.impulseLY = 0;
_this1.impulseLZ = 0;
_this._warmStarted = false;
_this._disabled = false;
_this._id = -1;
}
addManifoldPoint(point,tf1,tf2) {
let num = this._manifold._numPoints;
if(num == oimo.common.Setting.maxManifoldPoints) {
let targetIndex = this.computeTargetIndex(point,tf1,tf2);
let _this = this._manifold._points[targetIndex];
let v = point.position1;
_this._pos1X = v.x;
_this._pos1Y = v.y;
_this._pos1Z = v.z;
let v1 = point.position2;
_this._pos2X = v1.x;
_this._pos2Y = v1.y;
_this._pos2Z = v1.z;
_this._relPos1X = _this._pos1X - tf1._positionX;
_this._relPos1Y = _this._pos1Y - tf1._positionY;
_this._relPos1Z = _this._pos1Z - tf1._positionZ;
_this._relPos2X = _this._pos2X - tf2._positionX;
_this._relPos2Y = _this._pos2Y - tf2._positionY;
_this._relPos2Z = _this._pos2Z - tf2._positionZ;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = tf1._rotation00 * _this._relPos1X + tf1._rotation10 * _this._relPos1Y + tf1._rotation20 * _this._relPos1Z;
__tmp__Y = tf1._rotation01 * _this._relPos1X + tf1._rotation11 * _this._relPos1Y + tf1._rotation21 * _this._relPos1Z;
__tmp__Z = tf1._rotation02 * _this._relPos1X + tf1._rotation12 * _this._relPos1Y + tf1._rotation22 * _this._relPos1Z;
_this._localPos1X = __tmp__X;
_this._localPos1Y = __tmp__Y;
_this._localPos1Z = __tmp__Z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = tf2._rotation00 * _this._relPos2X + tf2._rotation10 * _this._relPos2Y + tf2._rotation20 * _this._relPos2Z;
__tmp__Y1 = tf2._rotation01 * _this._relPos2X + tf2._rotation11 * _this._relPos2Y + tf2._rotation21 * _this._relPos2Z;
__tmp__Z1 = tf2._rotation02 * _this._relPos2X + tf2._rotation12 * _this._relPos2Y + tf2._rotation22 * _this._relPos2Z;
_this._localPos2X = __tmp__X1;
_this._localPos2Y = __tmp__Y1;
_this._localPos2Z = __tmp__Z1;
_this._depth = point.depth;
let _this1 = _this._impulse;
_this1.impulseN = 0;
_this1.impulseT = 0;
_this1.impulseB = 0;
_this1.impulseP = 0;
_this1.impulseLX = 0;
_this1.impulseLY = 0;
_this1.impulseLZ = 0;
_this._id = point.id;
_this._warmStarted = false;
_this._disabled = false;
return;
}
let _this = this._manifold._points[num];
let v = point.position1;
_this._pos1X = v.x;
_this._pos1Y = v.y;
_this._pos1Z = v.z;
let v1 = point.position2;
_this._pos2X = v1.x;
_this._pos2Y = v1.y;
_this._pos2Z = v1.z;
_this._relPos1X = _this._pos1X - tf1._positionX;
_this._relPos1Y = _this._pos1Y - tf1._positionY;
_this._relPos1Z = _this._pos1Z - tf1._positionZ;
_this._relPos2X = _this._pos2X - tf2._positionX;
_this._relPos2Y = _this._pos2Y - tf2._positionY;
_this._relPos2Z = _this._pos2Z - tf2._positionZ;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = tf1._rotation00 * _this._relPos1X + tf1._rotation10 * _this._relPos1Y + tf1._rotation20 * _this._relPos1Z;
__tmp__Y = tf1._rotation01 * _this._relPos1X + tf1._rotation11 * _this._relPos1Y + tf1._rotation21 * _this._relPos1Z;
__tmp__Z = tf1._rotation02 * _this._relPos1X + tf1._rotation12 * _this._relPos1Y + tf1._rotation22 * _this._relPos1Z;
_this._localPos1X = __tmp__X;
_this._localPos1Y = __tmp__Y;
_this._localPos1Z = __tmp__Z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = tf2._rotation00 * _this._relPos2X + tf2._rotation10 * _this._relPos2Y + tf2._rotation20 * _this._relPos2Z;
__tmp__Y1 = tf2._rotation01 * _this._relPos2X + tf2._rotation11 * _this._relPos2Y + tf2._rotation21 * _this._relPos2Z;
__tmp__Z1 = tf2._rotation02 * _this._relPos2X + tf2._rotation12 * _this._relPos2Y + tf2._rotation22 * _this._relPos2Z;
_this._localPos2X = __tmp__X1;
_this._localPos2Y = __tmp__Y1;
_this._localPos2Z = __tmp__Z1;
_this._depth = point.depth;
let _this1 = _this._impulse;
_this1.impulseN = 0;
_this1.impulseT = 0;
_this1.impulseB = 0;
_this1.impulseP = 0;
_this1.impulseLX = 0;
_this1.impulseLY = 0;
_this1.impulseLZ = 0;
_this._id = point.id;
_this._warmStarted = false;
_this._disabled = false;
this._manifold._numPoints++;
}
computeTargetIndex(newPoint,tf1,tf2) {
let p1 = this._manifold._points[0];
let p2 = this._manifold._points[1];
let p3 = this._manifold._points[2];
let p4 = this._manifold._points[3];
let maxDepth = p1._depth;
let maxDepthIndex = 0;
if(p2._depth > maxDepth) {
maxDepth = p2._depth;
maxDepthIndex = 1;
}
if(p3._depth > maxDepth) {
maxDepth = p3._depth;
maxDepthIndex = 2;
}
if(p4._depth > maxDepth) {
maxDepthIndex = 3;
}
let rp1X;
let rp1Y;
let rp1Z;
let v = newPoint.position1;
rp1X = v.x;
rp1Y = v.y;
rp1Z = v.z;
rp1X -= tf1._positionX;
rp1Y -= tf1._positionY;
rp1Z -= tf1._positionZ;
let p1X = p2._relPos1X;
let p1Y = p2._relPos1Y;
let p1Z = p2._relPos1Z;
let p2X = p3._relPos1X;
let p2Y = p3._relPos1Y;
let p2Z = p3._relPos1Z;
let p3X = p4._relPos1X;
let p3Y = p4._relPos1Y;
let p3Z = p4._relPos1Z;
let v12X;
let v12Y;
let v12Z;
let v34X;
let v34Y;
let v34Z;
let v13X;
let v13Y;
let v13Z;
let v24X;
let v24Y;
let v24Z;
let v14X;
let v14Y;
let v14Z;
let v23X;
let v23Y;
let v23Z;
v12X = p2X - p1X;
v12Y = p2Y - p1Y;
v12Z = p2Z - p1Z;
v34X = rp1X - p3X;
v34Y = rp1Y - p3Y;
v34Z = rp1Z - p3Z;
v13X = p3X - p1X;
v13Y = p3Y - p1Y;
v13Z = p3Z - p1Z;
v24X = rp1X - p2X;
v24Y = rp1Y - p2Y;
v24Z = rp1Z - p2Z;
v14X = rp1X - p1X;
v14Y = rp1Y - p1Y;
v14Z = rp1Z - p1Z;
v23X = p3X - p2X;
v23Y = p3Y - p2Y;
v23Z = p3Z - p2Z;
let cross1X;
let cross1Y;
let cross1Z;
let cross2X;
let cross2Y;
let cross2Z;
let cross3X;
let cross3Y;
let cross3Z;
cross1X = v12Y * v34Z - v12Z * v34Y;
cross1Y = v12Z * v34X - v12X * v34Z;
cross1Z = v12X * v34Y - v12Y * v34X;
cross2X = v13Y * v24Z - v13Z * v24Y;
cross2Y = v13Z * v24X - v13X * v24Z;
cross2Z = v13X * v24Y - v13Y * v24X;
cross3X = v14Y * v23Z - v14Z * v23Y;
cross3Y = v14Z * v23X - v14X * v23Z;
cross3Z = v14X * v23Y - v14Y * v23X;
let a1 = cross1X * cross1X + cross1Y * cross1Y + cross1Z * cross1Z;
let a2 = cross2X * cross2X + cross2Y * cross2Y + cross2Z * cross2Z;
let a3 = cross3X * cross3X + cross3Y * cross3Y + cross3Z * cross3Z;
let p1X1 = p1._relPos1X;
let p1Y1 = p1._relPos1Y;
let p1Z1 = p1._relPos1Z;
let p2X1 = p3._relPos1X;
let p2Y1 = p3._relPos1Y;
let p2Z1 = p3._relPos1Z;
let p3X1 = p4._relPos1X;
let p3Y1 = p4._relPos1Y;
let p3Z1 = p4._relPos1Z;
let v12X1;
let v12Y1;
let v12Z1;
let v34X1;
let v34Y1;
let v34Z1;
let v13X1;
let v13Y1;
let v13Z1;
let v24X1;
let v24Y1;
let v24Z1;
let v14X1;
let v14Y1;
let v14Z1;
let v23X1;
let v23Y1;
let v23Z1;
v12X1 = p2X1 - p1X1;
v12Y1 = p2Y1 - p1Y1;
v12Z1 = p2Z1 - p1Z1;
v34X1 = rp1X - p3X1;
v34Y1 = rp1Y - p3Y1;
v34Z1 = rp1Z - p3Z1;
v13X1 = p3X1 - p1X1;
v13Y1 = p3Y1 - p1Y1;
v13Z1 = p3Z1 - p1Z1;
v24X1 = rp1X - p2X1;
v24Y1 = rp1Y - p2Y1;
v24Z1 = rp1Z - p2Z1;
v14X1 = rp1X - p1X1;
v14Y1 = rp1Y - p1Y1;
v14Z1 = rp1Z - p1Z1;
v23X1 = p3X1 - p2X1;
v23Y1 = p3Y1 - p2Y1;
v23Z1 = p3Z1 - p2Z1;
let cross1X1;
let cross1Y1;
let cross1Z1;
let cross2X1;
let cross2Y1;
let cross2Z1;
let cross3X1;
let cross3Y1;
let cross3Z1;
cross1X1 = v12Y1 * v34Z1 - v12Z1 * v34Y1;
cross1Y1 = v12Z1 * v34X1 - v12X1 * v34Z1;
cross1Z1 = v12X1 * v34Y1 - v12Y1 * v34X1;
cross2X1 = v13Y1 * v24Z1 - v13Z1 * v24Y1;
cross2Y1 = v13Z1 * v24X1 - v13X1 * v24Z1;
cross2Z1 = v13X1 * v24Y1 - v13Y1 * v24X1;
cross3X1 = v14Y1 * v23Z1 - v14Z1 * v23Y1;
cross3Y1 = v14Z1 * v23X1 - v14X1 * v23Z1;
cross3Z1 = v14X1 * v23Y1 - v14Y1 * v23X1;
let a11 = cross1X1 * cross1X1 + cross1Y1 * cross1Y1 + cross1Z1 * cross1Z1;
let a21 = cross2X1 * cross2X1 + cross2Y1 * cross2Y1 + cross2Z1 * cross2Z1;
let a31 = cross3X1 * cross3X1 + cross3Y1 * cross3Y1 + cross3Z1 * cross3Z1;
let a22 = a11 > a21 ? a11 > a31 ? a11 : a31 : a21 > a31 ? a21 : a31;
let p1X2 = p1._relPos1X;
let p1Y2 = p1._relPos1Y;
let p1Z2 = p1._relPos1Z;
let p2X2 = p2._relPos1X;
let p2Y2 = p2._relPos1Y;
let p2Z2 = p2._relPos1Z;
let p3X2 = p4._relPos1X;
let p3Y2 = p4._relPos1Y;
let p3Z2 = p4._relPos1Z;
let v12X2;
let v12Y2;
let v12Z2;
let v34X2;
let v34Y2;
let v34Z2;
let v13X2;
let v13Y2;
let v13Z2;
let v24X2;
let v24Y2;
let v24Z2;
let v14X2;
let v14Y2;
let v14Z2;
let v23X2;
let v23Y2;
let v23Z2;
v12X2 = p2X2 - p1X2;
v12Y2 = p2Y2 - p1Y2;
v12Z2 = p2Z2 - p1Z2;
v34X2 = rp1X - p3X2;
v34Y2 = rp1Y - p3Y2;
v34Z2 = rp1Z - p3Z2;
v13X2 = p3X2 - p1X2;
v13Y2 = p3Y2 - p1Y2;
v13Z2 = p3Z2 - p1Z2;
v24X2 = rp1X - p2X2;
v24Y2 = rp1Y - p2Y2;
v24Z2 = rp1Z - p2Z2;
v14X2 = rp1X - p1X2;
v14Y2 = rp1Y - p1Y2;
v14Z2 = rp1Z - p1Z2;
v23X2 = p3X2 - p2X2;
v23Y2 = p3Y2 - p2Y2;
v23Z2 = p3Z2 - p2Z2;
let cross1X2;
let cross1Y2;
let cross1Z2;
let cross2X2;
let cross2Y2;
let cross2Z2;
let cross3X2;
let cross3Y2;
let cross3Z2;
cross1X2 = v12Y2 * v34Z2 - v12Z2 * v34Y2;
cross1Y2 = v12Z2 * v34X2 - v12X2 * v34Z2;
cross1Z2 = v12X2 * v34Y2 - v12Y2 * v34X2;
cross2X2 = v13Y2 * v24Z2 - v13Z2 * v24Y2;
cross2Y2 = v13Z2 * v24X2 - v13X2 * v24Z2;
cross2Z2 = v13X2 * v24Y2 - v13Y2 * v24X2;
cross3X2 = v14Y2 * v23Z2 - v14Z2 * v23Y2;
cross3Y2 = v14Z2 * v23X2 - v14X2 * v23Z2;
cross3Z2 = v14X2 * v23Y2 - v14Y2 * v23X2;
let a12 = cross1X2 * cross1X2 + cross1Y2 * cross1Y2 + cross1Z2 * cross1Z2;
let a23 = cross2X2 * cross2X2 + cross2Y2 * cross2Y2 + cross2Z2 * cross2Z2;
let a32 = cross3X2 * cross3X2 + cross3Y2 * cross3Y2 + cross3Z2 * cross3Z2;
let a33 = a12 > a23 ? a12 > a32 ? a12 : a32 : a23 > a32 ? a23 : a32;
let p1X3 = p1._relPos1X;
let p1Y3 = p1._relPos1Y;
let p1Z3 = p1._relPos1Z;
let p2X3 = p2._relPos1X;
let p2Y3 = p2._relPos1Y;
let p2Z3 = p2._relPos1Z;
let p3X3 = p3._relPos1X;
let p3Y3 = p3._relPos1Y;
let p3Z3 = p3._relPos1Z;
let v12X3;
let v12Y3;
let v12Z3;
let v34X3;
let v34Y3;
let v34Z3;
let v13X3;
let v13Y3;
let v13Z3;
let v24X3;
let v24Y3;
let v24Z3;
let v14X3;
let v14Y3;
let v14Z3;
let v23X3;
let v23Y3;
let v23Z3;
v12X3 = p2X3 - p1X3;
v12Y3 = p2Y3 - p1Y3;
v12Z3 = p2Z3 - p1Z3;
v34X3 = rp1X - p3X3;
v34Y3 = rp1Y - p3Y3;
v34Z3 = rp1Z - p3Z3;
v13X3 = p3X3 - p1X3;
v13Y3 = p3Y3 - p1Y3;
v13Z3 = p3Z3 - p1Z3;
v24X3 = rp1X - p2X3;
v24Y3 = rp1Y - p2Y3;
v24Z3 = rp1Z - p2Z3;
v14X3 = rp1X - p1X3;
v14Y3 = rp1Y - p1Y3;
v14Z3 = rp1Z - p1Z3;
v23X3 = p3X3 - p2X3;
v23Y3 = p3Y3 - p2Y3;
v23Z3 = p3Z3 - p2Z3;
let cross1X3;
let cross1Y3;
let cross1Z3;
let cross2X3;
let cross2Y3;
let cross2Z3;
let cross3X3;
let cross3Y3;
let cross3Z3;
cross1X3 = v12Y3 * v34Z3 - v12Z3 * v34Y3;
cross1Y3 = v12Z3 * v34X3 - v12X3 * v34Z3;
cross1Z3 = v12X3 * v34Y3 - v12Y3 * v34X3;
cross2X3 = v13Y3 * v24Z3 - v13Z3 * v24Y3;
cross2Y3 = v13Z3 * v24X3 - v13X3 * v24Z3;
cross2Z3 = v13X3 * v24Y3 - v13Y3 * v24X3;
cross3X3 = v14Y3 * v23Z3 - v14Z3 * v23Y3;
cross3Y3 = v14Z3 * v23X3 - v14X3 * v23Z3;
cross3Z3 = v14X3 * v23Y3 - v14Y3 * v23X3;
let a13 = cross1X3 * cross1X3 + cross1Y3 * cross1Y3 + cross1Z3 * cross1Z3;
let a24 = cross2X3 * cross2X3 + cross2Y3 * cross2Y3 + cross2Z3 * cross2Z3;
let a34 = cross3X3 * cross3X3 + cross3Y3 * cross3Y3 + cross3Z3 * cross3Z3;
let a4 = a13 > a24 ? a13 > a34 ? a13 : a34 : a24 > a34 ? a24 : a34;
let max = a1 > a2 ? a1 > a3 ? a1 : a3 : a2 > a3 ? a2 : a3;
let target = 0;
if(a22 > max && maxDepthIndex != 1 || maxDepthIndex == 0) {
max = a22;
target = 1;
}
if(a33 > max && maxDepthIndex != 2) {
max = a33;
target = 2;
}
if(a4 > max && maxDepthIndex != 3) {
target = 3;
}
return target;
}
computeRelativePositions(tf1,tf2) {
let num = this._manifold._numPoints;
let _g = 0;
while(_g < num) {
let p = this._manifold._points[_g++];
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = tf1._rotation00 * p._localPos1X + tf1._rotation01 * p._localPos1Y + tf1._rotation02 * p._localPos1Z;
__tmp__Y = tf1._rotation10 * p._localPos1X + tf1._rotation11 * p._localPos1Y + tf1._rotation12 * p._localPos1Z;
__tmp__Z = tf1._rotation20 * p._localPos1X + tf1._rotation21 * p._localPos1Y + tf1._rotation22 * p._localPos1Z;
p._relPos1X = __tmp__X;
p._relPos1Y = __tmp__Y;
p._relPos1Z = __tmp__Z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = tf2._rotation00 * p._localPos2X + tf2._rotation01 * p._localPos2Y + tf2._rotation02 * p._localPos2Z;
__tmp__Y1 = tf2._rotation10 * p._localPos2X + tf2._rotation11 * p._localPos2Y + tf2._rotation12 * p._localPos2Z;
__tmp__Z1 = tf2._rotation20 * p._localPos2X + tf2._rotation21 * p._localPos2Y + tf2._rotation22 * p._localPos2Z;
p._relPos2X = __tmp__X1;
p._relPos2Y = __tmp__Y1;
p._relPos2Z = __tmp__Z1;
p._warmStarted = true;
}
}
findNearestContactPointIndex(target,tf1,tf2) {
let nearestSq = oimo.common.Setting.contactPersistenceThreshold * oimo.common.Setting.contactPersistenceThreshold;
let idx = -1;
let _g = 0;
let _g1 = this._manifold._numPoints;
while(_g < _g1) {
let i = _g++;
let mp = this._manifold._points[i];
let rp1X;
let rp1Y;
let rp1Z;
let rp2X;
let rp2Y;
let rp2Z;
let v = target.position1;
rp1X = v.x;
rp1Y = v.y;
rp1Z = v.z;
let v1 = target.position2;
rp2X = v1.x;
rp2Y = v1.y;
rp2Z = v1.z;
rp1X -= tf1._positionX;
rp1Y -= tf1._positionY;
rp1Z -= tf1._positionZ;
rp2X -= tf2._positionX;
rp2Y -= tf2._positionY;
rp2Z -= tf2._positionZ;
let diff1X;
let diff1Y;
let diff1Z;
let diff2X;
let diff2Y;
let diff2Z;
diff1X = mp._relPos1X - rp1X;
diff1Y = mp._relPos1Y - rp1Y;
diff1Z = mp._relPos1Z - rp1Z;
diff2X = mp._relPos2X - rp2X;
diff2Y = mp._relPos2Y - rp2Y;
diff2Z = mp._relPos2Z - rp2Z;
let sq1 = diff1X * diff1X + diff1Y * diff1Y + diff1Z * diff1Z;
let sq2 = diff2X * diff2X + diff2Y * diff2Y + diff2Z * diff2Z;
let d = sq1 < sq2 ? sq1 : sq2;
if(d < nearestSq) {
nearestSq = d;
idx = i;
}
}
return idx;
}
totalUpdate(result,tf1,tf2) {
this.numOldPoints = this._manifold._numPoints;
let _g = 0;
let _g1 = this.numOldPoints;
while(_g < _g1) {
let i = _g++;
let _this = this.oldPoints[i];
let cp = this._manifold._points[i];
_this._localPos1X = cp._localPos1X;
_this._localPos1Y = cp._localPos1Y;
_this._localPos1Z = cp._localPos1Z;
_this._localPos2X = cp._localPos2X;
_this._localPos2Y = cp._localPos2Y;
_this._localPos2Z = cp._localPos2Z;
_this._relPos1X = cp._relPos1X;
_this._relPos1Y = cp._relPos1Y;
_this._relPos1Z = cp._relPos1Z;
_this._relPos2X = cp._relPos2X;
_this._relPos2Y = cp._relPos2Y;
_this._relPos2Z = cp._relPos2Z;
_this._pos1X = cp._pos1X;
_this._pos1Y = cp._pos1Y;
_this._pos1Z = cp._pos1Z;
_this._pos2X = cp._pos2X;
_this._pos2Y = cp._pos2Y;
_this._pos2Z = cp._pos2Z;
_this._depth = cp._depth;
_this._impulse.copyFrom(cp._impulse);
_this._id = cp._id;
_this._warmStarted = cp._warmStarted;
_this._disabled = false;
}
let num = result.numPoints;
this._manifold._numPoints = num;
let _g2 = 0;
while(_g2 < num) {
let i = _g2++;
let p = this._manifold._points[i];
let ref = result.points[i];
let v = ref.position1;
p._pos1X = v.x;
p._pos1Y = v.y;
p._pos1Z = v.z;
let v1 = ref.position2;
p._pos2X = v1.x;
p._pos2Y = v1.y;
p._pos2Z = v1.z;
p._relPos1X = p._pos1X - tf1._positionX;
p._relPos1Y = p._pos1Y - tf1._positionY;
p._relPos1Z = p._pos1Z - tf1._positionZ;
p._relPos2X = p._pos2X - tf2._positionX;
p._relPos2Y = p._pos2Y - tf2._positionY;
p._relPos2Z = p._pos2Z - tf2._positionZ;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = tf1._rotation00 * p._relPos1X + tf1._rotation10 * p._relPos1Y + tf1._rotation20 * p._relPos1Z;
__tmp__Y = tf1._rotation01 * p._relPos1X + tf1._rotation11 * p._relPos1Y + tf1._rotation21 * p._relPos1Z;
__tmp__Z = tf1._rotation02 * p._relPos1X + tf1._rotation12 * p._relPos1Y + tf1._rotation22 * p._relPos1Z;
p._localPos1X = __tmp__X;
p._localPos1Y = __tmp__Y;
p._localPos1Z = __tmp__Z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = tf2._rotation00 * p._relPos2X + tf2._rotation10 * p._relPos2Y + tf2._rotation20 * p._relPos2Z;
__tmp__Y1 = tf2._rotation01 * p._relPos2X + tf2._rotation11 * p._relPos2Y + tf2._rotation21 * p._relPos2Z;
__tmp__Z1 = tf2._rotation02 * p._relPos2X + tf2._rotation12 * p._relPos2Y + tf2._rotation22 * p._relPos2Z;
p._localPos2X = __tmp__X1;
p._localPos2Y = __tmp__Y1;
p._localPos2Z = __tmp__Z1;
p._depth = ref.depth;
let _this = p._impulse;
_this.impulseN = 0;
_this.impulseT = 0;
_this.impulseB = 0;
_this.impulseP = 0;
_this.impulseLX = 0;
_this.impulseLY = 0;
_this.impulseLZ = 0;
p._id = ref.id;
p._warmStarted = false;
p._disabled = false;
let _g = 0;
let _g1 = this.numOldPoints;
while(_g < _g1) {
let ocp = this.oldPoints[_g++];
if(p._id == ocp._id) {
p._impulse.copyFrom(ocp._impulse);
p._warmStarted = true;
break;
}
}
}
}
incrementalUpdate(result,tf1,tf2) {
this._manifold._updateDepthsAndPositions(tf1,tf2);
let _g = 0;
let _g1 = this._manifold._numPoints;
while(_g < _g1) this._manifold._points[_g++]._warmStarted = true;
let newPoint = result.points[0];
let index = this.findNearestContactPointIndex(newPoint,tf1,tf2);
if(index == -1) {
this.addManifoldPoint(newPoint,tf1,tf2);
} else {
let cp = this._manifold._points[index];
let v = newPoint.position1;
cp._pos1X = v.x;
cp._pos1Y = v.y;
cp._pos1Z = v.z;
let v1 = newPoint.position2;
cp._pos2X = v1.x;
cp._pos2Y = v1.y;
cp._pos2Z = v1.z;
cp._relPos1X = cp._pos1X - tf1._positionX;
cp._relPos1Y = cp._pos1Y - tf1._positionY;
cp._relPos1Z = cp._pos1Z - tf1._positionZ;
cp._relPos2X = cp._pos2X - tf2._positionX;
cp._relPos2Y = cp._pos2Y - tf2._positionY;
cp._relPos2Z = cp._pos2Z - tf2._positionZ;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = tf1._rotation00 * cp._relPos1X + tf1._rotation10 * cp._relPos1Y + tf1._rotation20 * cp._relPos1Z;
__tmp__Y = tf1._rotation01 * cp._relPos1X + tf1._rotation11 * cp._relPos1Y + tf1._rotation21 * cp._relPos1Z;
__tmp__Z = tf1._rotation02 * cp._relPos1X + tf1._rotation12 * cp._relPos1Y + tf1._rotation22 * cp._relPos1Z;
cp._localPos1X = __tmp__X;
cp._localPos1Y = __tmp__Y;
cp._localPos1Z = __tmp__Z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = tf2._rotation00 * cp._relPos2X + tf2._rotation10 * cp._relPos2Y + tf2._rotation20 * cp._relPos2Z;
__tmp__Y1 = tf2._rotation01 * cp._relPos2X + tf2._rotation11 * cp._relPos2Y + tf2._rotation21 * cp._relPos2Z;
__tmp__Z1 = tf2._rotation02 * cp._relPos2X + tf2._rotation12 * cp._relPos2Y + tf2._rotation22 * cp._relPos2Z;
cp._localPos2X = __tmp__X1;
cp._localPos2Y = __tmp__Y1;
cp._localPos2Z = __tmp__Z1;
cp._depth = newPoint.depth;
}
this.removeOutdatedPoints();
}
}
if(!oimo.dynamics.constraint.info) oimo.dynamics.constraint.info = {};
oimo.dynamics.constraint.info.JacobianRow = class oimo_dynamics_constraint_info_JacobianRow {
constructor() {
this.lin1X = 0;
this.lin1Y = 0;
this.lin1Z = 0;
this.lin2X = 0;
this.lin2Y = 0;
this.lin2Z = 0;
this.ang1X = 0;
this.ang1Y = 0;
this.ang1Z = 0;
this.ang2X = 0;
this.ang2Y = 0;
this.ang2Z = 0;
this.flag = 0;
}
updateSparsity() {
this.flag = 0;
if(!(this.lin1X == 0 && this.lin1Y == 0 && this.lin1Z == 0) || !(this.lin2X == 0 && this.lin2Y == 0 && this.lin2Z == 0)) {
this.flag |= 1;
}
if(!(this.ang1X == 0 && this.ang1Y == 0 && this.ang1Z == 0) || !(this.ang2X == 0 && this.ang2Y == 0 && this.ang2Z == 0)) {
this.flag |= 2;
}
}
}
if(!oimo.dynamics.constraint.info.contact) oimo.dynamics.constraint.info.contact = {};
oimo.dynamics.constraint.info.contact.ContactSolverInfo = class oimo_dynamics_constraint_info_contact_ContactSolverInfo {
constructor() {
this.b1 = null;
this.b2 = null;
this.numRows = 0;
this.rows = new Array(oimo.common.Setting.maxManifoldPoints);
let _g = 0;
let _g1 = this.rows.length;
while(_g < _g1) this.rows[_g++] = new oimo.dynamics.constraint.info.contact.ContactSolverInfoRow();
}
}
oimo.dynamics.constraint.info.contact.ContactSolverInfoRow = class oimo_dynamics_constraint_info_contact_ContactSolverInfoRow {
constructor() {
this.jacobianN = new oimo.dynamics.constraint.info.JacobianRow();
this.jacobianT = new oimo.dynamics.constraint.info.JacobianRow();
this.jacobianB = new oimo.dynamics.constraint.info.JacobianRow();
this.rhs = 0;
this.cfm = 0;
this.friction = 0;
this.impulse = null;
}
}
if(!oimo.dynamics.constraint.info.joint) oimo.dynamics.constraint.info.joint = {};
oimo.dynamics.constraint.info.joint.JointSolverInfo = class oimo_dynamics_constraint_info_joint_JointSolverInfo {
constructor() {
this.b1 = null;
this.b2 = null;
this.numRows = 0;
this.rows = new Array(oimo.common.Setting.maxJacobianRows);
let _g = 0;
let _g1 = this.rows.length;
while(_g < _g1) this.rows[_g++] = new oimo.dynamics.constraint.info.joint.JointSolverInfoRow();
}
}
oimo.dynamics.constraint.info.joint.JointSolverInfoRow = class oimo_dynamics_constraint_info_joint_JointSolverInfoRow {
constructor() {
this.jacobian = new oimo.dynamics.constraint.info.JacobianRow();
this.rhs = 0;
this.cfm = 0;
this.minImpulse = 0;
this.maxImpulse = 0;
this.motorSpeed = 0;
this.motorMaxImpulse = 0;
this.impulse = null;
}
}
if(!oimo.dynamics.constraint.joint) oimo.dynamics.constraint.joint = {};
oimo.dynamics.constraint.joint.BasisTracker = class oimo_dynamics_constraint_joint_BasisTracker {
constructor(joint) {
this.joint = joint;
this.xX = 0;
this.xY = 0;
this.xZ = 0;
this.yX = 0;
this.yY = 0;
this.yZ = 0;
this.zX = 0;
this.zY = 0;
this.zZ = 0;
}
}
oimo.dynamics.constraint.joint.Joint = class oimo_dynamics_constraint_joint_Joint {
constructor(config,type) {
this._link1 = new oimo.dynamics.constraint.joint.JointLink(this);
this._link2 = new oimo.dynamics.constraint.joint.JointLink(this);
this._positionCorrectionAlgorithm = oimo.common.Setting.defaultJointPositionCorrectionAlgorithm;
this._type = type;
this._world = null;
this._b1 = config.rigidBody1;
this._b2 = config.rigidBody2;
this._allowCollision = config.allowCollision;
this._breakForce = config.breakForce;
this._breakTorque = config.breakTorque;
switch(config.solverType) {
case 0:
this._solver = new oimo.dynamics.constraint.solver.pgs.PgsJointConstraintSolver(this);
break;
case 1:
this._solver = new oimo.dynamics.constraint.solver.direct.DirectJointConstraintSolver(this);
break;
}
let v = config.localAnchor1;
this._localAnchor1X = v.x;
this._localAnchor1Y = v.y;
this._localAnchor1Z = v.z;
let v1 = config.localAnchor2;
this._localAnchor2X = v1.x;
this._localAnchor2Y = v1.y;
this._localAnchor2Z = v1.z;
this._relativeAnchor1X = 0;
this._relativeAnchor1Y = 0;
this._relativeAnchor1Z = 0;
this._relativeAnchor2X = 0;
this._relativeAnchor2Y = 0;
this._relativeAnchor2Z = 0;
this._anchor1X = 0;
this._anchor1Y = 0;
this._anchor1Z = 0;
this._anchor2X = 0;
this._anchor2Y = 0;
this._anchor2Z = 0;
this._localBasisX1X = 0;
this._localBasisX1Y = 0;
this._localBasisX1Z = 0;
this._localBasisY1X = 0;
this._localBasisY1Y = 0;
this._localBasisY1Z = 0;
this._localBasisZ1X = 0;
this._localBasisZ1Y = 0;
this._localBasisZ1Z = 0;
this._localBasisX2X = 0;
this._localBasisX2Y = 0;
this._localBasisX2Z = 0;
this._localBasisY2X = 0;
this._localBasisY2Y = 0;
this._localBasisY2Z = 0;
this._localBasisZ2X = 0;
this._localBasisZ2Y = 0;
this._localBasisZ2Z = 0;
this._impulses = new Array(oimo.common.Setting.maxJacobianRows);
let _g = 0;
let _g1 = oimo.common.Setting.maxJacobianRows;
while(_g < _g1) this._impulses[_g++] = new oimo.dynamics.constraint.joint.JointImpulse();
}
buildLocalBasesFromX() {
if(this._localBasisX1X * this._localBasisX1X + this._localBasisX1Y * this._localBasisX1Y + this._localBasisX1Z * this._localBasisX1Z == 0) {
this._localBasisX1X = 1;
this._localBasisX1Y = 0;
this._localBasisX1Z = 0;
} else {
let l = this._localBasisX1X * this._localBasisX1X + this._localBasisX1Y * this._localBasisX1Y + this._localBasisX1Z * this._localBasisX1Z;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
this._localBasisX1X *= l;
this._localBasisX1Y *= l;
this._localBasisX1Z *= l;
}
if(this._localBasisX2X * this._localBasisX2X + this._localBasisX2Y * this._localBasisX2Y + this._localBasisX2Z * this._localBasisX2Z == 0) {
this._localBasisX2X = 1;
this._localBasisX2Y = 0;
this._localBasisX2Z = 0;
} else {
let l = this._localBasisX2X * this._localBasisX2X + this._localBasisX2Y * this._localBasisX2Y + this._localBasisX2Z * this._localBasisX2Z;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
this._localBasisX2X *= l;
this._localBasisX2Y *= l;
this._localBasisX2Z *= l;
}
let slerpQX;
let slerpQY;
let slerpQZ;
let slerpQW;
let slerpM00;
let slerpM01;
let slerpM02;
let slerpM10;
let slerpM11;
let slerpM12;
let slerpM20;
let slerpM21;
let slerpM22;
let d = this._localBasisX1X * this._localBasisX2X + this._localBasisX1Y * this._localBasisX2Y + this._localBasisX1Z * this._localBasisX2Z;
if(d < -0.999999999) {
let vX;
let vY;
let vZ;
let x1 = this._localBasisX1X;
let y1 = this._localBasisX1Y;
let z1 = this._localBasisX1Z;
let x2 = x1 * x1;
let y2 = y1 * y1;
let z2 = z1 * z1;
let d;
if(x2 < y2) {
if(x2 < z2) {
d = 1 / Math.sqrt(y2 + z2);
vX = 0;
vY = z1 * d;
vZ = -y1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
vX = y1 * d;
vY = -x1 * d;
vZ = 0;
}
} else if(y2 < z2) {
d = 1 / Math.sqrt(z2 + x2);
vX = -z1 * d;
vY = 0;
vZ = x1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
vX = y1 * d;
vY = -x1 * d;
vZ = 0;
}
slerpQX = vX;
slerpQY = vY;
slerpQZ = vZ;
slerpQW = 0;
} else {
let cX;
let cY;
let cZ;
cX = this._localBasisX1Y * this._localBasisX2Z - this._localBasisX1Z * this._localBasisX2Y;
cY = this._localBasisX1Z * this._localBasisX2X - this._localBasisX1X * this._localBasisX2Z;
cZ = this._localBasisX1X * this._localBasisX2Y - this._localBasisX1Y * this._localBasisX2X;
let w = Math.sqrt((1 + d) * 0.5);
d = 0.5 / w;
cX *= d;
cY *= d;
cZ *= d;
slerpQX = cX;
slerpQY = cY;
slerpQZ = cZ;
slerpQW = w;
}
let x = slerpQX;
let y = slerpQY;
let z = slerpQZ;
let w = slerpQW;
let x2 = 2 * x;
let y2 = 2 * y;
let z2 = 2 * z;
let xx = x * x2;
let yy = y * y2;
let zz = z * z2;
let xy = x * y2;
let yz = y * z2;
let xz = x * z2;
let wx = w * x2;
let wy = w * y2;
let wz = w * z2;
slerpM00 = 1 - yy - zz;
slerpM01 = xy - wz;
slerpM02 = xz + wy;
slerpM10 = xy + wz;
slerpM11 = 1 - xx - zz;
slerpM12 = yz - wx;
slerpM20 = xz - wy;
slerpM21 = yz + wx;
slerpM22 = 1 - xx - yy;
let x1 = this._localBasisX1X;
let y1 = this._localBasisX1Y;
let z1 = this._localBasisX1Z;
let x21 = x1 * x1;
let y21 = y1 * y1;
let z21 = z1 * z1;
let d1;
if(x21 < y21) {
if(x21 < z21) {
d1 = 1 / Math.sqrt(y21 + z21);
this._localBasisY1X = 0;
this._localBasisY1Y = z1 * d1;
this._localBasisY1Z = -y1 * d1;
} else {
d1 = 1 / Math.sqrt(x21 + y21);
this._localBasisY1X = y1 * d1;
this._localBasisY1Y = -x1 * d1;
this._localBasisY1Z = 0;
}
} else if(y21 < z21) {
d1 = 1 / Math.sqrt(z21 + x21);
this._localBasisY1X = -z1 * d1;
this._localBasisY1Y = 0;
this._localBasisY1Z = x1 * d1;
} else {
d1 = 1 / Math.sqrt(x21 + y21);
this._localBasisY1X = y1 * d1;
this._localBasisY1Y = -x1 * d1;
this._localBasisY1Z = 0;
}
this._localBasisZ1X = this._localBasisX1Y * this._localBasisY1Z - this._localBasisX1Z * this._localBasisY1Y;
this._localBasisZ1Y = this._localBasisX1Z * this._localBasisY1X - this._localBasisX1X * this._localBasisY1Z;
this._localBasisZ1Z = this._localBasisX1X * this._localBasisY1Y - this._localBasisX1Y * this._localBasisY1X;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = slerpM00 * this._localBasisX1X + slerpM01 * this._localBasisX1Y + slerpM02 * this._localBasisX1Z;
__tmp__Y = slerpM10 * this._localBasisX1X + slerpM11 * this._localBasisX1Y + slerpM12 * this._localBasisX1Z;
__tmp__Z = slerpM20 * this._localBasisX1X + slerpM21 * this._localBasisX1Y + slerpM22 * this._localBasisX1Z;
this._localBasisX2X = __tmp__X;
this._localBasisX2Y = __tmp__Y;
this._localBasisX2Z = __tmp__Z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = slerpM00 * this._localBasisY1X + slerpM01 * this._localBasisY1Y + slerpM02 * this._localBasisY1Z;
__tmp__Y1 = slerpM10 * this._localBasisY1X + slerpM11 * this._localBasisY1Y + slerpM12 * this._localBasisY1Z;
__tmp__Z1 = slerpM20 * this._localBasisY1X + slerpM21 * this._localBasisY1Y + slerpM22 * this._localBasisY1Z;
this._localBasisY2X = __tmp__X1;
this._localBasisY2Y = __tmp__Y1;
this._localBasisY2Z = __tmp__Z1;
let __tmp__X2;
let __tmp__Y2;
let __tmp__Z2;
__tmp__X2 = slerpM00 * this._localBasisZ1X + slerpM01 * this._localBasisZ1Y + slerpM02 * this._localBasisZ1Z;
__tmp__Y2 = slerpM10 * this._localBasisZ1X + slerpM11 * this._localBasisZ1Y + slerpM12 * this._localBasisZ1Z;
__tmp__Z2 = slerpM20 * this._localBasisZ1X + slerpM21 * this._localBasisZ1Y + slerpM22 * this._localBasisZ1Z;
this._localBasisZ2X = __tmp__X2;
this._localBasisZ2Y = __tmp__Y2;
this._localBasisZ2Z = __tmp__Z2;
}
buildLocalBasesFromXY() {
if(this._localBasisX1X * this._localBasisX1X + this._localBasisX1Y * this._localBasisX1Y + this._localBasisX1Z * this._localBasisX1Z == 0) {
this._localBasisX1X = 1;
this._localBasisX1Y = 0;
this._localBasisX1Z = 0;
} else {
let l = this._localBasisX1X * this._localBasisX1X + this._localBasisX1Y * this._localBasisX1Y + this._localBasisX1Z * this._localBasisX1Z;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
this._localBasisX1X *= l;
this._localBasisX1Y *= l;
this._localBasisX1Z *= l;
}
if(this._localBasisX2X * this._localBasisX2X + this._localBasisX2Y * this._localBasisX2Y + this._localBasisX2Z * this._localBasisX2Z == 0) {
this._localBasisX2X = 1;
this._localBasisX2Y = 0;
this._localBasisX2Z = 0;
} else {
let l = this._localBasisX2X * this._localBasisX2X + this._localBasisX2Y * this._localBasisX2Y + this._localBasisX2Z * this._localBasisX2Z;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
this._localBasisX2X *= l;
this._localBasisX2Y *= l;
this._localBasisX2Z *= l;
}
this._localBasisZ1X = this._localBasisX1Y * this._localBasisY1Z - this._localBasisX1Z * this._localBasisY1Y;
this._localBasisZ1Y = this._localBasisX1Z * this._localBasisY1X - this._localBasisX1X * this._localBasisY1Z;
this._localBasisZ1Z = this._localBasisX1X * this._localBasisY1Y - this._localBasisX1Y * this._localBasisY1X;
this._localBasisZ2X = this._localBasisX2Y * this._localBasisY2Z - this._localBasisX2Z * this._localBasisY2Y;
this._localBasisZ2Y = this._localBasisX2Z * this._localBasisY2X - this._localBasisX2X * this._localBasisY2Z;
this._localBasisZ2Z = this._localBasisX2X * this._localBasisY2Y - this._localBasisX2Y * this._localBasisY2X;
if(this._localBasisZ1X * this._localBasisZ1X + this._localBasisZ1Y * this._localBasisZ1Y + this._localBasisZ1Z * this._localBasisZ1Z == 0) {
let x1 = this._localBasisX1X;
let y1 = this._localBasisX1Y;
let z1 = this._localBasisX1Z;
let x2 = x1 * x1;
let y2 = y1 * y1;
let z2 = z1 * z1;
let d;
if(x2 < y2) {
if(x2 < z2) {
d = 1 / Math.sqrt(y2 + z2);
this._localBasisY1X = 0;
this._localBasisY1Y = z1 * d;
this._localBasisY1Z = -y1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
this._localBasisY1X = y1 * d;
this._localBasisY1Y = -x1 * d;
this._localBasisY1Z = 0;
}
} else if(y2 < z2) {
d = 1 / Math.sqrt(z2 + x2);
this._localBasisY1X = -z1 * d;
this._localBasisY1Y = 0;
this._localBasisY1Z = x1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
this._localBasisY1X = y1 * d;
this._localBasisY1Y = -x1 * d;
this._localBasisY1Z = 0;
}
this._localBasisZ1X = this._localBasisX1Y * this._localBasisY1Z - this._localBasisX1Z * this._localBasisY1Y;
this._localBasisZ1Y = this._localBasisX1Z * this._localBasisY1X - this._localBasisX1X * this._localBasisY1Z;
this._localBasisZ1Z = this._localBasisX1X * this._localBasisY1Y - this._localBasisX1Y * this._localBasisY1X;
} else {
let l = this._localBasisZ1X * this._localBasisZ1X + this._localBasisZ1Y * this._localBasisZ1Y + this._localBasisZ1Z * this._localBasisZ1Z;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
this._localBasisZ1X *= l;
this._localBasisZ1Y *= l;
this._localBasisZ1Z *= l;
this._localBasisY1X = this._localBasisZ1Y * this._localBasisX1Z - this._localBasisZ1Z * this._localBasisX1Y;
this._localBasisY1Y = this._localBasisZ1Z * this._localBasisX1X - this._localBasisZ1X * this._localBasisX1Z;
this._localBasisY1Z = this._localBasisZ1X * this._localBasisX1Y - this._localBasisZ1Y * this._localBasisX1X;
}
if(this._localBasisZ2X * this._localBasisZ2X + this._localBasisZ2Y * this._localBasisZ2Y + this._localBasisZ2Z * this._localBasisZ2Z == 0) {
let x1 = this._localBasisX2X;
let y1 = this._localBasisX2Y;
let z1 = this._localBasisX2Z;
let x2 = x1 * x1;
let y2 = y1 * y1;
let z2 = z1 * z1;
let d;
if(x2 < y2) {
if(x2 < z2) {
d = 1 / Math.sqrt(y2 + z2);
this._localBasisY2X = 0;
this._localBasisY2Y = z1 * d;
this._localBasisY2Z = -y1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
this._localBasisY2X = y1 * d;
this._localBasisY2Y = -x1 * d;
this._localBasisY2Z = 0;
}
} else if(y2 < z2) {
d = 1 / Math.sqrt(z2 + x2);
this._localBasisY2X = -z1 * d;
this._localBasisY2Y = 0;
this._localBasisY2Z = x1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
this._localBasisY2X = y1 * d;
this._localBasisY2Y = -x1 * d;
this._localBasisY2Z = 0;
}
this._localBasisZ2X = this._localBasisX2Y * this._localBasisY2Z - this._localBasisX2Z * this._localBasisY2Y;
this._localBasisZ2Y = this._localBasisX2Z * this._localBasisY2X - this._localBasisX2X * this._localBasisY2Z;
this._localBasisZ2Z = this._localBasisX2X * this._localBasisY2Y - this._localBasisX2Y * this._localBasisY2X;
} else {
let l = this._localBasisZ2X * this._localBasisZ2X + this._localBasisZ2Y * this._localBasisZ2Y + this._localBasisZ2Z * this._localBasisZ2Z;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
this._localBasisZ2X *= l;
this._localBasisZ2Y *= l;
this._localBasisZ2Z *= l;
this._localBasisY2X = this._localBasisZ2Y * this._localBasisX2Z - this._localBasisZ2Z * this._localBasisX2Y;
this._localBasisY2Y = this._localBasisZ2Z * this._localBasisX2X - this._localBasisZ2X * this._localBasisX2Z;
this._localBasisY2Z = this._localBasisZ2X * this._localBasisX2Y - this._localBasisZ2Y * this._localBasisX2X;
}
}
buildLocalBasesFromX1Z2() {
if(this._localBasisX1X * this._localBasisX1X + this._localBasisX1Y * this._localBasisX1Y + this._localBasisX1Z * this._localBasisX1Z == 0) {
this._localBasisX1X = 1;
this._localBasisX1Y = 0;
this._localBasisX1Z = 0;
} else {
let l = this._localBasisX1X * this._localBasisX1X + this._localBasisX1Y * this._localBasisX1Y + this._localBasisX1Z * this._localBasisX1Z;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
this._localBasisX1X *= l;
this._localBasisX1Y *= l;
this._localBasisX1Z *= l;
}
if(this._localBasisZ2X * this._localBasisZ2X + this._localBasisZ2Y * this._localBasisZ2Y + this._localBasisZ2Z * this._localBasisZ2Z == 0) {
this._localBasisZ2X = 0;
this._localBasisZ2Y = 0;
this._localBasisZ2Z = 1;
} else {
let l = this._localBasisZ2X * this._localBasisZ2X + this._localBasisZ2Y * this._localBasisZ2Y + this._localBasisZ2Z * this._localBasisZ2Z;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
this._localBasisZ2X *= l;
this._localBasisZ2Y *= l;
this._localBasisZ2Z *= l;
}
let tf1 = this._b1._transform;
let tf2 = this._b2._transform;
let worldX1X;
let worldX1Y;
let worldX1Z;
let worldZ1X;
let worldZ1Y;
let worldZ1Z;
let worldYX;
let worldYY;
let worldYZ;
let worldX2X;
let worldX2Y;
let worldX2Z;
let worldZ2X;
let worldZ2Y;
let worldZ2Z;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = tf1._rotation00 * this._localBasisX1X + tf1._rotation01 * this._localBasisX1Y + tf1._rotation02 * this._localBasisX1Z;
__tmp__Y = tf1._rotation10 * this._localBasisX1X + tf1._rotation11 * this._localBasisX1Y + tf1._rotation12 * this._localBasisX1Z;
__tmp__Z = tf1._rotation20 * this._localBasisX1X + tf1._rotation21 * this._localBasisX1Y + tf1._rotation22 * this._localBasisX1Z;
worldX1X = __tmp__X;
worldX1Y = __tmp__Y;
worldX1Z = __tmp__Z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = tf2._rotation00 * this._localBasisZ2X + tf2._rotation01 * this._localBasisZ2Y + tf2._rotation02 * this._localBasisZ2Z;
__tmp__Y1 = tf2._rotation10 * this._localBasisZ2X + tf2._rotation11 * this._localBasisZ2Y + tf2._rotation12 * this._localBasisZ2Z;
__tmp__Z1 = tf2._rotation20 * this._localBasisZ2X + tf2._rotation21 * this._localBasisZ2Y + tf2._rotation22 * this._localBasisZ2Z;
worldZ2X = __tmp__X1;
worldZ2Y = __tmp__Y1;
worldZ2Z = __tmp__Z1;
worldYX = worldZ2Y * worldX1Z - worldZ2Z * worldX1Y;
worldYY = worldZ2Z * worldX1X - worldZ2X * worldX1Z;
worldYZ = worldZ2X * worldX1Y - worldZ2Y * worldX1X;
if(worldYX * worldYX + worldYY * worldYY + worldYZ * worldYZ == 0) {
let x1 = worldX1X;
let y1 = worldX1Y;
let z1 = worldX1Z;
let x2 = x1 * x1;
let y2 = y1 * y1;
let z2 = z1 * z1;
let d;
if(x2 < y2) {
if(x2 < z2) {
d = 1 / Math.sqrt(y2 + z2);
worldYX = 0;
worldYY = z1 * d;
worldYZ = -y1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
worldYX = y1 * d;
worldYY = -x1 * d;
worldYZ = 0;
}
} else if(y2 < z2) {
d = 1 / Math.sqrt(z2 + x2);
worldYX = -z1 * d;
worldYY = 0;
worldYZ = x1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
worldYX = y1 * d;
worldYY = -x1 * d;
worldYZ = 0;
}
}
worldZ1X = worldX1Y * worldYZ - worldX1Z * worldYY;
worldZ1Y = worldX1Z * worldYX - worldX1X * worldYZ;
worldZ1Z = worldX1X * worldYY - worldX1Y * worldYX;
worldX2X = worldYY * worldZ2Z - worldYZ * worldZ2Y;
worldX2Y = worldYZ * worldZ2X - worldYX * worldZ2Z;
worldX2Z = worldYX * worldZ2Y - worldYY * worldZ2X;
let __tmp__X2;
let __tmp__Y2;
let __tmp__Z2;
__tmp__X2 = tf1._rotation00 * worldX1X + tf1._rotation10 * worldX1Y + tf1._rotation20 * worldX1Z;
__tmp__Y2 = tf1._rotation01 * worldX1X + tf1._rotation11 * worldX1Y + tf1._rotation21 * worldX1Z;
__tmp__Z2 = tf1._rotation02 * worldX1X + tf1._rotation12 * worldX1Y + tf1._rotation22 * worldX1Z;
this._localBasisX1X = __tmp__X2;
this._localBasisX1Y = __tmp__Y2;
this._localBasisX1Z = __tmp__Z2;
let __tmp__X3;
let __tmp__Y3;
let __tmp__Z3;
__tmp__X3 = tf1._rotation00 * worldYX + tf1._rotation10 * worldYY + tf1._rotation20 * worldYZ;
__tmp__Y3 = tf1._rotation01 * worldYX + tf1._rotation11 * worldYY + tf1._rotation21 * worldYZ;
__tmp__Z3 = tf1._rotation02 * worldYX + tf1._rotation12 * worldYY + tf1._rotation22 * worldYZ;
this._localBasisY1X = __tmp__X3;
this._localBasisY1Y = __tmp__Y3;
this._localBasisY1Z = __tmp__Z3;
let __tmp__X4;
let __tmp__Y4;
let __tmp__Z4;
__tmp__X4 = tf1._rotation00 * worldZ1X + tf1._rotation10 * worldZ1Y + tf1._rotation20 * worldZ1Z;
__tmp__Y4 = tf1._rotation01 * worldZ1X + tf1._rotation11 * worldZ1Y + tf1._rotation21 * worldZ1Z;
__tmp__Z4 = tf1._rotation02 * worldZ1X + tf1._rotation12 * worldZ1Y + tf1._rotation22 * worldZ1Z;
this._localBasisZ1X = __tmp__X4;
this._localBasisZ1Y = __tmp__Y4;
this._localBasisZ1Z = __tmp__Z4;
let __tmp__X5;
let __tmp__Y5;
let __tmp__Z5;
__tmp__X5 = tf2._rotation00 * worldX2X + tf2._rotation10 * worldX2Y + tf2._rotation20 * worldX2Z;
__tmp__Y5 = tf2._rotation01 * worldX2X + tf2._rotation11 * worldX2Y + tf2._rotation21 * worldX2Z;
__tmp__Z5 = tf2._rotation02 * worldX2X + tf2._rotation12 * worldX2Y + tf2._rotation22 * worldX2Z;
this._localBasisX2X = __tmp__X5;
this._localBasisX2Y = __tmp__Y5;
this._localBasisX2Z = __tmp__Z5;
let __tmp__X6;
let __tmp__Y6;
let __tmp__Z6;
__tmp__X6 = tf2._rotation00 * worldYX + tf2._rotation10 * worldYY + tf2._rotation20 * worldYZ;
__tmp__Y6 = tf2._rotation01 * worldYX + tf2._rotation11 * worldYY + tf2._rotation21 * worldYZ;
__tmp__Z6 = tf2._rotation02 * worldYX + tf2._rotation12 * worldYY + tf2._rotation22 * worldYZ;
this._localBasisY2X = __tmp__X6;
this._localBasisY2Y = __tmp__Y6;
this._localBasisY2Z = __tmp__Z6;
let __tmp__X7;
let __tmp__Y7;
let __tmp__Z7;
__tmp__X7 = tf2._rotation00 * worldZ2X + tf2._rotation10 * worldZ2Y + tf2._rotation20 * worldZ2Z;
__tmp__Y7 = tf2._rotation01 * worldZ2X + tf2._rotation11 * worldZ2Y + tf2._rotation21 * worldZ2Z;
__tmp__Z7 = tf2._rotation02 * worldZ2X + tf2._rotation12 * worldZ2Y + tf2._rotation22 * worldZ2Z;
this._localBasisZ2X = __tmp__X7;
this._localBasisZ2Y = __tmp__Y7;
this._localBasisZ2Z = __tmp__Z7;
}
buildLocalBasesFromXY1X2() {
if(this._localBasisX1X * this._localBasisX1X + this._localBasisX1Y * this._localBasisX1Y + this._localBasisX1Z * this._localBasisX1Z == 0) {
this._localBasisX1X = 1;
this._localBasisX1Y = 0;
this._localBasisX1Z = 0;
} else {
let l = this._localBasisX1X * this._localBasisX1X + this._localBasisX1Y * this._localBasisX1Y + this._localBasisX1Z * this._localBasisX1Z;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
this._localBasisX1X *= l;
this._localBasisX1Y *= l;
this._localBasisX1Z *= l;
}
this._localBasisZ1X = this._localBasisX1Y * this._localBasisY1Z - this._localBasisX1Z * this._localBasisY1Y;
this._localBasisZ1Y = this._localBasisX1Z * this._localBasisY1X - this._localBasisX1X * this._localBasisY1Z;
this._localBasisZ1Z = this._localBasisX1X * this._localBasisY1Y - this._localBasisX1Y * this._localBasisY1X;
if(this._localBasisZ1X * this._localBasisZ1X + this._localBasisZ1Y * this._localBasisZ1Y + this._localBasisZ1Z * this._localBasisZ1Z == 0) {
let x1 = this._localBasisX1X;
let y1 = this._localBasisX1Y;
let z1 = this._localBasisX1Z;
let x2 = x1 * x1;
let y2 = y1 * y1;
let z2 = z1 * z1;
let d;
if(x2 < y2) {
if(x2 < z2) {
d = 1 / Math.sqrt(y2 + z2);
this._localBasisY1X = 0;
this._localBasisY1Y = z1 * d;
this._localBasisY1Z = -y1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
this._localBasisY1X = y1 * d;
this._localBasisY1Y = -x1 * d;
this._localBasisY1Z = 0;
}
} else if(y2 < z2) {
d = 1 / Math.sqrt(z2 + x2);
this._localBasisY1X = -z1 * d;
this._localBasisY1Y = 0;
this._localBasisY1Z = x1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
this._localBasisY1X = y1 * d;
this._localBasisY1Y = -x1 * d;
this._localBasisY1Z = 0;
}
this._localBasisZ1X = this._localBasisX1Y * this._localBasisY1Z - this._localBasisX1Z * this._localBasisY1Y;
this._localBasisZ1Y = this._localBasisX1Z * this._localBasisY1X - this._localBasisX1X * this._localBasisY1Z;
this._localBasisZ1Z = this._localBasisX1X * this._localBasisY1Y - this._localBasisX1Y * this._localBasisY1X;
} else {
let l = this._localBasisZ1X * this._localBasisZ1X + this._localBasisZ1Y * this._localBasisZ1Y + this._localBasisZ1Z * this._localBasisZ1Z;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
this._localBasisZ1X *= l;
this._localBasisZ1Y *= l;
this._localBasisZ1Z *= l;
this._localBasisY1X = this._localBasisZ1Y * this._localBasisX1Z - this._localBasisZ1Z * this._localBasisX1Y;
this._localBasisY1Y = this._localBasisZ1Z * this._localBasisX1X - this._localBasisZ1X * this._localBasisX1Z;
this._localBasisY1Z = this._localBasisZ1X * this._localBasisX1Y - this._localBasisZ1Y * this._localBasisX1X;
}
let slerpQX;
let slerpQY;
let slerpQZ;
let slerpQW;
let slerpM00;
let slerpM01;
let slerpM02;
let slerpM10;
let slerpM11;
let slerpM12;
let slerpM20;
let slerpM21;
let slerpM22;
let d = this._localBasisX1X * this._localBasisX2X + this._localBasisX1Y * this._localBasisX2Y + this._localBasisX1Z * this._localBasisX2Z;
if(d < -0.999999999) {
let vX;
let vY;
let vZ;
let x1 = this._localBasisX1X;
let y1 = this._localBasisX1Y;
let z1 = this._localBasisX1Z;
let x2 = x1 * x1;
let y2 = y1 * y1;
let z2 = z1 * z1;
let d;
if(x2 < y2) {
if(x2 < z2) {
d = 1 / Math.sqrt(y2 + z2);
vX = 0;
vY = z1 * d;
vZ = -y1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
vX = y1 * d;
vY = -x1 * d;
vZ = 0;
}
} else if(y2 < z2) {
d = 1 / Math.sqrt(z2 + x2);
vX = -z1 * d;
vY = 0;
vZ = x1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
vX = y1 * d;
vY = -x1 * d;
vZ = 0;
}
slerpQX = vX;
slerpQY = vY;
slerpQZ = vZ;
slerpQW = 0;
} else {
let cX;
let cY;
let cZ;
cX = this._localBasisX1Y * this._localBasisX2Z - this._localBasisX1Z * this._localBasisX2Y;
cY = this._localBasisX1Z * this._localBasisX2X - this._localBasisX1X * this._localBasisX2Z;
cZ = this._localBasisX1X * this._localBasisX2Y - this._localBasisX1Y * this._localBasisX2X;
let w = Math.sqrt((1 + d) * 0.5);
d = 0.5 / w;
cX *= d;
cY *= d;
cZ *= d;
slerpQX = cX;
slerpQY = cY;
slerpQZ = cZ;
slerpQW = w;
}
let x = slerpQX;
let y = slerpQY;
let z = slerpQZ;
let w = slerpQW;
let x2 = 2 * x;
let y2 = 2 * y;
let z2 = 2 * z;
let xx = x * x2;
let yy = y * y2;
let zz = z * z2;
let xy = x * y2;
let yz = y * z2;
let xz = x * z2;
let wx = w * x2;
let wy = w * y2;
let wz = w * z2;
slerpM00 = 1 - yy - zz;
slerpM01 = xy - wz;
slerpM02 = xz + wy;
slerpM10 = xy + wz;
slerpM11 = 1 - xx - zz;
slerpM12 = yz - wx;
slerpM20 = xz - wy;
slerpM21 = yz + wx;
slerpM22 = 1 - xx - yy;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = slerpM00 * this._localBasisX1X + slerpM01 * this._localBasisX1Y + slerpM02 * this._localBasisX1Z;
__tmp__Y = slerpM10 * this._localBasisX1X + slerpM11 * this._localBasisX1Y + slerpM12 * this._localBasisX1Z;
__tmp__Z = slerpM20 * this._localBasisX1X + slerpM21 * this._localBasisX1Y + slerpM22 * this._localBasisX1Z;
this._localBasisX2X = __tmp__X;
this._localBasisX2Y = __tmp__Y;
this._localBasisX2Z = __tmp__Z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = slerpM00 * this._localBasisY1X + slerpM01 * this._localBasisY1Y + slerpM02 * this._localBasisY1Z;
__tmp__Y1 = slerpM10 * this._localBasisY1X + slerpM11 * this._localBasisY1Y + slerpM12 * this._localBasisY1Z;
__tmp__Z1 = slerpM20 * this._localBasisY1X + slerpM21 * this._localBasisY1Y + slerpM22 * this._localBasisY1Z;
this._localBasisY2X = __tmp__X1;
this._localBasisY2Y = __tmp__Y1;
this._localBasisY2Z = __tmp__Z1;
let __tmp__X2;
let __tmp__Y2;
let __tmp__Z2;
__tmp__X2 = slerpM00 * this._localBasisZ1X + slerpM01 * this._localBasisZ1Y + slerpM02 * this._localBasisZ1Z;
__tmp__Y2 = slerpM10 * this._localBasisZ1X + slerpM11 * this._localBasisZ1Y + slerpM12 * this._localBasisZ1Z;
__tmp__Z2 = slerpM20 * this._localBasisZ1X + slerpM21 * this._localBasisZ1Y + slerpM22 * this._localBasisZ1Z;
this._localBasisZ2X = __tmp__X2;
this._localBasisZ2Y = __tmp__Y2;
this._localBasisZ2Z = __tmp__Z2;
}
setSolverInfoRowLinear(row,diff,lm,mass,sd,timeStep,isPositionPart) {
let cfmFactor;
let erp;
let slop = oimo.common.Setting.linearSlop;
if(isPositionPart) {
cfmFactor = 0;
erp = 1;
} else {
if(sd.frequency > 0) {
slop = 0;
let omega = 6.28318530717958 * sd.frequency;
let zeta = sd.dampingRatio;
if(zeta < oimo.common.Setting.minSpringDamperDampingRatio) {
zeta = oimo.common.Setting.minSpringDamperDampingRatio;
}
let h = timeStep.dt;
let c = 2 * zeta * omega;
let k = omega * omega;
if(sd.useSymplecticEuler) {
cfmFactor = 1 / (h * c);
erp = k / c;
} else {
cfmFactor = 1 / (h * (h * k + c));
erp = k / (h * k + c);
}
} else {
cfmFactor = 0;
erp = this.getErp(timeStep,false);
}
if(lm.motorForce > 0) {
row.motorSpeed = lm.motorSpeed;
row.motorMaxImpulse = lm.motorForce * timeStep.dt;
} else {
row.motorSpeed = 0;
row.motorMaxImpulse = 0;
}
}
let lower = lm.lowerLimit;
let upper = lm.upperLimit;
let minImp;
let maxImp;
let error;
if(lower > upper) {
minImp = 0;
maxImp = 0;
error = 0;
} else if(lower == upper) {
minImp = -1e65536;
maxImp = 1e65536;
error = diff - lower;
} else if(diff < lower) {
minImp = -1e65536;
maxImp = 0;
error = diff - lower + slop;
if(error > 0) {
error = 0;
}
} else if(diff > upper) {
minImp = 0;
maxImp = 1e65536;
error = diff - upper - slop;
if(error < 0) {
error = 0;
}
} else {
minImp = 0;
maxImp = 0;
error = 0;
}
row.minImpulse = minImp;
row.maxImpulse = maxImp;
row.cfm = cfmFactor * (mass == 0 ? 0 : 1 / mass);
row.rhs = error * erp;
}
setSolverInfoRowAngular(row,diff,lm,mass,sd,timeStep,isPositionPart) {
let cfmFactor;
let erp;
let slop = oimo.common.Setting.angularSlop;
if(isPositionPart) {
cfmFactor = 0;
erp = 1;
} else {
if(sd.frequency > 0) {
slop = 0;
let omega = 6.28318530717958 * sd.frequency;
let zeta = sd.dampingRatio;
if(zeta < oimo.common.Setting.minSpringDamperDampingRatio) {
zeta = oimo.common.Setting.minSpringDamperDampingRatio;
}
let h = timeStep.dt;
let c = 2 * zeta * omega;
let k = omega * omega;
if(sd.useSymplecticEuler) {
cfmFactor = 1 / (h * c);
erp = k / c;
} else {
cfmFactor = 1 / (h * (h * k + c));
erp = k / (h * k + c);
}
} else {
cfmFactor = 0;
erp = this.getErp(timeStep,false);
}
if(lm.motorTorque > 0) {
row.motorSpeed = lm.motorSpeed;
row.motorMaxImpulse = lm.motorTorque * timeStep.dt;
} else {
row.motorSpeed = 0;
row.motorMaxImpulse = 0;
}
}
let lower = lm.lowerLimit;
let upper = lm.upperLimit;
let mid = (lower + upper) * 0.5;
diff -= mid;
diff = ((diff + 3.14159265358979) % 6.28318530717958 + 6.28318530717958) % 6.28318530717958 - 3.14159265358979;
diff += mid;
let minImp;
let maxImp;
let error;
if(lower > upper) {
minImp = 0;
maxImp = 0;
error = 0;
} else if(lower == upper) {
minImp = -1e65536;
maxImp = 1e65536;
error = diff - lower;
} else if(diff < lower) {
minImp = -1e65536;
maxImp = 0;
error = diff - lower + slop;
if(error > 0) {
error = 0;
}
} else if(diff > upper) {
minImp = 0;
maxImp = 1e65536;
error = diff - upper - slop;
if(error < 0) {
error = 0;
}
} else {
minImp = 0;
maxImp = 0;
error = 0;
}
row.minImpulse = minImp;
row.maxImpulse = maxImp;
row.cfm = cfmFactor * (mass == 0 ? 0 : 1 / mass);
row.rhs = error * erp;
}
getErp(timeStep,isPositionPart) {
if(isPositionPart) {
return 1;
} else if(this._positionCorrectionAlgorithm == oimo.dynamics.constraint.PositionCorrectionAlgorithm.BAUMGARTE) {
return timeStep.invDt * oimo.common.Setting.velocityBaumgarte;
} else {
return 0;
}
}
computeEffectiveInertiaMoment(axisX,axisY,axisZ) {
let ia1X;
let ia1Y;
let ia1Z;
let ia2X;
let ia2Y;
let ia2Z;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = this._b1._invInertia00 * axisX + this._b1._invInertia01 * axisY + this._b1._invInertia02 * axisZ;
__tmp__Y = this._b1._invInertia10 * axisX + this._b1._invInertia11 * axisY + this._b1._invInertia12 * axisZ;
__tmp__Z = this._b1._invInertia20 * axisX + this._b1._invInertia21 * axisY + this._b1._invInertia22 * axisZ;
ia1X = __tmp__X;
ia1Y = __tmp__Y;
ia1Z = __tmp__Z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = this._b2._invInertia00 * axisX + this._b2._invInertia01 * axisY + this._b2._invInertia02 * axisZ;
__tmp__Y1 = this._b2._invInertia10 * axisX + this._b2._invInertia11 * axisY + this._b2._invInertia12 * axisZ;
__tmp__Z1 = this._b2._invInertia20 * axisX + this._b2._invInertia21 * axisY + this._b2._invInertia22 * axisZ;
ia2X = __tmp__X1;
ia2Y = __tmp__Y1;
ia2Z = __tmp__Z1;
let invI1 = ia1X * axisX + ia1Y * axisY + ia1Z * axisZ;
let invI2 = ia2X * axisX + ia2Y * axisY + ia2Z * axisZ;
if(invI1 > 0) {
let dot = axisX * this._relativeAnchor1X + axisY * this._relativeAnchor1Y + axisZ * this._relativeAnchor1Z;
let projsq = this._relativeAnchor1X * this._relativeAnchor1X + this._relativeAnchor1Y * this._relativeAnchor1Y + this._relativeAnchor1Z * this._relativeAnchor1Z - dot * dot;
if(projsq > 0) {
if(this._b1._invMass > 0) {
invI1 = 1 / (1 / invI1 + this._b1._mass * projsq);
} else {
invI1 = 0;
}
}
}
if(invI2 > 0) {
let dot = axisX * this._relativeAnchor2X + axisY * this._relativeAnchor2Y + axisZ * this._relativeAnchor2Z;
let projsq = this._relativeAnchor2X * this._relativeAnchor2X + this._relativeAnchor2Y * this._relativeAnchor2Y + this._relativeAnchor2Z * this._relativeAnchor2Z - dot * dot;
if(projsq > 0) {
if(this._b2._invMass > 0) {
invI2 = 1 / (1 / invI2 + this._b2._mass * projsq);
} else {
invI2 = 0;
}
}
}
if(invI1 + invI2 == 0) {
return 0;
} else {
return 1 / (invI1 + invI2);
}
}
computeEffectiveInertiaMoment2(axis1X,axis1Y,axis1Z,axis2X,axis2Y,axis2Z) {
let ia1X;
let ia1Y;
let ia1Z;
let ia2X;
let ia2Y;
let ia2Z;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = this._b1._invInertia00 * axis1X + this._b1._invInertia01 * axis1Y + this._b1._invInertia02 * axis1Z;
__tmp__Y = this._b1._invInertia10 * axis1X + this._b1._invInertia11 * axis1Y + this._b1._invInertia12 * axis1Z;
__tmp__Z = this._b1._invInertia20 * axis1X + this._b1._invInertia21 * axis1Y + this._b1._invInertia22 * axis1Z;
ia1X = __tmp__X;
ia1Y = __tmp__Y;
ia1Z = __tmp__Z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = this._b2._invInertia00 * axis2X + this._b2._invInertia01 * axis2Y + this._b2._invInertia02 * axis2Z;
__tmp__Y1 = this._b2._invInertia10 * axis2X + this._b2._invInertia11 * axis2Y + this._b2._invInertia12 * axis2Z;
__tmp__Z1 = this._b2._invInertia20 * axis2X + this._b2._invInertia21 * axis2Y + this._b2._invInertia22 * axis2Z;
ia2X = __tmp__X1;
ia2Y = __tmp__Y1;
ia2Z = __tmp__Z1;
let invI1 = ia1X * axis1X + ia1Y * axis1Y + ia1Z * axis1Z;
let invI2 = ia2X * axis2X + ia2Y * axis2Y + ia2Z * axis2Z;
if(invI1 > 0) {
let rsq = this._relativeAnchor1X * this._relativeAnchor1X + this._relativeAnchor1Y * this._relativeAnchor1Y + this._relativeAnchor1Z * this._relativeAnchor1Z;
let dot = axis1X * this._relativeAnchor1X + axis1Y * this._relativeAnchor1Y + axis1Z * this._relativeAnchor1Z;
let projsq = rsq * rsq - dot * dot;
if(projsq > 0) {
if(this._b1._invMass > 0) {
invI1 = 1 / (1 / invI1 + this._b1._mass * projsq);
} else {
invI1 = 0;
}
}
}
if(invI2 > 0) {
let rsq = this._relativeAnchor2X * this._relativeAnchor2X + this._relativeAnchor2Y * this._relativeAnchor2Y + this._relativeAnchor2Z * this._relativeAnchor2Z;
let dot = axis2X * this._relativeAnchor2X + axis2Y * this._relativeAnchor2Y + axis2Z * this._relativeAnchor2Z;
let projsq = rsq * rsq - dot * dot;
if(projsq > 0) {
if(this._b2._invMass > 0) {
invI2 = 1 / (1 / invI2 + this._b2._mass * projsq);
} else {
invI2 = 0;
}
}
}
if(invI1 + invI2 == 0) {
return 0;
} else {
return 1 / (invI1 + invI2);
}
}
_syncAnchors() {
let tf1 = this._b1._transform;
let tf2 = this._b2._transform;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = tf1._rotation00 * this._localAnchor1X + tf1._rotation01 * this._localAnchor1Y + tf1._rotation02 * this._localAnchor1Z;
__tmp__Y = tf1._rotation10 * this._localAnchor1X + tf1._rotation11 * this._localAnchor1Y + tf1._rotation12 * this._localAnchor1Z;
__tmp__Z = tf1._rotation20 * this._localAnchor1X + tf1._rotation21 * this._localAnchor1Y + tf1._rotation22 * this._localAnchor1Z;
this._relativeAnchor1X = __tmp__X;
this._relativeAnchor1Y = __tmp__Y;
this._relativeAnchor1Z = __tmp__Z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = tf2._rotation00 * this._localAnchor2X + tf2._rotation01 * this._localAnchor2Y + tf2._rotation02 * this._localAnchor2Z;
__tmp__Y1 = tf2._rotation10 * this._localAnchor2X + tf2._rotation11 * this._localAnchor2Y + tf2._rotation12 * this._localAnchor2Z;
__tmp__Z1 = tf2._rotation20 * this._localAnchor2X + tf2._rotation21 * this._localAnchor2Y + tf2._rotation22 * this._localAnchor2Z;
this._relativeAnchor2X = __tmp__X1;
this._relativeAnchor2Y = __tmp__Y1;
this._relativeAnchor2Z = __tmp__Z1;
this._anchor1X = this._relativeAnchor1X + tf1._positionX;
this._anchor1Y = this._relativeAnchor1Y + tf1._positionY;
this._anchor1Z = this._relativeAnchor1Z + tf1._positionZ;
this._anchor2X = this._relativeAnchor2X + tf2._positionX;
this._anchor2Y = this._relativeAnchor2Y + tf2._positionY;
this._anchor2Z = this._relativeAnchor2Z + tf2._positionZ;
let __tmp__X2;
let __tmp__Y2;
let __tmp__Z2;
__tmp__X2 = tf1._rotation00 * this._localBasisX1X + tf1._rotation01 * this._localBasisX1Y + tf1._rotation02 * this._localBasisX1Z;
__tmp__Y2 = tf1._rotation10 * this._localBasisX1X + tf1._rotation11 * this._localBasisX1Y + tf1._rotation12 * this._localBasisX1Z;
__tmp__Z2 = tf1._rotation20 * this._localBasisX1X + tf1._rotation21 * this._localBasisX1Y + tf1._rotation22 * this._localBasisX1Z;
this._basisX1X = __tmp__X2;
this._basisX1Y = __tmp__Y2;
this._basisX1Z = __tmp__Z2;
let __tmp__X3;
let __tmp__Y3;
let __tmp__Z3;
__tmp__X3 = tf1._rotation00 * this._localBasisY1X + tf1._rotation01 * this._localBasisY1Y + tf1._rotation02 * this._localBasisY1Z;
__tmp__Y3 = tf1._rotation10 * this._localBasisY1X + tf1._rotation11 * this._localBasisY1Y + tf1._rotation12 * this._localBasisY1Z;
__tmp__Z3 = tf1._rotation20 * this._localBasisY1X + tf1._rotation21 * this._localBasisY1Y + tf1._rotation22 * this._localBasisY1Z;
this._basisY1X = __tmp__X3;
this._basisY1Y = __tmp__Y3;
this._basisY1Z = __tmp__Z3;
let __tmp__X4;
let __tmp__Y4;
let __tmp__Z4;
__tmp__X4 = tf1._rotation00 * this._localBasisZ1X + tf1._rotation01 * this._localBasisZ1Y + tf1._rotation02 * this._localBasisZ1Z;
__tmp__Y4 = tf1._rotation10 * this._localBasisZ1X + tf1._rotation11 * this._localBasisZ1Y + tf1._rotation12 * this._localBasisZ1Z;
__tmp__Z4 = tf1._rotation20 * this._localBasisZ1X + tf1._rotation21 * this._localBasisZ1Y + tf1._rotation22 * this._localBasisZ1Z;
this._basisZ1X = __tmp__X4;
this._basisZ1Y = __tmp__Y4;
this._basisZ1Z = __tmp__Z4;
let __tmp__X5;
let __tmp__Y5;
let __tmp__Z5;
__tmp__X5 = tf2._rotation00 * this._localBasisX2X + tf2._rotation01 * this._localBasisX2Y + tf2._rotation02 * this._localBasisX2Z;
__tmp__Y5 = tf2._rotation10 * this._localBasisX2X + tf2._rotation11 * this._localBasisX2Y + tf2._rotation12 * this._localBasisX2Z;
__tmp__Z5 = tf2._rotation20 * this._localBasisX2X + tf2._rotation21 * this._localBasisX2Y + tf2._rotation22 * this._localBasisX2Z;
this._basisX2X = __tmp__X5;
this._basisX2Y = __tmp__Y5;
this._basisX2Z = __tmp__Z5;
let __tmp__X6;
let __tmp__Y6;
let __tmp__Z6;
__tmp__X6 = tf2._rotation00 * this._localBasisY2X + tf2._rotation01 * this._localBasisY2Y + tf2._rotation02 * this._localBasisY2Z;
__tmp__Y6 = tf2._rotation10 * this._localBasisY2X + tf2._rotation11 * this._localBasisY2Y + tf2._rotation12 * this._localBasisY2Z;
__tmp__Z6 = tf2._rotation20 * this._localBasisY2X + tf2._rotation21 * this._localBasisY2Y + tf2._rotation22 * this._localBasisY2Z;
this._basisY2X = __tmp__X6;
this._basisY2Y = __tmp__Y6;
this._basisY2Z = __tmp__Z6;
let __tmp__X7;
let __tmp__Y7;
let __tmp__Z7;
__tmp__X7 = tf2._rotation00 * this._localBasisZ2X + tf2._rotation01 * this._localBasisZ2Y + tf2._rotation02 * this._localBasisZ2Z;
__tmp__Y7 = tf2._rotation10 * this._localBasisZ2X + tf2._rotation11 * this._localBasisZ2Y + tf2._rotation12 * this._localBasisZ2Z;
__tmp__Z7 = tf2._rotation20 * this._localBasisZ2X + tf2._rotation21 * this._localBasisZ2Y + tf2._rotation22 * this._localBasisZ2Z;
this._basisZ2X = __tmp__X7;
this._basisZ2Y = __tmp__Y7;
this._basisZ2Z = __tmp__Z7;
}
_getVelocitySolverInfo(timeStep,info) {
info.b1 = this._b1;
info.b2 = this._b2;
info.numRows = 0;
}
_getPositionSolverInfo(info) {
info.b1 = this._b1;
info.b2 = this._b2;
info.numRows = 0;
}
_checkDestruction() {
let torqueSq = this._appliedTorqueX * this._appliedTorqueX + this._appliedTorqueY * this._appliedTorqueY + this._appliedTorqueZ * this._appliedTorqueZ;
if(this._breakForce > 0 && this._appliedForceX * this._appliedForceX + this._appliedForceY * this._appliedForceY + this._appliedForceZ * this._appliedForceZ > this._breakForce * this._breakForce) {
this._world.removeJoint(this);
return;
}
if(this._breakTorque > 0 && torqueSq > this._breakTorque * this._breakTorque) {
this._world.removeJoint(this);
return;
}
}
getRigidBody1() {
return this._b1;
}
getRigidBody2() {
return this._b2;
}
getType() {
return this._type;
}
getAnchor1() {
let v = new oimo.common.Vec3();
v.x = this._anchor1X;
v.y = this._anchor1Y;
v.z = this._anchor1Z;
return v;
}
getAnchor2() {
let v = new oimo.common.Vec3();
v.x = this._anchor2X;
v.y = this._anchor2Y;
v.z = this._anchor2Z;
return v;
}
getAnchor1To(anchor) {
anchor.x = this._anchor1X;
anchor.y = this._anchor1Y;
anchor.z = this._anchor1Z;
}
getAnchor2To(anchor) {
anchor.x = this._anchor2X;
anchor.y = this._anchor2Y;
anchor.z = this._anchor2Z;
}
getLocalAnchor1() {
let v = new oimo.common.Vec3();
v.x = this._localAnchor1X;
v.y = this._localAnchor1Y;
v.z = this._localAnchor1Z;
return v;
}
getLocalAnchor2() {
let v = new oimo.common.Vec3();
v.x = this._localAnchor2X;
v.y = this._localAnchor2Y;
v.z = this._localAnchor2Z;
return v;
}
getLocalAnchor1To(localAnchor) {
localAnchor.x = this._localAnchor1X;
localAnchor.y = this._localAnchor1Y;
localAnchor.z = this._localAnchor1Z;
}
getLocalAnchor2To(localAnchor) {
localAnchor.x = this._localAnchor2X;
localAnchor.y = this._localAnchor2Y;
localAnchor.z = this._localAnchor2Z;
}
getBasis1() {
let m = new oimo.common.Mat3();
let b00;
let b01;
let b02;
let b10;
let b11;
let b12;
let b20;
let b21;
let b22;
b00 = this._basisX1X;
b01 = this._basisY1X;
b02 = this._basisZ1X;
b10 = this._basisX1Y;
b11 = this._basisY1Y;
b12 = this._basisZ1Y;
b20 = this._basisX1Z;
b21 = this._basisY1Z;
b22 = this._basisZ1Z;
m.e00 = b00;
m.e01 = b01;
m.e02 = b02;
m.e10 = b10;
m.e11 = b11;
m.e12 = b12;
m.e20 = b20;
m.e21 = b21;
m.e22 = b22;
return m;
}
getBasis2() {
let m = new oimo.common.Mat3();
let b00;
let b01;
let b02;
let b10;
let b11;
let b12;
let b20;
let b21;
let b22;
b00 = this._basisX2X;
b01 = this._basisY2X;
b02 = this._basisZ2X;
b10 = this._basisX2Y;
b11 = this._basisY2Y;
b12 = this._basisZ2Y;
b20 = this._basisX2Z;
b21 = this._basisY2Z;
b22 = this._basisZ2Z;
m.e00 = b00;
m.e01 = b01;
m.e02 = b02;
m.e10 = b10;
m.e11 = b11;
m.e12 = b12;
m.e20 = b20;
m.e21 = b21;
m.e22 = b22;
return m;
}
getBasis1To(basis) {
let b00;
let b01;
let b02;
let b10;
let b11;
let b12;
let b20;
let b21;
let b22;
b00 = this._basisX1X;
b01 = this._basisY1X;
b02 = this._basisZ1X;
b10 = this._basisX1Y;
b11 = this._basisY1Y;
b12 = this._basisZ1Y;
b20 = this._basisX1Z;
b21 = this._basisY1Z;
b22 = this._basisZ1Z;
basis.e00 = b00;
basis.e01 = b01;
basis.e02 = b02;
basis.e10 = b10;
basis.e11 = b11;
basis.e12 = b12;
basis.e20 = b20;
basis.e21 = b21;
basis.e22 = b22;
}
getBasis2To(basis) {
let b00;
let b01;
let b02;
let b10;
let b11;
let b12;
let b20;
let b21;
let b22;
b00 = this._basisX2X;
b01 = this._basisY2X;
b02 = this._basisZ2X;
b10 = this._basisX2Y;
b11 = this._basisY2Y;
b12 = this._basisZ2Y;
b20 = this._basisX2Z;
b21 = this._basisY2Z;
b22 = this._basisZ2Z;
basis.e00 = b00;
basis.e01 = b01;
basis.e02 = b02;
basis.e10 = b10;
basis.e11 = b11;
basis.e12 = b12;
basis.e20 = b20;
basis.e21 = b21;
basis.e22 = b22;
}
getAllowCollision() {
return this._allowCollision;
}
setAllowCollision(allowCollision) {
this._allowCollision = allowCollision;
}
getBreakForce() {
return this._breakForce;
}
setBreakForce(breakForce) {
this._breakForce = breakForce;
}
getBreakTorque() {
return this._breakTorque;
}
setBreakTorque(breakTorque) {
this._breakTorque = breakTorque;
}
getPositionCorrectionAlgorithm() {
return this._positionCorrectionAlgorithm;
}
setPositionCorrectionAlgorithm(positionCorrectionAlgorithm) {
switch(positionCorrectionAlgorithm) {
case 0:case 1:case 2:
break;
default:
throw new Error("invalid position correction algorithm id: " + positionCorrectionAlgorithm);
}
this._positionCorrectionAlgorithm = positionCorrectionAlgorithm;
}
getAppliedForce() {
let v = new oimo.common.Vec3();
v.x = this._appliedForceX;
v.y = this._appliedForceY;
v.z = this._appliedForceZ;
return v;
}
getAppliedForceTo(appliedForce) {
appliedForce.x = this._appliedForceX;
appliedForce.y = this._appliedForceY;
appliedForce.z = this._appliedForceZ;
}
getAppliedTorque() {
let v = new oimo.common.Vec3();
v.x = this._appliedTorqueX;
v.y = this._appliedTorqueY;
v.z = this._appliedTorqueZ;
return v;
}
getAppliedTorqueTo(appliedTorque) {
appliedTorque.x = this._appliedTorqueX;
appliedTorque.y = this._appliedTorqueY;
appliedTorque.z = this._appliedTorqueZ;
}
getPrev() {
return this._prev;
}
getNext() {
return this._next;
}
}
oimo.dynamics.constraint.joint.CylindricalJoint = class oimo_dynamics_constraint_joint_CylindricalJoint extends oimo.dynamics.constraint.joint.Joint {
constructor(config) {
super(config,2);
let v = config.localAxis1;
this._localBasisX1X = v.x;
this._localBasisX1Y = v.y;
this._localBasisX1Z = v.z;
let v1 = config.localAxis2;
this._localBasisX2X = v1.x;
this._localBasisX2Y = v1.y;
this._localBasisX2Z = v1.z;
this.buildLocalBasesFromX();
this.angle = 0;
this.angularErrorY = 0;
this.angularErrorZ = 0;
this.translation = 0;
this.linearErrorY = 0;
this.linearErrorZ = 0;
this._basis = new oimo.dynamics.constraint.joint.BasisTracker(this);
this._translSd = config.translationalSpringDamper.clone();
this._translLm = config.translationalLimitMotor.clone();
this._rotSd = config.rotationalSpringDamper.clone();
this._rotLm = config.rotationalLimitMotor.clone();
}
getInfo(info,timeStep,isPositionPart) {
let erp = this.getErp(timeStep,isPositionPart);
let linRhsY = this.linearErrorY * erp;
let linRhsZ = this.linearErrorZ * erp;
let angRhsY = this.angularErrorY * erp;
let angRhsZ = this.angularErrorZ * erp;
let j;
let translationalMotorMass = 1 / (this._b1._invMass + this._b2._invMass);
let rotationalMotorMass = this.computeEffectiveInertiaMoment(this._basis.xX,this._basis.xY,this._basis.xZ);
if(this._translSd.frequency <= 0 || !isPositionPart) {
let impulse = this._impulses[0];
let row = info.rows[info.numRows++];
let _this = row.jacobian;
_this.lin1X = 0;
_this.lin1Y = 0;
_this.lin1Z = 0;
_this.lin2X = 0;
_this.lin2Y = 0;
_this.lin2Z = 0;
_this.ang1X = 0;
_this.ang1Y = 0;
_this.ang1Z = 0;
_this.ang2X = 0;
_this.ang2Y = 0;
_this.ang2Z = 0;
row.rhs = 0;
row.cfm = 0;
row.minImpulse = 0;
row.maxImpulse = 0;
row.motorSpeed = 0;
row.motorMaxImpulse = 0;
row.impulse = null;
row.impulse = impulse;
this.setSolverInfoRowLinear(row,this.translation,this._translLm,translationalMotorMass,this._translSd,timeStep,isPositionPart);
j = row.jacobian;
j.lin1X = this._basis.xX;
j.lin1Y = this._basis.xY;
j.lin1Z = this._basis.xZ;
j.lin2X = this._basis.xX;
j.lin2Y = this._basis.xY;
j.lin2Z = this._basis.xZ;
j.ang1X = this._relativeAnchor1Y * this._basis.xZ - this._relativeAnchor1Z * this._basis.xY;
j.ang1Y = this._relativeAnchor1Z * this._basis.xX - this._relativeAnchor1X * this._basis.xZ;
j.ang1Z = this._relativeAnchor1X * this._basis.xY - this._relativeAnchor1Y * this._basis.xX;
j.ang2X = this._relativeAnchor2Y * this._basis.xZ - this._relativeAnchor2Z * this._basis.xY;
j.ang2Y = this._relativeAnchor2Z * this._basis.xX - this._relativeAnchor2X * this._basis.xZ;
j.ang2Z = this._relativeAnchor2X * this._basis.xY - this._relativeAnchor2Y * this._basis.xX;
}
let impulse = this._impulses[1];
let row = info.rows[info.numRows++];
let _this = row.jacobian;
_this.lin1X = 0;
_this.lin1Y = 0;
_this.lin1Z = 0;
_this.lin2X = 0;
_this.lin2Y = 0;
_this.lin2Z = 0;
_this.ang1X = 0;
_this.ang1Y = 0;
_this.ang1Z = 0;
_this.ang2X = 0;
_this.ang2Y = 0;
_this.ang2Z = 0;
row.rhs = 0;
row.cfm = 0;
row.minImpulse = 0;
row.maxImpulse = 0;
row.motorSpeed = 0;
row.motorMaxImpulse = 0;
row.impulse = null;
row.impulse = impulse;
row.rhs = linRhsY;
row.cfm = 0;
row.minImpulse = -1e65536;
row.maxImpulse = 1e65536;
j = row.jacobian;
j.lin1X = this._basis.yX;
j.lin1Y = this._basis.yY;
j.lin1Z = this._basis.yZ;
j.lin2X = this._basis.yX;
j.lin2Y = this._basis.yY;
j.lin2Z = this._basis.yZ;
j.ang1X = this._relativeAnchor1Y * this._basis.yZ - this._relativeAnchor1Z * this._basis.yY;
j.ang1Y = this._relativeAnchor1Z * this._basis.yX - this._relativeAnchor1X * this._basis.yZ;
j.ang1Z = this._relativeAnchor1X * this._basis.yY - this._relativeAnchor1Y * this._basis.yX;
j.ang2X = this._relativeAnchor2Y * this._basis.yZ - this._relativeAnchor2Z * this._basis.yY;
j.ang2Y = this._relativeAnchor2Z * this._basis.yX - this._relativeAnchor2X * this._basis.yZ;
j.ang2Z = this._relativeAnchor2X * this._basis.yY - this._relativeAnchor2Y * this._basis.yX;
let impulse1 = this._impulses[2];
let row1 = info.rows[info.numRows++];
let _this1 = row1.jacobian;
_this1.lin1X = 0;
_this1.lin1Y = 0;
_this1.lin1Z = 0;
_this1.lin2X = 0;
_this1.lin2Y = 0;
_this1.lin2Z = 0;
_this1.ang1X = 0;
_this1.ang1Y = 0;
_this1.ang1Z = 0;
_this1.ang2X = 0;
_this1.ang2Y = 0;
_this1.ang2Z = 0;
row1.rhs = 0;
row1.cfm = 0;
row1.minImpulse = 0;
row1.maxImpulse = 0;
row1.motorSpeed = 0;
row1.motorMaxImpulse = 0;
row1.impulse = null;
row1.impulse = impulse1;
row1.rhs = linRhsZ;
row1.cfm = 0;
row1.minImpulse = -1e65536;
row1.maxImpulse = 1e65536;
j = row1.jacobian;
j.lin1X = this._basis.zX;
j.lin1Y = this._basis.zY;
j.lin1Z = this._basis.zZ;
j.lin2X = this._basis.zX;
j.lin2Y = this._basis.zY;
j.lin2Z = this._basis.zZ;
j.ang1X = this._relativeAnchor1Y * this._basis.zZ - this._relativeAnchor1Z * this._basis.zY;
j.ang1Y = this._relativeAnchor1Z * this._basis.zX - this._relativeAnchor1X * this._basis.zZ;
j.ang1Z = this._relativeAnchor1X * this._basis.zY - this._relativeAnchor1Y * this._basis.zX;
j.ang2X = this._relativeAnchor2Y * this._basis.zZ - this._relativeAnchor2Z * this._basis.zY;
j.ang2Y = this._relativeAnchor2Z * this._basis.zX - this._relativeAnchor2X * this._basis.zZ;
j.ang2Z = this._relativeAnchor2X * this._basis.zY - this._relativeAnchor2Y * this._basis.zX;
if(this._rotSd.frequency <= 0 || !isPositionPart) {
let impulse = this._impulses[3];
let row = info.rows[info.numRows++];
let _this = row.jacobian;
_this.lin1X = 0;
_this.lin1Y = 0;
_this.lin1Z = 0;
_this.lin2X = 0;
_this.lin2Y = 0;
_this.lin2Z = 0;
_this.ang1X = 0;
_this.ang1Y = 0;
_this.ang1Z = 0;
_this.ang2X = 0;
_this.ang2Y = 0;
_this.ang2Z = 0;
row.rhs = 0;
row.cfm = 0;
row.minImpulse = 0;
row.maxImpulse = 0;
row.motorSpeed = 0;
row.motorMaxImpulse = 0;
row.impulse = null;
row.impulse = impulse;
this.setSolverInfoRowAngular(row,this.angle,this._rotLm,rotationalMotorMass,this._rotSd,timeStep,isPositionPart);
j = row.jacobian;
j.ang1X = this._basis.xX;
j.ang1Y = this._basis.xY;
j.ang1Z = this._basis.xZ;
j.ang2X = this._basis.xX;
j.ang2Y = this._basis.xY;
j.ang2Z = this._basis.xZ;
}
let impulse2 = this._impulses[4];
let row2 = info.rows[info.numRows++];
let _this2 = row2.jacobian;
_this2.lin1X = 0;
_this2.lin1Y = 0;
_this2.lin1Z = 0;
_this2.lin2X = 0;
_this2.lin2Y = 0;
_this2.lin2Z = 0;
_this2.ang1X = 0;
_this2.ang1Y = 0;
_this2.ang1Z = 0;
_this2.ang2X = 0;
_this2.ang2Y = 0;
_this2.ang2Z = 0;
row2.rhs = 0;
row2.cfm = 0;
row2.minImpulse = 0;
row2.maxImpulse = 0;
row2.motorSpeed = 0;
row2.motorMaxImpulse = 0;
row2.impulse = null;
row2.impulse = impulse2;
row2.rhs = angRhsY;
row2.cfm = 0;
row2.minImpulse = -1e65536;
row2.maxImpulse = 1e65536;
j = row2.jacobian;
j.ang1X = this._basis.yX;
j.ang1Y = this._basis.yY;
j.ang1Z = this._basis.yZ;
j.ang2X = this._basis.yX;
j.ang2Y = this._basis.yY;
j.ang2Z = this._basis.yZ;
let impulse3 = this._impulses[5];
let row3 = info.rows[info.numRows++];
let _this3 = row3.jacobian;
_this3.lin1X = 0;
_this3.lin1Y = 0;
_this3.lin1Z = 0;
_this3.lin2X = 0;
_this3.lin2Y = 0;
_this3.lin2Z = 0;
_this3.ang1X = 0;
_this3.ang1Y = 0;
_this3.ang1Z = 0;
_this3.ang2X = 0;
_this3.ang2Y = 0;
_this3.ang2Z = 0;
row3.rhs = 0;
row3.cfm = 0;
row3.minImpulse = 0;
row3.maxImpulse = 0;
row3.motorSpeed = 0;
row3.motorMaxImpulse = 0;
row3.impulse = null;
row3.impulse = impulse3;
row3.rhs = angRhsZ;
row3.cfm = 0;
row3.minImpulse = -1e65536;
row3.maxImpulse = 1e65536;
j = row3.jacobian;
j.ang1X = this._basis.zX;
j.ang1Y = this._basis.zY;
j.ang1Z = this._basis.zZ;
j.ang2X = this._basis.zX;
j.ang2Y = this._basis.zY;
j.ang2Z = this._basis.zZ;
}
_syncAnchors() {
super._syncAnchors();
let _this = this._basis;
let invM1 = _this.joint._b1._invMass;
let invM2 = _this.joint._b2._invMass;
let qX;
let qY;
let qZ;
let qW;
let idQX;
let idQY;
let idQZ;
let idQW;
let slerpQX;
let slerpQY;
let slerpQZ;
let slerpQW;
let slerpM00;
let slerpM01;
let slerpM02;
let slerpM10;
let slerpM11;
let slerpM12;
let slerpM20;
let slerpM21;
let slerpM22;
let newXX;
let newXY;
let newXZ;
let newYX;
let newYY;
let newYZ;
let newZX;
let newZY;
let newZZ;
let prevXX;
let prevXY;
let prevXZ;
let prevYX;
let prevYY;
let prevYZ;
let d = _this.joint._basisX1X * _this.joint._basisX2X + _this.joint._basisX1Y * _this.joint._basisX2Y + _this.joint._basisX1Z * _this.joint._basisX2Z;
if(d < -0.999999999) {
let vX;
let vY;
let vZ;
let x1 = _this.joint._basisX1X;
let y1 = _this.joint._basisX1Y;
let z1 = _this.joint._basisX1Z;
let x2 = x1 * x1;
let y2 = y1 * y1;
let z2 = z1 * z1;
let d;
if(x2 < y2) {
if(x2 < z2) {
d = 1 / Math.sqrt(y2 + z2);
vX = 0;
vY = z1 * d;
vZ = -y1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
vX = y1 * d;
vY = -x1 * d;
vZ = 0;
}
} else if(y2 < z2) {
d = 1 / Math.sqrt(z2 + x2);
vX = -z1 * d;
vY = 0;
vZ = x1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
vX = y1 * d;
vY = -x1 * d;
vZ = 0;
}
qX = vX;
qY = vY;
qZ = vZ;
qW = 0;
} else {
let cX;
let cY;
let cZ;
cX = _this.joint._basisX1Y * _this.joint._basisX2Z - _this.joint._basisX1Z * _this.joint._basisX2Y;
cY = _this.joint._basisX1Z * _this.joint._basisX2X - _this.joint._basisX1X * _this.joint._basisX2Z;
cZ = _this.joint._basisX1X * _this.joint._basisX2Y - _this.joint._basisX1Y * _this.joint._basisX2X;
let w = Math.sqrt((1 + d) * 0.5);
d = 0.5 / w;
cX *= d;
cY *= d;
cZ *= d;
qX = cX;
qY = cY;
qZ = cZ;
qW = w;
}
idQX = 0;
idQY = 0;
idQZ = 0;
idQW = 1;
let q1X;
let q1Y;
let q1Z;
let q1W;
let q2X;
let q2Y;
let q2Z;
let q2W;
q1X = idQX;
q1Y = idQY;
q1Z = idQZ;
q1W = idQW;
q2X = qX;
q2Y = qY;
q2Z = qZ;
q2W = qW;
let d1 = q1X * q2X + q1Y * q2Y + q1Z * q2Z + q1W * q2W;
if(d1 < 0) {
d1 = -d1;
q2X = -q2X;
q2Y = -q2Y;
q2Z = -q2Z;
q2W = -q2W;
}
if(d1 > 0.999999) {
let dqX;
let dqY;
let dqZ;
let dqW;
dqX = q2X - q1X;
dqY = q2Y - q1Y;
dqZ = q2Z - q1Z;
dqW = q2W - q1W;
q2X = q1X + dqX * (invM1 / (invM1 + invM2));
q2Y = q1Y + dqY * (invM1 / (invM1 + invM2));
q2Z = q1Z + dqZ * (invM1 / (invM1 + invM2));
q2W = q1W + dqW * (invM1 / (invM1 + invM2));
let l = q2X * q2X + q2Y * q2Y + q2Z * q2Z + q2W * q2W;
if(l > 1e-32) {
l = 1 / Math.sqrt(l);
}
slerpQX = q2X * l;
slerpQY = q2Y * l;
slerpQZ = q2Z * l;
slerpQW = q2W * l;
} else {
let theta = invM1 / (invM1 + invM2) * Math.acos(d1);
q2X += q1X * -d1;
q2Y += q1Y * -d1;
q2Z += q1Z * -d1;
q2W += q1W * -d1;
let l = q2X * q2X + q2Y * q2Y + q2Z * q2Z + q2W * q2W;
if(l > 1e-32) {
l = 1 / Math.sqrt(l);
}
q2X *= l;
q2Y *= l;
q2Z *= l;
q2W *= l;
let sin = Math.sin(theta);
let cos = Math.cos(theta);
q1X *= cos;
q1Y *= cos;
q1Z *= cos;
q1W *= cos;
slerpQX = q1X + q2X * sin;
slerpQY = q1Y + q2Y * sin;
slerpQZ = q1Z + q2Z * sin;
slerpQW = q1W + q2W * sin;
}
let x = slerpQX;
let y = slerpQY;
let z = slerpQZ;
let w = slerpQW;
let x2 = 2 * x;
let y2 = 2 * y;
let z2 = 2 * z;
let xx = x * x2;
let yy = y * y2;
let zz = z * z2;
let xy = x * y2;
let yz = y * z2;
let xz = x * z2;
let wx = w * x2;
let wy = w * y2;
let wz = w * z2;
slerpM00 = 1 - yy - zz;
slerpM01 = xy - wz;
slerpM02 = xz + wy;
slerpM10 = xy + wz;
slerpM11 = 1 - xx - zz;
slerpM12 = yz - wx;
slerpM20 = xz - wy;
slerpM21 = yz + wx;
slerpM22 = 1 - xx - yy;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = slerpM00 * _this.joint._basisX1X + slerpM01 * _this.joint._basisX1Y + slerpM02 * _this.joint._basisX1Z;
__tmp__Y = slerpM10 * _this.joint._basisX1X + slerpM11 * _this.joint._basisX1Y + slerpM12 * _this.joint._basisX1Z;
__tmp__Z = slerpM20 * _this.joint._basisX1X + slerpM21 * _this.joint._basisX1Y + slerpM22 * _this.joint._basisX1Z;
newXX = __tmp__X;
newXY = __tmp__Y;
newXZ = __tmp__Z;
prevXX = _this.xX;
prevXY = _this.xY;
prevXZ = _this.xZ;
prevYX = _this.yX;
prevYY = _this.yY;
prevYZ = _this.yZ;
let d2 = prevXX * newXX + prevXY * newXY + prevXZ * newXZ;
if(d2 < -0.999999999) {
let vX;
let vY;
let vZ;
let x1 = prevXX;
let y1 = prevXY;
let z1 = prevXZ;
let x2 = x1 * x1;
let y2 = y1 * y1;
let z2 = z1 * z1;
let d;
if(x2 < y2) {
if(x2 < z2) {
d = 1 / Math.sqrt(y2 + z2);
vX = 0;
vY = z1 * d;
vZ = -y1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
vX = y1 * d;
vY = -x1 * d;
vZ = 0;
}
} else if(y2 < z2) {
d = 1 / Math.sqrt(z2 + x2);
vX = -z1 * d;
vY = 0;
vZ = x1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
vX = y1 * d;
vY = -x1 * d;
vZ = 0;
}
slerpQX = vX;
slerpQY = vY;
slerpQZ = vZ;
slerpQW = 0;
} else {
let cX;
let cY;
let cZ;
cX = prevXY * newXZ - prevXZ * newXY;
cY = prevXZ * newXX - prevXX * newXZ;
cZ = prevXX * newXY - prevXY * newXX;
let w = Math.sqrt((1 + d2) * 0.5);
d2 = 0.5 / w;
cX *= d2;
cY *= d2;
cZ *= d2;
slerpQX = cX;
slerpQY = cY;
slerpQZ = cZ;
slerpQW = w;
}
let x1 = slerpQX;
let y1 = slerpQY;
let z1 = slerpQZ;
let w1 = slerpQW;
let x21 = 2 * x1;
let y21 = 2 * y1;
let z21 = 2 * z1;
let xx1 = x1 * x21;
let yy1 = y1 * y21;
let zz1 = z1 * z21;
let xy1 = x1 * y21;
let yz1 = y1 * z21;
let xz1 = x1 * z21;
let wx1 = w1 * x21;
let wy1 = w1 * y21;
let wz1 = w1 * z21;
slerpM00 = 1 - yy1 - zz1;
slerpM01 = xy1 - wz1;
slerpM02 = xz1 + wy1;
slerpM10 = xy1 + wz1;
slerpM11 = 1 - xx1 - zz1;
slerpM12 = yz1 - wx1;
slerpM20 = xz1 - wy1;
slerpM21 = yz1 + wx1;
slerpM22 = 1 - xx1 - yy1;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = slerpM00 * prevYX + slerpM01 * prevYY + slerpM02 * prevYZ;
__tmp__Y1 = slerpM10 * prevYX + slerpM11 * prevYY + slerpM12 * prevYZ;
__tmp__Z1 = slerpM20 * prevYX + slerpM21 * prevYY + slerpM22 * prevYZ;
newYX = __tmp__X1;
newYY = __tmp__Y1;
newYZ = __tmp__Z1;
newZX = newXY * newYZ - newXZ * newYY;
newZY = newXZ * newYX - newXX * newYZ;
newZZ = newXX * newYY - newXY * newYX;
if(newZX * newZX + newZY * newZY + newZZ * newZZ > 1e-6) {
let l = newZX * newZX + newZY * newZY + newZZ * newZZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
newZX *= l;
newZY *= l;
newZZ *= l;
} else {
let x1 = newXX;
let y1 = newXY;
let z1 = newXZ;
let x2 = x1 * x1;
let y2 = y1 * y1;
let z2 = z1 * z1;
let d;
if(x2 < y2) {
if(x2 < z2) {
d = 1 / Math.sqrt(y2 + z2);
newZX = 0;
newZY = z1 * d;
newZZ = -y1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
newZX = y1 * d;
newZY = -x1 * d;
newZZ = 0;
}
} else if(y2 < z2) {
d = 1 / Math.sqrt(z2 + x2);
newZX = -z1 * d;
newZY = 0;
newZZ = x1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
newZX = y1 * d;
newZY = -x1 * d;
newZZ = 0;
}
}
newYX = newZY * newXZ - newZZ * newXY;
newYY = newZZ * newXX - newZX * newXZ;
newYZ = newZX * newXY - newZY * newXX;
_this.xX = newXX;
_this.xY = newXY;
_this.xZ = newXZ;
_this.yX = newYX;
_this.yY = newYY;
_this.yZ = newYZ;
_this.zX = newZX;
_this.zY = newZY;
_this.zZ = newZZ;
let angErrorX;
let angErrorY;
let angErrorZ;
angErrorX = this._basisX1Y * this._basisX2Z - this._basisX1Z * this._basisX2Y;
angErrorY = this._basisX1Z * this._basisX2X - this._basisX1X * this._basisX2Z;
angErrorZ = this._basisX1X * this._basisX2Y - this._basisX1Y * this._basisX2X;
let cos = this._basisX1X * this._basisX2X + this._basisX1Y * this._basisX2Y + this._basisX1Z * this._basisX2Z;
let theta = cos <= -1 ? 3.14159265358979 : cos >= 1 ? 0 : Math.acos(cos);
let l = angErrorX * angErrorX + angErrorY * angErrorY + angErrorZ * angErrorZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
angErrorX *= l;
angErrorY *= l;
angErrorZ *= l;
angErrorX *= theta;
angErrorY *= theta;
angErrorZ *= theta;
this.angularErrorY = angErrorX * this._basis.yX + angErrorY * this._basis.yY + angErrorZ * this._basis.yZ;
this.angularErrorZ = angErrorX * this._basis.zX + angErrorY * this._basis.zY + angErrorZ * this._basis.zZ;
let perpCrossX;
let perpCrossY;
let perpCrossZ;
perpCrossX = this._basisY1Y * this._basisY2Z - this._basisY1Z * this._basisY2Y;
perpCrossY = this._basisY1Z * this._basisY2X - this._basisY1X * this._basisY2Z;
perpCrossZ = this._basisY1X * this._basisY2Y - this._basisY1Y * this._basisY2X;
cos = this._basisY1X * this._basisY2X + this._basisY1Y * this._basisY2Y + this._basisY1Z * this._basisY2Z;
this.angle = cos <= -1 ? 3.14159265358979 : cos >= 1 ? 0 : Math.acos(cos);
if(perpCrossX * this._basis.xX + perpCrossY * this._basis.xY + perpCrossZ * this._basis.xZ < 0) {
this.angle = -this.angle;
}
let anchorDiffX;
let anchorDiffY;
let anchorDiffZ;
anchorDiffX = this._anchor2X - this._anchor1X;
anchorDiffY = this._anchor2Y - this._anchor1Y;
anchorDiffZ = this._anchor2Z - this._anchor1Z;
this.translation = anchorDiffX * this._basis.xX + anchorDiffY * this._basis.xY + anchorDiffZ * this._basis.xZ;
this.linearErrorY = anchorDiffX * this._basis.yX + anchorDiffY * this._basis.yY + anchorDiffZ * this._basis.yZ;
this.linearErrorZ = anchorDiffX * this._basis.zX + anchorDiffY * this._basis.zY + anchorDiffZ * this._basis.zZ;
}
_getVelocitySolverInfo(timeStep,info) {
super._getVelocitySolverInfo(timeStep,info);
this.getInfo(info,timeStep,false);
}
_getPositionSolverInfo(info) {
super._getPositionSolverInfo(info);
this.getInfo(info,null,true);
}
getAxis1() {
let v = new oimo.common.Vec3();
v.x = this._basisX1X;
v.y = this._basisX1Y;
v.z = this._basisX1Z;
return v;
}
getAxis2() {
let v = new oimo.common.Vec3();
v.x = this._basisX2X;
v.y = this._basisX2Y;
v.z = this._basisX2Z;
return v;
}
getAxis1To(axis) {
axis.x = this._basisX1X;
axis.y = this._basisX1Y;
axis.z = this._basisX1Z;
}
getAxis2To(axis) {
axis.x = this._basisX2X;
axis.y = this._basisX2Y;
axis.z = this._basisX2Z;
}
getLocalAxis1() {
let v = new oimo.common.Vec3();
v.x = this._localBasisX1X;
v.y = this._localBasisX1Y;
v.z = this._localBasisX1Z;
return v;
}
getLocalAxis2() {
let v = new oimo.common.Vec3();
v.x = this._localBasisX2X;
v.y = this._localBasisX2Y;
v.z = this._localBasisX2Z;
return v;
}
getLocalAxis1To(axis) {
axis.x = this._localBasisX1X;
axis.y = this._localBasisX1Y;
axis.z = this._localBasisX1Z;
}
getLocalAxis2To(axis) {
axis.x = this._localBasisX2X;
axis.y = this._localBasisX2Y;
axis.z = this._localBasisX2Z;
}
getTranslationalSpringDamper() {
return this._translSd;
}
getRotationalSpringDamper() {
return this._rotSd;
}
getTranslationalLimitMotor() {
return this._translLm;
}
getRotationalLimitMotor() {
return this._rotLm;
}
getAngle() {
return this.angle;
}
getTranslation() {
return this.translation;
}
}
oimo.dynamics.constraint.joint.JointConfig = class oimo_dynamics_constraint_joint_JointConfig {
constructor() {
this.rigidBody1 = null;
this.rigidBody2 = null;
this.localAnchor1 = new oimo.common.Vec3();
this.localAnchor2 = new oimo.common.Vec3();
this.allowCollision = false;
this.solverType = oimo.common.Setting.defaultJointConstraintSolverType;
this.positionCorrectionAlgorithm = oimo.common.Setting.defaultJointPositionCorrectionAlgorithm;
this.breakForce = 0;
this.breakTorque = 0;
}
_init(rb1,rb2,worldAnchor) {
this.rigidBody1 = rb1;
this.rigidBody2 = rb2;
let _this = this.rigidBody1;
let localPoint = this.localAnchor1;
let vX;
let vY;
let vZ;
vX = worldAnchor.x;
vY = worldAnchor.y;
vZ = worldAnchor.z;
vX -= _this._transform._positionX;
vY -= _this._transform._positionY;
vZ -= _this._transform._positionZ;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = _this._transform._rotation00 * vX + _this._transform._rotation10 * vY + _this._transform._rotation20 * vZ;
__tmp__Y = _this._transform._rotation01 * vX + _this._transform._rotation11 * vY + _this._transform._rotation21 * vZ;
__tmp__Z = _this._transform._rotation02 * vX + _this._transform._rotation12 * vY + _this._transform._rotation22 * vZ;
vX = __tmp__X;
vY = __tmp__Y;
vZ = __tmp__Z;
localPoint.x = vX;
localPoint.y = vY;
localPoint.z = vZ;
let _this1 = this.rigidBody2;
let localPoint1 = this.localAnchor2;
let vX1;
let vY1;
let vZ1;
vX1 = worldAnchor.x;
vY1 = worldAnchor.y;
vZ1 = worldAnchor.z;
vX1 -= _this1._transform._positionX;
vY1 -= _this1._transform._positionY;
vZ1 -= _this1._transform._positionZ;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = _this1._transform._rotation00 * vX1 + _this1._transform._rotation10 * vY1 + _this1._transform._rotation20 * vZ1;
__tmp__Y1 = _this1._transform._rotation01 * vX1 + _this1._transform._rotation11 * vY1 + _this1._transform._rotation21 * vZ1;
__tmp__Z1 = _this1._transform._rotation02 * vX1 + _this1._transform._rotation12 * vY1 + _this1._transform._rotation22 * vZ1;
vX1 = __tmp__X1;
vY1 = __tmp__Y1;
vZ1 = __tmp__Z1;
localPoint1.x = vX1;
localPoint1.y = vY1;
localPoint1.z = vZ1;
}
}
oimo.dynamics.constraint.joint.CylindricalJointConfig = class oimo_dynamics_constraint_joint_CylindricalJointConfig extends oimo.dynamics.constraint.joint.JointConfig {
constructor() {
super();
this.localAxis1 = new oimo.common.Vec3(1,0,0);
this.localAxis2 = new oimo.common.Vec3(1,0,0);
this.translationalLimitMotor = new oimo.dynamics.constraint.joint.TranslationalLimitMotor();
this.translationalSpringDamper = new oimo.dynamics.constraint.joint.SpringDamper();
this.rotationalLimitMotor = new oimo.dynamics.constraint.joint.RotationalLimitMotor();
this.rotationalSpringDamper = new oimo.dynamics.constraint.joint.SpringDamper();
}
init(rigidBody1,rigidBody2,worldAnchor,worldAxis) {
this._init(rigidBody1,rigidBody2,worldAnchor);
let localVector = this.localAxis1;
let vX;
let vY;
let vZ;
vX = worldAxis.x;
vY = worldAxis.y;
vZ = worldAxis.z;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = rigidBody1._transform._rotation00 * vX + rigidBody1._transform._rotation10 * vY + rigidBody1._transform._rotation20 * vZ;
__tmp__Y = rigidBody1._transform._rotation01 * vX + rigidBody1._transform._rotation11 * vY + rigidBody1._transform._rotation21 * vZ;
__tmp__Z = rigidBody1._transform._rotation02 * vX + rigidBody1._transform._rotation12 * vY + rigidBody1._transform._rotation22 * vZ;
vX = __tmp__X;
vY = __tmp__Y;
vZ = __tmp__Z;
localVector.x = vX;
localVector.y = vY;
localVector.z = vZ;
let localVector1 = this.localAxis2;
let vX1;
let vY1;
let vZ1;
vX1 = worldAxis.x;
vY1 = worldAxis.y;
vZ1 = worldAxis.z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = rigidBody2._transform._rotation00 * vX1 + rigidBody2._transform._rotation10 * vY1 + rigidBody2._transform._rotation20 * vZ1;
__tmp__Y1 = rigidBody2._transform._rotation01 * vX1 + rigidBody2._transform._rotation11 * vY1 + rigidBody2._transform._rotation21 * vZ1;
__tmp__Z1 = rigidBody2._transform._rotation02 * vX1 + rigidBody2._transform._rotation12 * vY1 + rigidBody2._transform._rotation22 * vZ1;
vX1 = __tmp__X1;
vY1 = __tmp__Y1;
vZ1 = __tmp__Z1;
localVector1.x = vX1;
localVector1.y = vY1;
localVector1.z = vZ1;
return this;
}
}
oimo.dynamics.constraint.joint.GenericJoint = class oimo_dynamics_constraint_joint_GenericJoint extends oimo.dynamics.constraint.joint.Joint {
constructor(config) {
super(config,oimo.dynamics.constraint.joint.JointType.GENERIC);
let tmp;
let _this = config.localBasis1;
if(!(_this.e00 * (_this.e11 * _this.e22 - _this.e12 * _this.e21) - _this.e01 * (_this.e10 * _this.e22 - _this.e12 * _this.e20) + _this.e02 * (_this.e10 * _this.e21 - _this.e11 * _this.e20) < 0)) {
let _this = config.localBasis2;
tmp = _this.e00 * (_this.e11 * _this.e22 - _this.e12 * _this.e21) - _this.e01 * (_this.e10 * _this.e22 - _this.e12 * _this.e20) + _this.e02 * (_this.e10 * _this.e21 - _this.e11 * _this.e20) < 0;
} else {
tmp = true;
}
if(tmp) {
console.log("src/oimo/dynamics/constraint/joint/GenericJoint.hx:50:","[warning] joint basis must be right handed");
}
let lb100;
let lb101;
let lb102;
let lb110;
let lb111;
let lb112;
let lb120;
let lb121;
let lb122;
let lb200;
let lb201;
let lb202;
let lb210;
let lb211;
let lb212;
let lb220;
let lb221;
let lb222;
let m = config.localBasis1;
lb100 = m.e00;
lb101 = m.e01;
lb102 = m.e02;
lb110 = m.e10;
lb111 = m.e11;
lb112 = m.e12;
lb120 = m.e20;
lb121 = m.e21;
lb122 = m.e22;
let m1 = config.localBasis2;
lb200 = m1.e00;
lb201 = m1.e01;
lb202 = m1.e02;
lb210 = m1.e10;
lb211 = m1.e11;
lb212 = m1.e12;
lb220 = m1.e20;
lb221 = m1.e21;
lb222 = m1.e22;
this._localBasisX1X = lb100;
this._localBasisX1Y = lb110;
this._localBasisX1Z = lb120;
this._localBasisY1X = lb101;
this._localBasisY1Y = lb111;
this._localBasisY1Z = lb121;
this._localBasisZ1X = lb102;
this._localBasisZ1Y = lb112;
this._localBasisZ1Z = lb122;
this._localBasisX2X = lb200;
this._localBasisX2Y = lb210;
this._localBasisX2Z = lb220;
this._localBasisY2X = lb201;
this._localBasisY2Y = lb211;
this._localBasisY2Z = lb221;
this._localBasisZ2X = lb202;
this._localBasisZ2Y = lb212;
this._localBasisZ2Z = lb222;
this._angleX = 0;
this._angleY = 0;
this._angleZ = 0;
this.translationX = 0;
this.translationY = 0;
this.translationZ = 0;
this.xSingular = false;
this.ySingular = false;
this.zSingular = false;
this._translLms = new Array(3);
this._translSds = new Array(3);
this._rotLms = new Array(3);
this._rotSds = new Array(3);
this._translLms[0] = config.translationalLimitMotors[0].clone();
this._translLms[1] = config.translationalLimitMotors[1].clone();
this._translLms[2] = config.translationalLimitMotors[2].clone();
this._translSds[0] = config.translationalSpringDampers[0].clone();
this._translSds[1] = config.translationalSpringDampers[1].clone();
this._translSds[2] = config.translationalSpringDampers[2].clone();
this._rotLms[0] = config.rotationalLimitMotors[0].clone();
this._rotLms[1] = config.rotationalLimitMotors[1].clone();
this._rotLms[2] = config.rotationalLimitMotors[2].clone();
this._rotSds[0] = config.rotationalSpringDampers[0].clone();
this._rotSds[1] = config.rotationalSpringDampers[1].clone();
this._rotSds[2] = config.rotationalSpringDampers[2].clone();
}
getInfo(info,timeStep,isPositionPart) {
let j;
let translMotorMass = 1 / (this._b1._invMass + this._b2._invMass);
let motorMassX = this.computeEffectiveInertiaMoment(this._axisXX,this._axisXY,this._axisXZ);
let motorMassY = this.computeEffectiveInertiaMoment(this._axisYX,this._axisYY,this._axisYZ);
let motorMassZ = this.computeEffectiveInertiaMoment(this._axisZX,this._axisZY,this._axisZZ);
if(this._translSds[0].frequency <= 0 || !isPositionPart) {
let impulse = this._impulses[0];
let row = info.rows[info.numRows++];
let _this = row.jacobian;
_this.lin1X = 0;
_this.lin1Y = 0;
_this.lin1Z = 0;
_this.lin2X = 0;
_this.lin2Y = 0;
_this.lin2Z = 0;
_this.ang1X = 0;
_this.ang1Y = 0;
_this.ang1Z = 0;
_this.ang2X = 0;
_this.ang2Y = 0;
_this.ang2Z = 0;
row.rhs = 0;
row.cfm = 0;
row.minImpulse = 0;
row.maxImpulse = 0;
row.motorSpeed = 0;
row.motorMaxImpulse = 0;
row.impulse = null;
row.impulse = impulse;
this.setSolverInfoRowLinear(row,this.translationX,this._translLms[0],translMotorMass,this._translSds[0],timeStep,isPositionPart);
j = row.jacobian;
j.lin1X = this._basisX1X;
j.lin1Y = this._basisX1Y;
j.lin1Z = this._basisX1Z;
j.lin2X = this._basisX1X;
j.lin2Y = this._basisX1Y;
j.lin2Z = this._basisX1Z;
j.ang1X = this._relativeAnchor1Y * this._basisX1Z - this._relativeAnchor1Z * this._basisX1Y;
j.ang1Y = this._relativeAnchor1Z * this._basisX1X - this._relativeAnchor1X * this._basisX1Z;
j.ang1Z = this._relativeAnchor1X * this._basisX1Y - this._relativeAnchor1Y * this._basisX1X;
j.ang2X = this._relativeAnchor2Y * this._basisX1Z - this._relativeAnchor2Z * this._basisX1Y;
j.ang2Y = this._relativeAnchor2Z * this._basisX1X - this._relativeAnchor2X * this._basisX1Z;
j.ang2Z = this._relativeAnchor2X * this._basisX1Y - this._relativeAnchor2Y * this._basisX1X;
}
if(this._translSds[1].frequency <= 0 || !isPositionPart) {
let impulse = this._impulses[1];
let row = info.rows[info.numRows++];
let _this = row.jacobian;
_this.lin1X = 0;
_this.lin1Y = 0;
_this.lin1Z = 0;
_this.lin2X = 0;
_this.lin2Y = 0;
_this.lin2Z = 0;
_this.ang1X = 0;
_this.ang1Y = 0;
_this.ang1Z = 0;
_this.ang2X = 0;
_this.ang2Y = 0;
_this.ang2Z = 0;
row.rhs = 0;
row.cfm = 0;
row.minImpulse = 0;
row.maxImpulse = 0;
row.motorSpeed = 0;
row.motorMaxImpulse = 0;
row.impulse = null;
row.impulse = impulse;
this.setSolverInfoRowLinear(row,this.translationY,this._translLms[1],translMotorMass,this._translSds[1],timeStep,isPositionPart);
j = row.jacobian;
j.lin1X = this._basisY1X;
j.lin1Y = this._basisY1Y;
j.lin1Z = this._basisY1Z;
j.lin2X = this._basisY1X;
j.lin2Y = this._basisY1Y;
j.lin2Z = this._basisY1Z;
j.ang1X = this._relativeAnchor1Y * this._basisY1Z - this._relativeAnchor1Z * this._basisY1Y;
j.ang1Y = this._relativeAnchor1Z * this._basisY1X - this._relativeAnchor1X * this._basisY1Z;
j.ang1Z = this._relativeAnchor1X * this._basisY1Y - this._relativeAnchor1Y * this._basisY1X;
j.ang2X = this._relativeAnchor2Y * this._basisY1Z - this._relativeAnchor2Z * this._basisY1Y;
j.ang2Y = this._relativeAnchor2Z * this._basisY1X - this._relativeAnchor2X * this._basisY1Z;
j.ang2Z = this._relativeAnchor2X * this._basisY1Y - this._relativeAnchor2Y * this._basisY1X;
}
if(this._translSds[2].frequency <= 0 || !isPositionPart) {
let impulse = this._impulses[2];
let row = info.rows[info.numRows++];
let _this = row.jacobian;
_this.lin1X = 0;
_this.lin1Y = 0;
_this.lin1Z = 0;
_this.lin2X = 0;
_this.lin2Y = 0;
_this.lin2Z = 0;
_this.ang1X = 0;
_this.ang1Y = 0;
_this.ang1Z = 0;
_this.ang2X = 0;
_this.ang2Y = 0;
_this.ang2Z = 0;
row.rhs = 0;
row.cfm = 0;
row.minImpulse = 0;
row.maxImpulse = 0;
row.motorSpeed = 0;
row.motorMaxImpulse = 0;
row.impulse = null;
row.impulse = impulse;
this.setSolverInfoRowLinear(row,this.translationZ,this._translLms[2],translMotorMass,this._translSds[2],timeStep,isPositionPart);
j = row.jacobian;
j.lin1X = this._basisZ1X;
j.lin1Y = this._basisZ1Y;
j.lin1Z = this._basisZ1Z;
j.lin2X = this._basisZ1X;
j.lin2Y = this._basisZ1Y;
j.lin2Z = this._basisZ1Z;
j.ang1X = this._relativeAnchor1Y * this._basisZ1Z - this._relativeAnchor1Z * this._basisZ1Y;
j.ang1Y = this._relativeAnchor1Z * this._basisZ1X - this._relativeAnchor1X * this._basisZ1Z;
j.ang1Z = this._relativeAnchor1X * this._basisZ1Y - this._relativeAnchor1Y * this._basisZ1X;
j.ang2X = this._relativeAnchor2Y * this._basisZ1Z - this._relativeAnchor2Z * this._basisZ1Y;
j.ang2Y = this._relativeAnchor2Z * this._basisZ1X - this._relativeAnchor2X * this._basisZ1Z;
j.ang2Z = this._relativeAnchor2X * this._basisZ1Y - this._relativeAnchor2Y * this._basisZ1X;
}
if(!this.xSingular && (this._rotSds[0].frequency <= 0 || !isPositionPart)) {
let impulse = this._impulses[3];
let row = info.rows[info.numRows++];
let _this = row.jacobian;
_this.lin1X = 0;
_this.lin1Y = 0;
_this.lin1Z = 0;
_this.lin2X = 0;
_this.lin2Y = 0;
_this.lin2Z = 0;
_this.ang1X = 0;
_this.ang1Y = 0;
_this.ang1Z = 0;
_this.ang2X = 0;
_this.ang2Y = 0;
_this.ang2Z = 0;
row.rhs = 0;
row.cfm = 0;
row.minImpulse = 0;
row.maxImpulse = 0;
row.motorSpeed = 0;
row.motorMaxImpulse = 0;
row.impulse = null;
row.impulse = impulse;
this.setSolverInfoRowAngular(row,this._angleX,this._rotLms[0],motorMassX,this._rotSds[0],timeStep,isPositionPart);
j = row.jacobian;
j.ang1X = this._axisXX;
j.ang1Y = this._axisXY;
j.ang1Z = this._axisXZ;
j.ang2X = this._axisXX;
j.ang2Y = this._axisXY;
j.ang2Z = this._axisXZ;
}
if(!this.ySingular && (this._rotSds[1].frequency <= 0 || !isPositionPart)) {
let impulse = this._impulses[4];
let row = info.rows[info.numRows++];
let _this = row.jacobian;
_this.lin1X = 0;
_this.lin1Y = 0;
_this.lin1Z = 0;
_this.lin2X = 0;
_this.lin2Y = 0;
_this.lin2Z = 0;
_this.ang1X = 0;
_this.ang1Y = 0;
_this.ang1Z = 0;
_this.ang2X = 0;
_this.ang2Y = 0;
_this.ang2Z = 0;
row.rhs = 0;
row.cfm = 0;
row.minImpulse = 0;
row.maxImpulse = 0;
row.motorSpeed = 0;
row.motorMaxImpulse = 0;
row.impulse = null;
row.impulse = impulse;
this.setSolverInfoRowAngular(row,this._angleY,this._rotLms[1],motorMassY,this._rotSds[1],timeStep,isPositionPart);
j = row.jacobian;
j.ang1X = this._axisYX;
j.ang1Y = this._axisYY;
j.ang1Z = this._axisYZ;
j.ang2X = this._axisYX;
j.ang2Y = this._axisYY;
j.ang2Z = this._axisYZ;
}
if(!this.zSingular && (this._rotSds[2].frequency <= 0 || !isPositionPart)) {
let impulse = this._impulses[5];
let row = info.rows[info.numRows++];
let _this = row.jacobian;
_this.lin1X = 0;
_this.lin1Y = 0;
_this.lin1Z = 0;
_this.lin2X = 0;
_this.lin2Y = 0;
_this.lin2Z = 0;
_this.ang1X = 0;
_this.ang1Y = 0;
_this.ang1Z = 0;
_this.ang2X = 0;
_this.ang2Y = 0;
_this.ang2Z = 0;
row.rhs = 0;
row.cfm = 0;
row.minImpulse = 0;
row.maxImpulse = 0;
row.motorSpeed = 0;
row.motorMaxImpulse = 0;
row.impulse = null;
row.impulse = impulse;
this.setSolverInfoRowAngular(row,this._angleZ,this._rotLms[2],motorMassZ,this._rotSds[2],timeStep,isPositionPart);
j = row.jacobian;
j.ang1X = this._axisZX;
j.ang1Y = this._axisZY;
j.ang1Z = this._axisZZ;
j.ang2X = this._axisZX;
j.ang2Y = this._axisZY;
j.ang2Z = this._axisZZ;
}
}
_syncAnchors() {
super._syncAnchors();
let angleAxisXX;
let angleAxisXY;
let angleAxisXZ;
let angleAxisYX;
let angleAxisYY;
let angleAxisYZ;
let angleAxisZX;
let angleAxisZY;
let angleAxisZZ;
angleAxisXX = this._basisX1X;
angleAxisXY = this._basisX1Y;
angleAxisXZ = this._basisX1Z;
angleAxisZX = this._basisZ2X;
angleAxisZY = this._basisZ2Y;
angleAxisZZ = this._basisZ2Z;
angleAxisYX = angleAxisZY * angleAxisXZ - angleAxisZZ * angleAxisXY;
angleAxisYY = angleAxisZZ * angleAxisXX - angleAxisZX * angleAxisXZ;
angleAxisYZ = angleAxisZX * angleAxisXY - angleAxisZY * angleAxisXX;
this._axisXX = angleAxisYY * angleAxisZZ - angleAxisYZ * angleAxisZY;
this._axisXY = angleAxisYZ * angleAxisZX - angleAxisYX * angleAxisZZ;
this._axisXZ = angleAxisYX * angleAxisZY - angleAxisYY * angleAxisZX;
this._axisYX = angleAxisYX;
this._axisYY = angleAxisYY;
this._axisYZ = angleAxisYZ;
this._axisZX = angleAxisXY * angleAxisYZ - angleAxisXZ * angleAxisYY;
this._axisZY = angleAxisXZ * angleAxisYX - angleAxisXX * angleAxisYZ;
this._axisZZ = angleAxisXX * angleAxisYY - angleAxisXY * angleAxisYX;
let l = this._axisXX * this._axisXX + this._axisXY * this._axisXY + this._axisXZ * this._axisXZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
this._axisXX *= l;
this._axisXY *= l;
this._axisXZ *= l;
let l1 = this._axisYX * this._axisYX + this._axisYY * this._axisYY + this._axisYZ * this._axisYZ;
if(l1 > 0) {
l1 = 1 / Math.sqrt(l1);
}
this._axisYX *= l1;
this._axisYY *= l1;
this._axisYZ *= l1;
let l2 = this._axisZX * this._axisZX + this._axisZY * this._axisZY + this._axisZZ * this._axisZZ;
if(l2 > 0) {
l2 = 1 / Math.sqrt(l2);
}
this._axisZX *= l2;
this._axisZY *= l2;
this._axisZZ *= l2;
this.xSingular = this._axisXX * this._axisXX + this._axisXY * this._axisXY + this._axisXZ * this._axisXZ == 0;
this.ySingular = this._axisYX * this._axisYX + this._axisYY * this._axisYY + this._axisYZ * this._axisYZ == 0;
this.zSingular = this._axisZX * this._axisZX + this._axisZY * this._axisZY + this._axisZZ * this._axisZZ == 0;
let rot100;
let rot101;
let rot102;
let rot110;
let rot111;
let rot112;
let rot120;
let rot121;
let rot122;
let rot200;
let rot201;
let rot202;
let rot210;
let rot211;
let rot212;
let rot220;
let rot221;
let rot222;
rot100 = this._basisX1X;
rot101 = this._basisY1X;
rot102 = this._basisZ1X;
rot110 = this._basisX1Y;
rot111 = this._basisY1Y;
rot112 = this._basisZ1Y;
rot120 = this._basisX1Z;
rot121 = this._basisY1Z;
rot122 = this._basisZ1Z;
rot200 = this._basisX2X;
rot201 = this._basisY2X;
rot202 = this._basisZ2X;
rot210 = this._basisX2Y;
rot211 = this._basisY2Y;
rot212 = this._basisZ2Y;
rot220 = this._basisX2Z;
rot221 = this._basisY2Z;
rot222 = this._basisZ2Z;
let relRot00;
let relRot01;
let relRot02;
let relRot11;
let relRot12;
let relRot21;
let relRot22;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__11;
let __tmp__12;
let __tmp__21;
let __tmp__22;
__tmp__00 = rot100 * rot200 + rot110 * rot210 + rot120 * rot220;
__tmp__01 = rot100 * rot201 + rot110 * rot211 + rot120 * rot221;
__tmp__02 = rot100 * rot202 + rot110 * rot212 + rot120 * rot222;
__tmp__11 = rot101 * rot201 + rot111 * rot211 + rot121 * rot221;
__tmp__12 = rot101 * rot202 + rot111 * rot212 + rot121 * rot222;
__tmp__21 = rot102 * rot201 + rot112 * rot211 + rot122 * rot221;
__tmp__22 = rot102 * rot202 + rot112 * rot212 + rot122 * rot222;
relRot00 = __tmp__00;
relRot01 = __tmp__01;
relRot02 = __tmp__02;
relRot11 = __tmp__11;
relRot12 = __tmp__12;
relRot21 = __tmp__21;
relRot22 = __tmp__22;
let anglesX;
let anglesY;
let anglesZ;
let sy = relRot02;
if(sy <= -1) {
let xSubZ = Math.atan2(relRot21,relRot11);
anglesX = xSubZ * 0.5;
anglesY = -1.570796326794895;
anglesZ = -xSubZ * 0.5;
} else if(sy >= 1) {
let xAddZ = Math.atan2(relRot21,relRot11);
anglesX = xAddZ * 0.5;
anglesY = 1.570796326794895;
anglesZ = xAddZ * 0.5;
} else {
anglesX = Math.atan2(-relRot12,relRot22);
anglesY = Math.asin(sy);
anglesZ = Math.atan2(-relRot01,relRot00);
}
this._angleX = anglesX;
this._angleY = anglesY;
this._angleZ = anglesZ;
let anchorDiffX;
let anchorDiffY;
let anchorDiffZ;
anchorDiffX = this._anchor2X - this._anchor1X;
anchorDiffY = this._anchor2Y - this._anchor1Y;
anchorDiffZ = this._anchor2Z - this._anchor1Z;
this.translationX = anchorDiffX * this._basisX1X + anchorDiffY * this._basisX1Y + anchorDiffZ * this._basisX1Z;
this.translationY = anchorDiffX * this._basisY1X + anchorDiffY * this._basisY1Y + anchorDiffZ * this._basisY1Z;
this.translationZ = anchorDiffX * this._basisZ1X + anchorDiffY * this._basisZ1Y + anchorDiffZ * this._basisZ1Z;
}
_getVelocitySolverInfo(timeStep,info) {
super._getVelocitySolverInfo(timeStep,info);
this.getInfo(info,timeStep,false);
}
_getPositionSolverInfo(info) {
super._getPositionSolverInfo(info);
this.getInfo(info,null,true);
}
getAxisX() {
let v = new oimo.common.Vec3();
v.x = this._basisX1X;
v.y = this._basisX1Y;
v.z = this._basisX1Z;
return v;
}
getAxisY() {
let v = new oimo.common.Vec3();
v.x = this._axisYX;
v.y = this._axisYY;
v.z = this._axisYZ;
return v;
}
getAxisZ() {
let v = new oimo.common.Vec3();
v.x = this._basisZ2X;
v.y = this._basisZ2Y;
v.z = this._basisZ2Z;
return v;
}
getTranslationalSpringDampers() {
return this._translSds.slice(0);
}
getRotationalSpringDampers() {
return this._translSds.slice(0);
}
getTranslationalLimitMotors() {
return this._translLms.slice(0);
}
getRotationalLimitMotors() {
return this._rotLms.slice(0);
}
getAngles() {
return new oimo.common.Vec3(this._angleX,this._angleY,this._angleZ);
}
getTranslations() {
return new oimo.common.Vec3(this.translationX,this.translationY,this.translationZ);
}
}
oimo.dynamics.constraint.joint.GenericJointConfig = class oimo_dynamics_constraint_joint_GenericJointConfig extends oimo.dynamics.constraint.joint.JointConfig {
constructor() {
super();
this.localBasis1 = new oimo.common.Mat3();
this.localBasis2 = new oimo.common.Mat3();
let _g = [];
_g.push(new oimo.dynamics.constraint.joint.TranslationalLimitMotor().setLimits(0,0));
_g.push(new oimo.dynamics.constraint.joint.TranslationalLimitMotor().setLimits(0,0));
_g.push(new oimo.dynamics.constraint.joint.TranslationalLimitMotor().setLimits(0,0));
this.translationalLimitMotors = _g;
let _g1 = [];
_g1.push(new oimo.dynamics.constraint.joint.RotationalLimitMotor().setLimits(0,0));
_g1.push(new oimo.dynamics.constraint.joint.RotationalLimitMotor().setLimits(0,0));
_g1.push(new oimo.dynamics.constraint.joint.RotationalLimitMotor().setLimits(0,0));
this.rotationalLimitMotors = _g1;
this.translationalSpringDampers = [new oimo.dynamics.constraint.joint.SpringDamper(),new oimo.dynamics.constraint.joint.SpringDamper(),new oimo.dynamics.constraint.joint.SpringDamper()];
this.rotationalSpringDampers = [new oimo.dynamics.constraint.joint.SpringDamper(),new oimo.dynamics.constraint.joint.SpringDamper(),new oimo.dynamics.constraint.joint.SpringDamper()];
}
init(rigidBody1,rigidBody2,worldAnchor,worldBasis1,worldBasis2) {
this._init(rigidBody1,rigidBody2,worldAnchor);
let tf1 = rigidBody1._transform;
let tf2 = rigidBody2._transform;
let wb100;
let wb101;
let wb102;
let wb110;
let wb111;
let wb112;
let wb120;
let wb121;
let wb122;
let wb200;
let wb201;
let wb202;
let wb210;
let wb211;
let wb212;
let wb220;
let wb221;
let wb222;
let lb100;
let lb101;
let lb102;
let lb110;
let lb111;
let lb112;
let lb120;
let lb121;
let lb122;
let lb200;
let lb201;
let lb202;
let lb210;
let lb211;
let lb212;
let lb220;
let lb221;
let lb222;
wb100 = worldBasis1.e00;
wb101 = worldBasis1.e01;
wb102 = worldBasis1.e02;
wb110 = worldBasis1.e10;
wb111 = worldBasis1.e11;
wb112 = worldBasis1.e12;
wb120 = worldBasis1.e20;
wb121 = worldBasis1.e21;
wb122 = worldBasis1.e22;
wb200 = worldBasis2.e00;
wb201 = worldBasis2.e01;
wb202 = worldBasis2.e02;
wb210 = worldBasis2.e10;
wb211 = worldBasis2.e11;
wb212 = worldBasis2.e12;
wb220 = worldBasis2.e20;
wb221 = worldBasis2.e21;
wb222 = worldBasis2.e22;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = tf1._rotation00 * wb100 + tf1._rotation10 * wb110 + tf1._rotation20 * wb120;
__tmp__01 = tf1._rotation00 * wb101 + tf1._rotation10 * wb111 + tf1._rotation20 * wb121;
__tmp__02 = tf1._rotation00 * wb102 + tf1._rotation10 * wb112 + tf1._rotation20 * wb122;
__tmp__10 = tf1._rotation01 * wb100 + tf1._rotation11 * wb110 + tf1._rotation21 * wb120;
__tmp__11 = tf1._rotation01 * wb101 + tf1._rotation11 * wb111 + tf1._rotation21 * wb121;
__tmp__12 = tf1._rotation01 * wb102 + tf1._rotation11 * wb112 + tf1._rotation21 * wb122;
__tmp__20 = tf1._rotation02 * wb100 + tf1._rotation12 * wb110 + tf1._rotation22 * wb120;
__tmp__21 = tf1._rotation02 * wb101 + tf1._rotation12 * wb111 + tf1._rotation22 * wb121;
__tmp__22 = tf1._rotation02 * wb102 + tf1._rotation12 * wb112 + tf1._rotation22 * wb122;
lb100 = __tmp__00;
lb101 = __tmp__01;
lb102 = __tmp__02;
lb110 = __tmp__10;
lb111 = __tmp__11;
lb112 = __tmp__12;
lb120 = __tmp__20;
lb121 = __tmp__21;
lb122 = __tmp__22;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = tf2._rotation00 * wb200 + tf2._rotation10 * wb210 + tf2._rotation20 * wb220;
__tmp__011 = tf2._rotation00 * wb201 + tf2._rotation10 * wb211 + tf2._rotation20 * wb221;
__tmp__021 = tf2._rotation00 * wb202 + tf2._rotation10 * wb212 + tf2._rotation20 * wb222;
__tmp__101 = tf2._rotation01 * wb200 + tf2._rotation11 * wb210 + tf2._rotation21 * wb220;
__tmp__111 = tf2._rotation01 * wb201 + tf2._rotation11 * wb211 + tf2._rotation21 * wb221;
__tmp__121 = tf2._rotation01 * wb202 + tf2._rotation11 * wb212 + tf2._rotation21 * wb222;
__tmp__201 = tf2._rotation02 * wb200 + tf2._rotation12 * wb210 + tf2._rotation22 * wb220;
__tmp__211 = tf2._rotation02 * wb201 + tf2._rotation12 * wb211 + tf2._rotation22 * wb221;
__tmp__221 = tf2._rotation02 * wb202 + tf2._rotation12 * wb212 + tf2._rotation22 * wb222;
lb200 = __tmp__001;
lb201 = __tmp__011;
lb202 = __tmp__021;
lb210 = __tmp__101;
lb211 = __tmp__111;
lb212 = __tmp__121;
lb220 = __tmp__201;
lb221 = __tmp__211;
lb222 = __tmp__221;
let m = this.localBasis1;
m.e00 = lb100;
m.e01 = lb101;
m.e02 = lb102;
m.e10 = lb110;
m.e11 = lb111;
m.e12 = lb112;
m.e20 = lb120;
m.e21 = lb121;
m.e22 = lb122;
let m1 = this.localBasis2;
m1.e00 = lb200;
m1.e01 = lb201;
m1.e02 = lb202;
m1.e10 = lb210;
m1.e11 = lb211;
m1.e12 = lb212;
m1.e20 = lb220;
m1.e21 = lb221;
m1.e22 = lb222;
return this;
}
}
oimo.dynamics.constraint.joint.JointImpulse = class oimo_dynamics_constraint_joint_JointImpulse {
constructor() {
this.impulse = 0;
this.impulseM = 0;
this.impulseP = 0;
}
}
oimo.dynamics.constraint.joint.JointLink = class oimo_dynamics_constraint_joint_JointLink {
constructor(joint) {
this._joint = joint;
}
getContact() {
return this._joint;
}
getOther() {
return this._other;
}
getPrev() {
return this._prev;
}
getNext() {
return this._next;
}
}
oimo.dynamics.constraint.joint.JointMacro = class oimo_dynamics_constraint_joint_JointMacro {
}
oimo.dynamics.constraint.joint.JointType = class oimo_dynamics_constraint_joint_JointType {
}
oimo.dynamics.constraint.joint.PrismaticJoint = class oimo_dynamics_constraint_joint_PrismaticJoint extends oimo.dynamics.constraint.joint.Joint {
constructor(config) {
super(config,oimo.dynamics.constraint.joint.JointType.PRISMATIC);
let v = config.localAxis1;
this._localBasisX1X = v.x;
this._localBasisX1Y = v.y;
this._localBasisX1Z = v.z;
let v1 = config.localAxis2;
this._localBasisX2X = v1.x;
this._localBasisX2Y = v1.y;
this._localBasisX2Z = v1.z;
this.buildLocalBasesFromX();
this._basis = new oimo.dynamics.constraint.joint.BasisTracker(this);
this.translation = 0;
this.linearErrorY = 0;
this.linearErrorZ = 0;
this.angularErrorX = 0;
this.angularErrorY = 0;
this.angularErrorZ = 0;
this._sd = config.springDamper.clone();
this._lm = config.limitMotor.clone();
}
getInfo(info,timeStep,isPositionPart) {
let erp = this.getErp(timeStep,isPositionPart);
let linRhsY = this.linearErrorY * erp;
let linRhsZ = this.linearErrorZ * erp;
let angRhsX = this.angularErrorX * erp;
let angRhsY = this.angularErrorY * erp;
let angRhsZ = this.angularErrorZ * erp;
let j;
if(this._sd.frequency <= 0 || !isPositionPart) {
let impulse = this._impulses[0];
let row = info.rows[info.numRows++];
let _this = row.jacobian;
_this.lin1X = 0;
_this.lin1Y = 0;
_this.lin1Z = 0;
_this.lin2X = 0;
_this.lin2Y = 0;
_this.lin2Z = 0;
_this.ang1X = 0;
_this.ang1Y = 0;
_this.ang1Z = 0;
_this.ang2X = 0;
_this.ang2Y = 0;
_this.ang2Z = 0;
row.rhs = 0;
row.cfm = 0;
row.minImpulse = 0;
row.maxImpulse = 0;
row.motorSpeed = 0;
row.motorMaxImpulse = 0;
row.impulse = null;
row.impulse = impulse;
this.setSolverInfoRowLinear(row,this.translation,this._lm,1 / (this._b1._invMass + this._b2._invMass),this._sd,timeStep,isPositionPart);
j = row.jacobian;
j.lin1X = this._basis.xX;
j.lin1Y = this._basis.xY;
j.lin1Z = this._basis.xZ;
j.lin2X = this._basis.xX;
j.lin2Y = this._basis.xY;
j.lin2Z = this._basis.xZ;
j.ang1X = this._relativeAnchor1Y * this._basis.xZ - this._relativeAnchor1Z * this._basis.xY;
j.ang1Y = this._relativeAnchor1Z * this._basis.xX - this._relativeAnchor1X * this._basis.xZ;
j.ang1Z = this._relativeAnchor1X * this._basis.xY - this._relativeAnchor1Y * this._basis.xX;
j.ang2X = this._relativeAnchor2Y * this._basis.xZ - this._relativeAnchor2Z * this._basis.xY;
j.ang2Y = this._relativeAnchor2Z * this._basis.xX - this._relativeAnchor2X * this._basis.xZ;
j.ang2Z = this._relativeAnchor2X * this._basis.xY - this._relativeAnchor2Y * this._basis.xX;
}
let impulse = this._impulses[1];
let row = info.rows[info.numRows++];
let _this = row.jacobian;
_this.lin1X = 0;
_this.lin1Y = 0;
_this.lin1Z = 0;
_this.lin2X = 0;
_this.lin2Y = 0;
_this.lin2Z = 0;
_this.ang1X = 0;
_this.ang1Y = 0;
_this.ang1Z = 0;
_this.ang2X = 0;
_this.ang2Y = 0;
_this.ang2Z = 0;
row.rhs = 0;
row.cfm = 0;
row.minImpulse = 0;
row.maxImpulse = 0;
row.motorSpeed = 0;
row.motorMaxImpulse = 0;
row.impulse = null;
row.impulse = impulse;
row.rhs = linRhsY;
row.cfm = 0;
row.minImpulse = -1e65536;
row.maxImpulse = 1e65536;
j = row.jacobian;
j.lin1X = this._basis.yX;
j.lin1Y = this._basis.yY;
j.lin1Z = this._basis.yZ;
j.lin2X = this._basis.yX;
j.lin2Y = this._basis.yY;
j.lin2Z = this._basis.yZ;
j.ang1X = this._relativeAnchor1Y * this._basis.yZ - this._relativeAnchor1Z * this._basis.yY;
j.ang1Y = this._relativeAnchor1Z * this._basis.yX - this._relativeAnchor1X * this._basis.yZ;
j.ang1Z = this._relativeAnchor1X * this._basis.yY - this._relativeAnchor1Y * this._basis.yX;
j.ang2X = this._relativeAnchor2Y * this._basis.yZ - this._relativeAnchor2Z * this._basis.yY;
j.ang2Y = this._relativeAnchor2Z * this._basis.yX - this._relativeAnchor2X * this._basis.yZ;
j.ang2Z = this._relativeAnchor2X * this._basis.yY - this._relativeAnchor2Y * this._basis.yX;
let impulse1 = this._impulses[2];
let row1 = info.rows[info.numRows++];
let _this1 = row1.jacobian;
_this1.lin1X = 0;
_this1.lin1Y = 0;
_this1.lin1Z = 0;
_this1.lin2X = 0;
_this1.lin2Y = 0;
_this1.lin2Z = 0;
_this1.ang1X = 0;
_this1.ang1Y = 0;
_this1.ang1Z = 0;
_this1.ang2X = 0;
_this1.ang2Y = 0;
_this1.ang2Z = 0;
row1.rhs = 0;
row1.cfm = 0;
row1.minImpulse = 0;
row1.maxImpulse = 0;
row1.motorSpeed = 0;
row1.motorMaxImpulse = 0;
row1.impulse = null;
row1.impulse = impulse1;
row1.rhs = linRhsZ;
row1.cfm = 0;
row1.minImpulse = -1e65536;
row1.maxImpulse = 1e65536;
j = row1.jacobian;
j.lin1X = this._basis.zX;
j.lin1Y = this._basis.zY;
j.lin1Z = this._basis.zZ;
j.lin2X = this._basis.zX;
j.lin2Y = this._basis.zY;
j.lin2Z = this._basis.zZ;
j.ang1X = this._relativeAnchor1Y * this._basis.zZ - this._relativeAnchor1Z * this._basis.zY;
j.ang1Y = this._relativeAnchor1Z * this._basis.zX - this._relativeAnchor1X * this._basis.zZ;
j.ang1Z = this._relativeAnchor1X * this._basis.zY - this._relativeAnchor1Y * this._basis.zX;
j.ang2X = this._relativeAnchor2Y * this._basis.zZ - this._relativeAnchor2Z * this._basis.zY;
j.ang2Y = this._relativeAnchor2Z * this._basis.zX - this._relativeAnchor2X * this._basis.zZ;
j.ang2Z = this._relativeAnchor2X * this._basis.zY - this._relativeAnchor2Y * this._basis.zX;
let impulse2 = this._impulses[3];
let row2 = info.rows[info.numRows++];
let _this2 = row2.jacobian;
_this2.lin1X = 0;
_this2.lin1Y = 0;
_this2.lin1Z = 0;
_this2.lin2X = 0;
_this2.lin2Y = 0;
_this2.lin2Z = 0;
_this2.ang1X = 0;
_this2.ang1Y = 0;
_this2.ang1Z = 0;
_this2.ang2X = 0;
_this2.ang2Y = 0;
_this2.ang2Z = 0;
row2.rhs = 0;
row2.cfm = 0;
row2.minImpulse = 0;
row2.maxImpulse = 0;
row2.motorSpeed = 0;
row2.motorMaxImpulse = 0;
row2.impulse = null;
row2.impulse = impulse2;
row2.rhs = angRhsX;
row2.cfm = 0;
row2.minImpulse = -1e65536;
row2.maxImpulse = 1e65536;
j = row2.jacobian;
j.ang1X = 1;
j.ang1Y = 0;
j.ang1Z = 0;
j.ang2X = 1;
j.ang2Y = 0;
j.ang2Z = 0;
let impulse3 = this._impulses[4];
let row3 = info.rows[info.numRows++];
let _this3 = row3.jacobian;
_this3.lin1X = 0;
_this3.lin1Y = 0;
_this3.lin1Z = 0;
_this3.lin2X = 0;
_this3.lin2Y = 0;
_this3.lin2Z = 0;
_this3.ang1X = 0;
_this3.ang1Y = 0;
_this3.ang1Z = 0;
_this3.ang2X = 0;
_this3.ang2Y = 0;
_this3.ang2Z = 0;
row3.rhs = 0;
row3.cfm = 0;
row3.minImpulse = 0;
row3.maxImpulse = 0;
row3.motorSpeed = 0;
row3.motorMaxImpulse = 0;
row3.impulse = null;
row3.impulse = impulse3;
row3.rhs = angRhsY;
row3.cfm = 0;
row3.minImpulse = -1e65536;
row3.maxImpulse = 1e65536;
j = row3.jacobian;
j.ang1X = 0;
j.ang1Y = 1;
j.ang1Z = 0;
j.ang2X = 0;
j.ang2Y = 1;
j.ang2Z = 0;
let impulse4 = this._impulses[5];
let row4 = info.rows[info.numRows++];
let _this4 = row4.jacobian;
_this4.lin1X = 0;
_this4.lin1Y = 0;
_this4.lin1Z = 0;
_this4.lin2X = 0;
_this4.lin2Y = 0;
_this4.lin2Z = 0;
_this4.ang1X = 0;
_this4.ang1Y = 0;
_this4.ang1Z = 0;
_this4.ang2X = 0;
_this4.ang2Y = 0;
_this4.ang2Z = 0;
row4.rhs = 0;
row4.cfm = 0;
row4.minImpulse = 0;
row4.maxImpulse = 0;
row4.motorSpeed = 0;
row4.motorMaxImpulse = 0;
row4.impulse = null;
row4.impulse = impulse4;
row4.rhs = angRhsZ;
row4.cfm = 0;
row4.minImpulse = -1e65536;
row4.maxImpulse = 1e65536;
j = row4.jacobian;
j.ang1X = 0;
j.ang1Y = 0;
j.ang1Z = 1;
j.ang2X = 0;
j.ang2Y = 0;
j.ang2Z = 1;
}
_syncAnchors() {
super._syncAnchors();
let _this = this._basis;
let invM1 = _this.joint._b1._invMass;
let invM2 = _this.joint._b2._invMass;
let qX;
let qY;
let qZ;
let qW;
let idQX;
let idQY;
let idQZ;
let idQW;
let slerpQX;
let slerpQY;
let slerpQZ;
let slerpQW;
let slerpM00;
let slerpM01;
let slerpM02;
let slerpM10;
let slerpM11;
let slerpM12;
let slerpM20;
let slerpM21;
let slerpM22;
let newXX;
let newXY;
let newXZ;
let newYX;
let newYY;
let newYZ;
let newZX;
let newZY;
let newZZ;
let prevXX;
let prevXY;
let prevXZ;
let prevYX;
let prevYY;
let prevYZ;
let d = _this.joint._basisX1X * _this.joint._basisX2X + _this.joint._basisX1Y * _this.joint._basisX2Y + _this.joint._basisX1Z * _this.joint._basisX2Z;
if(d < -0.999999999) {
let vX;
let vY;
let vZ;
let x1 = _this.joint._basisX1X;
let y1 = _this.joint._basisX1Y;
let z1 = _this.joint._basisX1Z;
let x2 = x1 * x1;
let y2 = y1 * y1;
let z2 = z1 * z1;
let d;
if(x2 < y2) {
if(x2 < z2) {
d = 1 / Math.sqrt(y2 + z2);
vX = 0;
vY = z1 * d;
vZ = -y1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
vX = y1 * d;
vY = -x1 * d;
vZ = 0;
}
} else if(y2 < z2) {
d = 1 / Math.sqrt(z2 + x2);
vX = -z1 * d;
vY = 0;
vZ = x1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
vX = y1 * d;
vY = -x1 * d;
vZ = 0;
}
qX = vX;
qY = vY;
qZ = vZ;
qW = 0;
} else {
let cX;
let cY;
let cZ;
cX = _this.joint._basisX1Y * _this.joint._basisX2Z - _this.joint._basisX1Z * _this.joint._basisX2Y;
cY = _this.joint._basisX1Z * _this.joint._basisX2X - _this.joint._basisX1X * _this.joint._basisX2Z;
cZ = _this.joint._basisX1X * _this.joint._basisX2Y - _this.joint._basisX1Y * _this.joint._basisX2X;
let w = Math.sqrt((1 + d) * 0.5);
d = 0.5 / w;
cX *= d;
cY *= d;
cZ *= d;
qX = cX;
qY = cY;
qZ = cZ;
qW = w;
}
idQX = 0;
idQY = 0;
idQZ = 0;
idQW = 1;
let q1X;
let q1Y;
let q1Z;
let q1W;
let q2X;
let q2Y;
let q2Z;
let q2W;
q1X = idQX;
q1Y = idQY;
q1Z = idQZ;
q1W = idQW;
q2X = qX;
q2Y = qY;
q2Z = qZ;
q2W = qW;
let d1 = q1X * q2X + q1Y * q2Y + q1Z * q2Z + q1W * q2W;
if(d1 < 0) {
d1 = -d1;
q2X = -q2X;
q2Y = -q2Y;
q2Z = -q2Z;
q2W = -q2W;
}
if(d1 > 0.999999) {
let dqX;
let dqY;
let dqZ;
let dqW;
dqX = q2X - q1X;
dqY = q2Y - q1Y;
dqZ = q2Z - q1Z;
dqW = q2W - q1W;
q2X = q1X + dqX * (invM1 / (invM1 + invM2));
q2Y = q1Y + dqY * (invM1 / (invM1 + invM2));
q2Z = q1Z + dqZ * (invM1 / (invM1 + invM2));
q2W = q1W + dqW * (invM1 / (invM1 + invM2));
let l = q2X * q2X + q2Y * q2Y + q2Z * q2Z + q2W * q2W;
if(l > 1e-32) {
l = 1 / Math.sqrt(l);
}
slerpQX = q2X * l;
slerpQY = q2Y * l;
slerpQZ = q2Z * l;
slerpQW = q2W * l;
} else {
let theta = invM1 / (invM1 + invM2) * Math.acos(d1);
q2X += q1X * -d1;
q2Y += q1Y * -d1;
q2Z += q1Z * -d1;
q2W += q1W * -d1;
let l = q2X * q2X + q2Y * q2Y + q2Z * q2Z + q2W * q2W;
if(l > 1e-32) {
l = 1 / Math.sqrt(l);
}
q2X *= l;
q2Y *= l;
q2Z *= l;
q2W *= l;
let sin = Math.sin(theta);
let cos = Math.cos(theta);
q1X *= cos;
q1Y *= cos;
q1Z *= cos;
q1W *= cos;
slerpQX = q1X + q2X * sin;
slerpQY = q1Y + q2Y * sin;
slerpQZ = q1Z + q2Z * sin;
slerpQW = q1W + q2W * sin;
}
let x = slerpQX;
let y = slerpQY;
let z = slerpQZ;
let w = slerpQW;
let x2 = 2 * x;
let y2 = 2 * y;
let z2 = 2 * z;
let xx = x * x2;
let yy = y * y2;
let zz = z * z2;
let xy = x * y2;
let yz = y * z2;
let xz = x * z2;
let wx = w * x2;
let wy = w * y2;
let wz = w * z2;
slerpM00 = 1 - yy - zz;
slerpM01 = xy - wz;
slerpM02 = xz + wy;
slerpM10 = xy + wz;
slerpM11 = 1 - xx - zz;
slerpM12 = yz - wx;
slerpM20 = xz - wy;
slerpM21 = yz + wx;
slerpM22 = 1 - xx - yy;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = slerpM00 * _this.joint._basisX1X + slerpM01 * _this.joint._basisX1Y + slerpM02 * _this.joint._basisX1Z;
__tmp__Y = slerpM10 * _this.joint._basisX1X + slerpM11 * _this.joint._basisX1Y + slerpM12 * _this.joint._basisX1Z;
__tmp__Z = slerpM20 * _this.joint._basisX1X + slerpM21 * _this.joint._basisX1Y + slerpM22 * _this.joint._basisX1Z;
newXX = __tmp__X;
newXY = __tmp__Y;
newXZ = __tmp__Z;
prevXX = _this.xX;
prevXY = _this.xY;
prevXZ = _this.xZ;
prevYX = _this.yX;
prevYY = _this.yY;
prevYZ = _this.yZ;
let d2 = prevXX * newXX + prevXY * newXY + prevXZ * newXZ;
if(d2 < -0.999999999) {
let vX;
let vY;
let vZ;
let x1 = prevXX;
let y1 = prevXY;
let z1 = prevXZ;
let x2 = x1 * x1;
let y2 = y1 * y1;
let z2 = z1 * z1;
let d;
if(x2 < y2) {
if(x2 < z2) {
d = 1 / Math.sqrt(y2 + z2);
vX = 0;
vY = z1 * d;
vZ = -y1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
vX = y1 * d;
vY = -x1 * d;
vZ = 0;
}
} else if(y2 < z2) {
d = 1 / Math.sqrt(z2 + x2);
vX = -z1 * d;
vY = 0;
vZ = x1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
vX = y1 * d;
vY = -x1 * d;
vZ = 0;
}
slerpQX = vX;
slerpQY = vY;
slerpQZ = vZ;
slerpQW = 0;
} else {
let cX;
let cY;
let cZ;
cX = prevXY * newXZ - prevXZ * newXY;
cY = prevXZ * newXX - prevXX * newXZ;
cZ = prevXX * newXY - prevXY * newXX;
let w = Math.sqrt((1 + d2) * 0.5);
d2 = 0.5 / w;
cX *= d2;
cY *= d2;
cZ *= d2;
slerpQX = cX;
slerpQY = cY;
slerpQZ = cZ;
slerpQW = w;
}
let x1 = slerpQX;
let y1 = slerpQY;
let z1 = slerpQZ;
let w1 = slerpQW;
let x21 = 2 * x1;
let y21 = 2 * y1;
let z21 = 2 * z1;
let xx1 = x1 * x21;
let yy1 = y1 * y21;
let zz1 = z1 * z21;
let xy1 = x1 * y21;
let yz1 = y1 * z21;
let xz1 = x1 * z21;
let wx1 = w1 * x21;
let wy1 = w1 * y21;
let wz1 = w1 * z21;
slerpM00 = 1 - yy1 - zz1;
slerpM01 = xy1 - wz1;
slerpM02 = xz1 + wy1;
slerpM10 = xy1 + wz1;
slerpM11 = 1 - xx1 - zz1;
slerpM12 = yz1 - wx1;
slerpM20 = xz1 - wy1;
slerpM21 = yz1 + wx1;
slerpM22 = 1 - xx1 - yy1;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = slerpM00 * prevYX + slerpM01 * prevYY + slerpM02 * prevYZ;
__tmp__Y1 = slerpM10 * prevYX + slerpM11 * prevYY + slerpM12 * prevYZ;
__tmp__Z1 = slerpM20 * prevYX + slerpM21 * prevYY + slerpM22 * prevYZ;
newYX = __tmp__X1;
newYY = __tmp__Y1;
newYZ = __tmp__Z1;
newZX = newXY * newYZ - newXZ * newYY;
newZY = newXZ * newYX - newXX * newYZ;
newZZ = newXX * newYY - newXY * newYX;
if(newZX * newZX + newZY * newZY + newZZ * newZZ > 1e-6) {
let l = newZX * newZX + newZY * newZY + newZZ * newZZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
newZX *= l;
newZY *= l;
newZZ *= l;
} else {
let x1 = newXX;
let y1 = newXY;
let z1 = newXZ;
let x2 = x1 * x1;
let y2 = y1 * y1;
let z2 = z1 * z1;
let d;
if(x2 < y2) {
if(x2 < z2) {
d = 1 / Math.sqrt(y2 + z2);
newZX = 0;
newZY = z1 * d;
newZZ = -y1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
newZX = y1 * d;
newZY = -x1 * d;
newZZ = 0;
}
} else if(y2 < z2) {
d = 1 / Math.sqrt(z2 + x2);
newZX = -z1 * d;
newZY = 0;
newZZ = x1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
newZX = y1 * d;
newZY = -x1 * d;
newZZ = 0;
}
}
newYX = newZY * newXZ - newZZ * newXY;
newYY = newZZ * newXX - newZX * newXZ;
newYZ = newZX * newXY - newZY * newXX;
_this.xX = newXX;
_this.xY = newXY;
_this.xZ = newXZ;
_this.yX = newYX;
_this.yY = newYY;
_this.yZ = newYZ;
_this.zX = newZX;
_this.zY = newZY;
_this.zZ = newZZ;
let rot100;
let rot101;
let rot102;
let rot110;
let rot111;
let rot112;
let rot120;
let rot121;
let rot122;
let rot200;
let rot201;
let rot202;
let rot210;
let rot211;
let rot212;
let rot220;
let rot221;
let rot222;
rot100 = this._basisX1X;
rot101 = this._basisY1X;
rot102 = this._basisZ1X;
rot110 = this._basisX1Y;
rot111 = this._basisY1Y;
rot112 = this._basisZ1Y;
rot120 = this._basisX1Z;
rot121 = this._basisY1Z;
rot122 = this._basisZ1Z;
rot200 = this._basisX2X;
rot201 = this._basisY2X;
rot202 = this._basisZ2X;
rot210 = this._basisX2Y;
rot211 = this._basisY2Y;
rot212 = this._basisZ2Y;
rot220 = this._basisX2Z;
rot221 = this._basisY2Z;
rot222 = this._basisZ2Z;
let relRot00;
let relRot01;
let relRot02;
let relRot10;
let relRot11;
let relRot12;
let relRot20;
let relRot21;
let relRot22;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = rot200 * rot100 + rot201 * rot101 + rot202 * rot102;
__tmp__01 = rot200 * rot110 + rot201 * rot111 + rot202 * rot112;
__tmp__02 = rot200 * rot120 + rot201 * rot121 + rot202 * rot122;
__tmp__10 = rot210 * rot100 + rot211 * rot101 + rot212 * rot102;
__tmp__11 = rot210 * rot110 + rot211 * rot111 + rot212 * rot112;
__tmp__12 = rot210 * rot120 + rot211 * rot121 + rot212 * rot122;
__tmp__20 = rot220 * rot100 + rot221 * rot101 + rot222 * rot102;
__tmp__21 = rot220 * rot110 + rot221 * rot111 + rot222 * rot112;
__tmp__22 = rot220 * rot120 + rot221 * rot121 + rot222 * rot122;
relRot00 = __tmp__00;
relRot01 = __tmp__01;
relRot02 = __tmp__02;
relRot10 = __tmp__10;
relRot11 = __tmp__11;
relRot12 = __tmp__12;
relRot20 = __tmp__20;
relRot21 = __tmp__21;
relRot22 = __tmp__22;
let relQX;
let relQY;
let relQZ;
let relQW;
let e00 = relRot00;
let e11 = relRot11;
let e22 = relRot22;
let t = e00 + e11 + e22;
let s;
if(t > 0) {
s = Math.sqrt(t + 1);
relQW = 0.5 * s;
s = 0.5 / s;
relQX = (relRot21 - relRot12) * s;
relQY = (relRot02 - relRot20) * s;
relQZ = (relRot10 - relRot01) * s;
} else if(e00 > e11) {
if(e00 > e22) {
s = Math.sqrt(e00 - e11 - e22 + 1);
relQX = 0.5 * s;
s = 0.5 / s;
relQY = (relRot01 + relRot10) * s;
relQZ = (relRot02 + relRot20) * s;
relQW = (relRot21 - relRot12) * s;
} else {
s = Math.sqrt(e22 - e00 - e11 + 1);
relQZ = 0.5 * s;
s = 0.5 / s;
relQX = (relRot02 + relRot20) * s;
relQY = (relRot12 + relRot21) * s;
relQW = (relRot10 - relRot01) * s;
}
} else if(e11 > e22) {
s = Math.sqrt(e11 - e22 - e00 + 1);
relQY = 0.5 * s;
s = 0.5 / s;
relQX = (relRot01 + relRot10) * s;
relQZ = (relRot12 + relRot21) * s;
relQW = (relRot02 - relRot20) * s;
} else {
s = Math.sqrt(e22 - e00 - e11 + 1);
relQZ = 0.5 * s;
s = 0.5 / s;
relQX = (relRot02 + relRot20) * s;
relQY = (relRot12 + relRot21) * s;
relQW = (relRot10 - relRot01) * s;
}
let cosHalfTheta = relQW;
let theta = (cosHalfTheta <= -1 ? 3.14159265358979 : cosHalfTheta >= 1 ? 0 : Math.acos(cosHalfTheta)) * 2;
this.angularErrorX = relQX;
this.angularErrorY = relQY;
this.angularErrorZ = relQZ;
let l = this.angularErrorX * this.angularErrorX + this.angularErrorY * this.angularErrorY + this.angularErrorZ * this.angularErrorZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
this.angularErrorX *= l;
this.angularErrorY *= l;
this.angularErrorZ *= l;
this.angularErrorX *= theta;
this.angularErrorY *= theta;
this.angularErrorZ *= theta;
let anchorDiffX;
let anchorDiffY;
let anchorDiffZ;
anchorDiffX = this._anchor2X - this._anchor1X;
anchorDiffY = this._anchor2Y - this._anchor1Y;
anchorDiffZ = this._anchor2Z - this._anchor1Z;
this.translation = anchorDiffX * this._basis.xX + anchorDiffY * this._basis.xY + anchorDiffZ * this._basis.xZ;
this.linearErrorY = anchorDiffX * this._basis.yX + anchorDiffY * this._basis.yY + anchorDiffZ * this._basis.yZ;
this.linearErrorZ = anchorDiffX * this._basis.zX + anchorDiffY * this._basis.zY + anchorDiffZ * this._basis.zZ;
}
_getVelocitySolverInfo(timeStep,info) {
super._getVelocitySolverInfo(timeStep,info);
this.getInfo(info,timeStep,false);
}
_getPositionSolverInfo(info) {
super._getPositionSolverInfo(info);
this.getInfo(info,null,true);
}
getAxis1() {
let v = new oimo.common.Vec3();
v.x = this._basisX1X;
v.y = this._basisX1Y;
v.z = this._basisX1Z;
return v;
}
getAxis2() {
let v = new oimo.common.Vec3();
v.x = this._basisX2X;
v.y = this._basisX2Y;
v.z = this._basisX2Z;
return v;
}
getAxis1To(axis) {
axis.x = this._basisX1X;
axis.y = this._basisX1Y;
axis.z = this._basisX1Z;
}
getAxis2To(axis) {
axis.x = this._basisX2X;
axis.y = this._basisX2Y;
axis.z = this._basisX2Z;
}
getLocalAxis1() {
let v = new oimo.common.Vec3();
v.x = this._localBasisX1X;
v.y = this._localBasisX1Y;
v.z = this._localBasisX1Z;
return v;
}
getLocalAxis2() {
let v = new oimo.common.Vec3();
v.x = this._localBasisX2X;
v.y = this._localBasisX2Y;
v.z = this._localBasisX2Z;
return v;
}
getLocalAxis1To(axis) {
axis.x = this._localBasisX1X;
axis.y = this._localBasisX1Y;
axis.z = this._localBasisX1Z;
}
getLocalAxis2To(axis) {
axis.x = this._localBasisX2X;
axis.y = this._localBasisX2Y;
axis.z = this._localBasisX2Z;
}
getSpringDamper() {
return this._sd;
}
getLimitMotor() {
return this._lm;
}
getTranslation() {
return this.translation;
}
}
oimo.dynamics.constraint.joint.PrismaticJointConfig = class oimo_dynamics_constraint_joint_PrismaticJointConfig extends oimo.dynamics.constraint.joint.JointConfig {
constructor() {
super();
this.localAxis1 = new oimo.common.Vec3(1,0,0);
this.localAxis2 = new oimo.common.Vec3(1,0,0);
this.limitMotor = new oimo.dynamics.constraint.joint.TranslationalLimitMotor();
this.springDamper = new oimo.dynamics.constraint.joint.SpringDamper();
}
init(rigidBody1,rigidBody2,worldAnchor,worldAxis) {
this._init(rigidBody1,rigidBody2,worldAnchor);
let localVector = this.localAxis1;
let vX;
let vY;
let vZ;
vX = worldAxis.x;
vY = worldAxis.y;
vZ = worldAxis.z;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = rigidBody1._transform._rotation00 * vX + rigidBody1._transform._rotation10 * vY + rigidBody1._transform._rotation20 * vZ;
__tmp__Y = rigidBody1._transform._rotation01 * vX + rigidBody1._transform._rotation11 * vY + rigidBody1._transform._rotation21 * vZ;
__tmp__Z = rigidBody1._transform._rotation02 * vX + rigidBody1._transform._rotation12 * vY + rigidBody1._transform._rotation22 * vZ;
vX = __tmp__X;
vY = __tmp__Y;
vZ = __tmp__Z;
localVector.x = vX;
localVector.y = vY;
localVector.z = vZ;
let localVector1 = this.localAxis2;
let vX1;
let vY1;
let vZ1;
vX1 = worldAxis.x;
vY1 = worldAxis.y;
vZ1 = worldAxis.z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = rigidBody2._transform._rotation00 * vX1 + rigidBody2._transform._rotation10 * vY1 + rigidBody2._transform._rotation20 * vZ1;
__tmp__Y1 = rigidBody2._transform._rotation01 * vX1 + rigidBody2._transform._rotation11 * vY1 + rigidBody2._transform._rotation21 * vZ1;
__tmp__Z1 = rigidBody2._transform._rotation02 * vX1 + rigidBody2._transform._rotation12 * vY1 + rigidBody2._transform._rotation22 * vZ1;
vX1 = __tmp__X1;
vY1 = __tmp__Y1;
vZ1 = __tmp__Z1;
localVector1.x = vX1;
localVector1.y = vY1;
localVector1.z = vZ1;
return this;
}
}
oimo.dynamics.constraint.joint.RagdollJoint = class oimo_dynamics_constraint_joint_RagdollJoint extends oimo.dynamics.constraint.joint.Joint {
constructor(config) {
super(config,oimo.dynamics.constraint.joint.JointType.RAGDOLL);
let v = config.localTwistAxis1;
this._localBasisX1X = v.x;
this._localBasisX1Y = v.y;
this._localBasisX1Z = v.z;
let v1 = config.localSwingAxis1;
this._localBasisY1X = v1.x;
this._localBasisY1Y = v1.y;
this._localBasisY1Z = v1.z;
let v2 = config.localTwistAxis2;
this._localBasisX2X = v2.x;
this._localBasisX2Y = v2.y;
this._localBasisX2Z = v2.z;
this.buildLocalBasesFromXY1X2();
this._twistSd = config.twistSpringDamper.clone();
this._twistLm = config.twistLimitMotor.clone();
this._swingSd = config.swingSpringDamper.clone();
this._maxSwingAngle1 = config.maxSwingAngle1;
this._maxSwingAngle2 = config.maxSwingAngle2;
if(this._maxSwingAngle1 < oimo.common.Setting.minRagdollMaxSwingAngle) {
this._maxSwingAngle1 = oimo.common.Setting.minRagdollMaxSwingAngle;
}
if(this._maxSwingAngle2 < oimo.common.Setting.minRagdollMaxSwingAngle) {
this._maxSwingAngle2 = oimo.common.Setting.minRagdollMaxSwingAngle;
}
this.dummySwingLm = new oimo.dynamics.constraint.joint.RotationalLimitMotor();
this.dummySwingLm.lowerLimit = -1;
this.dummySwingLm.upperLimit = 0;
this._swingAngle = 0;
this._twistAngle = 0;
this.swingError = 0;
this.swingAxisX = 0;
this.swingAxisY = 0;
this.swingAxisZ = 0;
this.twistAxisX = 0;
this.twistAxisY = 0;
this.twistAxisZ = 0;
}
getInfo(info,timeStep,isPositionPart) {
let erp = this.getErp(timeStep,isPositionPart);
let linearRhsX;
let linearRhsY;
let linearRhsZ;
linearRhsX = this.linearErrorX * erp;
linearRhsY = this.linearErrorY * erp;
linearRhsZ = this.linearErrorZ * erp;
let crossR100;
let crossR101;
let crossR102;
let crossR110;
let crossR111;
let crossR112;
let crossR120;
let crossR121;
let crossR122;
let crossR200;
let crossR201;
let crossR202;
let crossR210;
let crossR211;
let crossR212;
let crossR220;
let crossR221;
let crossR222;
crossR100 = 0;
crossR101 = -this._relativeAnchor1Z;
crossR102 = this._relativeAnchor1Y;
crossR110 = this._relativeAnchor1Z;
crossR111 = 0;
crossR112 = -this._relativeAnchor1X;
crossR120 = -this._relativeAnchor1Y;
crossR121 = this._relativeAnchor1X;
crossR122 = 0;
crossR200 = 0;
crossR201 = -this._relativeAnchor2Z;
crossR202 = this._relativeAnchor2Y;
crossR210 = this._relativeAnchor2Z;
crossR211 = 0;
crossR212 = -this._relativeAnchor2X;
crossR220 = -this._relativeAnchor2Y;
crossR221 = this._relativeAnchor2X;
crossR222 = 0;
crossR100 = -crossR100;
crossR101 = -crossR101;
crossR102 = -crossR102;
crossR110 = -crossR110;
crossR111 = -crossR111;
crossR112 = -crossR112;
crossR120 = -crossR120;
crossR121 = -crossR121;
crossR122 = -crossR122;
crossR200 = -crossR200;
crossR201 = -crossR201;
crossR202 = -crossR202;
crossR210 = -crossR210;
crossR211 = -crossR211;
crossR212 = -crossR212;
crossR220 = -crossR220;
crossR221 = -crossR221;
crossR222 = -crossR222;
let swingMass = this.computeEffectiveInertiaMoment(this.swingAxisX,this.swingAxisY,this.swingAxisZ);
let twistMass = this.computeEffectiveInertiaMoment(this._basisX2X,this._basisX2Y,this._basisX2Z);
let impulse = this._impulses[0];
let row = info.rows[info.numRows++];
let _this = row.jacobian;
_this.lin1X = 0;
_this.lin1Y = 0;
_this.lin1Z = 0;
_this.lin2X = 0;
_this.lin2Y = 0;
_this.lin2Z = 0;
_this.ang1X = 0;
_this.ang1Y = 0;
_this.ang1Z = 0;
_this.ang2X = 0;
_this.ang2Y = 0;
_this.ang2Z = 0;
row.rhs = 0;
row.cfm = 0;
row.minImpulse = 0;
row.maxImpulse = 0;
row.motorSpeed = 0;
row.motorMaxImpulse = 0;
row.impulse = null;
row.impulse = impulse;
row.rhs = linearRhsX;
row.cfm = 0;
row.minImpulse = -1e65536;
row.maxImpulse = 1e65536;
let j = row.jacobian;
j.lin1X = 1;
j.lin1Y = 0;
j.lin1Z = 0;
j.lin2X = 1;
j.lin2Y = 0;
j.lin2Z = 0;
j.ang1X = crossR100;
j.ang1Y = crossR101;
j.ang1Z = crossR102;
j.ang2X = crossR200;
j.ang2Y = crossR201;
j.ang2Z = crossR202;
let impulse1 = this._impulses[1];
let row1 = info.rows[info.numRows++];
let _this1 = row1.jacobian;
_this1.lin1X = 0;
_this1.lin1Y = 0;
_this1.lin1Z = 0;
_this1.lin2X = 0;
_this1.lin2Y = 0;
_this1.lin2Z = 0;
_this1.ang1X = 0;
_this1.ang1Y = 0;
_this1.ang1Z = 0;
_this1.ang2X = 0;
_this1.ang2Y = 0;
_this1.ang2Z = 0;
row1.rhs = 0;
row1.cfm = 0;
row1.minImpulse = 0;
row1.maxImpulse = 0;
row1.motorSpeed = 0;
row1.motorMaxImpulse = 0;
row1.impulse = null;
row1.impulse = impulse1;
row1.rhs = linearRhsY;
row1.cfm = 0;
row1.minImpulse = -1e65536;
row1.maxImpulse = 1e65536;
j = row1.jacobian;
j.lin1X = 0;
j.lin1Y = 1;
j.lin1Z = 0;
j.lin2X = 0;
j.lin2Y = 1;
j.lin2Z = 0;
j.ang1X = crossR110;
j.ang1Y = crossR111;
j.ang1Z = crossR112;
j.ang2X = crossR210;
j.ang2Y = crossR211;
j.ang2Z = crossR212;
let impulse2 = this._impulses[2];
let row2 = info.rows[info.numRows++];
let _this2 = row2.jacobian;
_this2.lin1X = 0;
_this2.lin1Y = 0;
_this2.lin1Z = 0;
_this2.lin2X = 0;
_this2.lin2Y = 0;
_this2.lin2Z = 0;
_this2.ang1X = 0;
_this2.ang1Y = 0;
_this2.ang1Z = 0;
_this2.ang2X = 0;
_this2.ang2Y = 0;
_this2.ang2Z = 0;
row2.rhs = 0;
row2.cfm = 0;
row2.minImpulse = 0;
row2.maxImpulse = 0;
row2.motorSpeed = 0;
row2.motorMaxImpulse = 0;
row2.impulse = null;
row2.impulse = impulse2;
row2.rhs = linearRhsZ;
row2.cfm = 0;
row2.minImpulse = -1e65536;
row2.maxImpulse = 1e65536;
j = row2.jacobian;
j.lin1X = 0;
j.lin1Y = 0;
j.lin1Z = 1;
j.lin2X = 0;
j.lin2Y = 0;
j.lin2Z = 1;
j.ang1X = crossR120;
j.ang1Y = crossR121;
j.ang1Z = crossR122;
j.ang2X = crossR220;
j.ang2Y = crossR221;
j.ang2Z = crossR222;
if(this.swingError > 0 && (this._swingSd.frequency <= 0 || !isPositionPart)) {
let impulse = this._impulses[3];
let row = info.rows[info.numRows++];
let _this = row.jacobian;
_this.lin1X = 0;
_this.lin1Y = 0;
_this.lin1Z = 0;
_this.lin2X = 0;
_this.lin2Y = 0;
_this.lin2Z = 0;
_this.ang1X = 0;
_this.ang1Y = 0;
_this.ang1Z = 0;
_this.ang2X = 0;
_this.ang2Y = 0;
_this.ang2Z = 0;
row.rhs = 0;
row.cfm = 0;
row.minImpulse = 0;
row.maxImpulse = 0;
row.motorSpeed = 0;
row.motorMaxImpulse = 0;
row.impulse = null;
row.impulse = impulse;
this.setSolverInfoRowAngular(row,this.swingError,this.dummySwingLm,swingMass,this._swingSd,timeStep,isPositionPart);
j = row.jacobian;
j.ang1X = this.swingAxisX;
j.ang1Y = this.swingAxisY;
j.ang1Z = this.swingAxisZ;
j.ang2X = this.swingAxisX;
j.ang2Y = this.swingAxisY;
j.ang2Z = this.swingAxisZ;
}
if(this._twistSd.frequency <= 0 || !isPositionPart) {
let impulse = this._impulses[4];
let row = info.rows[info.numRows++];
let _this = row.jacobian;
_this.lin1X = 0;
_this.lin1Y = 0;
_this.lin1Z = 0;
_this.lin2X = 0;
_this.lin2Y = 0;
_this.lin2Z = 0;
_this.ang1X = 0;
_this.ang1Y = 0;
_this.ang1Z = 0;
_this.ang2X = 0;
_this.ang2Y = 0;
_this.ang2Z = 0;
row.rhs = 0;
row.cfm = 0;
row.minImpulse = 0;
row.maxImpulse = 0;
row.motorSpeed = 0;
row.motorMaxImpulse = 0;
row.impulse = null;
row.impulse = impulse;
this.setSolverInfoRowAngular(row,this._twistAngle,this._twistLm,twistMass,this._twistSd,timeStep,isPositionPart);
j = row.jacobian;
j.ang1X = this.twistAxisX;
j.ang1Y = this.twistAxisY;
j.ang1Z = this.twistAxisZ;
j.ang2X = this.twistAxisX;
j.ang2Y = this.twistAxisY;
j.ang2Z = this.twistAxisZ;
}
}
_syncAnchors() {
super._syncAnchors();
let axis1X;
let axis1Y;
let axis1Z;
let axis2X;
let axis2Y;
let axis2Z;
axis1X = this._basisX1X;
axis1Y = this._basisX1Y;
axis1Z = this._basisX1Z;
axis2X = this._basisX2X;
axis2Y = this._basisX2Y;
axis2Z = this._basisX2Z;
let basis1Mat00;
let basis1Mat01;
let basis1Mat02;
let basis1Mat10;
let basis1Mat11;
let basis1Mat12;
let basis1Mat20;
let basis1Mat21;
let basis1Mat22;
basis1Mat00 = this._basisX1X;
basis1Mat01 = this._basisY1X;
basis1Mat02 = this._basisZ1X;
basis1Mat10 = this._basisX1Y;
basis1Mat11 = this._basisY1Y;
basis1Mat12 = this._basisZ1Y;
basis1Mat20 = this._basisX1Z;
basis1Mat21 = this._basisY1Z;
basis1Mat22 = this._basisZ1Z;
let swingQX;
let swingQY;
let swingQZ;
let swingQW;
let swingM00;
let swingM01;
let swingM02;
let swingM10;
let swingM11;
let swingM12;
let swingM20;
let swingM21;
let swingM22;
let swingVX;
let swingVY;
let swingVZ;
let d = axis1X * axis2X + axis1Y * axis2Y + axis1Z * axis2Z;
if(d < -0.999999999) {
let vX;
let vY;
let vZ;
let x1 = axis1X;
let y1 = axis1Y;
let z1 = axis1Z;
let x2 = x1 * x1;
let y2 = y1 * y1;
let z2 = z1 * z1;
let d;
if(x2 < y2) {
if(x2 < z2) {
d = 1 / Math.sqrt(y2 + z2);
vX = 0;
vY = z1 * d;
vZ = -y1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
vX = y1 * d;
vY = -x1 * d;
vZ = 0;
}
} else if(y2 < z2) {
d = 1 / Math.sqrt(z2 + x2);
vX = -z1 * d;
vY = 0;
vZ = x1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
vX = y1 * d;
vY = -x1 * d;
vZ = 0;
}
swingQX = vX;
swingQY = vY;
swingQZ = vZ;
swingQW = 0;
} else {
let cX;
let cY;
let cZ;
cX = axis1Y * axis2Z - axis1Z * axis2Y;
cY = axis1Z * axis2X - axis1X * axis2Z;
cZ = axis1X * axis2Y - axis1Y * axis2X;
let w = Math.sqrt((1 + d) * 0.5);
d = 0.5 / w;
cX *= d;
cY *= d;
cZ *= d;
swingQX = cX;
swingQY = cY;
swingQZ = cZ;
swingQW = w;
}
let x = swingQX;
let y = swingQY;
let z = swingQZ;
let w = swingQW;
let x2 = 2 * x;
let y2 = 2 * y;
let z2 = 2 * z;
let xx = x * x2;
let yy = y * y2;
let zz = z * z2;
let xy = x * y2;
let yz = y * z2;
let xz = x * z2;
let wx = w * x2;
let wy = w * y2;
let wz = w * z2;
swingM00 = 1 - yy - zz;
swingM01 = xy - wz;
swingM02 = xz + wy;
swingM10 = xy + wz;
swingM11 = 1 - xx - zz;
swingM12 = yz - wx;
swingM20 = xz - wy;
swingM21 = yz + wx;
swingM22 = 1 - xx - yy;
this._swingAngle = (swingQW <= -1 ? 3.14159265358979 : swingQW >= 1 ? 0 : Math.acos(swingQW)) * 2;
swingVX = swingQX;
swingVY = swingQY;
swingVZ = swingQZ;
let basisY2In1X;
let basisY2In1Y;
let basisY2In1Z;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = swingM00 * this._basisY2X + swingM10 * this._basisY2Y + swingM20 * this._basisY2Z;
__tmp__Y = swingM01 * this._basisY2X + swingM11 * this._basisY2Y + swingM21 * this._basisY2Z;
__tmp__Z = swingM02 * this._basisY2X + swingM12 * this._basisY2Y + swingM22 * this._basisY2Z;
basisY2In1X = __tmp__X;
basisY2In1Y = __tmp__Y;
basisY2In1Z = __tmp__Z;
this._twistAngle = Math.atan2(this._basisZ1X * basisY2In1X + this._basisZ1Y * basisY2In1Y + this._basisZ1Z * basisY2In1Z,this._basisY1X * basisY2In1X + this._basisY1Y * basisY2In1Y + this._basisY1Z * basisY2In1Z);
this.twistAxisX = this._basisX1X + this._basisX2X;
this.twistAxisY = this._basisX1Y + this._basisX2Y;
this.twistAxisZ = this._basisX1Z + this._basisX2Z;
let l = this.twistAxisX * this.twistAxisX + this.twistAxisY * this.twistAxisY + this.twistAxisZ * this.twistAxisZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
this.twistAxisX *= l;
this.twistAxisY *= l;
this.twistAxisZ *= l;
let invLen = Math.sqrt(swingVX * swingVX + swingVY * swingVY + swingVZ * swingVZ);
if(invLen > 0) {
invLen = 1 / invLen;
}
swingVX *= invLen * this._swingAngle;
swingVY *= invLen * this._swingAngle;
swingVZ *= invLen * this._swingAngle;
let __tmp__Y1;
let __tmp__Z1;
__tmp__Y1 = basis1Mat01 * swingVX + basis1Mat11 * swingVY + basis1Mat21 * swingVZ;
__tmp__Z1 = basis1Mat02 * swingVX + basis1Mat12 * swingVY + basis1Mat22 * swingVZ;
swingVY = __tmp__Y1;
swingVZ = __tmp__Z1;
let x1 = swingVY;
let y1 = swingVZ;
let a = this._maxSwingAngle1;
let b = this._maxSwingAngle2;
let invA2 = 1 / (a * a);
let invB2 = 1 / (b * b);
let w1 = x1 * x1 * invA2 + y1 * y1 * invB2;
if(w1 == 0) {
this.swingAxisX = 0;
this.swingAxisY = 0;
this.swingAxisZ = 0;
this.swingError = 0;
} else {
let t = Math.sqrt(1 / w1);
let x0 = x1 * t;
let y0 = y1 * t;
let nx = x0 * invA2;
let ny = y0 * invB2;
invLen = 1 / Math.sqrt(nx * nx + ny * ny);
nx *= invLen;
ny *= invLen;
let depth = (x1 - x0) * nx + (y1 - y0) * ny;
if(depth > 0) {
this.swingError = depth;
this.swingAxisX = 0;
this.swingAxisY = nx;
this.swingAxisZ = ny;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = basis1Mat00 * this.swingAxisX + basis1Mat01 * this.swingAxisY + basis1Mat02 * this.swingAxisZ;
__tmp__Y = basis1Mat10 * this.swingAxisX + basis1Mat11 * this.swingAxisY + basis1Mat12 * this.swingAxisZ;
__tmp__Z = basis1Mat20 * this.swingAxisX + basis1Mat21 * this.swingAxisY + basis1Mat22 * this.swingAxisZ;
this.swingAxisX = __tmp__X;
this.swingAxisY = __tmp__Y;
this.swingAxisZ = __tmp__Z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = swingM00 * this.swingAxisX + swingM01 * this.swingAxisY + swingM02 * this.swingAxisZ;
__tmp__Y1 = swingM10 * this.swingAxisX + swingM11 * this.swingAxisY + swingM12 * this.swingAxisZ;
__tmp__Z1 = swingM20 * this.swingAxisX + swingM21 * this.swingAxisY + swingM22 * this.swingAxisZ;
this.swingAxisX = __tmp__X1;
this.swingAxisY = __tmp__Y1;
this.swingAxisZ = __tmp__Z1;
} else {
this.swingError = 0;
}
}
this.linearErrorX = this._anchor2X - this._anchor1X;
this.linearErrorY = this._anchor2Y - this._anchor1Y;
this.linearErrorZ = this._anchor2Z - this._anchor1Z;
}
_getVelocitySolverInfo(timeStep,info) {
super._getVelocitySolverInfo(timeStep,info);
this.getInfo(info,timeStep,false);
}
_getPositionSolverInfo(info) {
super._getPositionSolverInfo(info);
this.getInfo(info,null,true);
}
getAxis1() {
let v = new oimo.common.Vec3();
v.x = this._basisX1X;
v.y = this._basisX1Y;
v.z = this._basisX1Z;
return v;
}
getAxis2() {
let v = new oimo.common.Vec3();
v.x = this._basisX2X;
v.y = this._basisX2Y;
v.z = this._basisX2Z;
return v;
}
getAxis1To(axis) {
axis.x = this._basisX1X;
axis.y = this._basisX1Y;
axis.z = this._basisX1Z;
}
getAxis2To(axis) {
axis.x = this._basisX2X;
axis.y = this._basisX2Y;
axis.z = this._basisX2Z;
}
getLocalAxis1() {
let v = new oimo.common.Vec3();
v.x = this._localBasisX1X;
v.y = this._localBasisX1Y;
v.z = this._localBasisX1Z;
return v;
}
getLocalAxis2() {
let v = new oimo.common.Vec3();
v.x = this._localBasisX2X;
v.y = this._localBasisX2Y;
v.z = this._localBasisX2Z;
return v;
}
getLocalAxis1To(axis) {
axis.x = this._localBasisX1X;
axis.y = this._localBasisX1Y;
axis.z = this._localBasisX1Z;
}
getLocalAxis2To(axis) {
axis.x = this._localBasisX2X;
axis.y = this._localBasisX2Y;
axis.z = this._localBasisX2Z;
}
getTwistSpringDamper() {
return this._twistSd;
}
getTwistLimitMotor() {
return this._twistLm;
}
getSwingSpringDamper() {
return this._swingSd;
}
getSwingAxis() {
let v = new oimo.common.Vec3();
v.x = this.swingAxisX;
v.y = this.swingAxisY;
v.z = this.swingAxisZ;
return v;
}
getSwingAxisTo(axis) {
axis.x = this.swingAxisX;
axis.y = this.swingAxisY;
axis.z = this.swingAxisZ;
}
getSwingAngle() {
return this._swingAngle;
}
getTwistAngle() {
return this._twistAngle;
}
}
oimo.dynamics.constraint.joint.RagdollJointConfig = class oimo_dynamics_constraint_joint_RagdollJointConfig extends oimo.dynamics.constraint.joint.JointConfig {
constructor() {
super();
this.localTwistAxis1 = new oimo.common.Vec3(1,0,0);
this.localTwistAxis2 = new oimo.common.Vec3(1,0,0);
this.localSwingAxis1 = new oimo.common.Vec3(0,1,0);
this.twistSpringDamper = new oimo.dynamics.constraint.joint.SpringDamper();
this.swingSpringDamper = new oimo.dynamics.constraint.joint.SpringDamper();
this.twistLimitMotor = new oimo.dynamics.constraint.joint.RotationalLimitMotor();
this.maxSwingAngle1 = 3.14159265358979;
this.maxSwingAngle2 = 3.14159265358979;
}
init(rigidBody1,rigidBody2,worldAnchor,worldTwistAxis,worldSwingAxis) {
this._init(rigidBody1,rigidBody2,worldAnchor);
let localVector = this.localTwistAxis1;
let vX;
let vY;
let vZ;
vX = worldTwistAxis.x;
vY = worldTwistAxis.y;
vZ = worldTwistAxis.z;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = rigidBody1._transform._rotation00 * vX + rigidBody1._transform._rotation10 * vY + rigidBody1._transform._rotation20 * vZ;
__tmp__Y = rigidBody1._transform._rotation01 * vX + rigidBody1._transform._rotation11 * vY + rigidBody1._transform._rotation21 * vZ;
__tmp__Z = rigidBody1._transform._rotation02 * vX + rigidBody1._transform._rotation12 * vY + rigidBody1._transform._rotation22 * vZ;
vX = __tmp__X;
vY = __tmp__Y;
vZ = __tmp__Z;
localVector.x = vX;
localVector.y = vY;
localVector.z = vZ;
let localVector1 = this.localTwistAxis2;
let vX1;
let vY1;
let vZ1;
vX1 = worldTwistAxis.x;
vY1 = worldTwistAxis.y;
vZ1 = worldTwistAxis.z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = rigidBody2._transform._rotation00 * vX1 + rigidBody2._transform._rotation10 * vY1 + rigidBody2._transform._rotation20 * vZ1;
__tmp__Y1 = rigidBody2._transform._rotation01 * vX1 + rigidBody2._transform._rotation11 * vY1 + rigidBody2._transform._rotation21 * vZ1;
__tmp__Z1 = rigidBody2._transform._rotation02 * vX1 + rigidBody2._transform._rotation12 * vY1 + rigidBody2._transform._rotation22 * vZ1;
vX1 = __tmp__X1;
vY1 = __tmp__Y1;
vZ1 = __tmp__Z1;
localVector1.x = vX1;
localVector1.y = vY1;
localVector1.z = vZ1;
let localVector2 = this.localSwingAxis1;
let vX2;
let vY2;
let vZ2;
vX2 = worldSwingAxis.x;
vY2 = worldSwingAxis.y;
vZ2 = worldSwingAxis.z;
let __tmp__X2;
let __tmp__Y2;
let __tmp__Z2;
__tmp__X2 = rigidBody1._transform._rotation00 * vX2 + rigidBody1._transform._rotation10 * vY2 + rigidBody1._transform._rotation20 * vZ2;
__tmp__Y2 = rigidBody1._transform._rotation01 * vX2 + rigidBody1._transform._rotation11 * vY2 + rigidBody1._transform._rotation21 * vZ2;
__tmp__Z2 = rigidBody1._transform._rotation02 * vX2 + rigidBody1._transform._rotation12 * vY2 + rigidBody1._transform._rotation22 * vZ2;
vX2 = __tmp__X2;
vY2 = __tmp__Y2;
vZ2 = __tmp__Z2;
localVector2.x = vX2;
localVector2.y = vY2;
localVector2.z = vZ2;
return this;
}
}
oimo.dynamics.constraint.joint.RevoluteJoint = class oimo_dynamics_constraint_joint_RevoluteJoint extends oimo.dynamics.constraint.joint.Joint {
constructor(config) {
super(config,1);
let v = config.localAxis1;
this._localBasisX1X = v.x;
this._localBasisX1Y = v.y;
this._localBasisX1Z = v.z;
let v1 = config.localAxis2;
this._localBasisX2X = v1.x;
this._localBasisX2Y = v1.y;
this._localBasisX2Z = v1.z;
this.buildLocalBasesFromX();
this.angle = 0;
this.angularErrorY = 0;
this.angularErrorZ = 0;
this._basis = new oimo.dynamics.constraint.joint.BasisTracker(this);
this._sd = config.springDamper.clone();
this._lm = config.limitMotor.clone();
}
getInfo(info,timeStep,isPositionPart) {
let erp = this.getErp(timeStep,isPositionPart);
let linearRhsX;
let linearRhsY;
let linearRhsZ;
linearRhsX = this.linearErrorX * erp;
linearRhsY = this.linearErrorY * erp;
linearRhsZ = this.linearErrorZ * erp;
let angRhsY = this.angularErrorY * erp;
let angRhsZ = this.angularErrorZ * erp;
let crossR100;
let crossR101;
let crossR102;
let crossR110;
let crossR111;
let crossR112;
let crossR120;
let crossR121;
let crossR122;
let crossR200;
let crossR201;
let crossR202;
let crossR210;
let crossR211;
let crossR212;
let crossR220;
let crossR221;
let crossR222;
crossR100 = 0;
crossR101 = -this._relativeAnchor1Z;
crossR102 = this._relativeAnchor1Y;
crossR110 = this._relativeAnchor1Z;
crossR111 = 0;
crossR112 = -this._relativeAnchor1X;
crossR120 = -this._relativeAnchor1Y;
crossR121 = this._relativeAnchor1X;
crossR122 = 0;
crossR200 = 0;
crossR201 = -this._relativeAnchor2Z;
crossR202 = this._relativeAnchor2Y;
crossR210 = this._relativeAnchor2Z;
crossR211 = 0;
crossR212 = -this._relativeAnchor2X;
crossR220 = -this._relativeAnchor2Y;
crossR221 = this._relativeAnchor2X;
crossR222 = 0;
crossR100 = -crossR100;
crossR101 = -crossR101;
crossR102 = -crossR102;
crossR110 = -crossR110;
crossR111 = -crossR111;
crossR112 = -crossR112;
crossR120 = -crossR120;
crossR121 = -crossR121;
crossR122 = -crossR122;
crossR200 = -crossR200;
crossR201 = -crossR201;
crossR202 = -crossR202;
crossR210 = -crossR210;
crossR211 = -crossR211;
crossR212 = -crossR212;
crossR220 = -crossR220;
crossR221 = -crossR221;
crossR222 = -crossR222;
let motorMass = this.computeEffectiveInertiaMoment(this._basis.xX,this._basis.xY,this._basis.xZ);
let impulse = this._impulses[0];
let row = info.rows[info.numRows++];
let _this = row.jacobian;
_this.lin1X = 0;
_this.lin1Y = 0;
_this.lin1Z = 0;
_this.lin2X = 0;
_this.lin2Y = 0;
_this.lin2Z = 0;
_this.ang1X = 0;
_this.ang1Y = 0;
_this.ang1Z = 0;
_this.ang2X = 0;
_this.ang2Y = 0;
_this.ang2Z = 0;
row.rhs = 0;
row.cfm = 0;
row.minImpulse = 0;
row.maxImpulse = 0;
row.motorSpeed = 0;
row.motorMaxImpulse = 0;
row.impulse = null;
row.impulse = impulse;
row.rhs = linearRhsX;
row.cfm = 0;
row.minImpulse = -1e65536;
row.maxImpulse = 1e65536;
let j = row.jacobian;
j.lin1X = 1;
j.lin1Y = 0;
j.lin1Z = 0;
j.lin2X = 1;
j.lin2Y = 0;
j.lin2Z = 0;
j.ang1X = crossR100;
j.ang1Y = crossR101;
j.ang1Z = crossR102;
j.ang2X = crossR200;
j.ang2Y = crossR201;
j.ang2Z = crossR202;
let impulse1 = this._impulses[1];
let row1 = info.rows[info.numRows++];
let _this1 = row1.jacobian;
_this1.lin1X = 0;
_this1.lin1Y = 0;
_this1.lin1Z = 0;
_this1.lin2X = 0;
_this1.lin2Y = 0;
_this1.lin2Z = 0;
_this1.ang1X = 0;
_this1.ang1Y = 0;
_this1.ang1Z = 0;
_this1.ang2X = 0;
_this1.ang2Y = 0;
_this1.ang2Z = 0;
row1.rhs = 0;
row1.cfm = 0;
row1.minImpulse = 0;
row1.maxImpulse = 0;
row1.motorSpeed = 0;
row1.motorMaxImpulse = 0;
row1.impulse = null;
row1.impulse = impulse1;
row1.rhs = linearRhsY;
row1.cfm = 0;
row1.minImpulse = -1e65536;
row1.maxImpulse = 1e65536;
j = row1.jacobian;
j.lin1X = 0;
j.lin1Y = 1;
j.lin1Z = 0;
j.lin2X = 0;
j.lin2Y = 1;
j.lin2Z = 0;
j.ang1X = crossR110;
j.ang1Y = crossR111;
j.ang1Z = crossR112;
j.ang2X = crossR210;
j.ang2Y = crossR211;
j.ang2Z = crossR212;
let impulse2 = this._impulses[2];
let row2 = info.rows[info.numRows++];
let _this2 = row2.jacobian;
_this2.lin1X = 0;
_this2.lin1Y = 0;
_this2.lin1Z = 0;
_this2.lin2X = 0;
_this2.lin2Y = 0;
_this2.lin2Z = 0;
_this2.ang1X = 0;
_this2.ang1Y = 0;
_this2.ang1Z = 0;
_this2.ang2X = 0;
_this2.ang2Y = 0;
_this2.ang2Z = 0;
row2.rhs = 0;
row2.cfm = 0;
row2.minImpulse = 0;
row2.maxImpulse = 0;
row2.motorSpeed = 0;
row2.motorMaxImpulse = 0;
row2.impulse = null;
row2.impulse = impulse2;
row2.rhs = linearRhsZ;
row2.cfm = 0;
row2.minImpulse = -1e65536;
row2.maxImpulse = 1e65536;
j = row2.jacobian;
j.lin1X = 0;
j.lin1Y = 0;
j.lin1Z = 1;
j.lin2X = 0;
j.lin2Y = 0;
j.lin2Z = 1;
j.ang1X = crossR120;
j.ang1Y = crossR121;
j.ang1Z = crossR122;
j.ang2X = crossR220;
j.ang2Y = crossR221;
j.ang2Z = crossR222;
if(this._sd.frequency <= 0 || !isPositionPart) {
let impulse = this._impulses[3];
let row = info.rows[info.numRows++];
let _this = row.jacobian;
_this.lin1X = 0;
_this.lin1Y = 0;
_this.lin1Z = 0;
_this.lin2X = 0;
_this.lin2Y = 0;
_this.lin2Z = 0;
_this.ang1X = 0;
_this.ang1Y = 0;
_this.ang1Z = 0;
_this.ang2X = 0;
_this.ang2Y = 0;
_this.ang2Z = 0;
row.rhs = 0;
row.cfm = 0;
row.minImpulse = 0;
row.maxImpulse = 0;
row.motorSpeed = 0;
row.motorMaxImpulse = 0;
row.impulse = null;
row.impulse = impulse;
this.setSolverInfoRowAngular(row,this.angle,this._lm,motorMass,this._sd,timeStep,isPositionPart);
j = row.jacobian;
j.ang1X = this._basis.xX;
j.ang1Y = this._basis.xY;
j.ang1Z = this._basis.xZ;
j.ang2X = this._basis.xX;
j.ang2Y = this._basis.xY;
j.ang2Z = this._basis.xZ;
}
let impulse3 = this._impulses[4];
let row3 = info.rows[info.numRows++];
let _this3 = row3.jacobian;
_this3.lin1X = 0;
_this3.lin1Y = 0;
_this3.lin1Z = 0;
_this3.lin2X = 0;
_this3.lin2Y = 0;
_this3.lin2Z = 0;
_this3.ang1X = 0;
_this3.ang1Y = 0;
_this3.ang1Z = 0;
_this3.ang2X = 0;
_this3.ang2Y = 0;
_this3.ang2Z = 0;
row3.rhs = 0;
row3.cfm = 0;
row3.minImpulse = 0;
row3.maxImpulse = 0;
row3.motorSpeed = 0;
row3.motorMaxImpulse = 0;
row3.impulse = null;
row3.impulse = impulse3;
row3.rhs = angRhsY;
row3.cfm = 0;
row3.minImpulse = -1e65536;
row3.maxImpulse = 1e65536;
j = row3.jacobian;
j.ang1X = this._basis.yX;
j.ang1Y = this._basis.yY;
j.ang1Z = this._basis.yZ;
j.ang2X = this._basis.yX;
j.ang2Y = this._basis.yY;
j.ang2Z = this._basis.yZ;
let impulse4 = this._impulses[5];
let row4 = info.rows[info.numRows++];
let _this4 = row4.jacobian;
_this4.lin1X = 0;
_this4.lin1Y = 0;
_this4.lin1Z = 0;
_this4.lin2X = 0;
_this4.lin2Y = 0;
_this4.lin2Z = 0;
_this4.ang1X = 0;
_this4.ang1Y = 0;
_this4.ang1Z = 0;
_this4.ang2X = 0;
_this4.ang2Y = 0;
_this4.ang2Z = 0;
row4.rhs = 0;
row4.cfm = 0;
row4.minImpulse = 0;
row4.maxImpulse = 0;
row4.motorSpeed = 0;
row4.motorMaxImpulse = 0;
row4.impulse = null;
row4.impulse = impulse4;
row4.rhs = angRhsZ;
row4.cfm = 0;
row4.minImpulse = -1e65536;
row4.maxImpulse = 1e65536;
j = row4.jacobian;
j.ang1X = this._basis.zX;
j.ang1Y = this._basis.zY;
j.ang1Z = this._basis.zZ;
j.ang2X = this._basis.zX;
j.ang2Y = this._basis.zY;
j.ang2Z = this._basis.zZ;
}
_syncAnchors() {
super._syncAnchors();
let _this = this._basis;
let invM1 = _this.joint._b1._invMass;
let invM2 = _this.joint._b2._invMass;
let qX;
let qY;
let qZ;
let qW;
let idQX;
let idQY;
let idQZ;
let idQW;
let slerpQX;
let slerpQY;
let slerpQZ;
let slerpQW;
let slerpM00;
let slerpM01;
let slerpM02;
let slerpM10;
let slerpM11;
let slerpM12;
let slerpM20;
let slerpM21;
let slerpM22;
let newXX;
let newXY;
let newXZ;
let newYX;
let newYY;
let newYZ;
let newZX;
let newZY;
let newZZ;
let prevXX;
let prevXY;
let prevXZ;
let prevYX;
let prevYY;
let prevYZ;
let d = _this.joint._basisX1X * _this.joint._basisX2X + _this.joint._basisX1Y * _this.joint._basisX2Y + _this.joint._basisX1Z * _this.joint._basisX2Z;
if(d < -0.999999999) {
let vX;
let vY;
let vZ;
let x1 = _this.joint._basisX1X;
let y1 = _this.joint._basisX1Y;
let z1 = _this.joint._basisX1Z;
let x2 = x1 * x1;
let y2 = y1 * y1;
let z2 = z1 * z1;
let d;
if(x2 < y2) {
if(x2 < z2) {
d = 1 / Math.sqrt(y2 + z2);
vX = 0;
vY = z1 * d;
vZ = -y1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
vX = y1 * d;
vY = -x1 * d;
vZ = 0;
}
} else if(y2 < z2) {
d = 1 / Math.sqrt(z2 + x2);
vX = -z1 * d;
vY = 0;
vZ = x1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
vX = y1 * d;
vY = -x1 * d;
vZ = 0;
}
qX = vX;
qY = vY;
qZ = vZ;
qW = 0;
} else {
let cX;
let cY;
let cZ;
cX = _this.joint._basisX1Y * _this.joint._basisX2Z - _this.joint._basisX1Z * _this.joint._basisX2Y;
cY = _this.joint._basisX1Z * _this.joint._basisX2X - _this.joint._basisX1X * _this.joint._basisX2Z;
cZ = _this.joint._basisX1X * _this.joint._basisX2Y - _this.joint._basisX1Y * _this.joint._basisX2X;
let w = Math.sqrt((1 + d) * 0.5);
d = 0.5 / w;
cX *= d;
cY *= d;
cZ *= d;
qX = cX;
qY = cY;
qZ = cZ;
qW = w;
}
idQX = 0;
idQY = 0;
idQZ = 0;
idQW = 1;
let q1X;
let q1Y;
let q1Z;
let q1W;
let q2X;
let q2Y;
let q2Z;
let q2W;
q1X = idQX;
q1Y = idQY;
q1Z = idQZ;
q1W = idQW;
q2X = qX;
q2Y = qY;
q2Z = qZ;
q2W = qW;
let d1 = q1X * q2X + q1Y * q2Y + q1Z * q2Z + q1W * q2W;
if(d1 < 0) {
d1 = -d1;
q2X = -q2X;
q2Y = -q2Y;
q2Z = -q2Z;
q2W = -q2W;
}
if(d1 > 0.999999) {
let dqX;
let dqY;
let dqZ;
let dqW;
dqX = q2X - q1X;
dqY = q2Y - q1Y;
dqZ = q2Z - q1Z;
dqW = q2W - q1W;
q2X = q1X + dqX * (invM1 / (invM1 + invM2));
q2Y = q1Y + dqY * (invM1 / (invM1 + invM2));
q2Z = q1Z + dqZ * (invM1 / (invM1 + invM2));
q2W = q1W + dqW * (invM1 / (invM1 + invM2));
let l = q2X * q2X + q2Y * q2Y + q2Z * q2Z + q2W * q2W;
if(l > 1e-32) {
l = 1 / Math.sqrt(l);
}
slerpQX = q2X * l;
slerpQY = q2Y * l;
slerpQZ = q2Z * l;
slerpQW = q2W * l;
} else {
let theta = invM1 / (invM1 + invM2) * Math.acos(d1);
q2X += q1X * -d1;
q2Y += q1Y * -d1;
q2Z += q1Z * -d1;
q2W += q1W * -d1;
let l = q2X * q2X + q2Y * q2Y + q2Z * q2Z + q2W * q2W;
if(l > 1e-32) {
l = 1 / Math.sqrt(l);
}
q2X *= l;
q2Y *= l;
q2Z *= l;
q2W *= l;
let sin = Math.sin(theta);
let cos = Math.cos(theta);
q1X *= cos;
q1Y *= cos;
q1Z *= cos;
q1W *= cos;
slerpQX = q1X + q2X * sin;
slerpQY = q1Y + q2Y * sin;
slerpQZ = q1Z + q2Z * sin;
slerpQW = q1W + q2W * sin;
}
let x = slerpQX;
let y = slerpQY;
let z = slerpQZ;
let w = slerpQW;
let x2 = 2 * x;
let y2 = 2 * y;
let z2 = 2 * z;
let xx = x * x2;
let yy = y * y2;
let zz = z * z2;
let xy = x * y2;
let yz = y * z2;
let xz = x * z2;
let wx = w * x2;
let wy = w * y2;
let wz = w * z2;
slerpM00 = 1 - yy - zz;
slerpM01 = xy - wz;
slerpM02 = xz + wy;
slerpM10 = xy + wz;
slerpM11 = 1 - xx - zz;
slerpM12 = yz - wx;
slerpM20 = xz - wy;
slerpM21 = yz + wx;
slerpM22 = 1 - xx - yy;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = slerpM00 * _this.joint._basisX1X + slerpM01 * _this.joint._basisX1Y + slerpM02 * _this.joint._basisX1Z;
__tmp__Y = slerpM10 * _this.joint._basisX1X + slerpM11 * _this.joint._basisX1Y + slerpM12 * _this.joint._basisX1Z;
__tmp__Z = slerpM20 * _this.joint._basisX1X + slerpM21 * _this.joint._basisX1Y + slerpM22 * _this.joint._basisX1Z;
newXX = __tmp__X;
newXY = __tmp__Y;
newXZ = __tmp__Z;
prevXX = _this.xX;
prevXY = _this.xY;
prevXZ = _this.xZ;
prevYX = _this.yX;
prevYY = _this.yY;
prevYZ = _this.yZ;
let d2 = prevXX * newXX + prevXY * newXY + prevXZ * newXZ;
if(d2 < -0.999999999) {
let vX;
let vY;
let vZ;
let x1 = prevXX;
let y1 = prevXY;
let z1 = prevXZ;
let x2 = x1 * x1;
let y2 = y1 * y1;
let z2 = z1 * z1;
let d;
if(x2 < y2) {
if(x2 < z2) {
d = 1 / Math.sqrt(y2 + z2);
vX = 0;
vY = z1 * d;
vZ = -y1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
vX = y1 * d;
vY = -x1 * d;
vZ = 0;
}
} else if(y2 < z2) {
d = 1 / Math.sqrt(z2 + x2);
vX = -z1 * d;
vY = 0;
vZ = x1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
vX = y1 * d;
vY = -x1 * d;
vZ = 0;
}
slerpQX = vX;
slerpQY = vY;
slerpQZ = vZ;
slerpQW = 0;
} else {
let cX;
let cY;
let cZ;
cX = prevXY * newXZ - prevXZ * newXY;
cY = prevXZ * newXX - prevXX * newXZ;
cZ = prevXX * newXY - prevXY * newXX;
let w = Math.sqrt((1 + d2) * 0.5);
d2 = 0.5 / w;
cX *= d2;
cY *= d2;
cZ *= d2;
slerpQX = cX;
slerpQY = cY;
slerpQZ = cZ;
slerpQW = w;
}
let x1 = slerpQX;
let y1 = slerpQY;
let z1 = slerpQZ;
let w1 = slerpQW;
let x21 = 2 * x1;
let y21 = 2 * y1;
let z21 = 2 * z1;
let xx1 = x1 * x21;
let yy1 = y1 * y21;
let zz1 = z1 * z21;
let xy1 = x1 * y21;
let yz1 = y1 * z21;
let xz1 = x1 * z21;
let wx1 = w1 * x21;
let wy1 = w1 * y21;
let wz1 = w1 * z21;
slerpM00 = 1 - yy1 - zz1;
slerpM01 = xy1 - wz1;
slerpM02 = xz1 + wy1;
slerpM10 = xy1 + wz1;
slerpM11 = 1 - xx1 - zz1;
slerpM12 = yz1 - wx1;
slerpM20 = xz1 - wy1;
slerpM21 = yz1 + wx1;
slerpM22 = 1 - xx1 - yy1;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = slerpM00 * prevYX + slerpM01 * prevYY + slerpM02 * prevYZ;
__tmp__Y1 = slerpM10 * prevYX + slerpM11 * prevYY + slerpM12 * prevYZ;
__tmp__Z1 = slerpM20 * prevYX + slerpM21 * prevYY + slerpM22 * prevYZ;
newYX = __tmp__X1;
newYY = __tmp__Y1;
newYZ = __tmp__Z1;
newZX = newXY * newYZ - newXZ * newYY;
newZY = newXZ * newYX - newXX * newYZ;
newZZ = newXX * newYY - newXY * newYX;
if(newZX * newZX + newZY * newZY + newZZ * newZZ > 1e-6) {
let l = newZX * newZX + newZY * newZY + newZZ * newZZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
newZX *= l;
newZY *= l;
newZZ *= l;
} else {
let x1 = newXX;
let y1 = newXY;
let z1 = newXZ;
let x2 = x1 * x1;
let y2 = y1 * y1;
let z2 = z1 * z1;
let d;
if(x2 < y2) {
if(x2 < z2) {
d = 1 / Math.sqrt(y2 + z2);
newZX = 0;
newZY = z1 * d;
newZZ = -y1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
newZX = y1 * d;
newZY = -x1 * d;
newZZ = 0;
}
} else if(y2 < z2) {
d = 1 / Math.sqrt(z2 + x2);
newZX = -z1 * d;
newZY = 0;
newZZ = x1 * d;
} else {
d = 1 / Math.sqrt(x2 + y2);
newZX = y1 * d;
newZY = -x1 * d;
newZZ = 0;
}
}
newYX = newZY * newXZ - newZZ * newXY;
newYY = newZZ * newXX - newZX * newXZ;
newYZ = newZX * newXY - newZY * newXX;
_this.xX = newXX;
_this.xY = newXY;
_this.xZ = newXZ;
_this.yX = newYX;
_this.yY = newYY;
_this.yZ = newYZ;
_this.zX = newZX;
_this.zY = newZY;
_this.zZ = newZZ;
let angErrorX;
let angErrorY;
let angErrorZ;
angErrorX = this._basisX1Y * this._basisX2Z - this._basisX1Z * this._basisX2Y;
angErrorY = this._basisX1Z * this._basisX2X - this._basisX1X * this._basisX2Z;
angErrorZ = this._basisX1X * this._basisX2Y - this._basisX1Y * this._basisX2X;
let cos = this._basisX1X * this._basisX2X + this._basisX1Y * this._basisX2Y + this._basisX1Z * this._basisX2Z;
let theta = cos <= -1 ? 3.14159265358979 : cos >= 1 ? 0 : Math.acos(cos);
let l = angErrorX * angErrorX + angErrorY * angErrorY + angErrorZ * angErrorZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
angErrorX *= l;
angErrorY *= l;
angErrorZ *= l;
angErrorX *= theta;
angErrorY *= theta;
angErrorZ *= theta;
this.angularErrorY = angErrorX * this._basis.yX + angErrorY * this._basis.yY + angErrorZ * this._basis.yZ;
this.angularErrorZ = angErrorX * this._basis.zX + angErrorY * this._basis.zY + angErrorZ * this._basis.zZ;
let perpCrossX;
let perpCrossY;
let perpCrossZ;
perpCrossX = this._basisY1Y * this._basisY2Z - this._basisY1Z * this._basisY2Y;
perpCrossY = this._basisY1Z * this._basisY2X - this._basisY1X * this._basisY2Z;
perpCrossZ = this._basisY1X * this._basisY2Y - this._basisY1Y * this._basisY2X;
cos = this._basisY1X * this._basisY2X + this._basisY1Y * this._basisY2Y + this._basisY1Z * this._basisY2Z;
this.angle = cos <= -1 ? 3.14159265358979 : cos >= 1 ? 0 : Math.acos(cos);
if(perpCrossX * this._basis.xX + perpCrossY * this._basis.xY + perpCrossZ * this._basis.xZ < 0) {
this.angle = -this.angle;
}
this.linearErrorX = this._anchor2X - this._anchor1X;
this.linearErrorY = this._anchor2Y - this._anchor1Y;
this.linearErrorZ = this._anchor2Z - this._anchor1Z;
}
_getVelocitySolverInfo(timeStep,info) {
super._getVelocitySolverInfo(timeStep,info);
this.getInfo(info,timeStep,false);
}
_getPositionSolverInfo(info) {
super._getPositionSolverInfo(info);
this.getInfo(info,null,true);
}
getAxis1() {
let v = new oimo.common.Vec3();
v.x = this._basisX1X;
v.y = this._basisX1Y;
v.z = this._basisX1Z;
return v;
}
getAxis2() {
let v = new oimo.common.Vec3();
v.x = this._basisX2X;
v.y = this._basisX2Y;
v.z = this._basisX2Z;
return v;
}
getAxis1To(axis) {
axis.x = this._basisX1X;
axis.y = this._basisX1Y;
axis.z = this._basisX1Z;
}
getAxis2To(axis) {
axis.x = this._basisX2X;
axis.y = this._basisX2Y;
axis.z = this._basisX2Z;
}
getLocalAxis1() {
let v = new oimo.common.Vec3();
v.x = this._localBasisX1X;
v.y = this._localBasisX1Y;
v.z = this._localBasisX1Z;
return v;
}
getLocalAxis2() {
let v = new oimo.common.Vec3();
v.x = this._localBasisX2X;
v.y = this._localBasisX2Y;
v.z = this._localBasisX2Z;
return v;
}
getLocalAxis1To(axis) {
axis.x = this._localBasisX1X;
axis.y = this._localBasisX1Y;
axis.z = this._localBasisX1Z;
}
getLocalAxis2To(axis) {
axis.x = this._localBasisX2X;
axis.y = this._localBasisX2Y;
axis.z = this._localBasisX2Z;
}
getSpringDamper() {
return this._sd;
}
getLimitMotor() {
return this._lm;
}
getAngle() {
return this.angle;
}
}
oimo.dynamics.constraint.joint.RevoluteJointConfig = class oimo_dynamics_constraint_joint_RevoluteJointConfig extends oimo.dynamics.constraint.joint.JointConfig {
constructor() {
super();
this.localAxis1 = new oimo.common.Vec3(1,0,0);
this.localAxis2 = new oimo.common.Vec3(1,0,0);
this.springDamper = new oimo.dynamics.constraint.joint.SpringDamper();
this.limitMotor = new oimo.dynamics.constraint.joint.RotationalLimitMotor();
}
init(rigidBody1,rigidBody2,worldAnchor,worldAxis) {
this._init(rigidBody1,rigidBody2,worldAnchor);
let localVector = this.localAxis1;
let vX;
let vY;
let vZ;
vX = worldAxis.x;
vY = worldAxis.y;
vZ = worldAxis.z;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = rigidBody1._transform._rotation00 * vX + rigidBody1._transform._rotation10 * vY + rigidBody1._transform._rotation20 * vZ;
__tmp__Y = rigidBody1._transform._rotation01 * vX + rigidBody1._transform._rotation11 * vY + rigidBody1._transform._rotation21 * vZ;
__tmp__Z = rigidBody1._transform._rotation02 * vX + rigidBody1._transform._rotation12 * vY + rigidBody1._transform._rotation22 * vZ;
vX = __tmp__X;
vY = __tmp__Y;
vZ = __tmp__Z;
localVector.x = vX;
localVector.y = vY;
localVector.z = vZ;
let localVector1 = this.localAxis2;
let vX1;
let vY1;
let vZ1;
vX1 = worldAxis.x;
vY1 = worldAxis.y;
vZ1 = worldAxis.z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = rigidBody2._transform._rotation00 * vX1 + rigidBody2._transform._rotation10 * vY1 + rigidBody2._transform._rotation20 * vZ1;
__tmp__Y1 = rigidBody2._transform._rotation01 * vX1 + rigidBody2._transform._rotation11 * vY1 + rigidBody2._transform._rotation21 * vZ1;
__tmp__Z1 = rigidBody2._transform._rotation02 * vX1 + rigidBody2._transform._rotation12 * vY1 + rigidBody2._transform._rotation22 * vZ1;
vX1 = __tmp__X1;
vY1 = __tmp__Y1;
vZ1 = __tmp__Z1;
localVector1.x = vX1;
localVector1.y = vY1;
localVector1.z = vZ1;
return this;
}
}
oimo.dynamics.constraint.joint.RotationalLimitMotor = class oimo_dynamics_constraint_joint_RotationalLimitMotor {
constructor() {
this.lowerLimit = 1;
this.upperLimit = 0;
this.motorTorque = 0;
}
setLimits(lower,upper) {
this.lowerLimit = lower;
this.upperLimit = upper;
return this;
}
setMotor(speed,torque) {
this.motorSpeed = speed;
this.motorTorque = torque;
return this;
}
clone() {
let lm = new oimo.dynamics.constraint.joint.RotationalLimitMotor();
lm.lowerLimit = this.lowerLimit;
lm.upperLimit = this.upperLimit;
lm.motorSpeed = this.motorSpeed;
lm.motorTorque = this.motorTorque;
return lm;
}
}
oimo.dynamics.constraint.joint.SphericalJoint = class oimo_dynamics_constraint_joint_SphericalJoint extends oimo.dynamics.constraint.joint.Joint {
constructor(config) {
super(config,0);
this._sd = config.springDamper.clone();
}
getInfo(info,timeStep,isPositionPart) {
if(this._sd.frequency > 0 && isPositionPart) {
return;
}
let errorX;
let errorY;
let errorZ;
errorX = this._anchor2X - this._anchor1X;
errorY = this._anchor2Y - this._anchor1Y;
errorZ = this._anchor2Z - this._anchor1Z;
let cfm;
let erp;
if(this._sd.frequency > 0) {
let omega = 6.28318530717958 * this._sd.frequency;
let zeta = this._sd.dampingRatio;
if(zeta < oimo.common.Setting.minSpringDamperDampingRatio) {
zeta = oimo.common.Setting.minSpringDamperDampingRatio;
}
let h = timeStep.dt;
let c = 2 * zeta * omega;
let k = omega * omega;
if(this._sd.useSymplecticEuler) {
cfm = 1 / (h * c);
erp = k / c;
} else {
cfm = 1 / (h * (h * k + c));
erp = k / (h * k + c);
}
cfm *= this._b1._invMass + this._b2._invMass;
} else {
cfm = 0;
erp = this.getErp(timeStep,isPositionPart);
}
let linearRhsX;
let linearRhsY;
let linearRhsZ;
linearRhsX = errorX * erp;
linearRhsY = errorY * erp;
linearRhsZ = errorZ * erp;
let crossR100;
let crossR101;
let crossR102;
let crossR110;
let crossR111;
let crossR112;
let crossR120;
let crossR121;
let crossR122;
let crossR200;
let crossR201;
let crossR202;
let crossR210;
let crossR211;
let crossR212;
let crossR220;
let crossR221;
let crossR222;
crossR100 = 0;
crossR101 = -this._relativeAnchor1Z;
crossR102 = this._relativeAnchor1Y;
crossR110 = this._relativeAnchor1Z;
crossR111 = 0;
crossR112 = -this._relativeAnchor1X;
crossR120 = -this._relativeAnchor1Y;
crossR121 = this._relativeAnchor1X;
crossR122 = 0;
crossR200 = 0;
crossR201 = -this._relativeAnchor2Z;
crossR202 = this._relativeAnchor2Y;
crossR210 = this._relativeAnchor2Z;
crossR211 = 0;
crossR212 = -this._relativeAnchor2X;
crossR220 = -this._relativeAnchor2Y;
crossR221 = this._relativeAnchor2X;
crossR222 = 0;
crossR100 = -crossR100;
crossR101 = -crossR101;
crossR102 = -crossR102;
crossR110 = -crossR110;
crossR111 = -crossR111;
crossR112 = -crossR112;
crossR120 = -crossR120;
crossR121 = -crossR121;
crossR122 = -crossR122;
crossR200 = -crossR200;
crossR201 = -crossR201;
crossR202 = -crossR202;
crossR210 = -crossR210;
crossR211 = -crossR211;
crossR212 = -crossR212;
crossR220 = -crossR220;
crossR221 = -crossR221;
crossR222 = -crossR222;
let impulse = this._impulses[0];
let row = info.rows[info.numRows++];
let _this = row.jacobian;
_this.lin1X = 0;
_this.lin1Y = 0;
_this.lin1Z = 0;
_this.lin2X = 0;
_this.lin2Y = 0;
_this.lin2Z = 0;
_this.ang1X = 0;
_this.ang1Y = 0;
_this.ang1Z = 0;
_this.ang2X = 0;
_this.ang2Y = 0;
_this.ang2Z = 0;
row.rhs = 0;
row.cfm = 0;
row.minImpulse = 0;
row.maxImpulse = 0;
row.motorSpeed = 0;
row.motorMaxImpulse = 0;
row.impulse = null;
row.impulse = impulse;
row.rhs = linearRhsX;
row.cfm = cfm;
row.minImpulse = -1e65536;
row.maxImpulse = 1e65536;
let j = row.jacobian;
j.lin1X = 1;
j.lin1Y = 0;
j.lin1Z = 0;
j.lin2X = 1;
j.lin2Y = 0;
j.lin2Z = 0;
j.ang1X = crossR100;
j.ang1Y = crossR101;
j.ang1Z = crossR102;
j.ang2X = crossR200;
j.ang2Y = crossR201;
j.ang2Z = crossR202;
let impulse1 = this._impulses[1];
let row1 = info.rows[info.numRows++];
let _this1 = row1.jacobian;
_this1.lin1X = 0;
_this1.lin1Y = 0;
_this1.lin1Z = 0;
_this1.lin2X = 0;
_this1.lin2Y = 0;
_this1.lin2Z = 0;
_this1.ang1X = 0;
_this1.ang1Y = 0;
_this1.ang1Z = 0;
_this1.ang2X = 0;
_this1.ang2Y = 0;
_this1.ang2Z = 0;
row1.rhs = 0;
row1.cfm = 0;
row1.minImpulse = 0;
row1.maxImpulse = 0;
row1.motorSpeed = 0;
row1.motorMaxImpulse = 0;
row1.impulse = null;
row1.impulse = impulse1;
row1.rhs = linearRhsY;
row1.cfm = cfm;
row1.minImpulse = -1e65536;
row1.maxImpulse = 1e65536;
j = row1.jacobian;
j.lin1X = 0;
j.lin1Y = 1;
j.lin1Z = 0;
j.lin2X = 0;
j.lin2Y = 1;
j.lin2Z = 0;
j.ang1X = crossR110;
j.ang1Y = crossR111;
j.ang1Z = crossR112;
j.ang2X = crossR210;
j.ang2Y = crossR211;
j.ang2Z = crossR212;
let impulse2 = this._impulses[2];
let row2 = info.rows[info.numRows++];
let _this2 = row2.jacobian;
_this2.lin1X = 0;
_this2.lin1Y = 0;
_this2.lin1Z = 0;
_this2.lin2X = 0;
_this2.lin2Y = 0;
_this2.lin2Z = 0;
_this2.ang1X = 0;
_this2.ang1Y = 0;
_this2.ang1Z = 0;
_this2.ang2X = 0;
_this2.ang2Y = 0;
_this2.ang2Z = 0;
row2.rhs = 0;
row2.cfm = 0;
row2.minImpulse = 0;
row2.maxImpulse = 0;
row2.motorSpeed = 0;
row2.motorMaxImpulse = 0;
row2.impulse = null;
row2.impulse = impulse2;
row2.rhs = linearRhsZ;
row2.cfm = cfm;
row2.minImpulse = -1e65536;
row2.maxImpulse = 1e65536;
j = row2.jacobian;
j.lin1X = 0;
j.lin1Y = 0;
j.lin1Z = 1;
j.lin2X = 0;
j.lin2Y = 0;
j.lin2Z = 1;
j.ang1X = crossR120;
j.ang1Y = crossR121;
j.ang1Z = crossR122;
j.ang2X = crossR220;
j.ang2Y = crossR221;
j.ang2Z = crossR222;
}
_getVelocitySolverInfo(timeStep,info) {
super._getVelocitySolverInfo(timeStep,info);
this.getInfo(info,timeStep,false);
}
_getPositionSolverInfo(info) {
super._getPositionSolverInfo(info);
this.getInfo(info,null,true);
}
getSpringDamper() {
return this._sd;
}
}
oimo.dynamics.constraint.joint.SphericalJointConfig = class oimo_dynamics_constraint_joint_SphericalJointConfig extends oimo.dynamics.constraint.joint.JointConfig {
constructor() {
super();
this.springDamper = new oimo.dynamics.constraint.joint.SpringDamper();
}
init(rigidBody1,rigidBody2,worldAnchor) {
this._init(rigidBody1,rigidBody2,worldAnchor);
return this;
}
}
oimo.dynamics.constraint.joint.SpringDamper = class oimo_dynamics_constraint_joint_SpringDamper {
constructor() {
this.frequency = 0;
this.dampingRatio = 0;
this.useSymplecticEuler = false;
}
setSpring(frequency,dampingRatio) {
this.frequency = frequency;
this.dampingRatio = dampingRatio;
return this;
}
setSymplecticEuler(useSymplecticEuler) {
this.useSymplecticEuler = useSymplecticEuler;
return this;
}
clone() {
let sd = new oimo.dynamics.constraint.joint.SpringDamper();
sd.frequency = this.frequency;
sd.dampingRatio = this.dampingRatio;
sd.useSymplecticEuler = this.useSymplecticEuler;
return sd;
}
}
oimo.dynamics.constraint.joint.TranslationalLimitMotor = class oimo_dynamics_constraint_joint_TranslationalLimitMotor {
constructor() {
this.lowerLimit = 1;
this.upperLimit = 0;
this.motorForce = 0;
}
setLimits(lower,upper) {
this.lowerLimit = lower;
this.upperLimit = upper;
return this;
}
setMotor(speed,force) {
this.motorSpeed = speed;
this.motorForce = force;
return this;
}
clone() {
let lm = new oimo.dynamics.constraint.joint.TranslationalLimitMotor();
lm.lowerLimit = this.lowerLimit;
lm.upperLimit = this.upperLimit;
lm.motorSpeed = this.motorSpeed;
lm.motorForce = this.motorForce;
return lm;
}
}
oimo.dynamics.constraint.joint.UniversalJoint = class oimo_dynamics_constraint_joint_UniversalJoint extends oimo.dynamics.constraint.joint.Joint {
constructor(config) {
super(config,oimo.dynamics.constraint.joint.JointType.UNIVERSAL);
let v = config.localAxis1;
this._localBasisX1X = v.x;
this._localBasisX1Y = v.y;
this._localBasisX1Z = v.z;
let v1 = config.localAxis2;
this._localBasisZ2X = v1.x;
this._localBasisZ2Y = v1.y;
this._localBasisZ2Z = v1.z;
this.buildLocalBasesFromX1Z2();
this._angleX = 0;
this._angleY = 0;
this._angleZ = 0;
this.xSingular = false;
this.ySingular = false;
this.zSingular = false;
this._sd1 = config.springDamper1.clone();
this._sd2 = config.springDamper2.clone();
this._lm1 = config.limitMotor1.clone();
this._lm2 = config.limitMotor2.clone();
}
getInfo(info,timeStep,isPositionPart) {
let erp = this.getErp(timeStep,isPositionPart);
let linearRhsX;
let linearRhsY;
let linearRhsZ;
linearRhsX = this.linearErrorX * erp;
linearRhsY = this.linearErrorY * erp;
linearRhsZ = this.linearErrorZ * erp;
let angRhsY = this._angleY * erp;
let crossR100;
let crossR101;
let crossR102;
let crossR110;
let crossR111;
let crossR112;
let crossR120;
let crossR121;
let crossR122;
let crossR200;
let crossR201;
let crossR202;
let crossR210;
let crossR211;
let crossR212;
let crossR220;
let crossR221;
let crossR222;
crossR100 = 0;
crossR101 = -this._relativeAnchor1Z;
crossR102 = this._relativeAnchor1Y;
crossR110 = this._relativeAnchor1Z;
crossR111 = 0;
crossR112 = -this._relativeAnchor1X;
crossR120 = -this._relativeAnchor1Y;
crossR121 = this._relativeAnchor1X;
crossR122 = 0;
crossR200 = 0;
crossR201 = -this._relativeAnchor2Z;
crossR202 = this._relativeAnchor2Y;
crossR210 = this._relativeAnchor2Z;
crossR211 = 0;
crossR212 = -this._relativeAnchor2X;
crossR220 = -this._relativeAnchor2Y;
crossR221 = this._relativeAnchor2X;
crossR222 = 0;
crossR100 = -crossR100;
crossR101 = -crossR101;
crossR102 = -crossR102;
crossR110 = -crossR110;
crossR111 = -crossR111;
crossR112 = -crossR112;
crossR120 = -crossR120;
crossR121 = -crossR121;
crossR122 = -crossR122;
crossR200 = -crossR200;
crossR201 = -crossR201;
crossR202 = -crossR202;
crossR210 = -crossR210;
crossR211 = -crossR211;
crossR212 = -crossR212;
crossR220 = -crossR220;
crossR221 = -crossR221;
crossR222 = -crossR222;
let motorMassX = this.computeEffectiveInertiaMoment(this._axisXX,this._axisXY,this._axisXZ);
let motorMassZ = this.computeEffectiveInertiaMoment(this._axisZX,this._axisZY,this._axisZZ);
let impulse = this._impulses[0];
let row = info.rows[info.numRows++];
let _this = row.jacobian;
_this.lin1X = 0;
_this.lin1Y = 0;
_this.lin1Z = 0;
_this.lin2X = 0;
_this.lin2Y = 0;
_this.lin2Z = 0;
_this.ang1X = 0;
_this.ang1Y = 0;
_this.ang1Z = 0;
_this.ang2X = 0;
_this.ang2Y = 0;
_this.ang2Z = 0;
row.rhs = 0;
row.cfm = 0;
row.minImpulse = 0;
row.maxImpulse = 0;
row.motorSpeed = 0;
row.motorMaxImpulse = 0;
row.impulse = null;
row.impulse = impulse;
row.rhs = linearRhsX;
row.cfm = 0;
row.minImpulse = -1e65536;
row.maxImpulse = 1e65536;
let j = row.jacobian;
j.lin1X = 1;
j.lin1Y = 0;
j.lin1Z = 0;
j.lin2X = 1;
j.lin2Y = 0;
j.lin2Z = 0;
j.ang1X = crossR100;
j.ang1Y = crossR101;
j.ang1Z = crossR102;
j.ang2X = crossR200;
j.ang2Y = crossR201;
j.ang2Z = crossR202;
let impulse1 = this._impulses[1];
let row1 = info.rows[info.numRows++];
let _this1 = row1.jacobian;
_this1.lin1X = 0;
_this1.lin1Y = 0;
_this1.lin1Z = 0;
_this1.lin2X = 0;
_this1.lin2Y = 0;
_this1.lin2Z = 0;
_this1.ang1X = 0;
_this1.ang1Y = 0;
_this1.ang1Z = 0;
_this1.ang2X = 0;
_this1.ang2Y = 0;
_this1.ang2Z = 0;
row1.rhs = 0;
row1.cfm = 0;
row1.minImpulse = 0;
row1.maxImpulse = 0;
row1.motorSpeed = 0;
row1.motorMaxImpulse = 0;
row1.impulse = null;
row1.impulse = impulse1;
row1.rhs = linearRhsY;
row1.cfm = 0;
row1.minImpulse = -1e65536;
row1.maxImpulse = 1e65536;
j = row1.jacobian;
j.lin1X = 0;
j.lin1Y = 1;
j.lin1Z = 0;
j.lin2X = 0;
j.lin2Y = 1;
j.lin2Z = 0;
j.ang1X = crossR110;
j.ang1Y = crossR111;
j.ang1Z = crossR112;
j.ang2X = crossR210;
j.ang2Y = crossR211;
j.ang2Z = crossR212;
let impulse2 = this._impulses[2];
let row2 = info.rows[info.numRows++];
let _this2 = row2.jacobian;
_this2.lin1X = 0;
_this2.lin1Y = 0;
_this2.lin1Z = 0;
_this2.lin2X = 0;
_this2.lin2Y = 0;
_this2.lin2Z = 0;
_this2.ang1X = 0;
_this2.ang1Y = 0;
_this2.ang1Z = 0;
_this2.ang2X = 0;
_this2.ang2Y = 0;
_this2.ang2Z = 0;
row2.rhs = 0;
row2.cfm = 0;
row2.minImpulse = 0;
row2.maxImpulse = 0;
row2.motorSpeed = 0;
row2.motorMaxImpulse = 0;
row2.impulse = null;
row2.impulse = impulse2;
row2.rhs = linearRhsZ;
row2.cfm = 0;
row2.minImpulse = -1e65536;
row2.maxImpulse = 1e65536;
j = row2.jacobian;
j.lin1X = 0;
j.lin1Y = 0;
j.lin1Z = 1;
j.lin2X = 0;
j.lin2Y = 0;
j.lin2Z = 1;
j.ang1X = crossR120;
j.ang1Y = crossR121;
j.ang1Z = crossR122;
j.ang2X = crossR220;
j.ang2Y = crossR221;
j.ang2Z = crossR222;
if(!this.xSingular && (this._sd1.frequency <= 0 || !isPositionPart)) {
let impulse = this._impulses[3];
let row = info.rows[info.numRows++];
let _this = row.jacobian;
_this.lin1X = 0;
_this.lin1Y = 0;
_this.lin1Z = 0;
_this.lin2X = 0;
_this.lin2Y = 0;
_this.lin2Z = 0;
_this.ang1X = 0;
_this.ang1Y = 0;
_this.ang1Z = 0;
_this.ang2X = 0;
_this.ang2Y = 0;
_this.ang2Z = 0;
row.rhs = 0;
row.cfm = 0;
row.minImpulse = 0;
row.maxImpulse = 0;
row.motorSpeed = 0;
row.motorMaxImpulse = 0;
row.impulse = null;
row.impulse = impulse;
this.setSolverInfoRowAngular(row,this._angleX,this._lm1,motorMassX,this._sd1,timeStep,isPositionPart);
j = row.jacobian;
j.ang1X = this._axisXX;
j.ang1Y = this._axisXY;
j.ang1Z = this._axisXZ;
j.ang2X = this._axisXX;
j.ang2Y = this._axisXY;
j.ang2Z = this._axisXZ;
}
if(!this.ySingular) {
let impulse = this._impulses[4];
let row = info.rows[info.numRows++];
let _this = row.jacobian;
_this.lin1X = 0;
_this.lin1Y = 0;
_this.lin1Z = 0;
_this.lin2X = 0;
_this.lin2Y = 0;
_this.lin2Z = 0;
_this.ang1X = 0;
_this.ang1Y = 0;
_this.ang1Z = 0;
_this.ang2X = 0;
_this.ang2Y = 0;
_this.ang2Z = 0;
row.rhs = 0;
row.cfm = 0;
row.minImpulse = 0;
row.maxImpulse = 0;
row.motorSpeed = 0;
row.motorMaxImpulse = 0;
row.impulse = null;
row.impulse = impulse;
row.rhs = angRhsY;
row.cfm = 0;
row.minImpulse = -1e65536;
row.maxImpulse = 1e65536;
j = row.jacobian;
j.ang1X = this._axisYX;
j.ang1Y = this._axisYY;
j.ang1Z = this._axisYZ;
j.ang2X = this._axisYX;
j.ang2Y = this._axisYY;
j.ang2Z = this._axisYZ;
}
if(!this.zSingular && (this._sd2.frequency <= 0 || !isPositionPart)) {
let impulse = this._impulses[5];
let row = info.rows[info.numRows++];
let _this = row.jacobian;
_this.lin1X = 0;
_this.lin1Y = 0;
_this.lin1Z = 0;
_this.lin2X = 0;
_this.lin2Y = 0;
_this.lin2Z = 0;
_this.ang1X = 0;
_this.ang1Y = 0;
_this.ang1Z = 0;
_this.ang2X = 0;
_this.ang2Y = 0;
_this.ang2Z = 0;
row.rhs = 0;
row.cfm = 0;
row.minImpulse = 0;
row.maxImpulse = 0;
row.motorSpeed = 0;
row.motorMaxImpulse = 0;
row.impulse = null;
row.impulse = impulse;
this.setSolverInfoRowAngular(row,this._angleZ,this._lm2,motorMassZ,this._sd2,timeStep,isPositionPart);
j = row.jacobian;
j.ang1X = this._axisZX;
j.ang1Y = this._axisZY;
j.ang1Z = this._axisZZ;
j.ang2X = this._axisZX;
j.ang2Y = this._axisZY;
j.ang2Z = this._axisZZ;
}
}
_syncAnchors() {
super._syncAnchors();
let angleAxisXX;
let angleAxisXY;
let angleAxisXZ;
let angleAxisYX;
let angleAxisYY;
let angleAxisYZ;
let angleAxisZX;
let angleAxisZY;
let angleAxisZZ;
angleAxisXX = this._basisX1X;
angleAxisXY = this._basisX1Y;
angleAxisXZ = this._basisX1Z;
angleAxisZX = this._basisZ2X;
angleAxisZY = this._basisZ2Y;
angleAxisZZ = this._basisZ2Z;
angleAxisYX = angleAxisZY * angleAxisXZ - angleAxisZZ * angleAxisXY;
angleAxisYY = angleAxisZZ * angleAxisXX - angleAxisZX * angleAxisXZ;
angleAxisYZ = angleAxisZX * angleAxisXY - angleAxisZY * angleAxisXX;
this._axisXX = angleAxisYY * angleAxisZZ - angleAxisYZ * angleAxisZY;
this._axisXY = angleAxisYZ * angleAxisZX - angleAxisYX * angleAxisZZ;
this._axisXZ = angleAxisYX * angleAxisZY - angleAxisYY * angleAxisZX;
this._axisYX = angleAxisYX;
this._axisYY = angleAxisYY;
this._axisYZ = angleAxisYZ;
this._axisZX = angleAxisXY * angleAxisYZ - angleAxisXZ * angleAxisYY;
this._axisZY = angleAxisXZ * angleAxisYX - angleAxisXX * angleAxisYZ;
this._axisZZ = angleAxisXX * angleAxisYY - angleAxisXY * angleAxisYX;
let l = this._axisXX * this._axisXX + this._axisXY * this._axisXY + this._axisXZ * this._axisXZ;
if(l > 0) {
l = 1 / Math.sqrt(l);
}
this._axisXX *= l;
this._axisXY *= l;
this._axisXZ *= l;
let l1 = this._axisYX * this._axisYX + this._axisYY * this._axisYY + this._axisYZ * this._axisYZ;
if(l1 > 0) {
l1 = 1 / Math.sqrt(l1);
}
this._axisYX *= l1;
this._axisYY *= l1;
this._axisYZ *= l1;
let l2 = this._axisZX * this._axisZX + this._axisZY * this._axisZY + this._axisZZ * this._axisZZ;
if(l2 > 0) {
l2 = 1 / Math.sqrt(l2);
}
this._axisZX *= l2;
this._axisZY *= l2;
this._axisZZ *= l2;
this.xSingular = this._axisXX * this._axisXX + this._axisXY * this._axisXY + this._axisXZ * this._axisXZ == 0;
this.ySingular = this._axisYX * this._axisYX + this._axisYY * this._axisYY + this._axisYZ * this._axisYZ == 0;
this.zSingular = this._axisZX * this._axisZX + this._axisZY * this._axisZY + this._axisZZ * this._axisZZ == 0;
let rot100;
let rot101;
let rot102;
let rot110;
let rot111;
let rot112;
let rot120;
let rot121;
let rot122;
let rot200;
let rot201;
let rot202;
let rot210;
let rot211;
let rot212;
let rot220;
let rot221;
let rot222;
rot100 = this._basisX1X;
rot101 = this._basisY1X;
rot102 = this._basisZ1X;
rot110 = this._basisX1Y;
rot111 = this._basisY1Y;
rot112 = this._basisZ1Y;
rot120 = this._basisX1Z;
rot121 = this._basisY1Z;
rot122 = this._basisZ1Z;
rot200 = this._basisX2X;
rot201 = this._basisY2X;
rot202 = this._basisZ2X;
rot210 = this._basisX2Y;
rot211 = this._basisY2Y;
rot212 = this._basisZ2Y;
rot220 = this._basisX2Z;
rot221 = this._basisY2Z;
rot222 = this._basisZ2Z;
let relRot00;
let relRot01;
let relRot02;
let relRot11;
let relRot12;
let relRot21;
let relRot22;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__11;
let __tmp__12;
let __tmp__21;
let __tmp__22;
__tmp__00 = rot100 * rot200 + rot110 * rot210 + rot120 * rot220;
__tmp__01 = rot100 * rot201 + rot110 * rot211 + rot120 * rot221;
__tmp__02 = rot100 * rot202 + rot110 * rot212 + rot120 * rot222;
__tmp__11 = rot101 * rot201 + rot111 * rot211 + rot121 * rot221;
__tmp__12 = rot101 * rot202 + rot111 * rot212 + rot121 * rot222;
__tmp__21 = rot102 * rot201 + rot112 * rot211 + rot122 * rot221;
__tmp__22 = rot102 * rot202 + rot112 * rot212 + rot122 * rot222;
relRot00 = __tmp__00;
relRot01 = __tmp__01;
relRot02 = __tmp__02;
relRot11 = __tmp__11;
relRot12 = __tmp__12;
relRot21 = __tmp__21;
relRot22 = __tmp__22;
let anglesX;
let anglesY;
let anglesZ;
let sy = relRot02;
if(sy <= -1) {
let xSubZ = Math.atan2(relRot21,relRot11);
anglesX = xSubZ * 0.5;
anglesY = -1.570796326794895;
anglesZ = -xSubZ * 0.5;
} else if(sy >= 1) {
let xAddZ = Math.atan2(relRot21,relRot11);
anglesX = xAddZ * 0.5;
anglesY = 1.570796326794895;
anglesZ = xAddZ * 0.5;
} else {
anglesX = Math.atan2(-relRot12,relRot22);
anglesY = Math.asin(sy);
anglesZ = Math.atan2(-relRot01,relRot00);
}
this._angleX = anglesX;
this._angleY = anglesY;
this._angleZ = anglesZ;
this.linearErrorX = this._anchor2X - this._anchor1X;
this.linearErrorY = this._anchor2Y - this._anchor1Y;
this.linearErrorZ = this._anchor2Z - this._anchor1Z;
}
_getVelocitySolverInfo(timeStep,info) {
super._getVelocitySolverInfo(timeStep,info);
this.getInfo(info,timeStep,false);
}
_getPositionSolverInfo(info) {
super._getPositionSolverInfo(info);
this.getInfo(info,null,true);
}
getAxis1() {
let v = new oimo.common.Vec3();
v.x = this._basisX1X;
v.y = this._basisX1Y;
v.z = this._basisX1Z;
return v;
}
getAxis2() {
let v = new oimo.common.Vec3();
v.x = this._basisZ2X;
v.y = this._basisZ2Y;
v.z = this._basisZ2Z;
return v;
}
getAxis1To(axis) {
axis.x = this._basisX1X;
axis.y = this._basisX1Y;
axis.z = this._basisX1Z;
}
getAxis2To(axis) {
axis.x = this._basisZ2X;
axis.y = this._basisZ2Y;
axis.z = this._basisZ2Z;
}
getLocalAxis1() {
let v = new oimo.common.Vec3();
v.x = this._localBasisX1X;
v.y = this._localBasisX1Y;
v.z = this._localBasisX1Z;
return v;
}
getLocalAxis2() {
let v = new oimo.common.Vec3();
v.x = this._localBasisZ2X;
v.y = this._localBasisZ2Y;
v.z = this._localBasisZ2Z;
return v;
}
getLocalAxis1To(axis) {
axis.x = this._localBasisX1X;
axis.y = this._localBasisX1Y;
axis.z = this._localBasisX1Z;
}
getLocalAxis2To(axis) {
axis.x = this._localBasisZ2X;
axis.y = this._localBasisZ2Y;
axis.z = this._localBasisZ2Z;
}
getSpringDamper1() {
return this._sd1;
}
getSpringDamper2() {
return this._sd2;
}
getLimitMotor1() {
return this._lm1;
}
getLimitMotor2() {
return this._lm2;
}
getAngle1() {
return this._angleX;
}
getAngle2() {
return this._angleZ;
}
}
oimo.dynamics.constraint.joint.UniversalJointConfig = class oimo_dynamics_constraint_joint_UniversalJointConfig extends oimo.dynamics.constraint.joint.JointConfig {
constructor() {
super();
this.localAxis1 = new oimo.common.Vec3(1,0,0);
this.localAxis2 = new oimo.common.Vec3(1,0,0);
this.springDamper1 = new oimo.dynamics.constraint.joint.SpringDamper();
this.springDamper2 = new oimo.dynamics.constraint.joint.SpringDamper();
this.limitMotor1 = new oimo.dynamics.constraint.joint.RotationalLimitMotor();
this.limitMotor2 = new oimo.dynamics.constraint.joint.RotationalLimitMotor();
}
init(rigidBody1,rigidBody2,worldAnchor,worldAxis1,worldAxis2) {
this._init(rigidBody1,rigidBody2,worldAnchor);
let localVector = this.localAxis1;
let vX;
let vY;
let vZ;
vX = worldAxis1.x;
vY = worldAxis1.y;
vZ = worldAxis1.z;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = rigidBody1._transform._rotation00 * vX + rigidBody1._transform._rotation10 * vY + rigidBody1._transform._rotation20 * vZ;
__tmp__Y = rigidBody1._transform._rotation01 * vX + rigidBody1._transform._rotation11 * vY + rigidBody1._transform._rotation21 * vZ;
__tmp__Z = rigidBody1._transform._rotation02 * vX + rigidBody1._transform._rotation12 * vY + rigidBody1._transform._rotation22 * vZ;
vX = __tmp__X;
vY = __tmp__Y;
vZ = __tmp__Z;
localVector.x = vX;
localVector.y = vY;
localVector.z = vZ;
let localVector1 = this.localAxis2;
let vX1;
let vY1;
let vZ1;
vX1 = worldAxis2.x;
vY1 = worldAxis2.y;
vZ1 = worldAxis2.z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = rigidBody2._transform._rotation00 * vX1 + rigidBody2._transform._rotation10 * vY1 + rigidBody2._transform._rotation20 * vZ1;
__tmp__Y1 = rigidBody2._transform._rotation01 * vX1 + rigidBody2._transform._rotation11 * vY1 + rigidBody2._transform._rotation21 * vZ1;
__tmp__Z1 = rigidBody2._transform._rotation02 * vX1 + rigidBody2._transform._rotation12 * vY1 + rigidBody2._transform._rotation22 * vZ1;
vX1 = __tmp__X1;
vY1 = __tmp__Y1;
vZ1 = __tmp__Z1;
localVector1.x = vX1;
localVector1.y = vY1;
localVector1.z = vZ1;
return this;
}
}
if(!oimo.dynamics.constraint.solver) oimo.dynamics.constraint.solver = {};
oimo.dynamics.constraint.solver.ConstraintSolverType = class oimo_dynamics_constraint_solver_ConstraintSolverType {
}
if(!oimo.dynamics.constraint.solver.common) oimo.dynamics.constraint.solver.common = {};
oimo.dynamics.constraint.solver.common.ContactSolverMassDataRow = class oimo_dynamics_constraint_solver_common_ContactSolverMassDataRow {
constructor() {
this.invMLinN1X = 0;
this.invMLinN1Y = 0;
this.invMLinN1Z = 0;
this.invMLinN2X = 0;
this.invMLinN2Y = 0;
this.invMLinN2Z = 0;
this.invMAngN1X = 0;
this.invMAngN1Y = 0;
this.invMAngN1Z = 0;
this.invMAngN2X = 0;
this.invMAngN2Y = 0;
this.invMAngN2Z = 0;
this.invMLinT1X = 0;
this.invMLinT1Y = 0;
this.invMLinT1Z = 0;
this.invMLinT2X = 0;
this.invMLinT2Y = 0;
this.invMLinT2Z = 0;
this.invMAngT1X = 0;
this.invMAngT1Y = 0;
this.invMAngT1Z = 0;
this.invMAngT2X = 0;
this.invMAngT2Y = 0;
this.invMAngT2Z = 0;
this.invMLinB1X = 0;
this.invMLinB1Y = 0;
this.invMLinB1Z = 0;
this.invMLinB2X = 0;
this.invMLinB2Y = 0;
this.invMLinB2Z = 0;
this.invMAngB1X = 0;
this.invMAngB1Y = 0;
this.invMAngB1Z = 0;
this.invMAngB2X = 0;
this.invMAngB2Y = 0;
this.invMAngB2Z = 0;
this.massN = 0;
this.massTB00 = 0;
this.massTB01 = 0;
this.massTB10 = 0;
this.massTB11 = 0;
}
}
oimo.dynamics.constraint.solver.common.JointSolverMassDataRow = class oimo_dynamics_constraint_solver_common_JointSolverMassDataRow {
constructor() {
this.invMLin1X = 0;
this.invMLin1Y = 0;
this.invMLin1Z = 0;
this.invMLin2X = 0;
this.invMLin2Y = 0;
this.invMLin2Z = 0;
this.invMAng1X = 0;
this.invMAng1Y = 0;
this.invMAng1Z = 0;
this.invMAng2X = 0;
this.invMAng2Y = 0;
this.invMAng2Z = 0;
this.mass = 0;
this.massWithoutCfm = 0;
}
}
if(!oimo.dynamics.constraint.solver.direct) oimo.dynamics.constraint.solver.direct = {};
oimo.dynamics.constraint.solver.direct.Boundary = class oimo_dynamics_constraint_solver_direct_Boundary {
constructor(maxRows) {
this.iBounded = new Array(maxRows);
this.iUnbounded = new Array(maxRows);
this.signs = new Array(maxRows);
this.b = new Array(maxRows);
this.numBounded = 0;
this.numUnbounded = 0;
this.matrixId = 0;
}
init(buildInfo) {
this.numBounded = buildInfo.numBounded;
let _g = 0;
let _g1 = this.numBounded;
while(_g < _g1) {
let i = _g++;
this.iBounded[i] = buildInfo.iBounded[i];
this.signs[i] = buildInfo.signs[i];
}
this.numUnbounded = buildInfo.numUnbounded;
this.matrixId = 0;
let _g2 = 0;
let _g3 = this.numUnbounded;
while(_g2 < _g3) {
let i = _g2++;
let idx = buildInfo.iUnbounded[i];
this.iUnbounded[i] = idx;
this.matrixId |= 1 << idx;
}
}
computeImpulses(info,mass,relVels,impulses,dImpulses,impulseFactor,noCheck) {
let _g = 0;
let _g1 = this.numUnbounded;
while(_g < _g1) {
let idx = this.iUnbounded[_g++];
let row = info.rows[idx];
this.b[idx] = row.rhs * impulseFactor - relVels[idx] - row.cfm * impulses[idx];
}
let invMassWithoutCfm = mass._invMassWithoutCfm;
let _g2 = 0;
let _g3 = this.numBounded;
while(_g2 < _g3) {
let i = _g2++;
let idx = this.iBounded[i];
let sign = this.signs[i];
let row = info.rows[idx];
let dImpulse = (sign < 0 ? row.minImpulse : sign > 0 ? row.maxImpulse : 0) - impulses[idx];
dImpulses[idx] = dImpulse;
if(dImpulse != 0) {
let _g = 0;
let _g1 = this.numUnbounded;
while(_g < _g1) {
let idx2 = this.iUnbounded[_g++];
this.b[idx2] -= invMassWithoutCfm[idx][idx2] * dImpulse;
}
}
}
let indices = this.iUnbounded;
let n = this.numUnbounded;
let id = 0;
let _g4 = 0;
while(_g4 < n) id |= 1 << indices[_g4++];
let massMatrix;
if(mass._cacheComputed[id]) {
massMatrix = mass._cachedSubmatrices[id];
} else {
mass.computeSubmatrix(id,indices,n);
mass._cacheComputed[id] = true;
massMatrix = mass._cachedSubmatrices[id];
}
let ok = true;
let _g5 = 0;
let _g6 = this.numUnbounded;
while(_g5 < _g6) {
let i = _g5++;
let idx = this.iUnbounded[i];
let row = info.rows[idx];
let oldImpulse = impulses[idx];
let impulse = oldImpulse;
let _g = 0;
let _g1 = this.numUnbounded;
while(_g < _g1) {
let j = _g++;
impulse += this.b[this.iUnbounded[j]] * massMatrix[i][j];
}
if(impulse < row.minImpulse - oimo.common.Setting.directMlcpSolverEps || impulse > row.maxImpulse + oimo.common.Setting.directMlcpSolverEps) {
ok = false;
break;
}
dImpulses[idx] = impulse - oldImpulse;
}
if(noCheck) {
return true;
}
if(!ok) {
return false;
}
let _g7 = 0;
let _g8 = this.numBounded;
while(_g7 < _g8) {
let i = _g7++;
let idx = this.iBounded[i];
let row = info.rows[idx];
let sign = this.signs[i];
let error = 0;
let newImpulse = impulses[idx] + dImpulses[idx];
let relVel = relVels[idx];
let _g = 0;
let _g1 = info.numRows;
while(_g < _g1) {
let j = _g++;
relVel += invMassWithoutCfm[idx][j] * dImpulses[j];
}
error = row.rhs * impulseFactor - relVel - row.cfm * newImpulse;
if(sign < 0 && error > oimo.common.Setting.directMlcpSolverEps || sign > 0 && error < -oimo.common.Setting.directMlcpSolverEps) {
ok = false;
break;
}
}
return ok;
}
}
oimo.dynamics.constraint.solver.direct.BoundaryBuildInfo = class oimo_dynamics_constraint_solver_direct_BoundaryBuildInfo {
constructor(size) {
this.size = size;
this.numBounded = 0;
this.iBounded = new Array(size);
this.signs = new Array(size);
this.numUnbounded = 0;
this.iUnbounded = new Array(size);
}
}
oimo.dynamics.constraint.solver.direct.BoundaryBuilder = class oimo_dynamics_constraint_solver_direct_BoundaryBuilder {
constructor(maxRows) {
this.maxRows = maxRows;
this.numBoundaries = 0;
this.boundaries = new Array(1 << maxRows);
this.bbInfo = new oimo.dynamics.constraint.solver.direct.BoundaryBuildInfo(maxRows);
}
buildBoundariesRecursive(info,i) {
if(i == info.numRows) {
if(this.boundaries[this.numBoundaries] == null) {
this.boundaries[this.numBoundaries] = new oimo.dynamics.constraint.solver.direct.Boundary(this.maxRows);
}
this.boundaries[this.numBoundaries++].init(this.bbInfo);
return;
}
let row = info.rows[i];
let lowerLimitEnabled = row.minImpulse > -1e65536;
let upperLimitEnabled = row.maxImpulse < 1e65536;
if(row.minImpulse == 0 && row.maxImpulse == 0) {
let _this = this.bbInfo;
_this.iBounded[_this.numBounded] = i;
_this.signs[_this.numBounded] = 0;
_this.numBounded++;
this.buildBoundariesRecursive(info,i + 1);
this.bbInfo.numBounded--;
return;
}
let _this = this.bbInfo;
_this.iUnbounded[_this.numUnbounded] = i;
_this.numUnbounded++;
this.buildBoundariesRecursive(info,i + 1);
this.bbInfo.numUnbounded--;
if(lowerLimitEnabled) {
let _this = this.bbInfo;
_this.iBounded[_this.numBounded] = i;
_this.signs[_this.numBounded] = -1;
_this.numBounded++;
this.buildBoundariesRecursive(info,i + 1);
this.bbInfo.numBounded--;
}
if(upperLimitEnabled) {
let _this = this.bbInfo;
_this.iBounded[_this.numBounded] = i;
_this.signs[_this.numBounded] = 1;
_this.numBounded++;
this.buildBoundariesRecursive(info,i + 1);
this.bbInfo.numBounded--;
}
}
buildBoundaries(info) {
this.numBoundaries = 0;
let _this = this.bbInfo;
_this.numBounded = 0;
_this.numUnbounded = 0;
this.buildBoundariesRecursive(info,0);
}
}
oimo.dynamics.constraint.solver.direct.BoundarySelector = class oimo_dynamics_constraint_solver_direct_BoundarySelector {
constructor(n) {
this.n = n;
this.indices = new Array(n);
this.tmpIndices = new Array(n);
let _g = 0;
while(_g < n) {
let i = _g++;
this.indices[i] = i;
}
}
getIndex(i) {
return this.indices[i];
}
select(index) {
let i = 0;
while(this.indices[i] != index) ++i;
while(i > 0) {
let tmp = this.indices[i];
this.indices[i] = this.indices[i - 1];
this.indices[i - 1] = tmp;
--i;
}
}
setSize(size) {
let numSmaller = 0;
let numGreater = 0;
let _g = 0;
let _g1 = this.n;
while(_g < _g1) {
let idx = this.indices[_g++];
if(idx < size) {
this.tmpIndices[numSmaller] = idx;
++numSmaller;
} else {
this.tmpIndices[size + numGreater] = idx;
++numGreater;
}
}
let tmp = this.indices;
this.indices = this.tmpIndices;
this.tmpIndices = tmp;
}
}
oimo.dynamics.constraint.solver.direct.DirectJointConstraintSolver = class oimo_dynamics_constraint_solver_direct_DirectJointConstraintSolver extends oimo.dynamics.constraint.ConstraintSolver {
constructor(joint) {
super();
this.joint = joint;
this.info = new oimo.dynamics.constraint.info.joint.JointSolverInfo();
let maxRows = oimo.common.Setting.maxJacobianRows;
this.massMatrix = new oimo.dynamics.constraint.solver.direct.MassMatrix(maxRows);
this.boundaryBuilder = new oimo.dynamics.constraint.solver.direct.BoundaryBuilder(maxRows);
this.massData = new Array(maxRows);
let _g = 0;
let _g1 = this.massData.length;
while(_g < _g1) this.massData[_g++] = new oimo.dynamics.constraint.solver.common.JointSolverMassDataRow();
let numMaxBoundaries = this.boundaryBuilder.boundaries.length;
this.velBoundarySelector = new oimo.dynamics.constraint.solver.direct.BoundarySelector(numMaxBoundaries);
this.posBoundarySelector = new oimo.dynamics.constraint.solver.direct.BoundarySelector(numMaxBoundaries);
this.relVels = new Array(maxRows);
this.impulses = new Array(maxRows);
this.dImpulses = new Array(maxRows);
this.dTotalImpulses = new Array(maxRows);
let _g2 = 0;
while(_g2 < maxRows) {
let i = _g2++;
this.relVels[i] = 0;
this.impulses[i] = 0;
this.dImpulses[i] = 0;
this.dTotalImpulses[i] = 0;
}
}
preSolveVelocity(timeStep) {
this.joint._syncAnchors();
this.joint._getVelocitySolverInfo(timeStep,this.info);
this._b1 = this.info.b1;
this._b2 = this.info.b2;
this.massMatrix.computeInvMass(this.info,this.massData);
let _this = this.boundaryBuilder;
_this.numBoundaries = 0;
let _this1 = _this.bbInfo;
_this1.numBounded = 0;
_this1.numUnbounded = 0;
_this.buildBoundariesRecursive(this.info,0);
let _this2 = this.velBoundarySelector;
let size = this.boundaryBuilder.numBoundaries;
let numSmaller = 0;
let numGreater = 0;
let _g = 0;
let _g1 = _this2.n;
while(_g < _g1) {
let idx = _this2.indices[_g++];
if(idx < size) {
_this2.tmpIndices[numSmaller] = idx;
++numSmaller;
} else {
_this2.tmpIndices[size + numGreater] = idx;
++numGreater;
}
}
let tmp = _this2.indices;
_this2.indices = _this2.tmpIndices;
_this2.tmpIndices = tmp;
}
warmStart(timeStep) {
let factor = this.joint._positionCorrectionAlgorithm == oimo.dynamics.constraint.PositionCorrectionAlgorithm.BAUMGARTE ? oimo.common.Setting.jointWarmStartingFactorForBaungarte : oimo.common.Setting.jointWarmStartingFactor;
factor *= timeStep.dtRatio;
if(factor <= 0) {
let _g = 0;
let _g1 = this.info.numRows;
while(_g < _g1) {
let _this = this.info.rows[_g++].impulse;
_this.impulse = 0;
_this.impulseM = 0;
_this.impulseP = 0;
}
return;
}
let _g = 0;
let _g1 = this.info.numRows;
while(_g < _g1) {
let i = _g++;
let row = this.info.rows[i];
let imp = row.impulse;
let impulse = imp.impulse * factor;
if(impulse < row.minImpulse) {
impulse = row.minImpulse;
} else if(impulse > row.maxImpulse) {
impulse = row.maxImpulse;
}
imp.impulse = impulse;
if(row.motorMaxImpulse > 0) {
let impulseM = imp.impulseM * factor;
let max = row.motorMaxImpulse;
if(impulseM < -max) {
impulseM = -max;
} else if(impulseM > max) {
impulseM = max;
}
imp.impulseM = impulseM;
} else {
imp.impulseM = 0;
}
this.dImpulses[i] = imp.impulse + imp.impulseM;
}
let impulses = this.dImpulses;
let linearSet = false;
let angularSet = false;
let lv1X;
let lv1Y;
let lv1Z;
let lv2X;
let lv2Y;
let lv2Z;
let av1X;
let av1Y;
let av1Z;
let av2X;
let av2Y;
let av2Z;
lv1X = this._b1._velX;
lv1Y = this._b1._velY;
lv1Z = this._b1._velZ;
lv2X = this._b2._velX;
lv2Y = this._b2._velY;
lv2Z = this._b2._velZ;
av1X = this._b1._angVelX;
av1Y = this._b1._angVelY;
av1Z = this._b1._angVelZ;
av2X = this._b2._angVelX;
av2Y = this._b2._angVelY;
av2Z = this._b2._angVelZ;
let _g2 = 0;
let _g3 = this.info.numRows;
while(_g2 < _g3) {
let i = _g2++;
let j = this.info.rows[i].jacobian;
let md = this.massData[i];
let imp = impulses[i];
if((j.flag & 1) != 0) {
lv1X += md.invMLin1X * imp;
lv1Y += md.invMLin1Y * imp;
lv1Z += md.invMLin1Z * imp;
lv2X += md.invMLin2X * -imp;
lv2Y += md.invMLin2Y * -imp;
lv2Z += md.invMLin2Z * -imp;
linearSet = true;
}
if((j.flag & 2) != 0) {
av1X += md.invMAng1X * imp;
av1Y += md.invMAng1Y * imp;
av1Z += md.invMAng1Z * imp;
av2X += md.invMAng2X * -imp;
av2Y += md.invMAng2Y * -imp;
av2Z += md.invMAng2Z * -imp;
angularSet = true;
}
}
if(linearSet) {
this._b1._velX = lv1X;
this._b1._velY = lv1Y;
this._b1._velZ = lv1Z;
this._b2._velX = lv2X;
this._b2._velY = lv2Y;
this._b2._velZ = lv2Z;
}
if(angularSet) {
this._b1._angVelX = av1X;
this._b1._angVelY = av1Y;
this._b1._angVelZ = av1Z;
this._b2._angVelX = av2X;
this._b2._angVelY = av2Y;
this._b2._angVelZ = av2Z;
}
}
solveVelocity() {
let numRows = this.info.numRows;
let lv1X;
let lv1Y;
let lv1Z;
let lv2X;
let lv2Y;
let lv2Z;
let av1X;
let av1Y;
let av1Z;
let av2X;
let av2Y;
let av2Z;
lv1X = this._b1._velX;
lv1Y = this._b1._velY;
lv1Z = this._b1._velZ;
lv2X = this._b2._velX;
lv2Y = this._b2._velY;
lv2Z = this._b2._velZ;
av1X = this._b1._angVelX;
av1Y = this._b1._angVelY;
av1Z = this._b1._angVelZ;
av2X = this._b2._angVelX;
av2Y = this._b2._angVelY;
av2Z = this._b2._angVelZ;
let _g = 0;
while(_g < numRows) {
let i = _g++;
let row = this.info.rows[i];
let j = row.jacobian;
let relVel = 0;
relVel += lv1X * j.lin1X + lv1Y * j.lin1Y + lv1Z * j.lin1Z;
relVel -= lv2X * j.lin2X + lv2Y * j.lin2Y + lv2Z * j.lin2Z;
relVel += av1X * j.ang1X + av1Y * j.ang1Y + av1Z * j.ang1Z;
relVel -= av2X * j.ang2X + av2Y * j.ang2Y + av2Z * j.ang2Z;
this.relVels[i] = relVel;
this.impulses[i] = row.impulse.impulse;
this.dTotalImpulses[i] = 0;
}
let invMass = this.massMatrix._invMassWithoutCfm;
let _g1 = 0;
while(_g1 < numRows) {
let i = _g1++;
let row = this.info.rows[i];
let imp = row.impulse;
if(row.motorMaxImpulse > 0) {
let oldImpulseM = imp.impulseM;
let impulseM = oldImpulseM + this.massData[i].massWithoutCfm * (-row.motorSpeed - this.relVels[i]);
let maxImpulseM = row.motorMaxImpulse;
if(impulseM < -maxImpulseM) {
impulseM = -maxImpulseM;
} else if(impulseM > maxImpulseM) {
impulseM = maxImpulseM;
}
imp.impulseM = impulseM;
let dImpulseM = impulseM - oldImpulseM;
this.dTotalImpulses[i] = dImpulseM;
let _g = 0;
while(_g < numRows) {
let j = _g++;
this.relVels[j] += dImpulseM * invMass[i][j];
}
}
}
let solved = false;
let _g2 = 0;
let _g3 = this.boundaryBuilder.numBoundaries;
while(_g2 < _g3) {
let idx = this.velBoundarySelector.indices[_g2++];
if(this.boundaryBuilder.boundaries[idx].computeImpulses(this.info,this.massMatrix,this.relVels,this.impulses,this.dImpulses,1,false)) {
let _g = 0;
while(_g < numRows) {
let j = _g++;
let dimp = this.dImpulses[j];
this.info.rows[j].impulse.impulse += dimp;
this.dTotalImpulses[j] += dimp;
}
let impulses = this.dTotalImpulses;
let linearSet = false;
let angularSet = false;
let lv1X;
let lv1Y;
let lv1Z;
let lv2X;
let lv2Y;
let lv2Z;
let av1X;
let av1Y;
let av1Z;
let av2X;
let av2Y;
let av2Z;
lv1X = this._b1._velX;
lv1Y = this._b1._velY;
lv1Z = this._b1._velZ;
lv2X = this._b2._velX;
lv2Y = this._b2._velY;
lv2Z = this._b2._velZ;
av1X = this._b1._angVelX;
av1Y = this._b1._angVelY;
av1Z = this._b1._angVelZ;
av2X = this._b2._angVelX;
av2Y = this._b2._angVelY;
av2Z = this._b2._angVelZ;
let _g1 = 0;
let _g2 = this.info.numRows;
while(_g1 < _g2) {
let i = _g1++;
let j = this.info.rows[i].jacobian;
let md = this.massData[i];
let imp = impulses[i];
if((j.flag & 1) != 0) {
lv1X += md.invMLin1X * imp;
lv1Y += md.invMLin1Y * imp;
lv1Z += md.invMLin1Z * imp;
lv2X += md.invMLin2X * -imp;
lv2Y += md.invMLin2Y * -imp;
lv2Z += md.invMLin2Z * -imp;
linearSet = true;
}
if((j.flag & 2) != 0) {
av1X += md.invMAng1X * imp;
av1Y += md.invMAng1Y * imp;
av1Z += md.invMAng1Z * imp;
av2X += md.invMAng2X * -imp;
av2Y += md.invMAng2Y * -imp;
av2Z += md.invMAng2Z * -imp;
angularSet = true;
}
}
if(linearSet) {
this._b1._velX = lv1X;
this._b1._velY = lv1Y;
this._b1._velZ = lv1Z;
this._b2._velX = lv2X;
this._b2._velY = lv2Y;
this._b2._velZ = lv2Z;
}
if(angularSet) {
this._b1._angVelX = av1X;
this._b1._angVelY = av1Y;
this._b1._angVelZ = av1Z;
this._b2._angVelX = av2X;
this._b2._angVelY = av2Y;
this._b2._angVelZ = av2Z;
}
let _this = this.velBoundarySelector;
let i = 0;
while(_this.indices[i] != idx) ++i;
while(i > 0) {
let tmp = _this.indices[i];
_this.indices[i] = _this.indices[i - 1];
_this.indices[i - 1] = tmp;
--i;
}
solved = true;
break;
}
}
if(!solved) {
console.log("src/oimo/dynamics/constraint/solver/direct/DirectJointConstraintSolver.hx:335:","could not find solution. (velocity)");
return;
}
}
postSolveVelocity(timeStep) {
let linX;
let linY;
let linZ;
let angX;
let angY;
let angZ;
linX = 0;
linY = 0;
linZ = 0;
angX = 0;
angY = 0;
angZ = 0;
let _g = 0;
let _g1 = this.info.numRows;
while(_g < _g1) {
let row = this.info.rows[_g++];
let imp = row.impulse;
let j = row.jacobian;
if((j.flag & 1) != 0) {
linX += j.lin1X * imp.impulse;
linY += j.lin1Y * imp.impulse;
linZ += j.lin1Z * imp.impulse;
} else if((j.flag & 2) != 0) {
angX += j.ang1X * imp.impulse;
angY += j.ang1Y * imp.impulse;
angZ += j.ang1Z * imp.impulse;
}
}
this.joint._appliedForceX = linX * timeStep.invDt;
this.joint._appliedForceY = linY * timeStep.invDt;
this.joint._appliedForceZ = linZ * timeStep.invDt;
this.joint._appliedTorqueX = angX * timeStep.invDt;
this.joint._appliedTorqueY = angY * timeStep.invDt;
this.joint._appliedTorqueZ = angZ * timeStep.invDt;
}
preSolvePosition(timeStep) {
this.joint._syncAnchors();
this.joint._getPositionSolverInfo(this.info);
this._b1 = this.info.b1;
this._b2 = this.info.b2;
this.massMatrix.computeInvMass(this.info,this.massData);
let _this = this.boundaryBuilder;
_this.numBoundaries = 0;
let _this1 = _this.bbInfo;
_this1.numBounded = 0;
_this1.numUnbounded = 0;
_this.buildBoundariesRecursive(this.info,0);
let _this2 = this.posBoundarySelector;
let size = this.boundaryBuilder.numBoundaries;
let numSmaller = 0;
let numGreater = 0;
let _g = 0;
let _g1 = _this2.n;
while(_g < _g1) {
let idx = _this2.indices[_g++];
if(idx < size) {
_this2.tmpIndices[numSmaller] = idx;
++numSmaller;
} else {
_this2.tmpIndices[size + numGreater] = idx;
++numGreater;
}
}
let tmp = _this2.indices;
_this2.indices = _this2.tmpIndices;
_this2.tmpIndices = tmp;
let _g2 = 0;
let _g3 = this.info.numRows;
while(_g2 < _g3) this.info.rows[_g2++].impulse.impulseP = 0;
}
solvePositionSplitImpulse() {
let numRows = this.info.numRows;
let lv1X;
let lv1Y;
let lv1Z;
let lv2X;
let lv2Y;
let lv2Z;
let av1X;
let av1Y;
let av1Z;
let av2X;
let av2Y;
let av2Z;
lv1X = this._b1._pseudoVelX;
lv1Y = this._b1._pseudoVelY;
lv1Z = this._b1._pseudoVelZ;
lv2X = this._b2._pseudoVelX;
lv2Y = this._b2._pseudoVelY;
lv2Z = this._b2._pseudoVelZ;
av1X = this._b1._angPseudoVelX;
av1Y = this._b1._angPseudoVelY;
av1Z = this._b1._angPseudoVelZ;
av2X = this._b2._angPseudoVelX;
av2Y = this._b2._angPseudoVelY;
av2Z = this._b2._angPseudoVelZ;
let _g = 0;
while(_g < numRows) {
let i = _g++;
let row = this.info.rows[i];
let j = row.jacobian;
let relVel = 0;
relVel += lv1X * j.lin1X + lv1Y * j.lin1Y + lv1Z * j.lin1Z;
relVel -= lv2X * j.lin2X + lv2Y * j.lin2Y + lv2Z * j.lin2Z;
relVel += av1X * j.ang1X + av1Y * j.ang1Y + av1Z * j.ang1Z;
relVel -= av2X * j.ang2X + av2Y * j.ang2Y + av2Z * j.ang2Z;
this.relVels[i] = relVel;
this.impulses[i] = row.impulse.impulseP;
}
let solved = false;
let _g1 = 0;
let _g2 = this.boundaryBuilder.numBoundaries;
while(_g1 < _g2) {
let idx = this.posBoundarySelector.indices[_g1++];
if(this.boundaryBuilder.boundaries[idx].computeImpulses(this.info,this.massMatrix,this.relVels,this.impulses,this.dImpulses,oimo.common.Setting.positionSplitImpulseBaumgarte,false)) {
let _g = 0;
while(_g < numRows) {
let j = _g++;
this.info.rows[j].impulse.impulseP += this.dImpulses[j];
}
let impulses = this.dImpulses;
let linearSet = false;
let angularSet = false;
let lv1X;
let lv1Y;
let lv1Z;
let lv2X;
let lv2Y;
let lv2Z;
let av1X;
let av1Y;
let av1Z;
let av2X;
let av2Y;
let av2Z;
lv1X = this._b1._pseudoVelX;
lv1Y = this._b1._pseudoVelY;
lv1Z = this._b1._pseudoVelZ;
lv2X = this._b2._pseudoVelX;
lv2Y = this._b2._pseudoVelY;
lv2Z = this._b2._pseudoVelZ;
av1X = this._b1._angPseudoVelX;
av1Y = this._b1._angPseudoVelY;
av1Z = this._b1._angPseudoVelZ;
av2X = this._b2._angPseudoVelX;
av2Y = this._b2._angPseudoVelY;
av2Z = this._b2._angPseudoVelZ;
let _g1 = 0;
let _g2 = this.info.numRows;
while(_g1 < _g2) {
let i = _g1++;
let j = this.info.rows[i].jacobian;
let md = this.massData[i];
let imp = impulses[i];
if((j.flag & 1) != 0) {
lv1X += md.invMLin1X * imp;
lv1Y += md.invMLin1Y * imp;
lv1Z += md.invMLin1Z * imp;
lv2X += md.invMLin2X * -imp;
lv2Y += md.invMLin2Y * -imp;
lv2Z += md.invMLin2Z * -imp;
linearSet = true;
}
if((j.flag & 2) != 0) {
av1X += md.invMAng1X * imp;
av1Y += md.invMAng1Y * imp;
av1Z += md.invMAng1Z * imp;
av2X += md.invMAng2X * -imp;
av2Y += md.invMAng2Y * -imp;
av2Z += md.invMAng2Z * -imp;
angularSet = true;
}
}
if(linearSet) {
this._b1._pseudoVelX = lv1X;
this._b1._pseudoVelY = lv1Y;
this._b1._pseudoVelZ = lv1Z;
this._b2._pseudoVelX = lv2X;
this._b2._pseudoVelY = lv2Y;
this._b2._pseudoVelZ = lv2Z;
}
if(angularSet) {
this._b1._angPseudoVelX = av1X;
this._b1._angPseudoVelY = av1Y;
this._b1._angPseudoVelZ = av1Z;
this._b2._angPseudoVelX = av2X;
this._b2._angPseudoVelY = av2Y;
this._b2._angPseudoVelZ = av2Z;
}
let _this = this.posBoundarySelector;
let i = 0;
while(_this.indices[i] != idx) ++i;
while(i > 0) {
let tmp = _this.indices[i];
_this.indices[i] = _this.indices[i - 1];
_this.indices[i - 1] = tmp;
--i;
}
solved = true;
break;
}
}
if(!solved) {
console.log("src/oimo/dynamics/constraint/solver/direct/DirectJointConstraintSolver.hx:450:","could not find solution. (split impulse)");
return;
}
}
solvePositionNgs(timeStep) {
this.joint._syncAnchors();
this.joint._getPositionSolverInfo(this.info);
this._b1 = this.info.b1;
this._b2 = this.info.b2;
this.massMatrix.computeInvMass(this.info,this.massData);
let _this = this.boundaryBuilder;
_this.numBoundaries = 0;
let _this1 = _this.bbInfo;
_this1.numBounded = 0;
_this1.numUnbounded = 0;
_this.buildBoundariesRecursive(this.info,0);
let _this2 = this.posBoundarySelector;
let size = this.boundaryBuilder.numBoundaries;
let numSmaller = 0;
let numGreater = 0;
let _g = 0;
let _g1 = _this2.n;
while(_g < _g1) {
let idx = _this2.indices[_g++];
if(idx < size) {
_this2.tmpIndices[numSmaller] = idx;
++numSmaller;
} else {
_this2.tmpIndices[size + numGreater] = idx;
++numGreater;
}
}
let tmp = _this2.indices;
_this2.indices = _this2.tmpIndices;
_this2.tmpIndices = tmp;
let numRows = this.info.numRows;
let _g2 = 0;
while(_g2 < numRows) {
let i = _g2++;
let imp = this.info.rows[i].impulse;
this.relVels[i] = 0;
this.impulses[i] = imp.impulseP;
}
let solved = false;
let _g3 = 0;
let _g4 = this.boundaryBuilder.numBoundaries;
while(_g3 < _g4) {
let idx = this.posBoundarySelector.indices[_g3++];
if(this.boundaryBuilder.boundaries[idx].computeImpulses(this.info,this.massMatrix,this.relVels,this.impulses,this.dImpulses,oimo.common.Setting.positionNgsBaumgarte,false)) {
let _g = 0;
while(_g < numRows) {
let j = _g++;
this.info.rows[j].impulse.impulseP += this.dImpulses[j];
}
let impulses = this.dImpulses;
let linearSet = false;
let angularSet = false;
let lv1X;
let lv1Y;
let lv1Z;
let lv2X;
let lv2Y;
let lv2Z;
let av1X;
let av1Y;
let av1Z;
let av2X;
let av2Y;
let av2Z;
lv1X = 0;
lv1Y = 0;
lv1Z = 0;
lv2X = 0;
lv2Y = 0;
lv2Z = 0;
av1X = 0;
av1Y = 0;
av1Z = 0;
av2X = 0;
av2Y = 0;
av2Z = 0;
let _g1 = 0;
let _g2 = this.info.numRows;
while(_g1 < _g2) {
let i = _g1++;
let j = this.info.rows[i].jacobian;
let md = this.massData[i];
let imp = impulses[i];
if((j.flag & 1) != 0) {
lv1X += md.invMLin1X * imp;
lv1Y += md.invMLin1Y * imp;
lv1Z += md.invMLin1Z * imp;
lv2X += md.invMLin2X * -imp;
lv2Y += md.invMLin2Y * -imp;
lv2Z += md.invMLin2Z * -imp;
linearSet = true;
}
if((j.flag & 2) != 0) {
av1X += md.invMAng1X * imp;
av1Y += md.invMAng1Y * imp;
av1Z += md.invMAng1Z * imp;
av2X += md.invMAng2X * -imp;
av2Y += md.invMAng2Y * -imp;
av2Z += md.invMAng2Z * -imp;
angularSet = true;
}
}
if(linearSet) {
let _this = this._b1;
_this._transform._positionX += lv1X;
_this._transform._positionY += lv1Y;
_this._transform._positionZ += lv1Z;
let _this1 = this._b2;
_this1._transform._positionX += lv2X;
_this1._transform._positionY += lv2Y;
_this1._transform._positionZ += lv2Z;
}
if(angularSet) {
let _this = this._b1;
let theta = Math.sqrt(av1X * av1X + av1Y * av1Y + av1Z * av1Z);
let halfTheta = theta * 0.5;
let rotationToSinAxisFactor;
let cosHalfTheta;
if(halfTheta < 0.5) {
let ht2 = halfTheta * halfTheta;
rotationToSinAxisFactor = 0.5 * (1 - ht2 * 0.16666666666666666 + ht2 * ht2 * 0.0083333333333333332);
cosHalfTheta = 1 - ht2 * 0.5 + ht2 * ht2 * 0.041666666666666664;
} else {
rotationToSinAxisFactor = Math.sin(halfTheta) / theta;
cosHalfTheta = Math.cos(halfTheta);
}
let sinAxisX;
let sinAxisY;
let sinAxisZ;
sinAxisX = av1X * rotationToSinAxisFactor;
sinAxisY = av1Y * rotationToSinAxisFactor;
sinAxisZ = av1Z * rotationToSinAxisFactor;
let dqX;
let dqY;
let dqZ;
let dqW;
dqX = sinAxisX;
dqY = sinAxisY;
dqZ = sinAxisZ;
dqW = cosHalfTheta;
let qX;
let qY;
let qZ;
let qW;
let e00 = _this._transform._rotation00;
let e11 = _this._transform._rotation11;
let e22 = _this._transform._rotation22;
let t = e00 + e11 + e22;
let s;
if(t > 0) {
s = Math.sqrt(t + 1);
qW = 0.5 * s;
s = 0.5 / s;
qX = (_this._transform._rotation21 - _this._transform._rotation12) * s;
qY = (_this._transform._rotation02 - _this._transform._rotation20) * s;
qZ = (_this._transform._rotation10 - _this._transform._rotation01) * s;
} else if(e00 > e11) {
if(e00 > e22) {
s = Math.sqrt(e00 - e11 - e22 + 1);
qX = 0.5 * s;
s = 0.5 / s;
qY = (_this._transform._rotation01 + _this._transform._rotation10) * s;
qZ = (_this._transform._rotation02 + _this._transform._rotation20) * s;
qW = (_this._transform._rotation21 - _this._transform._rotation12) * s;
} else {
s = Math.sqrt(e22 - e00 - e11 + 1);
qZ = 0.5 * s;
s = 0.5 / s;
qX = (_this._transform._rotation02 + _this._transform._rotation20) * s;
qY = (_this._transform._rotation12 + _this._transform._rotation21) * s;
qW = (_this._transform._rotation10 - _this._transform._rotation01) * s;
}
} else if(e11 > e22) {
s = Math.sqrt(e11 - e22 - e00 + 1);
qY = 0.5 * s;
s = 0.5 / s;
qX = (_this._transform._rotation01 + _this._transform._rotation10) * s;
qZ = (_this._transform._rotation12 + _this._transform._rotation21) * s;
qW = (_this._transform._rotation02 - _this._transform._rotation20) * s;
} else {
s = Math.sqrt(e22 - e00 - e11 + 1);
qZ = 0.5 * s;
s = 0.5 / s;
qX = (_this._transform._rotation02 + _this._transform._rotation20) * s;
qY = (_this._transform._rotation12 + _this._transform._rotation21) * s;
qW = (_this._transform._rotation10 - _this._transform._rotation01) * s;
}
qX = dqW * qX + dqX * qW + dqY * qZ - dqZ * qY;
qY = dqW * qY - dqX * qZ + dqY * qW + dqZ * qX;
qZ = dqW * qZ + dqX * qY - dqY * qX + dqZ * qW;
qW = dqW * qW - dqX * qX - dqY * qY - dqZ * qZ;
let l = qX * qX + qY * qY + qZ * qZ + qW * qW;
if(l > 1e-32) {
l = 1 / Math.sqrt(l);
}
qX *= l;
qY *= l;
qZ *= l;
qW *= l;
let x = qX;
let y = qY;
let z = qZ;
let w = qW;
let x2 = 2 * x;
let y2 = 2 * y;
let z2 = 2 * z;
let xx = x * x2;
let yy = y * y2;
let zz = z * z2;
let xy = x * y2;
let yz = y * z2;
let xz = x * z2;
let wx = w * x2;
let wy = w * y2;
let wz = w * z2;
_this._transform._rotation00 = 1 - yy - zz;
_this._transform._rotation01 = xy - wz;
_this._transform._rotation02 = xz + wy;
_this._transform._rotation10 = xy + wz;
_this._transform._rotation11 = 1 - xx - zz;
_this._transform._rotation12 = yz - wx;
_this._transform._rotation20 = xz - wy;
_this._transform._rotation21 = yz + wx;
_this._transform._rotation22 = 1 - xx - yy;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = _this._transform._rotation00 * _this._invLocalInertia00 + _this._transform._rotation01 * _this._invLocalInertia10 + _this._transform._rotation02 * _this._invLocalInertia20;
__tmp__01 = _this._transform._rotation00 * _this._invLocalInertia01 + _this._transform._rotation01 * _this._invLocalInertia11 + _this._transform._rotation02 * _this._invLocalInertia21;
__tmp__02 = _this._transform._rotation00 * _this._invLocalInertia02 + _this._transform._rotation01 * _this._invLocalInertia12 + _this._transform._rotation02 * _this._invLocalInertia22;
__tmp__10 = _this._transform._rotation10 * _this._invLocalInertia00 + _this._transform._rotation11 * _this._invLocalInertia10 + _this._transform._rotation12 * _this._invLocalInertia20;
__tmp__11 = _this._transform._rotation10 * _this._invLocalInertia01 + _this._transform._rotation11 * _this._invLocalInertia11 + _this._transform._rotation12 * _this._invLocalInertia21;
__tmp__12 = _this._transform._rotation10 * _this._invLocalInertia02 + _this._transform._rotation11 * _this._invLocalInertia12 + _this._transform._rotation12 * _this._invLocalInertia22;
__tmp__20 = _this._transform._rotation20 * _this._invLocalInertia00 + _this._transform._rotation21 * _this._invLocalInertia10 + _this._transform._rotation22 * _this._invLocalInertia20;
__tmp__21 = _this._transform._rotation20 * _this._invLocalInertia01 + _this._transform._rotation21 * _this._invLocalInertia11 + _this._transform._rotation22 * _this._invLocalInertia21;
__tmp__22 = _this._transform._rotation20 * _this._invLocalInertia02 + _this._transform._rotation21 * _this._invLocalInertia12 + _this._transform._rotation22 * _this._invLocalInertia22;
_this._invInertia00 = __tmp__00;
_this._invInertia01 = __tmp__01;
_this._invInertia02 = __tmp__02;
_this._invInertia10 = __tmp__10;
_this._invInertia11 = __tmp__11;
_this._invInertia12 = __tmp__12;
_this._invInertia20 = __tmp__20;
_this._invInertia21 = __tmp__21;
_this._invInertia22 = __tmp__22;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = _this._invInertia00 * _this._transform._rotation00 + _this._invInertia01 * _this._transform._rotation01 + _this._invInertia02 * _this._transform._rotation02;
__tmp__011 = _this._invInertia00 * _this._transform._rotation10 + _this._invInertia01 * _this._transform._rotation11 + _this._invInertia02 * _this._transform._rotation12;
__tmp__021 = _this._invInertia00 * _this._transform._rotation20 + _this._invInertia01 * _this._transform._rotation21 + _this._invInertia02 * _this._transform._rotation22;
__tmp__101 = _this._invInertia10 * _this._transform._rotation00 + _this._invInertia11 * _this._transform._rotation01 + _this._invInertia12 * _this._transform._rotation02;
__tmp__111 = _this._invInertia10 * _this._transform._rotation10 + _this._invInertia11 * _this._transform._rotation11 + _this._invInertia12 * _this._transform._rotation12;
__tmp__121 = _this._invInertia10 * _this._transform._rotation20 + _this._invInertia11 * _this._transform._rotation21 + _this._invInertia12 * _this._transform._rotation22;
__tmp__201 = _this._invInertia20 * _this._transform._rotation00 + _this._invInertia21 * _this._transform._rotation01 + _this._invInertia22 * _this._transform._rotation02;
__tmp__211 = _this._invInertia20 * _this._transform._rotation10 + _this._invInertia21 * _this._transform._rotation11 + _this._invInertia22 * _this._transform._rotation12;
__tmp__221 = _this._invInertia20 * _this._transform._rotation20 + _this._invInertia21 * _this._transform._rotation21 + _this._invInertia22 * _this._transform._rotation22;
_this._invInertia00 = __tmp__001;
_this._invInertia01 = __tmp__011;
_this._invInertia02 = __tmp__021;
_this._invInertia10 = __tmp__101;
_this._invInertia11 = __tmp__111;
_this._invInertia12 = __tmp__121;
_this._invInertia20 = __tmp__201;
_this._invInertia21 = __tmp__211;
_this._invInertia22 = __tmp__221;
_this._invInertia00 *= _this._rotFactor.x;
_this._invInertia01 *= _this._rotFactor.x;
_this._invInertia02 *= _this._rotFactor.x;
_this._invInertia10 *= _this._rotFactor.y;
_this._invInertia11 *= _this._rotFactor.y;
_this._invInertia12 *= _this._rotFactor.y;
_this._invInertia20 *= _this._rotFactor.z;
_this._invInertia21 *= _this._rotFactor.z;
_this._invInertia22 *= _this._rotFactor.z;
let _this1 = this._b2;
let theta1 = Math.sqrt(av2X * av2X + av2Y * av2Y + av2Z * av2Z);
let halfTheta1 = theta1 * 0.5;
let rotationToSinAxisFactor1;
let cosHalfTheta1;
if(halfTheta1 < 0.5) {
let ht2 = halfTheta1 * halfTheta1;
rotationToSinAxisFactor1 = 0.5 * (1 - ht2 * 0.16666666666666666 + ht2 * ht2 * 0.0083333333333333332);
cosHalfTheta1 = 1 - ht2 * 0.5 + ht2 * ht2 * 0.041666666666666664;
} else {
rotationToSinAxisFactor1 = Math.sin(halfTheta1) / theta1;
cosHalfTheta1 = Math.cos(halfTheta1);
}
let sinAxisX1;
let sinAxisY1;
let sinAxisZ1;
sinAxisX1 = av2X * rotationToSinAxisFactor1;
sinAxisY1 = av2Y * rotationToSinAxisFactor1;
sinAxisZ1 = av2Z * rotationToSinAxisFactor1;
let dqX1;
let dqY1;
let dqZ1;
let dqW1;
dqX1 = sinAxisX1;
dqY1 = sinAxisY1;
dqZ1 = sinAxisZ1;
dqW1 = cosHalfTheta1;
let qX1;
let qY1;
let qZ1;
let qW1;
let e001 = _this1._transform._rotation00;
let e111 = _this1._transform._rotation11;
let e221 = _this1._transform._rotation22;
let t1 = e001 + e111 + e221;
let s1;
if(t1 > 0) {
s1 = Math.sqrt(t1 + 1);
qW1 = 0.5 * s1;
s1 = 0.5 / s1;
qX1 = (_this1._transform._rotation21 - _this1._transform._rotation12) * s1;
qY1 = (_this1._transform._rotation02 - _this1._transform._rotation20) * s1;
qZ1 = (_this1._transform._rotation10 - _this1._transform._rotation01) * s1;
} else if(e001 > e111) {
if(e001 > e221) {
s1 = Math.sqrt(e001 - e111 - e221 + 1);
qX1 = 0.5 * s1;
s1 = 0.5 / s1;
qY1 = (_this1._transform._rotation01 + _this1._transform._rotation10) * s1;
qZ1 = (_this1._transform._rotation02 + _this1._transform._rotation20) * s1;
qW1 = (_this1._transform._rotation21 - _this1._transform._rotation12) * s1;
} else {
s1 = Math.sqrt(e221 - e001 - e111 + 1);
qZ1 = 0.5 * s1;
s1 = 0.5 / s1;
qX1 = (_this1._transform._rotation02 + _this1._transform._rotation20) * s1;
qY1 = (_this1._transform._rotation12 + _this1._transform._rotation21) * s1;
qW1 = (_this1._transform._rotation10 - _this1._transform._rotation01) * s1;
}
} else if(e111 > e221) {
s1 = Math.sqrt(e111 - e221 - e001 + 1);
qY1 = 0.5 * s1;
s1 = 0.5 / s1;
qX1 = (_this1._transform._rotation01 + _this1._transform._rotation10) * s1;
qZ1 = (_this1._transform._rotation12 + _this1._transform._rotation21) * s1;
qW1 = (_this1._transform._rotation02 - _this1._transform._rotation20) * s1;
} else {
s1 = Math.sqrt(e221 - e001 - e111 + 1);
qZ1 = 0.5 * s1;
s1 = 0.5 / s1;
qX1 = (_this1._transform._rotation02 + _this1._transform._rotation20) * s1;
qY1 = (_this1._transform._rotation12 + _this1._transform._rotation21) * s1;
qW1 = (_this1._transform._rotation10 - _this1._transform._rotation01) * s1;
}
qX1 = dqW1 * qX1 + dqX1 * qW1 + dqY1 * qZ1 - dqZ1 * qY1;
qY1 = dqW1 * qY1 - dqX1 * qZ1 + dqY1 * qW1 + dqZ1 * qX1;
qZ1 = dqW1 * qZ1 + dqX1 * qY1 - dqY1 * qX1 + dqZ1 * qW1;
qW1 = dqW1 * qW1 - dqX1 * qX1 - dqY1 * qY1 - dqZ1 * qZ1;
let l1 = qX1 * qX1 + qY1 * qY1 + qZ1 * qZ1 + qW1 * qW1;
if(l1 > 1e-32) {
l1 = 1 / Math.sqrt(l1);
}
qX1 *= l1;
qY1 *= l1;
qZ1 *= l1;
qW1 *= l1;
let x1 = qX1;
let y1 = qY1;
let z1 = qZ1;
let w1 = qW1;
let x21 = 2 * x1;
let y21 = 2 * y1;
let z21 = 2 * z1;
let xx1 = x1 * x21;
let yy1 = y1 * y21;
let zz1 = z1 * z21;
let xy1 = x1 * y21;
let yz1 = y1 * z21;
let xz1 = x1 * z21;
let wx1 = w1 * x21;
let wy1 = w1 * y21;
let wz1 = w1 * z21;
_this1._transform._rotation00 = 1 - yy1 - zz1;
_this1._transform._rotation01 = xy1 - wz1;
_this1._transform._rotation02 = xz1 + wy1;
_this1._transform._rotation10 = xy1 + wz1;
_this1._transform._rotation11 = 1 - xx1 - zz1;
_this1._transform._rotation12 = yz1 - wx1;
_this1._transform._rotation20 = xz1 - wy1;
_this1._transform._rotation21 = yz1 + wx1;
_this1._transform._rotation22 = 1 - xx1 - yy1;
let __tmp__002;
let __tmp__012;
let __tmp__022;
let __tmp__102;
let __tmp__112;
let __tmp__122;
let __tmp__202;
let __tmp__212;
let __tmp__222;
__tmp__002 = _this1._transform._rotation00 * _this1._invLocalInertia00 + _this1._transform._rotation01 * _this1._invLocalInertia10 + _this1._transform._rotation02 * _this1._invLocalInertia20;
__tmp__012 = _this1._transform._rotation00 * _this1._invLocalInertia01 + _this1._transform._rotation01 * _this1._invLocalInertia11 + _this1._transform._rotation02 * _this1._invLocalInertia21;
__tmp__022 = _this1._transform._rotation00 * _this1._invLocalInertia02 + _this1._transform._rotation01 * _this1._invLocalInertia12 + _this1._transform._rotation02 * _this1._invLocalInertia22;
__tmp__102 = _this1._transform._rotation10 * _this1._invLocalInertia00 + _this1._transform._rotation11 * _this1._invLocalInertia10 + _this1._transform._rotation12 * _this1._invLocalInertia20;
__tmp__112 = _this1._transform._rotation10 * _this1._invLocalInertia01 + _this1._transform._rotation11 * _this1._invLocalInertia11 + _this1._transform._rotation12 * _this1._invLocalInertia21;
__tmp__122 = _this1._transform._rotation10 * _this1._invLocalInertia02 + _this1._transform._rotation11 * _this1._invLocalInertia12 + _this1._transform._rotation12 * _this1._invLocalInertia22;
__tmp__202 = _this1._transform._rotation20 * _this1._invLocalInertia00 + _this1._transform._rotation21 * _this1._invLocalInertia10 + _this1._transform._rotation22 * _this1._invLocalInertia20;
__tmp__212 = _this1._transform._rotation20 * _this1._invLocalInertia01 + _this1._transform._rotation21 * _this1._invLocalInertia11 + _this1._transform._rotation22 * _this1._invLocalInertia21;
__tmp__222 = _this1._transform._rotation20 * _this1._invLocalInertia02 + _this1._transform._rotation21 * _this1._invLocalInertia12 + _this1._transform._rotation22 * _this1._invLocalInertia22;
_this1._invInertia00 = __tmp__002;
_this1._invInertia01 = __tmp__012;
_this1._invInertia02 = __tmp__022;
_this1._invInertia10 = __tmp__102;
_this1._invInertia11 = __tmp__112;
_this1._invInertia12 = __tmp__122;
_this1._invInertia20 = __tmp__202;
_this1._invInertia21 = __tmp__212;
_this1._invInertia22 = __tmp__222;
let __tmp__003;
let __tmp__013;
let __tmp__023;
let __tmp__103;
let __tmp__113;
let __tmp__123;
let __tmp__203;
let __tmp__213;
let __tmp__223;
__tmp__003 = _this1._invInertia00 * _this1._transform._rotation00 + _this1._invInertia01 * _this1._transform._rotation01 + _this1._invInertia02 * _this1._transform._rotation02;
__tmp__013 = _this1._invInertia00 * _this1._transform._rotation10 + _this1._invInertia01 * _this1._transform._rotation11 + _this1._invInertia02 * _this1._transform._rotation12;
__tmp__023 = _this1._invInertia00 * _this1._transform._rotation20 + _this1._invInertia01 * _this1._transform._rotation21 + _this1._invInertia02 * _this1._transform._rotation22;
__tmp__103 = _this1._invInertia10 * _this1._transform._rotation00 + _this1._invInertia11 * _this1._transform._rotation01 + _this1._invInertia12 * _this1._transform._rotation02;
__tmp__113 = _this1._invInertia10 * _this1._transform._rotation10 + _this1._invInertia11 * _this1._transform._rotation11 + _this1._invInertia12 * _this1._transform._rotation12;
__tmp__123 = _this1._invInertia10 * _this1._transform._rotation20 + _this1._invInertia11 * _this1._transform._rotation21 + _this1._invInertia12 * _this1._transform._rotation22;
__tmp__203 = _this1._invInertia20 * _this1._transform._rotation00 + _this1._invInertia21 * _this1._transform._rotation01 + _this1._invInertia22 * _this1._transform._rotation02;
__tmp__213 = _this1._invInertia20 * _this1._transform._rotation10 + _this1._invInertia21 * _this1._transform._rotation11 + _this1._invInertia22 * _this1._transform._rotation12;
__tmp__223 = _this1._invInertia20 * _this1._transform._rotation20 + _this1._invInertia21 * _this1._transform._rotation21 + _this1._invInertia22 * _this1._transform._rotation22;
_this1._invInertia00 = __tmp__003;
_this1._invInertia01 = __tmp__013;
_this1._invInertia02 = __tmp__023;
_this1._invInertia10 = __tmp__103;
_this1._invInertia11 = __tmp__113;
_this1._invInertia12 = __tmp__123;
_this1._invInertia20 = __tmp__203;
_this1._invInertia21 = __tmp__213;
_this1._invInertia22 = __tmp__223;
_this1._invInertia00 *= _this1._rotFactor.x;
_this1._invInertia01 *= _this1._rotFactor.x;
_this1._invInertia02 *= _this1._rotFactor.x;
_this1._invInertia10 *= _this1._rotFactor.y;
_this1._invInertia11 *= _this1._rotFactor.y;
_this1._invInertia12 *= _this1._rotFactor.y;
_this1._invInertia20 *= _this1._rotFactor.z;
_this1._invInertia21 *= _this1._rotFactor.z;
_this1._invInertia22 *= _this1._rotFactor.z;
}
let _this = this.posBoundarySelector;
let i = 0;
while(_this.indices[i] != idx) ++i;
while(i > 0) {
let tmp = _this.indices[i];
_this.indices[i] = _this.indices[i - 1];
_this.indices[i - 1] = tmp;
--i;
}
solved = true;
break;
}
}
if(!solved) {
console.log("src/oimo/dynamics/constraint/solver/direct/DirectJointConstraintSolver.hx:502:","could not find solution. (NGS)");
return;
}
}
postSolve() {
this.joint._syncAnchors();
this.joint._checkDestruction();
}
}
oimo.dynamics.constraint.solver.direct.MassMatrix = class oimo_dynamics_constraint_solver_direct_MassMatrix {
constructor(size) {
this._size = size;
this.tmpMatrix = new Array(this._size);
this._invMass = new Array(this._size);
this._invMassWithoutCfm = new Array(this._size);
let _g = 0;
let _g1 = this._size;
while(_g < _g1) {
let i = _g++;
this.tmpMatrix[i] = new Array(this._size);
this._invMass[i] = new Array(this._size);
this._invMassWithoutCfm[i] = new Array(this._size);
let _g1 = 0;
let _g2 = this._size;
while(_g1 < _g2) {
let j = _g1++;
this.tmpMatrix[i][j] = 0;
this._invMass[i][j] = 0;
this._invMassWithoutCfm[i][j] = 0;
}
}
this._maxSubmatrixId = 1 << this._size;
this._cacheComputed = new Array(this._maxSubmatrixId);
this._cachedSubmatrices = new Array(this._maxSubmatrixId);
let _g2 = 0;
let _g3 = this._maxSubmatrixId;
while(_g2 < _g3) {
let i = _g2++;
let t;
t = (i & 85) + (i >> 1 & 85);
t = (t & 51) + (t >> 2 & 51);
t = (t & 15) + (t >> 4 & 15);
let matrixSize = t;
let subMatrix = new Array(matrixSize);
let _g = 0;
while(_g < matrixSize) {
let j = _g++;
subMatrix[j] = new Array(matrixSize);
let _g1 = 0;
while(_g1 < matrixSize) subMatrix[j][_g1++] = 0;
}
this._cacheComputed[i] = false;
this._cachedSubmatrices[i] = subMatrix;
}
}
computeSubmatrix(id,indices,size) {
let _g = 0;
while(_g < size) {
let i = _g++;
let ii = indices[i];
let _g1 = 0;
while(_g1 < size) {
let j = _g1++;
this.tmpMatrix[i][j] = this._invMass[ii][indices[j]];
}
}
let src = this.tmpMatrix;
let dst = this._cachedSubmatrices[id];
let srci;
let dsti;
let srcj;
let dstj;
let diag;
switch(size) {
case 4:
srci = src[0];
dsti = dst[0];
diag = 1 / srci[0];
dsti[0] = diag;
srci[1] *= diag;
srci[2] *= diag;
srci[3] *= diag;
srcj = src[1];
dstj = dst[1];
dstj[0] = -diag * srcj[0];
srcj[1] -= srci[1] * srcj[0];
srcj[2] -= srci[2] * srcj[0];
srcj[3] -= srci[3] * srcj[0];
srcj = src[2];
dstj = dst[2];
dstj[0] = -diag * srcj[0];
srcj[1] -= srci[1] * srcj[0];
srcj[2] -= srci[2] * srcj[0];
srcj[3] -= srci[3] * srcj[0];
srcj = src[3];
dstj = dst[3];
dstj[0] = -diag * srcj[0];
srcj[1] -= srci[1] * srcj[0];
srcj[2] -= srci[2] * srcj[0];
srcj[3] -= srci[3] * srcj[0];
srci = src[1];
dsti = dst[1];
diag = 1 / srci[1];
dsti[1] = diag;
dsti[0] *= diag;
srci[2] *= diag;
srci[3] *= diag;
srcj = src[0];
dstj = dst[0];
dstj[0] -= dsti[0] * srcj[1];
srcj[2] -= srci[2] * srcj[1];
srcj[3] -= srci[3] * srcj[1];
srcj = src[2];
dstj = dst[2];
dstj[0] -= dsti[0] * srcj[1];
dstj[1] = -diag * srcj[1];
srcj[2] -= srci[2] * srcj[1];
srcj[3] -= srci[3] * srcj[1];
srcj = src[3];
dstj = dst[3];
dstj[0] -= dsti[0] * srcj[1];
dstj[1] = -diag * srcj[1];
srcj[2] -= srci[2] * srcj[1];
srcj[3] -= srci[3] * srcj[1];
srci = src[2];
dsti = dst[2];
diag = 1 / srci[2];
dsti[2] = diag;
dsti[0] *= diag;
dsti[1] *= diag;
srci[3] *= diag;
srcj = src[0];
dstj = dst[0];
dstj[0] -= dsti[0] * srcj[2];
srcj[3] -= srci[3] * srcj[2];
srcj = src[1];
dstj = dst[1];
dstj[0] -= dsti[0] * srcj[2];
dstj[1] -= dsti[1] * srcj[2];
srcj[3] -= srci[3] * srcj[2];
srcj = src[3];
dstj = dst[3];
dstj[0] -= dsti[0] * srcj[2];
dstj[1] -= dsti[1] * srcj[2];
dstj[2] = -diag * srcj[2];
srcj[3] -= srci[3] * srcj[2];
srci = src[3];
dsti = dst[3];
diag = 1 / srci[3];
dsti[3] = diag;
dsti[0] *= diag;
dsti[1] *= diag;
dsti[2] *= diag;
srcj = src[0];
dstj = dst[0];
dstj[0] -= dsti[0] * srcj[3];
srcj = src[1];
dstj = dst[1];
dstj[0] -= dsti[0] * srcj[3];
dstj[1] -= dsti[1] * srcj[3];
srcj = src[2];
dstj = dst[2];
dstj[0] -= dsti[0] * srcj[3];
dstj[1] -= dsti[1] * srcj[3];
dstj[2] -= dsti[2] * srcj[3];
dsti = dst[1];
dst[0][1] = dsti[0];
dsti = dst[2];
dst[0][2] = dsti[0];
dst[1][2] = dsti[1];
dsti = dst[3];
dst[0][3] = dsti[0];
dst[1][3] = dsti[1];
dst[2][3] = dsti[2];
break;
case 5:
srci = src[0];
dsti = dst[0];
diag = 1 / srci[0];
dsti[0] = diag;
srci[1] *= diag;
srci[2] *= diag;
srci[3] *= diag;
srci[4] *= diag;
srcj = src[1];
dstj = dst[1];
dstj[0] = -diag * srcj[0];
srcj[1] -= srci[1] * srcj[0];
srcj[2] -= srci[2] * srcj[0];
srcj[3] -= srci[3] * srcj[0];
srcj[4] -= srci[4] * srcj[0];
srcj = src[2];
dstj = dst[2];
dstj[0] = -diag * srcj[0];
srcj[1] -= srci[1] * srcj[0];
srcj[2] -= srci[2] * srcj[0];
srcj[3] -= srci[3] * srcj[0];
srcj[4] -= srci[4] * srcj[0];
srcj = src[3];
dstj = dst[3];
dstj[0] = -diag * srcj[0];
srcj[1] -= srci[1] * srcj[0];
srcj[2] -= srci[2] * srcj[0];
srcj[3] -= srci[3] * srcj[0];
srcj[4] -= srci[4] * srcj[0];
srcj = src[4];
dstj = dst[4];
dstj[0] = -diag * srcj[0];
srcj[1] -= srci[1] * srcj[0];
srcj[2] -= srci[2] * srcj[0];
srcj[3] -= srci[3] * srcj[0];
srcj[4] -= srci[4] * srcj[0];
srci = src[1];
dsti = dst[1];
diag = 1 / srci[1];
dsti[1] = diag;
dsti[0] *= diag;
srci[2] *= diag;
srci[3] *= diag;
srci[4] *= diag;
srcj = src[0];
dstj = dst[0];
dstj[0] -= dsti[0] * srcj[1];
srcj[2] -= srci[2] * srcj[1];
srcj[3] -= srci[3] * srcj[1];
srcj[4] -= srci[4] * srcj[1];
srcj = src[2];
dstj = dst[2];
dstj[0] -= dsti[0] * srcj[1];
dstj[1] = -diag * srcj[1];
srcj[2] -= srci[2] * srcj[1];
srcj[3] -= srci[3] * srcj[1];
srcj[4] -= srci[4] * srcj[1];
srcj = src[3];
dstj = dst[3];
dstj[0] -= dsti[0] * srcj[1];
dstj[1] = -diag * srcj[1];
srcj[2] -= srci[2] * srcj[1];
srcj[3] -= srci[3] * srcj[1];
srcj[4] -= srci[4] * srcj[1];
srcj = src[4];
dstj = dst[4];
dstj[0] -= dsti[0] * srcj[1];
dstj[1] = -diag * srcj[1];
srcj[2] -= srci[2] * srcj[1];
srcj[3] -= srci[3] * srcj[1];
srcj[4] -= srci[4] * srcj[1];
srci = src[2];
dsti = dst[2];
diag = 1 / srci[2];
dsti[2] = diag;
dsti[0] *= diag;
dsti[1] *= diag;
srci[3] *= diag;
srci[4] *= diag;
srcj = src[0];
dstj = dst[0];
dstj[0] -= dsti[0] * srcj[2];
srcj[3] -= srci[3] * srcj[2];
srcj[4] -= srci[4] * srcj[2];
srcj = src[1];
dstj = dst[1];
dstj[0] -= dsti[0] * srcj[2];
dstj[1] -= dsti[1] * srcj[2];
srcj[3] -= srci[3] * srcj[2];
srcj[4] -= srci[4] * srcj[2];
srcj = src[3];
dstj = dst[3];
dstj[0] -= dsti[0] * srcj[2];
dstj[1] -= dsti[1] * srcj[2];
dstj[2] = -diag * srcj[2];
srcj[3] -= srci[3] * srcj[2];
srcj[4] -= srci[4] * srcj[2];
srcj = src[4];
dstj = dst[4];
dstj[0] -= dsti[0] * srcj[2];
dstj[1] -= dsti[1] * srcj[2];
dstj[2] = -diag * srcj[2];
srcj[3] -= srci[3] * srcj[2];
srcj[4] -= srci[4] * srcj[2];
srci = src[3];
dsti = dst[3];
diag = 1 / srci[3];
dsti[3] = diag;
dsti[0] *= diag;
dsti[1] *= diag;
dsti[2] *= diag;
srci[4] *= diag;
srcj = src[0];
dstj = dst[0];
dstj[0] -= dsti[0] * srcj[3];
srcj[4] -= srci[4] * srcj[3];
srcj = src[1];
dstj = dst[1];
dstj[0] -= dsti[0] * srcj[3];
dstj[1] -= dsti[1] * srcj[3];
srcj[4] -= srci[4] * srcj[3];
srcj = src[2];
dstj = dst[2];
dstj[0] -= dsti[0] * srcj[3];
dstj[1] -= dsti[1] * srcj[3];
dstj[2] -= dsti[2] * srcj[3];
srcj[4] -= srci[4] * srcj[3];
srcj = src[4];
dstj = dst[4];
dstj[0] -= dsti[0] * srcj[3];
dstj[1] -= dsti[1] * srcj[3];
dstj[2] -= dsti[2] * srcj[3];
dstj[3] = -diag * srcj[3];
srcj[4] -= srci[4] * srcj[3];
srci = src[4];
dsti = dst[4];
diag = 1 / srci[4];
dsti[4] = diag;
dsti[0] *= diag;
dsti[1] *= diag;
dsti[2] *= diag;
dsti[3] *= diag;
srcj = src[0];
dstj = dst[0];
dstj[0] -= dsti[0] * srcj[4];
srcj = src[1];
dstj = dst[1];
dstj[0] -= dsti[0] * srcj[4];
dstj[1] -= dsti[1] * srcj[4];
srcj = src[2];
dstj = dst[2];
dstj[0] -= dsti[0] * srcj[4];
dstj[1] -= dsti[1] * srcj[4];
dstj[2] -= dsti[2] * srcj[4];
srcj = src[3];
dstj = dst[3];
dstj[0] -= dsti[0] * srcj[4];
dstj[1] -= dsti[1] * srcj[4];
dstj[2] -= dsti[2] * srcj[4];
dstj[3] -= dsti[3] * srcj[4];
dsti = dst[1];
dst[0][1] = dsti[0];
dsti = dst[2];
dst[0][2] = dsti[0];
dst[1][2] = dsti[1];
dsti = dst[3];
dst[0][3] = dsti[0];
dst[1][3] = dsti[1];
dst[2][3] = dsti[2];
dsti = dst[4];
dst[0][4] = dsti[0];
dst[1][4] = dsti[1];
dst[2][4] = dsti[2];
dst[3][4] = dsti[3];
break;
case 6:
srci = src[0];
dsti = dst[0];
diag = 1 / srci[0];
dsti[0] = diag;
srci[1] *= diag;
srci[2] *= diag;
srci[3] *= diag;
srci[4] *= diag;
srci[5] *= diag;
srcj = src[1];
dstj = dst[1];
dstj[0] = -diag * srcj[0];
srcj[1] -= srci[1] * srcj[0];
srcj[2] -= srci[2] * srcj[0];
srcj[3] -= srci[3] * srcj[0];
srcj[4] -= srci[4] * srcj[0];
srcj[5] -= srci[5] * srcj[0];
srcj = src[2];
dstj = dst[2];
dstj[0] = -diag * srcj[0];
srcj[1] -= srci[1] * srcj[0];
srcj[2] -= srci[2] * srcj[0];
srcj[3] -= srci[3] * srcj[0];
srcj[4] -= srci[4] * srcj[0];
srcj[5] -= srci[5] * srcj[0];
srcj = src[3];
dstj = dst[3];
dstj[0] = -diag * srcj[0];
srcj[1] -= srci[1] * srcj[0];
srcj[2] -= srci[2] * srcj[0];
srcj[3] -= srci[3] * srcj[0];
srcj[4] -= srci[4] * srcj[0];
srcj[5] -= srci[5] * srcj[0];
srcj = src[4];
dstj = dst[4];
dstj[0] = -diag * srcj[0];
srcj[1] -= srci[1] * srcj[0];
srcj[2] -= srci[2] * srcj[0];
srcj[3] -= srci[3] * srcj[0];
srcj[4] -= srci[4] * srcj[0];
srcj[5] -= srci[5] * srcj[0];
srcj = src[5];
dstj = dst[5];
dstj[0] = -diag * srcj[0];
srcj[1] -= srci[1] * srcj[0];
srcj[2] -= srci[2] * srcj[0];
srcj[3] -= srci[3] * srcj[0];
srcj[4] -= srci[4] * srcj[0];
srcj[5] -= srci[5] * srcj[0];
srci = src[1];
dsti = dst[1];
diag = 1 / srci[1];
dsti[1] = diag;
dsti[0] *= diag;
srci[2] *= diag;
srci[3] *= diag;
srci[4] *= diag;
srci[5] *= diag;
srcj = src[0];
dstj = dst[0];
dstj[0] -= dsti[0] * srcj[1];
srcj[2] -= srci[2] * srcj[1];
srcj[3] -= srci[3] * srcj[1];
srcj[4] -= srci[4] * srcj[1];
srcj[5] -= srci[5] * srcj[1];
srcj = src[2];
dstj = dst[2];
dstj[0] -= dsti[0] * srcj[1];
dstj[1] = -diag * srcj[1];
srcj[2] -= srci[2] * srcj[1];
srcj[3] -= srci[3] * srcj[1];
srcj[4] -= srci[4] * srcj[1];
srcj[5] -= srci[5] * srcj[1];
srcj = src[3];
dstj = dst[3];
dstj[0] -= dsti[0] * srcj[1];
dstj[1] = -diag * srcj[1];
srcj[2] -= srci[2] * srcj[1];
srcj[3] -= srci[3] * srcj[1];
srcj[4] -= srci[4] * srcj[1];
srcj[5] -= srci[5] * srcj[1];
srcj = src[4];
dstj = dst[4];
dstj[0] -= dsti[0] * srcj[1];
dstj[1] = -diag * srcj[1];
srcj[2] -= srci[2] * srcj[1];
srcj[3] -= srci[3] * srcj[1];
srcj[4] -= srci[4] * srcj[1];
srcj[5] -= srci[5] * srcj[1];
srcj = src[5];
dstj = dst[5];
dstj[0] -= dsti[0] * srcj[1];
dstj[1] = -diag * srcj[1];
srcj[2] -= srci[2] * srcj[1];
srcj[3] -= srci[3] * srcj[1];
srcj[4] -= srci[4] * srcj[1];
srcj[5] -= srci[5] * srcj[1];
srci = src[2];
dsti = dst[2];
diag = 1 / srci[2];
dsti[2] = diag;
dsti[0] *= diag;
dsti[1] *= diag;
srci[3] *= diag;
srci[4] *= diag;
srci[5] *= diag;
srcj = src[0];
dstj = dst[0];
dstj[0] -= dsti[0] * srcj[2];
srcj[3] -= srci[3] * srcj[2];
srcj[4] -= srci[4] * srcj[2];
srcj[5] -= srci[5] * srcj[2];
srcj = src[1];
dstj = dst[1];
dstj[0] -= dsti[0] * srcj[2];
dstj[1] -= dsti[1] * srcj[2];
srcj[3] -= srci[3] * srcj[2];
srcj[4] -= srci[4] * srcj[2];
srcj[5] -= srci[5] * srcj[2];
srcj = src[3];
dstj = dst[3];
dstj[0] -= dsti[0] * srcj[2];
dstj[1] -= dsti[1] * srcj[2];
dstj[2] = -diag * srcj[2];
srcj[3] -= srci[3] * srcj[2];
srcj[4] -= srci[4] * srcj[2];
srcj[5] -= srci[5] * srcj[2];
srcj = src[4];
dstj = dst[4];
dstj[0] -= dsti[0] * srcj[2];
dstj[1] -= dsti[1] * srcj[2];
dstj[2] = -diag * srcj[2];
srcj[3] -= srci[3] * srcj[2];
srcj[4] -= srci[4] * srcj[2];
srcj[5] -= srci[5] * srcj[2];
srcj = src[5];
dstj = dst[5];
dstj[0] -= dsti[0] * srcj[2];
dstj[1] -= dsti[1] * srcj[2];
dstj[2] = -diag * srcj[2];
srcj[3] -= srci[3] * srcj[2];
srcj[4] -= srci[4] * srcj[2];
srcj[5] -= srci[5] * srcj[2];
srci = src[3];
dsti = dst[3];
diag = 1 / srci[3];
dsti[3] = diag;
dsti[0] *= diag;
dsti[1] *= diag;
dsti[2] *= diag;
srci[4] *= diag;
srci[5] *= diag;
srcj = src[0];
dstj = dst[0];
dstj[0] -= dsti[0] * srcj[3];
srcj[4] -= srci[4] * srcj[3];
srcj[5] -= srci[5] * srcj[3];
srcj = src[1];
dstj = dst[1];
dstj[0] -= dsti[0] * srcj[3];
dstj[1] -= dsti[1] * srcj[3];
srcj[4] -= srci[4] * srcj[3];
srcj[5] -= srci[5] * srcj[3];
srcj = src[2];
dstj = dst[2];
dstj[0] -= dsti[0] * srcj[3];
dstj[1] -= dsti[1] * srcj[3];
dstj[2] -= dsti[2] * srcj[3];
srcj[4] -= srci[4] * srcj[3];
srcj[5] -= srci[5] * srcj[3];
srcj = src[4];
dstj = dst[4];
dstj[0] -= dsti[0] * srcj[3];
dstj[1] -= dsti[1] * srcj[3];
dstj[2] -= dsti[2] * srcj[3];
dstj[3] = -diag * srcj[3];
srcj[4] -= srci[4] * srcj[3];
srcj[5] -= srci[5] * srcj[3];
srcj = src[5];
dstj = dst[5];
dstj[0] -= dsti[0] * srcj[3];
dstj[1] -= dsti[1] * srcj[3];
dstj[2] -= dsti[2] * srcj[3];
dstj[3] = -diag * srcj[3];
srcj[4] -= srci[4] * srcj[3];
srcj[5] -= srci[5] * srcj[3];
srci = src[4];
dsti = dst[4];
diag = 1 / srci[4];
dsti[4] = diag;
dsti[0] *= diag;
dsti[1] *= diag;
dsti[2] *= diag;
dsti[3] *= diag;
srci[5] *= diag;
srcj = src[0];
dstj = dst[0];
dstj[0] -= dsti[0] * srcj[4];
srcj[5] -= srci[5] * srcj[4];
srcj = src[1];
dstj = dst[1];
dstj[0] -= dsti[0] * srcj[4];
dstj[1] -= dsti[1] * srcj[4];
srcj[5] -= srci[5] * srcj[4];
srcj = src[2];
dstj = dst[2];
dstj[0] -= dsti[0] * srcj[4];
dstj[1] -= dsti[1] * srcj[4];
dstj[2] -= dsti[2] * srcj[4];
srcj[5] -= srci[5] * srcj[4];
srcj = src[3];
dstj = dst[3];
dstj[0] -= dsti[0] * srcj[4];
dstj[1] -= dsti[1] * srcj[4];
dstj[2] -= dsti[2] * srcj[4];
dstj[3] -= dsti[3] * srcj[4];
srcj[5] -= srci[5] * srcj[4];
srcj = src[5];
dstj = dst[5];
dstj[0] -= dsti[0] * srcj[4];
dstj[1] -= dsti[1] * srcj[4];
dstj[2] -= dsti[2] * srcj[4];
dstj[3] -= dsti[3] * srcj[4];
dstj[4] = -diag * srcj[4];
srcj[5] -= srci[5] * srcj[4];
srci = src[5];
dsti = dst[5];
diag = 1 / srci[5];
dsti[5] = diag;
dsti[0] *= diag;
dsti[1] *= diag;
dsti[2] *= diag;
dsti[3] *= diag;
dsti[4] *= diag;
srcj = src[0];
dstj = dst[0];
dstj[0] -= dsti[0] * srcj[5];
srcj = src[1];
dstj = dst[1];
dstj[0] -= dsti[0] * srcj[5];
dstj[1] -= dsti[1] * srcj[5];
srcj = src[2];
dstj = dst[2];
dstj[0] -= dsti[0] * srcj[5];
dstj[1] -= dsti[1] * srcj[5];
dstj[2] -= dsti[2] * srcj[5];
srcj = src[3];
dstj = dst[3];
dstj[0] -= dsti[0] * srcj[5];
dstj[1] -= dsti[1] * srcj[5];
dstj[2] -= dsti[2] * srcj[5];
dstj[3] -= dsti[3] * srcj[5];
srcj = src[4];
dstj = dst[4];
dstj[0] -= dsti[0] * srcj[5];
dstj[1] -= dsti[1] * srcj[5];
dstj[2] -= dsti[2] * srcj[5];
dstj[3] -= dsti[3] * srcj[5];
dstj[4] -= dsti[4] * srcj[5];
dsti = dst[1];
dst[0][1] = dsti[0];
dsti = dst[2];
dst[0][2] = dsti[0];
dst[1][2] = dsti[1];
dsti = dst[3];
dst[0][3] = dsti[0];
dst[1][3] = dsti[1];
dst[2][3] = dsti[2];
dsti = dst[4];
dst[0][4] = dsti[0];
dst[1][4] = dsti[1];
dst[2][4] = dsti[2];
dst[3][4] = dsti[3];
dsti = dst[5];
dst[0][5] = dsti[0];
dst[1][5] = dsti[1];
dst[2][5] = dsti[2];
dst[3][5] = dsti[3];
dst[4][5] = dsti[4];
break;
default:
let _g1 = 0;
while(_g1 < size) {
let i = _g1++;
srci = src[i];
dsti = dst[i];
let diag = 1 / srci[i];
dsti[i] = diag;
let _g = 0;
while(_g < i) dsti[_g++] *= diag;
let _g2 = i + 1;
while(_g2 < size) srci[_g2++] *= diag;
let _g3 = 0;
while(_g3 < i) {
let j = _g3++;
srcj = src[j];
dstj = dst[j];
let _g = 0;
let _g1 = j + 1;
while(_g < _g1) {
let k = _g++;
dstj[k] -= dsti[k] * srcj[i];
}
let _g2 = i + 1;
while(_g2 < size) {
let k = _g2++;
srcj[k] -= srci[k] * srcj[i];
}
}
let _g4 = i + 1;
while(_g4 < size) {
let j = _g4++;
srcj = src[j];
dstj = dst[j];
let _g = 0;
while(_g < i) {
let k = _g++;
dstj[k] -= dsti[k] * srcj[i];
}
dstj[i] = -diag * srcj[i];
let _g1 = i + 1;
while(_g1 < size) {
let k = _g1++;
srcj[k] -= srci[k] * srcj[i];
}
}
}
let _g2 = 1;
while(_g2 < size) {
let i = _g2++;
dsti = dst[i];
let _g = 0;
while(_g < i) {
let j = _g++;
dst[j][i] = dsti[j];
}
}
}
}
computeInvMass(info,massData) {
let invMass = this._invMass;
let invMassWithoutCfm = this._invMassWithoutCfm;
let numRows = info.numRows;
let b1 = info.b1;
let b2 = info.b2;
let invM1 = b1._invMass;
let invM2 = b2._invMass;
let invI100;
let invI101;
let invI102;
let invI110;
let invI111;
let invI112;
let invI120;
let invI121;
let invI122;
let invI200;
let invI201;
let invI202;
let invI210;
let invI211;
let invI212;
let invI220;
let invI221;
let invI222;
invI100 = b1._invInertia00;
invI101 = b1._invInertia01;
invI102 = b1._invInertia02;
invI110 = b1._invInertia10;
invI111 = b1._invInertia11;
invI112 = b1._invInertia12;
invI120 = b1._invInertia20;
invI121 = b1._invInertia21;
invI122 = b1._invInertia22;
invI200 = b2._invInertia00;
invI201 = b2._invInertia01;
invI202 = b2._invInertia02;
invI210 = b2._invInertia10;
invI211 = b2._invInertia11;
invI212 = b2._invInertia12;
invI220 = b2._invInertia20;
invI221 = b2._invInertia21;
invI222 = b2._invInertia22;
let _g = 0;
while(_g < numRows) {
let i = _g++;
let j = info.rows[i].jacobian;
let md = massData[i];
j.updateSparsity();
if((j.flag & 1) != 0) {
md.invMLin1X = j.lin1X * invM1;
md.invMLin1Y = j.lin1Y * invM1;
md.invMLin1Z = j.lin1Z * invM1;
md.invMLin2X = j.lin2X * invM2;
md.invMLin2Y = j.lin2Y * invM2;
md.invMLin2Z = j.lin2Z * invM2;
} else {
md.invMLin1X = 0;
md.invMLin1Y = 0;
md.invMLin1Z = 0;
md.invMLin2X = 0;
md.invMLin2Y = 0;
md.invMLin2Z = 0;
}
if((j.flag & 2) != 0) {
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = invI100 * j.ang1X + invI101 * j.ang1Y + invI102 * j.ang1Z;
__tmp__Y = invI110 * j.ang1X + invI111 * j.ang1Y + invI112 * j.ang1Z;
__tmp__Z = invI120 * j.ang1X + invI121 * j.ang1Y + invI122 * j.ang1Z;
md.invMAng1X = __tmp__X;
md.invMAng1Y = __tmp__Y;
md.invMAng1Z = __tmp__Z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = invI200 * j.ang2X + invI201 * j.ang2Y + invI202 * j.ang2Z;
__tmp__Y1 = invI210 * j.ang2X + invI211 * j.ang2Y + invI212 * j.ang2Z;
__tmp__Z1 = invI220 * j.ang2X + invI221 * j.ang2Y + invI222 * j.ang2Z;
md.invMAng2X = __tmp__X1;
md.invMAng2Y = __tmp__Y1;
md.invMAng2Z = __tmp__Z1;
} else {
md.invMAng1X = 0;
md.invMAng1Y = 0;
md.invMAng1Z = 0;
md.invMAng2X = 0;
md.invMAng2Y = 0;
md.invMAng2Z = 0;
}
}
let _g1 = 0;
while(_g1 < numRows) {
let i = _g1++;
let j1 = info.rows[i].jacobian;
let _g = i;
while(_g < numRows) {
let j = _g++;
let md2 = massData[j];
let val = j1.lin1X * md2.invMLin1X + j1.lin1Y * md2.invMLin1Y + j1.lin1Z * md2.invMLin1Z + (j1.ang1X * md2.invMAng1X + j1.ang1Y * md2.invMAng1Y + j1.ang1Z * md2.invMAng1Z) + (j1.lin2X * md2.invMLin2X + j1.lin2Y * md2.invMLin2Y + j1.lin2Z * md2.invMLin2Z) + (j1.ang2X * md2.invMAng2X + j1.ang2Y * md2.invMAng2Y + j1.ang2Z * md2.invMAng2Z);
if(i == j) {
invMass[i][j] = val + info.rows[i].cfm;
invMassWithoutCfm[i][j] = val;
md2.mass = val + info.rows[i].cfm;
md2.massWithoutCfm = val;
if(md2.mass != 0) {
md2.mass = 1 / md2.mass;
}
if(md2.massWithoutCfm != 0) {
md2.massWithoutCfm = 1 / md2.massWithoutCfm;
}
} else {
invMass[i][j] = val;
invMass[j][i] = val;
invMassWithoutCfm[i][j] = val;
invMassWithoutCfm[j][i] = val;
}
}
}
let _g2 = 0;
let _g3 = this._maxSubmatrixId;
while(_g2 < _g3) this._cacheComputed[_g2++] = false;
}
}
if(!oimo.dynamics.constraint.solver.pgs) oimo.dynamics.constraint.solver.pgs = {};
oimo.dynamics.constraint.solver.pgs.PgsContactConstraintSolver = class oimo_dynamics_constraint_solver_pgs_PgsContactConstraintSolver extends oimo.dynamics.constraint.ConstraintSolver {
constructor(constraint) {
super();
this.constraint = constraint;
this.info = new oimo.dynamics.constraint.info.contact.ContactSolverInfo();
this.massData = new Array(oimo.common.Setting.maxManifoldPoints);
let _g = 0;
let _g1 = this.massData.length;
while(_g < _g1) this.massData[_g++] = new oimo.dynamics.constraint.solver.common.ContactSolverMassDataRow();
}
preSolveVelocity(timeStep) {
this.constraint._getVelocitySolverInfo(timeStep,this.info);
this._b1 = this.info.b1;
this._b2 = this.info.b2;
let invM1 = this._b1._invMass;
let invM2 = this._b2._invMass;
let invI100;
let invI101;
let invI102;
let invI110;
let invI111;
let invI112;
let invI120;
let invI121;
let invI122;
let invI200;
let invI201;
let invI202;
let invI210;
let invI211;
let invI212;
let invI220;
let invI221;
let invI222;
invI100 = this._b1._invInertia00;
invI101 = this._b1._invInertia01;
invI102 = this._b1._invInertia02;
invI110 = this._b1._invInertia10;
invI111 = this._b1._invInertia11;
invI112 = this._b1._invInertia12;
invI120 = this._b1._invInertia20;
invI121 = this._b1._invInertia21;
invI122 = this._b1._invInertia22;
invI200 = this._b2._invInertia00;
invI201 = this._b2._invInertia01;
invI202 = this._b2._invInertia02;
invI210 = this._b2._invInertia10;
invI211 = this._b2._invInertia11;
invI212 = this._b2._invInertia12;
invI220 = this._b2._invInertia20;
invI221 = this._b2._invInertia21;
invI222 = this._b2._invInertia22;
let _g = 0;
let _g1 = this.info.numRows;
while(_g < _g1) {
let i = _g++;
let row = this.info.rows[i];
let md = this.massData[i];
let j = row.jacobianN;
md.invMLinN1X = j.lin1X * invM1;
md.invMLinN1Y = j.lin1Y * invM1;
md.invMLinN1Z = j.lin1Z * invM1;
md.invMLinN2X = j.lin2X * invM2;
md.invMLinN2Y = j.lin2Y * invM2;
md.invMLinN2Z = j.lin2Z * invM2;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = invI100 * j.ang1X + invI101 * j.ang1Y + invI102 * j.ang1Z;
__tmp__Y = invI110 * j.ang1X + invI111 * j.ang1Y + invI112 * j.ang1Z;
__tmp__Z = invI120 * j.ang1X + invI121 * j.ang1Y + invI122 * j.ang1Z;
md.invMAngN1X = __tmp__X;
md.invMAngN1Y = __tmp__Y;
md.invMAngN1Z = __tmp__Z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = invI200 * j.ang2X + invI201 * j.ang2Y + invI202 * j.ang2Z;
__tmp__Y1 = invI210 * j.ang2X + invI211 * j.ang2Y + invI212 * j.ang2Z;
__tmp__Z1 = invI220 * j.ang2X + invI221 * j.ang2Y + invI222 * j.ang2Z;
md.invMAngN2X = __tmp__X1;
md.invMAngN2Y = __tmp__Y1;
md.invMAngN2Z = __tmp__Z1;
md.massN = invM1 + invM2 + (md.invMAngN1X * j.ang1X + md.invMAngN1Y * j.ang1Y + md.invMAngN1Z * j.ang1Z) + (md.invMAngN2X * j.ang2X + md.invMAngN2Y * j.ang2Y + md.invMAngN2Z * j.ang2Z);
if(md.massN != 0) {
md.massN = 1 / md.massN;
}
let jt = row.jacobianT;
let jb = row.jacobianB;
md.invMLinT1X = jt.lin1X * invM1;
md.invMLinT1Y = jt.lin1Y * invM1;
md.invMLinT1Z = jt.lin1Z * invM1;
md.invMLinT2X = jt.lin2X * invM2;
md.invMLinT2Y = jt.lin2Y * invM2;
md.invMLinT2Z = jt.lin2Z * invM2;
md.invMLinB1X = jb.lin1X * invM1;
md.invMLinB1Y = jb.lin1Y * invM1;
md.invMLinB1Z = jb.lin1Z * invM1;
md.invMLinB2X = jb.lin2X * invM2;
md.invMLinB2Y = jb.lin2Y * invM2;
md.invMLinB2Z = jb.lin2Z * invM2;
let __tmp__X2;
let __tmp__Y2;
let __tmp__Z2;
__tmp__X2 = invI100 * jt.ang1X + invI101 * jt.ang1Y + invI102 * jt.ang1Z;
__tmp__Y2 = invI110 * jt.ang1X + invI111 * jt.ang1Y + invI112 * jt.ang1Z;
__tmp__Z2 = invI120 * jt.ang1X + invI121 * jt.ang1Y + invI122 * jt.ang1Z;
md.invMAngT1X = __tmp__X2;
md.invMAngT1Y = __tmp__Y2;
md.invMAngT1Z = __tmp__Z2;
let __tmp__X3;
let __tmp__Y3;
let __tmp__Z3;
__tmp__X3 = invI200 * jt.ang2X + invI201 * jt.ang2Y + invI202 * jt.ang2Z;
__tmp__Y3 = invI210 * jt.ang2X + invI211 * jt.ang2Y + invI212 * jt.ang2Z;
__tmp__Z3 = invI220 * jt.ang2X + invI221 * jt.ang2Y + invI222 * jt.ang2Z;
md.invMAngT2X = __tmp__X3;
md.invMAngT2Y = __tmp__Y3;
md.invMAngT2Z = __tmp__Z3;
let __tmp__X4;
let __tmp__Y4;
let __tmp__Z4;
__tmp__X4 = invI100 * jb.ang1X + invI101 * jb.ang1Y + invI102 * jb.ang1Z;
__tmp__Y4 = invI110 * jb.ang1X + invI111 * jb.ang1Y + invI112 * jb.ang1Z;
__tmp__Z4 = invI120 * jb.ang1X + invI121 * jb.ang1Y + invI122 * jb.ang1Z;
md.invMAngB1X = __tmp__X4;
md.invMAngB1Y = __tmp__Y4;
md.invMAngB1Z = __tmp__Z4;
let __tmp__X5;
let __tmp__Y5;
let __tmp__Z5;
__tmp__X5 = invI200 * jb.ang2X + invI201 * jb.ang2Y + invI202 * jb.ang2Z;
__tmp__Y5 = invI210 * jb.ang2X + invI211 * jb.ang2Y + invI212 * jb.ang2Z;
__tmp__Z5 = invI220 * jb.ang2X + invI221 * jb.ang2Y + invI222 * jb.ang2Z;
md.invMAngB2X = __tmp__X5;
md.invMAngB2Y = __tmp__Y5;
md.invMAngB2Z = __tmp__Z5;
let invMassTB00 = invM1 + invM2 + (md.invMAngT1X * jt.ang1X + md.invMAngT1Y * jt.ang1Y + md.invMAngT1Z * jt.ang1Z) + (md.invMAngT2X * jt.ang2X + md.invMAngT2Y * jt.ang2Y + md.invMAngT2Z * jt.ang2Z);
let invMassTB01 = md.invMAngT1X * jb.ang1X + md.invMAngT1Y * jb.ang1Y + md.invMAngT1Z * jb.ang1Z + (md.invMAngT2X * jb.ang2X + md.invMAngT2Y * jb.ang2Y + md.invMAngT2Z * jb.ang2Z);
let invMassTB11 = invM1 + invM2 + (md.invMAngB1X * jb.ang1X + md.invMAngB1Y * jb.ang1Y + md.invMAngB1Z * jb.ang1Z) + (md.invMAngB2X * jb.ang2X + md.invMAngB2Y * jb.ang2Y + md.invMAngB2Z * jb.ang2Z);
let invDet = invMassTB00 * invMassTB11 - invMassTB01 * invMassTB01;
if(invDet != 0) {
invDet = 1 / invDet;
}
md.massTB00 = invMassTB11 * invDet;
md.massTB01 = -invMassTB01 * invDet;
md.massTB10 = -invMassTB01 * invDet;
md.massTB11 = invMassTB00 * invDet;
}
}
warmStart(timeStep) {
let lv1X;
let lv1Y;
let lv1Z;
let lv2X;
let lv2Y;
let lv2Z;
let av1X;
let av1Y;
let av1Z;
let av2X;
let av2Y;
let av2Z;
lv1X = this._b1._velX;
lv1Y = this._b1._velY;
lv1Z = this._b1._velZ;
lv2X = this._b2._velX;
lv2Y = this._b2._velY;
lv2Z = this._b2._velZ;
av1X = this._b1._angVelX;
av1Y = this._b1._angVelY;
av1Z = this._b1._angVelZ;
av2X = this._b2._angVelX;
av2Y = this._b2._angVelY;
av2Z = this._b2._angVelZ;
let _g = 0;
let _g1 = this.info.numRows;
while(_g < _g1) {
let i = _g++;
let row = this.info.rows[i];
let imp = row.impulse;
let md = this.massData[i];
let jt = row.jacobianT;
let jb = row.jacobianB;
let impulseN = imp.impulseN;
let impulseT = imp.impulseLX * jt.lin1X + imp.impulseLY * jt.lin1Y + imp.impulseLZ * jt.lin1Z;
let impulseB = imp.impulseLX * jb.lin1X + imp.impulseLY * jb.lin1Y + imp.impulseLZ * jb.lin1Z;
imp.impulseT = impulseT;
imp.impulseB = impulseB;
imp.impulseN *= timeStep.dtRatio;
imp.impulseT *= timeStep.dtRatio;
imp.impulseB *= timeStep.dtRatio;
lv1X += md.invMLinN1X * impulseN;
lv1Y += md.invMLinN1Y * impulseN;
lv1Z += md.invMLinN1Z * impulseN;
lv1X += md.invMLinT1X * impulseT;
lv1Y += md.invMLinT1Y * impulseT;
lv1Z += md.invMLinT1Z * impulseT;
lv1X += md.invMLinB1X * impulseB;
lv1Y += md.invMLinB1Y * impulseB;
lv1Z += md.invMLinB1Z * impulseB;
lv2X += md.invMLinN2X * -impulseN;
lv2Y += md.invMLinN2Y * -impulseN;
lv2Z += md.invMLinN2Z * -impulseN;
lv2X += md.invMLinT2X * -impulseT;
lv2Y += md.invMLinT2Y * -impulseT;
lv2Z += md.invMLinT2Z * -impulseT;
lv2X += md.invMLinB2X * -impulseB;
lv2Y += md.invMLinB2Y * -impulseB;
lv2Z += md.invMLinB2Z * -impulseB;
av1X += md.invMAngN1X * impulseN;
av1Y += md.invMAngN1Y * impulseN;
av1Z += md.invMAngN1Z * impulseN;
av1X += md.invMAngT1X * impulseT;
av1Y += md.invMAngT1Y * impulseT;
av1Z += md.invMAngT1Z * impulseT;
av1X += md.invMAngB1X * impulseB;
av1Y += md.invMAngB1Y * impulseB;
av1Z += md.invMAngB1Z * impulseB;
av2X += md.invMAngN2X * -impulseN;
av2Y += md.invMAngN2Y * -impulseN;
av2Z += md.invMAngN2Z * -impulseN;
av2X += md.invMAngT2X * -impulseT;
av2Y += md.invMAngT2Y * -impulseT;
av2Z += md.invMAngT2Z * -impulseT;
av2X += md.invMAngB2X * -impulseB;
av2Y += md.invMAngB2Y * -impulseB;
av2Z += md.invMAngB2Z * -impulseB;
}
this._b1._velX = lv1X;
this._b1._velY = lv1Y;
this._b1._velZ = lv1Z;
this._b2._velX = lv2X;
this._b2._velY = lv2Y;
this._b2._velZ = lv2Z;
this._b1._angVelX = av1X;
this._b1._angVelY = av1Y;
this._b1._angVelZ = av1Z;
this._b2._angVelX = av2X;
this._b2._angVelY = av2Y;
this._b2._angVelZ = av2Z;
}
solveVelocity() {
let lv1X;
let lv1Y;
let lv1Z;
let lv2X;
let lv2Y;
let lv2Z;
let av1X;
let av1Y;
let av1Z;
let av2X;
let av2Y;
let av2Z;
lv1X = this._b1._velX;
lv1Y = this._b1._velY;
lv1Z = this._b1._velZ;
lv2X = this._b2._velX;
lv2Y = this._b2._velY;
lv2Z = this._b2._velZ;
av1X = this._b1._angVelX;
av1Y = this._b1._angVelY;
av1Z = this._b1._angVelZ;
av2X = this._b2._angVelX;
av2Y = this._b2._angVelY;
av2Z = this._b2._angVelZ;
let _g = 0;
let _g1 = this.info.numRows;
while(_g < _g1) {
let i = _g++;
let row = this.info.rows[i];
let md = this.massData[i];
let imp = row.impulse;
let rvt = 0;
let j = row.jacobianT;
rvt += lv1X * j.lin1X + lv1Y * j.lin1Y + lv1Z * j.lin1Z;
rvt -= lv2X * j.lin2X + lv2Y * j.lin2Y + lv2Z * j.lin2Z;
rvt += av1X * j.ang1X + av1Y * j.ang1Y + av1Z * j.ang1Z;
rvt -= av2X * j.ang2X + av2Y * j.ang2Y + av2Z * j.ang2Z;
let rvb = 0;
j = row.jacobianB;
rvb += lv1X * j.lin1X + lv1Y * j.lin1Y + lv1Z * j.lin1Z;
rvb -= lv2X * j.lin2X + lv2Y * j.lin2Y + lv2Z * j.lin2Z;
rvb += av1X * j.ang1X + av1Y * j.ang1Y + av1Z * j.ang1Z;
rvb -= av2X * j.ang2X + av2Y * j.ang2Y + av2Z * j.ang2Z;
let impulseT = -(rvt * md.massTB00 + rvb * md.massTB01);
let impulseB = -(rvt * md.massTB10 + rvb * md.massTB11);
let oldImpulseT = imp.impulseT;
let oldImpulseB = imp.impulseB;
imp.impulseT += impulseT;
imp.impulseB += impulseB;
let maxImpulse = row.friction * imp.impulseN;
if(maxImpulse == 0) {
imp.impulseT = 0;
imp.impulseB = 0;
} else {
let impulseLengthSq = imp.impulseT * imp.impulseT + imp.impulseB * imp.impulseB;
if(impulseLengthSq > maxImpulse * maxImpulse) {
let invL = maxImpulse / Math.sqrt(impulseLengthSq);
imp.impulseT *= invL;
imp.impulseB *= invL;
}
}
impulseT = imp.impulseT - oldImpulseT;
impulseB = imp.impulseB - oldImpulseB;
lv1X += md.invMLinT1X * impulseT;
lv1Y += md.invMLinT1Y * impulseT;
lv1Z += md.invMLinT1Z * impulseT;
lv1X += md.invMLinB1X * impulseB;
lv1Y += md.invMLinB1Y * impulseB;
lv1Z += md.invMLinB1Z * impulseB;
lv2X += md.invMLinT2X * -impulseT;
lv2Y += md.invMLinT2Y * -impulseT;
lv2Z += md.invMLinT2Z * -impulseT;
lv2X += md.invMLinB2X * -impulseB;
lv2Y += md.invMLinB2Y * -impulseB;
lv2Z += md.invMLinB2Z * -impulseB;
av1X += md.invMAngT1X * impulseT;
av1Y += md.invMAngT1Y * impulseT;
av1Z += md.invMAngT1Z * impulseT;
av1X += md.invMAngB1X * impulseB;
av1Y += md.invMAngB1Y * impulseB;
av1Z += md.invMAngB1Z * impulseB;
av2X += md.invMAngT2X * -impulseT;
av2Y += md.invMAngT2Y * -impulseT;
av2Z += md.invMAngT2Z * -impulseT;
av2X += md.invMAngB2X * -impulseB;
av2Y += md.invMAngB2Y * -impulseB;
av2Z += md.invMAngB2Z * -impulseB;
}
let _g2 = 0;
let _g3 = this.info.numRows;
while(_g2 < _g3) {
let i = _g2++;
let row = this.info.rows[i];
let md = this.massData[i];
let imp = row.impulse;
let rvn = 0;
let j = row.jacobianN;
rvn += lv1X * j.lin1X + lv1Y * j.lin1Y + lv1Z * j.lin1Z;
rvn -= lv2X * j.lin2X + lv2Y * j.lin2Y + lv2Z * j.lin2Z;
rvn += av1X * j.ang1X + av1Y * j.ang1Y + av1Z * j.ang1Z;
rvn -= av2X * j.ang2X + av2Y * j.ang2Y + av2Z * j.ang2Z;
let impulseN = (row.rhs - rvn) * md.massN;
let oldImpulseN = imp.impulseN;
imp.impulseN += impulseN;
if(imp.impulseN < 0) {
imp.impulseN = 0;
}
impulseN = imp.impulseN - oldImpulseN;
lv1X += md.invMLinN1X * impulseN;
lv1Y += md.invMLinN1Y * impulseN;
lv1Z += md.invMLinN1Z * impulseN;
lv2X += md.invMLinN2X * -impulseN;
lv2Y += md.invMLinN2Y * -impulseN;
lv2Z += md.invMLinN2Z * -impulseN;
av1X += md.invMAngN1X * impulseN;
av1Y += md.invMAngN1Y * impulseN;
av1Z += md.invMAngN1Z * impulseN;
av2X += md.invMAngN2X * -impulseN;
av2Y += md.invMAngN2Y * -impulseN;
av2Z += md.invMAngN2Z * -impulseN;
}
this._b1._velX = lv1X;
this._b1._velY = lv1Y;
this._b1._velZ = lv1Z;
this._b2._velX = lv2X;
this._b2._velY = lv2Y;
this._b2._velZ = lv2Z;
this._b1._angVelX = av1X;
this._b1._angVelY = av1Y;
this._b1._angVelZ = av1Z;
this._b2._angVelX = av2X;
this._b2._angVelY = av2Y;
this._b2._angVelZ = av2Z;
}
preSolvePosition(timeStep) {
this.constraint._syncManifold();
this.constraint._getPositionSolverInfo(this.info);
let invM1 = this._b1._invMass;
let invM2 = this._b2._invMass;
let invI100;
let invI101;
let invI102;
let invI110;
let invI111;
let invI112;
let invI120;
let invI121;
let invI122;
let invI200;
let invI201;
let invI202;
let invI210;
let invI211;
let invI212;
let invI220;
let invI221;
let invI222;
invI100 = this._b1._invInertia00;
invI101 = this._b1._invInertia01;
invI102 = this._b1._invInertia02;
invI110 = this._b1._invInertia10;
invI111 = this._b1._invInertia11;
invI112 = this._b1._invInertia12;
invI120 = this._b1._invInertia20;
invI121 = this._b1._invInertia21;
invI122 = this._b1._invInertia22;
invI200 = this._b2._invInertia00;
invI201 = this._b2._invInertia01;
invI202 = this._b2._invInertia02;
invI210 = this._b2._invInertia10;
invI211 = this._b2._invInertia11;
invI212 = this._b2._invInertia12;
invI220 = this._b2._invInertia20;
invI221 = this._b2._invInertia21;
invI222 = this._b2._invInertia22;
let _g = 0;
let _g1 = this.info.numRows;
while(_g < _g1) {
let i = _g++;
let md = this.massData[i];
let j = this.info.rows[i].jacobianN;
md.invMLinN1X = j.lin1X * invM1;
md.invMLinN1Y = j.lin1Y * invM1;
md.invMLinN1Z = j.lin1Z * invM1;
md.invMLinN2X = j.lin2X * invM2;
md.invMLinN2Y = j.lin2Y * invM2;
md.invMLinN2Z = j.lin2Z * invM2;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = invI100 * j.ang1X + invI101 * j.ang1Y + invI102 * j.ang1Z;
__tmp__Y = invI110 * j.ang1X + invI111 * j.ang1Y + invI112 * j.ang1Z;
__tmp__Z = invI120 * j.ang1X + invI121 * j.ang1Y + invI122 * j.ang1Z;
md.invMAngN1X = __tmp__X;
md.invMAngN1Y = __tmp__Y;
md.invMAngN1Z = __tmp__Z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = invI200 * j.ang2X + invI201 * j.ang2Y + invI202 * j.ang2Z;
__tmp__Y1 = invI210 * j.ang2X + invI211 * j.ang2Y + invI212 * j.ang2Z;
__tmp__Z1 = invI220 * j.ang2X + invI221 * j.ang2Y + invI222 * j.ang2Z;
md.invMAngN2X = __tmp__X1;
md.invMAngN2Y = __tmp__Y1;
md.invMAngN2Z = __tmp__Z1;
md.massN = invM1 + invM2 + (md.invMAngN1X * j.ang1X + md.invMAngN1Y * j.ang1Y + md.invMAngN1Z * j.ang1Z) + (md.invMAngN2X * j.ang2X + md.invMAngN2Y * j.ang2Y + md.invMAngN2Z * j.ang2Z);
if(md.massN != 0) {
md.massN = 1 / md.massN;
}
}
let _g2 = 0;
let _g3 = this.info.numRows;
while(_g2 < _g3) this.info.rows[_g2++].impulse.impulseP = 0;
}
solvePositionSplitImpulse() {
let lv1X;
let lv1Y;
let lv1Z;
let lv2X;
let lv2Y;
let lv2Z;
let av1X;
let av1Y;
let av1Z;
let av2X;
let av2Y;
let av2Z;
lv1X = this._b1._pseudoVelX;
lv1Y = this._b1._pseudoVelY;
lv1Z = this._b1._pseudoVelZ;
lv2X = this._b2._pseudoVelX;
lv2Y = this._b2._pseudoVelY;
lv2Z = this._b2._pseudoVelZ;
av1X = this._b1._angPseudoVelX;
av1Y = this._b1._angPseudoVelY;
av1Z = this._b1._angPseudoVelZ;
av2X = this._b2._angPseudoVelX;
av2Y = this._b2._angPseudoVelY;
av2Z = this._b2._angPseudoVelZ;
let _g = 0;
let _g1 = this.info.numRows;
while(_g < _g1) {
let i = _g++;
let row = this.info.rows[i];
let md = this.massData[i];
let imp = row.impulse;
let j = row.jacobianN;
let rvn = 0;
rvn += lv1X * j.lin1X + lv1Y * j.lin1Y + lv1Z * j.lin1Z;
rvn -= lv2X * j.lin2X + lv2Y * j.lin2Y + lv2Z * j.lin2Z;
rvn += av1X * j.ang1X + av1Y * j.ang1Y + av1Z * j.ang1Z;
rvn -= av2X * j.ang2X + av2Y * j.ang2Y + av2Z * j.ang2Z;
let impulseP = (row.rhs - rvn) * md.massN * oimo.common.Setting.positionSplitImpulseBaumgarte;
let oldImpulseP = imp.impulseP;
imp.impulseP += impulseP;
if(imp.impulseP < 0) {
imp.impulseP = 0;
}
impulseP = imp.impulseP - oldImpulseP;
lv1X += md.invMLinN1X * impulseP;
lv1Y += md.invMLinN1Y * impulseP;
lv1Z += md.invMLinN1Z * impulseP;
lv2X += md.invMLinN2X * -impulseP;
lv2Y += md.invMLinN2Y * -impulseP;
lv2Z += md.invMLinN2Z * -impulseP;
av1X += md.invMAngN1X * impulseP;
av1Y += md.invMAngN1Y * impulseP;
av1Z += md.invMAngN1Z * impulseP;
av2X += md.invMAngN2X * -impulseP;
av2Y += md.invMAngN2Y * -impulseP;
av2Z += md.invMAngN2Z * -impulseP;
}
this._b1._pseudoVelX = lv1X;
this._b1._pseudoVelY = lv1Y;
this._b1._pseudoVelZ = lv1Z;
this._b2._pseudoVelX = lv2X;
this._b2._pseudoVelY = lv2Y;
this._b2._pseudoVelZ = lv2Z;
this._b1._angPseudoVelX = av1X;
this._b1._angPseudoVelY = av1Y;
this._b1._angPseudoVelZ = av1Z;
this._b2._angPseudoVelX = av2X;
this._b2._angPseudoVelY = av2Y;
this._b2._angPseudoVelZ = av2Z;
}
solvePositionNgs(timeStep) {
this.constraint._syncManifold();
this.constraint._getPositionSolverInfo(this.info);
let invM1 = this._b1._invMass;
let invM2 = this._b2._invMass;
let invI100;
let invI101;
let invI102;
let invI110;
let invI111;
let invI112;
let invI120;
let invI121;
let invI122;
let invI200;
let invI201;
let invI202;
let invI210;
let invI211;
let invI212;
let invI220;
let invI221;
let invI222;
invI100 = this._b1._invInertia00;
invI101 = this._b1._invInertia01;
invI102 = this._b1._invInertia02;
invI110 = this._b1._invInertia10;
invI111 = this._b1._invInertia11;
invI112 = this._b1._invInertia12;
invI120 = this._b1._invInertia20;
invI121 = this._b1._invInertia21;
invI122 = this._b1._invInertia22;
invI200 = this._b2._invInertia00;
invI201 = this._b2._invInertia01;
invI202 = this._b2._invInertia02;
invI210 = this._b2._invInertia10;
invI211 = this._b2._invInertia11;
invI212 = this._b2._invInertia12;
invI220 = this._b2._invInertia20;
invI221 = this._b2._invInertia21;
invI222 = this._b2._invInertia22;
let _g = 0;
let _g1 = this.info.numRows;
while(_g < _g1) {
let i = _g++;
let md = this.massData[i];
let j = this.info.rows[i].jacobianN;
md.invMLinN1X = j.lin1X * invM1;
md.invMLinN1Y = j.lin1Y * invM1;
md.invMLinN1Z = j.lin1Z * invM1;
md.invMLinN2X = j.lin2X * invM2;
md.invMLinN2Y = j.lin2Y * invM2;
md.invMLinN2Z = j.lin2Z * invM2;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = invI100 * j.ang1X + invI101 * j.ang1Y + invI102 * j.ang1Z;
__tmp__Y = invI110 * j.ang1X + invI111 * j.ang1Y + invI112 * j.ang1Z;
__tmp__Z = invI120 * j.ang1X + invI121 * j.ang1Y + invI122 * j.ang1Z;
md.invMAngN1X = __tmp__X;
md.invMAngN1Y = __tmp__Y;
md.invMAngN1Z = __tmp__Z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = invI200 * j.ang2X + invI201 * j.ang2Y + invI202 * j.ang2Z;
__tmp__Y1 = invI210 * j.ang2X + invI211 * j.ang2Y + invI212 * j.ang2Z;
__tmp__Z1 = invI220 * j.ang2X + invI221 * j.ang2Y + invI222 * j.ang2Z;
md.invMAngN2X = __tmp__X1;
md.invMAngN2Y = __tmp__Y1;
md.invMAngN2Z = __tmp__Z1;
md.massN = invM1 + invM2 + (md.invMAngN1X * j.ang1X + md.invMAngN1Y * j.ang1Y + md.invMAngN1Z * j.ang1Z) + (md.invMAngN2X * j.ang2X + md.invMAngN2Y * j.ang2Y + md.invMAngN2Z * j.ang2Z);
if(md.massN != 0) {
md.massN = 1 / md.massN;
}
}
let lv1X;
let lv1Y;
let lv1Z;
let lv2X;
let lv2Y;
let lv2Z;
let av1X;
let av1Y;
let av1Z;
let av2X;
let av2Y;
let av2Z;
lv1X = 0;
lv1Y = 0;
lv1Z = 0;
lv2X = 0;
lv2Y = 0;
lv2Z = 0;
av1X = 0;
av1Y = 0;
av1Z = 0;
av2X = 0;
av2Y = 0;
av2Z = 0;
let _g2 = 0;
let _g3 = this.info.numRows;
while(_g2 < _g3) {
let i = _g2++;
let row = this.info.rows[i];
let md = this.massData[i];
let imp = row.impulse;
let j = row.jacobianN;
let rvn = 0;
rvn += lv1X * j.lin1X + lv1Y * j.lin1Y + lv1Z * j.lin1Z;
rvn -= lv2X * j.lin2X + lv2Y * j.lin2Y + lv2Z * j.lin2Z;
rvn += av1X * j.ang1X + av1Y * j.ang1Y + av1Z * j.ang1Z;
rvn -= av2X * j.ang2X + av2Y * j.ang2Y + av2Z * j.ang2Z;
let impulseP = (row.rhs - rvn) * md.massN * oimo.common.Setting.positionNgsBaumgarte;
let oldImpulseP = imp.impulseP;
imp.impulseP += impulseP;
if(imp.impulseP < 0) {
imp.impulseP = 0;
}
impulseP = imp.impulseP - oldImpulseP;
lv1X += md.invMLinN1X * impulseP;
lv1Y += md.invMLinN1Y * impulseP;
lv1Z += md.invMLinN1Z * impulseP;
lv2X += md.invMLinN2X * -impulseP;
lv2Y += md.invMLinN2Y * -impulseP;
lv2Z += md.invMLinN2Z * -impulseP;
av1X += md.invMAngN1X * impulseP;
av1Y += md.invMAngN1Y * impulseP;
av1Z += md.invMAngN1Z * impulseP;
av2X += md.invMAngN2X * -impulseP;
av2Y += md.invMAngN2Y * -impulseP;
av2Z += md.invMAngN2Z * -impulseP;
}
let _this = this._b1;
_this._transform._positionX += lv1X;
_this._transform._positionY += lv1Y;
_this._transform._positionZ += lv1Z;
let _this1 = this._b2;
_this1._transform._positionX += lv2X;
_this1._transform._positionY += lv2Y;
_this1._transform._positionZ += lv2Z;
let _this2 = this._b1;
let theta = Math.sqrt(av1X * av1X + av1Y * av1Y + av1Z * av1Z);
let halfTheta = theta * 0.5;
let rotationToSinAxisFactor;
let cosHalfTheta;
if(halfTheta < 0.5) {
let ht2 = halfTheta * halfTheta;
rotationToSinAxisFactor = 0.5 * (1 - ht2 * 0.16666666666666666 + ht2 * ht2 * 0.0083333333333333332);
cosHalfTheta = 1 - ht2 * 0.5 + ht2 * ht2 * 0.041666666666666664;
} else {
rotationToSinAxisFactor = Math.sin(halfTheta) / theta;
cosHalfTheta = Math.cos(halfTheta);
}
let sinAxisX;
let sinAxisY;
let sinAxisZ;
sinAxisX = av1X * rotationToSinAxisFactor;
sinAxisY = av1Y * rotationToSinAxisFactor;
sinAxisZ = av1Z * rotationToSinAxisFactor;
let dqX;
let dqY;
let dqZ;
let dqW;
dqX = sinAxisX;
dqY = sinAxisY;
dqZ = sinAxisZ;
dqW = cosHalfTheta;
let qX;
let qY;
let qZ;
let qW;
let e00 = _this2._transform._rotation00;
let e11 = _this2._transform._rotation11;
let e22 = _this2._transform._rotation22;
let t = e00 + e11 + e22;
let s;
if(t > 0) {
s = Math.sqrt(t + 1);
qW = 0.5 * s;
s = 0.5 / s;
qX = (_this2._transform._rotation21 - _this2._transform._rotation12) * s;
qY = (_this2._transform._rotation02 - _this2._transform._rotation20) * s;
qZ = (_this2._transform._rotation10 - _this2._transform._rotation01) * s;
} else if(e00 > e11) {
if(e00 > e22) {
s = Math.sqrt(e00 - e11 - e22 + 1);
qX = 0.5 * s;
s = 0.5 / s;
qY = (_this2._transform._rotation01 + _this2._transform._rotation10) * s;
qZ = (_this2._transform._rotation02 + _this2._transform._rotation20) * s;
qW = (_this2._transform._rotation21 - _this2._transform._rotation12) * s;
} else {
s = Math.sqrt(e22 - e00 - e11 + 1);
qZ = 0.5 * s;
s = 0.5 / s;
qX = (_this2._transform._rotation02 + _this2._transform._rotation20) * s;
qY = (_this2._transform._rotation12 + _this2._transform._rotation21) * s;
qW = (_this2._transform._rotation10 - _this2._transform._rotation01) * s;
}
} else if(e11 > e22) {
s = Math.sqrt(e11 - e22 - e00 + 1);
qY = 0.5 * s;
s = 0.5 / s;
qX = (_this2._transform._rotation01 + _this2._transform._rotation10) * s;
qZ = (_this2._transform._rotation12 + _this2._transform._rotation21) * s;
qW = (_this2._transform._rotation02 - _this2._transform._rotation20) * s;
} else {
s = Math.sqrt(e22 - e00 - e11 + 1);
qZ = 0.5 * s;
s = 0.5 / s;
qX = (_this2._transform._rotation02 + _this2._transform._rotation20) * s;
qY = (_this2._transform._rotation12 + _this2._transform._rotation21) * s;
qW = (_this2._transform._rotation10 - _this2._transform._rotation01) * s;
}
qX = dqW * qX + dqX * qW + dqY * qZ - dqZ * qY;
qY = dqW * qY - dqX * qZ + dqY * qW + dqZ * qX;
qZ = dqW * qZ + dqX * qY - dqY * qX + dqZ * qW;
qW = dqW * qW - dqX * qX - dqY * qY - dqZ * qZ;
let l = qX * qX + qY * qY + qZ * qZ + qW * qW;
if(l > 1e-32) {
l = 1 / Math.sqrt(l);
}
qX *= l;
qY *= l;
qZ *= l;
qW *= l;
let x = qX;
let y = qY;
let z = qZ;
let w = qW;
let x2 = 2 * x;
let y2 = 2 * y;
let z2 = 2 * z;
let xx = x * x2;
let yy = y * y2;
let zz = z * z2;
let xy = x * y2;
let yz = y * z2;
let xz = x * z2;
let wx = w * x2;
let wy = w * y2;
let wz = w * z2;
_this2._transform._rotation00 = 1 - yy - zz;
_this2._transform._rotation01 = xy - wz;
_this2._transform._rotation02 = xz + wy;
_this2._transform._rotation10 = xy + wz;
_this2._transform._rotation11 = 1 - xx - zz;
_this2._transform._rotation12 = yz - wx;
_this2._transform._rotation20 = xz - wy;
_this2._transform._rotation21 = yz + wx;
_this2._transform._rotation22 = 1 - xx - yy;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = _this2._transform._rotation00 * _this2._invLocalInertia00 + _this2._transform._rotation01 * _this2._invLocalInertia10 + _this2._transform._rotation02 * _this2._invLocalInertia20;
__tmp__01 = _this2._transform._rotation00 * _this2._invLocalInertia01 + _this2._transform._rotation01 * _this2._invLocalInertia11 + _this2._transform._rotation02 * _this2._invLocalInertia21;
__tmp__02 = _this2._transform._rotation00 * _this2._invLocalInertia02 + _this2._transform._rotation01 * _this2._invLocalInertia12 + _this2._transform._rotation02 * _this2._invLocalInertia22;
__tmp__10 = _this2._transform._rotation10 * _this2._invLocalInertia00 + _this2._transform._rotation11 * _this2._invLocalInertia10 + _this2._transform._rotation12 * _this2._invLocalInertia20;
__tmp__11 = _this2._transform._rotation10 * _this2._invLocalInertia01 + _this2._transform._rotation11 * _this2._invLocalInertia11 + _this2._transform._rotation12 * _this2._invLocalInertia21;
__tmp__12 = _this2._transform._rotation10 * _this2._invLocalInertia02 + _this2._transform._rotation11 * _this2._invLocalInertia12 + _this2._transform._rotation12 * _this2._invLocalInertia22;
__tmp__20 = _this2._transform._rotation20 * _this2._invLocalInertia00 + _this2._transform._rotation21 * _this2._invLocalInertia10 + _this2._transform._rotation22 * _this2._invLocalInertia20;
__tmp__21 = _this2._transform._rotation20 * _this2._invLocalInertia01 + _this2._transform._rotation21 * _this2._invLocalInertia11 + _this2._transform._rotation22 * _this2._invLocalInertia21;
__tmp__22 = _this2._transform._rotation20 * _this2._invLocalInertia02 + _this2._transform._rotation21 * _this2._invLocalInertia12 + _this2._transform._rotation22 * _this2._invLocalInertia22;
_this2._invInertia00 = __tmp__00;
_this2._invInertia01 = __tmp__01;
_this2._invInertia02 = __tmp__02;
_this2._invInertia10 = __tmp__10;
_this2._invInertia11 = __tmp__11;
_this2._invInertia12 = __tmp__12;
_this2._invInertia20 = __tmp__20;
_this2._invInertia21 = __tmp__21;
_this2._invInertia22 = __tmp__22;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = _this2._invInertia00 * _this2._transform._rotation00 + _this2._invInertia01 * _this2._transform._rotation01 + _this2._invInertia02 * _this2._transform._rotation02;
__tmp__011 = _this2._invInertia00 * _this2._transform._rotation10 + _this2._invInertia01 * _this2._transform._rotation11 + _this2._invInertia02 * _this2._transform._rotation12;
__tmp__021 = _this2._invInertia00 * _this2._transform._rotation20 + _this2._invInertia01 * _this2._transform._rotation21 + _this2._invInertia02 * _this2._transform._rotation22;
__tmp__101 = _this2._invInertia10 * _this2._transform._rotation00 + _this2._invInertia11 * _this2._transform._rotation01 + _this2._invInertia12 * _this2._transform._rotation02;
__tmp__111 = _this2._invInertia10 * _this2._transform._rotation10 + _this2._invInertia11 * _this2._transform._rotation11 + _this2._invInertia12 * _this2._transform._rotation12;
__tmp__121 = _this2._invInertia10 * _this2._transform._rotation20 + _this2._invInertia11 * _this2._transform._rotation21 + _this2._invInertia12 * _this2._transform._rotation22;
__tmp__201 = _this2._invInertia20 * _this2._transform._rotation00 + _this2._invInertia21 * _this2._transform._rotation01 + _this2._invInertia22 * _this2._transform._rotation02;
__tmp__211 = _this2._invInertia20 * _this2._transform._rotation10 + _this2._invInertia21 * _this2._transform._rotation11 + _this2._invInertia22 * _this2._transform._rotation12;
__tmp__221 = _this2._invInertia20 * _this2._transform._rotation20 + _this2._invInertia21 * _this2._transform._rotation21 + _this2._invInertia22 * _this2._transform._rotation22;
_this2._invInertia00 = __tmp__001;
_this2._invInertia01 = __tmp__011;
_this2._invInertia02 = __tmp__021;
_this2._invInertia10 = __tmp__101;
_this2._invInertia11 = __tmp__111;
_this2._invInertia12 = __tmp__121;
_this2._invInertia20 = __tmp__201;
_this2._invInertia21 = __tmp__211;
_this2._invInertia22 = __tmp__221;
_this2._invInertia00 *= _this2._rotFactor.x;
_this2._invInertia01 *= _this2._rotFactor.x;
_this2._invInertia02 *= _this2._rotFactor.x;
_this2._invInertia10 *= _this2._rotFactor.y;
_this2._invInertia11 *= _this2._rotFactor.y;
_this2._invInertia12 *= _this2._rotFactor.y;
_this2._invInertia20 *= _this2._rotFactor.z;
_this2._invInertia21 *= _this2._rotFactor.z;
_this2._invInertia22 *= _this2._rotFactor.z;
let _this3 = this._b2;
let theta1 = Math.sqrt(av2X * av2X + av2Y * av2Y + av2Z * av2Z);
let halfTheta1 = theta1 * 0.5;
let rotationToSinAxisFactor1;
let cosHalfTheta1;
if(halfTheta1 < 0.5) {
let ht2 = halfTheta1 * halfTheta1;
rotationToSinAxisFactor1 = 0.5 * (1 - ht2 * 0.16666666666666666 + ht2 * ht2 * 0.0083333333333333332);
cosHalfTheta1 = 1 - ht2 * 0.5 + ht2 * ht2 * 0.041666666666666664;
} else {
rotationToSinAxisFactor1 = Math.sin(halfTheta1) / theta1;
cosHalfTheta1 = Math.cos(halfTheta1);
}
let sinAxisX1;
let sinAxisY1;
let sinAxisZ1;
sinAxisX1 = av2X * rotationToSinAxisFactor1;
sinAxisY1 = av2Y * rotationToSinAxisFactor1;
sinAxisZ1 = av2Z * rotationToSinAxisFactor1;
let dqX1;
let dqY1;
let dqZ1;
let dqW1;
dqX1 = sinAxisX1;
dqY1 = sinAxisY1;
dqZ1 = sinAxisZ1;
dqW1 = cosHalfTheta1;
let qX1;
let qY1;
let qZ1;
let qW1;
let e001 = _this3._transform._rotation00;
let e111 = _this3._transform._rotation11;
let e221 = _this3._transform._rotation22;
let t1 = e001 + e111 + e221;
let s1;
if(t1 > 0) {
s1 = Math.sqrt(t1 + 1);
qW1 = 0.5 * s1;
s1 = 0.5 / s1;
qX1 = (_this3._transform._rotation21 - _this3._transform._rotation12) * s1;
qY1 = (_this3._transform._rotation02 - _this3._transform._rotation20) * s1;
qZ1 = (_this3._transform._rotation10 - _this3._transform._rotation01) * s1;
} else if(e001 > e111) {
if(e001 > e221) {
s1 = Math.sqrt(e001 - e111 - e221 + 1);
qX1 = 0.5 * s1;
s1 = 0.5 / s1;
qY1 = (_this3._transform._rotation01 + _this3._transform._rotation10) * s1;
qZ1 = (_this3._transform._rotation02 + _this3._transform._rotation20) * s1;
qW1 = (_this3._transform._rotation21 - _this3._transform._rotation12) * s1;
} else {
s1 = Math.sqrt(e221 - e001 - e111 + 1);
qZ1 = 0.5 * s1;
s1 = 0.5 / s1;
qX1 = (_this3._transform._rotation02 + _this3._transform._rotation20) * s1;
qY1 = (_this3._transform._rotation12 + _this3._transform._rotation21) * s1;
qW1 = (_this3._transform._rotation10 - _this3._transform._rotation01) * s1;
}
} else if(e111 > e221) {
s1 = Math.sqrt(e111 - e221 - e001 + 1);
qY1 = 0.5 * s1;
s1 = 0.5 / s1;
qX1 = (_this3._transform._rotation01 + _this3._transform._rotation10) * s1;
qZ1 = (_this3._transform._rotation12 + _this3._transform._rotation21) * s1;
qW1 = (_this3._transform._rotation02 - _this3._transform._rotation20) * s1;
} else {
s1 = Math.sqrt(e221 - e001 - e111 + 1);
qZ1 = 0.5 * s1;
s1 = 0.5 / s1;
qX1 = (_this3._transform._rotation02 + _this3._transform._rotation20) * s1;
qY1 = (_this3._transform._rotation12 + _this3._transform._rotation21) * s1;
qW1 = (_this3._transform._rotation10 - _this3._transform._rotation01) * s1;
}
qX1 = dqW1 * qX1 + dqX1 * qW1 + dqY1 * qZ1 - dqZ1 * qY1;
qY1 = dqW1 * qY1 - dqX1 * qZ1 + dqY1 * qW1 + dqZ1 * qX1;
qZ1 = dqW1 * qZ1 + dqX1 * qY1 - dqY1 * qX1 + dqZ1 * qW1;
qW1 = dqW1 * qW1 - dqX1 * qX1 - dqY1 * qY1 - dqZ1 * qZ1;
let l1 = qX1 * qX1 + qY1 * qY1 + qZ1 * qZ1 + qW1 * qW1;
if(l1 > 1e-32) {
l1 = 1 / Math.sqrt(l1);
}
qX1 *= l1;
qY1 *= l1;
qZ1 *= l1;
qW1 *= l1;
let x1 = qX1;
let y1 = qY1;
let z1 = qZ1;
let w1 = qW1;
let x21 = 2 * x1;
let y21 = 2 * y1;
let z21 = 2 * z1;
let xx1 = x1 * x21;
let yy1 = y1 * y21;
let zz1 = z1 * z21;
let xy1 = x1 * y21;
let yz1 = y1 * z21;
let xz1 = x1 * z21;
let wx1 = w1 * x21;
let wy1 = w1 * y21;
let wz1 = w1 * z21;
_this3._transform._rotation00 = 1 - yy1 - zz1;
_this3._transform._rotation01 = xy1 - wz1;
_this3._transform._rotation02 = xz1 + wy1;
_this3._transform._rotation10 = xy1 + wz1;
_this3._transform._rotation11 = 1 - xx1 - zz1;
_this3._transform._rotation12 = yz1 - wx1;
_this3._transform._rotation20 = xz1 - wy1;
_this3._transform._rotation21 = yz1 + wx1;
_this3._transform._rotation22 = 1 - xx1 - yy1;
let __tmp__002;
let __tmp__012;
let __tmp__022;
let __tmp__102;
let __tmp__112;
let __tmp__122;
let __tmp__202;
let __tmp__212;
let __tmp__222;
__tmp__002 = _this3._transform._rotation00 * _this3._invLocalInertia00 + _this3._transform._rotation01 * _this3._invLocalInertia10 + _this3._transform._rotation02 * _this3._invLocalInertia20;
__tmp__012 = _this3._transform._rotation00 * _this3._invLocalInertia01 + _this3._transform._rotation01 * _this3._invLocalInertia11 + _this3._transform._rotation02 * _this3._invLocalInertia21;
__tmp__022 = _this3._transform._rotation00 * _this3._invLocalInertia02 + _this3._transform._rotation01 * _this3._invLocalInertia12 + _this3._transform._rotation02 * _this3._invLocalInertia22;
__tmp__102 = _this3._transform._rotation10 * _this3._invLocalInertia00 + _this3._transform._rotation11 * _this3._invLocalInertia10 + _this3._transform._rotation12 * _this3._invLocalInertia20;
__tmp__112 = _this3._transform._rotation10 * _this3._invLocalInertia01 + _this3._transform._rotation11 * _this3._invLocalInertia11 + _this3._transform._rotation12 * _this3._invLocalInertia21;
__tmp__122 = _this3._transform._rotation10 * _this3._invLocalInertia02 + _this3._transform._rotation11 * _this3._invLocalInertia12 + _this3._transform._rotation12 * _this3._invLocalInertia22;
__tmp__202 = _this3._transform._rotation20 * _this3._invLocalInertia00 + _this3._transform._rotation21 * _this3._invLocalInertia10 + _this3._transform._rotation22 * _this3._invLocalInertia20;
__tmp__212 = _this3._transform._rotation20 * _this3._invLocalInertia01 + _this3._transform._rotation21 * _this3._invLocalInertia11 + _this3._transform._rotation22 * _this3._invLocalInertia21;
__tmp__222 = _this3._transform._rotation20 * _this3._invLocalInertia02 + _this3._transform._rotation21 * _this3._invLocalInertia12 + _this3._transform._rotation22 * _this3._invLocalInertia22;
_this3._invInertia00 = __tmp__002;
_this3._invInertia01 = __tmp__012;
_this3._invInertia02 = __tmp__022;
_this3._invInertia10 = __tmp__102;
_this3._invInertia11 = __tmp__112;
_this3._invInertia12 = __tmp__122;
_this3._invInertia20 = __tmp__202;
_this3._invInertia21 = __tmp__212;
_this3._invInertia22 = __tmp__222;
let __tmp__003;
let __tmp__013;
let __tmp__023;
let __tmp__103;
let __tmp__113;
let __tmp__123;
let __tmp__203;
let __tmp__213;
let __tmp__223;
__tmp__003 = _this3._invInertia00 * _this3._transform._rotation00 + _this3._invInertia01 * _this3._transform._rotation01 + _this3._invInertia02 * _this3._transform._rotation02;
__tmp__013 = _this3._invInertia00 * _this3._transform._rotation10 + _this3._invInertia01 * _this3._transform._rotation11 + _this3._invInertia02 * _this3._transform._rotation12;
__tmp__023 = _this3._invInertia00 * _this3._transform._rotation20 + _this3._invInertia01 * _this3._transform._rotation21 + _this3._invInertia02 * _this3._transform._rotation22;
__tmp__103 = _this3._invInertia10 * _this3._transform._rotation00 + _this3._invInertia11 * _this3._transform._rotation01 + _this3._invInertia12 * _this3._transform._rotation02;
__tmp__113 = _this3._invInertia10 * _this3._transform._rotation10 + _this3._invInertia11 * _this3._transform._rotation11 + _this3._invInertia12 * _this3._transform._rotation12;
__tmp__123 = _this3._invInertia10 * _this3._transform._rotation20 + _this3._invInertia11 * _this3._transform._rotation21 + _this3._invInertia12 * _this3._transform._rotation22;
__tmp__203 = _this3._invInertia20 * _this3._transform._rotation00 + _this3._invInertia21 * _this3._transform._rotation01 + _this3._invInertia22 * _this3._transform._rotation02;
__tmp__213 = _this3._invInertia20 * _this3._transform._rotation10 + _this3._invInertia21 * _this3._transform._rotation11 + _this3._invInertia22 * _this3._transform._rotation12;
__tmp__223 = _this3._invInertia20 * _this3._transform._rotation20 + _this3._invInertia21 * _this3._transform._rotation21 + _this3._invInertia22 * _this3._transform._rotation22;
_this3._invInertia00 = __tmp__003;
_this3._invInertia01 = __tmp__013;
_this3._invInertia02 = __tmp__023;
_this3._invInertia10 = __tmp__103;
_this3._invInertia11 = __tmp__113;
_this3._invInertia12 = __tmp__123;
_this3._invInertia20 = __tmp__203;
_this3._invInertia21 = __tmp__213;
_this3._invInertia22 = __tmp__223;
_this3._invInertia00 *= _this3._rotFactor.x;
_this3._invInertia01 *= _this3._rotFactor.x;
_this3._invInertia02 *= _this3._rotFactor.x;
_this3._invInertia10 *= _this3._rotFactor.y;
_this3._invInertia11 *= _this3._rotFactor.y;
_this3._invInertia12 *= _this3._rotFactor.y;
_this3._invInertia20 *= _this3._rotFactor.z;
_this3._invInertia21 *= _this3._rotFactor.z;
_this3._invInertia22 *= _this3._rotFactor.z;
}
postSolve() {
let lin1X;
let lin1Y;
let lin1Z;
let ang1X;
let ang1Y;
let ang1Z;
let ang2X;
let ang2Y;
let ang2Z;
lin1X = 0;
lin1Y = 0;
lin1Z = 0;
ang1X = 0;
ang1Y = 0;
ang1Z = 0;
ang2X = 0;
ang2Y = 0;
ang2Z = 0;
let _g = 0;
let _g1 = this.info.numRows;
while(_g < _g1) {
let row = this.info.rows[_g++];
let imp = row.impulse;
let jn = row.jacobianN;
let jt = row.jacobianT;
let jb = row.jacobianB;
let impN = imp.impulseN;
let impT = imp.impulseT;
let impB = imp.impulseB;
let impulseLX;
let impulseLY;
let impulseLZ;
impulseLX = 0;
impulseLY = 0;
impulseLZ = 0;
impulseLX += jt.lin1X * impT;
impulseLY += jt.lin1Y * impT;
impulseLZ += jt.lin1Z * impT;
impulseLX += jb.lin1X * impB;
impulseLY += jb.lin1Y * impB;
impulseLZ += jb.lin1Z * impB;
imp.impulseLX = impulseLX;
imp.impulseLY = impulseLY;
imp.impulseLZ = impulseLZ;
lin1X += jn.lin1X * impN;
lin1Y += jn.lin1Y * impN;
lin1Z += jn.lin1Z * impN;
ang1X += jn.ang1X * impN;
ang1Y += jn.ang1Y * impN;
ang1Z += jn.ang1Z * impN;
ang2X += jn.ang2X * impN;
ang2Y += jn.ang2Y * impN;
ang2Z += jn.ang2Z * impN;
lin1X += jt.lin1X * impT;
lin1Y += jt.lin1Y * impT;
lin1Z += jt.lin1Z * impT;
ang1X += jt.ang1X * impT;
ang1Y += jt.ang1Y * impT;
ang1Z += jt.ang1Z * impT;
ang2X += jt.ang2X * impT;
ang2Y += jt.ang2Y * impT;
ang2Z += jt.ang2Z * impT;
lin1X += jb.lin1X * impB;
lin1Y += jb.lin1Y * impB;
lin1Z += jb.lin1Z * impB;
ang1X += jb.ang1X * impB;
ang1Y += jb.ang1Y * impB;
ang1Z += jb.ang1Z * impB;
ang2X += jb.ang2X * impB;
ang2Y += jb.ang2Y * impB;
ang2Z += jb.ang2Z * impB;
}
this._b1._linearContactImpulseX += lin1X;
this._b1._linearContactImpulseY += lin1Y;
this._b1._linearContactImpulseZ += lin1Z;
this._b1._angularContactImpulseX += ang1X;
this._b1._angularContactImpulseY += ang1Y;
this._b1._angularContactImpulseZ += ang1Z;
this._b2._linearContactImpulseX -= lin1X;
this._b2._linearContactImpulseY -= lin1Y;
this._b2._linearContactImpulseZ -= lin1Z;
this._b2._angularContactImpulseX -= ang2X;
this._b2._angularContactImpulseY -= ang2Y;
this._b2._angularContactImpulseZ -= ang2Z;
this.constraint._syncManifold();
}
}
oimo.dynamics.constraint.solver.pgs.PgsJointConstraintSolver = class oimo_dynamics_constraint_solver_pgs_PgsJointConstraintSolver extends oimo.dynamics.constraint.ConstraintSolver {
constructor(joint) {
super();
this.joint = joint;
this.info = new oimo.dynamics.constraint.info.joint.JointSolverInfo();
this.massData = new Array(oimo.common.Setting.maxJacobianRows);
let _g = 0;
let _g1 = this.massData.length;
while(_g < _g1) this.massData[_g++] = new oimo.dynamics.constraint.solver.common.JointSolverMassDataRow();
}
preSolveVelocity(timeStep) {
this.joint._syncAnchors();
this.joint._getVelocitySolverInfo(timeStep,this.info);
this._b1 = this.info.b1;
this._b2 = this.info.b2;
let invM1 = this._b1._invMass;
let invM2 = this._b2._invMass;
let invI100;
let invI101;
let invI102;
let invI110;
let invI111;
let invI112;
let invI120;
let invI121;
let invI122;
let invI200;
let invI201;
let invI202;
let invI210;
let invI211;
let invI212;
let invI220;
let invI221;
let invI222;
invI100 = this._b1._invInertia00;
invI101 = this._b1._invInertia01;
invI102 = this._b1._invInertia02;
invI110 = this._b1._invInertia10;
invI111 = this._b1._invInertia11;
invI112 = this._b1._invInertia12;
invI120 = this._b1._invInertia20;
invI121 = this._b1._invInertia21;
invI122 = this._b1._invInertia22;
invI200 = this._b2._invInertia00;
invI201 = this._b2._invInertia01;
invI202 = this._b2._invInertia02;
invI210 = this._b2._invInertia10;
invI211 = this._b2._invInertia11;
invI212 = this._b2._invInertia12;
invI220 = this._b2._invInertia20;
invI221 = this._b2._invInertia21;
invI222 = this._b2._invInertia22;
let _g = 0;
let _g1 = this.info.numRows;
while(_g < _g1) {
let i = _g++;
let row = this.info.rows[i];
let md = this.massData[i];
let j = row.jacobian;
j.updateSparsity();
if((j.flag & 1) != 0) {
md.invMLin1X = j.lin1X * invM1;
md.invMLin1Y = j.lin1Y * invM1;
md.invMLin1Z = j.lin1Z * invM1;
md.invMLin2X = j.lin2X * invM2;
md.invMLin2Y = j.lin2Y * invM2;
md.invMLin2Z = j.lin2Z * invM2;
} else {
md.invMLin1X = 0;
md.invMLin1Y = 0;
md.invMLin1Z = 0;
md.invMLin2X = 0;
md.invMLin2Y = 0;
md.invMLin2Z = 0;
}
if((j.flag & 2) != 0) {
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = invI100 * j.ang1X + invI101 * j.ang1Y + invI102 * j.ang1Z;
__tmp__Y = invI110 * j.ang1X + invI111 * j.ang1Y + invI112 * j.ang1Z;
__tmp__Z = invI120 * j.ang1X + invI121 * j.ang1Y + invI122 * j.ang1Z;
md.invMAng1X = __tmp__X;
md.invMAng1Y = __tmp__Y;
md.invMAng1Z = __tmp__Z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = invI200 * j.ang2X + invI201 * j.ang2Y + invI202 * j.ang2Z;
__tmp__Y1 = invI210 * j.ang2X + invI211 * j.ang2Y + invI212 * j.ang2Z;
__tmp__Z1 = invI220 * j.ang2X + invI221 * j.ang2Y + invI222 * j.ang2Z;
md.invMAng2X = __tmp__X1;
md.invMAng2Y = __tmp__Y1;
md.invMAng2Z = __tmp__Z1;
} else {
md.invMAng1X = 0;
md.invMAng1Y = 0;
md.invMAng1Z = 0;
md.invMAng2X = 0;
md.invMAng2Y = 0;
md.invMAng2Z = 0;
}
md.massWithoutCfm = md.invMLin1X * j.lin1X + md.invMLin1Y * j.lin1Y + md.invMLin1Z * j.lin1Z + (md.invMLin2X * j.lin2X + md.invMLin2Y * j.lin2Y + md.invMLin2Z * j.lin2Z) + (md.invMAng1X * j.ang1X + md.invMAng1Y * j.ang1Y + md.invMAng1Z * j.ang1Z) + (md.invMAng2X * j.ang2X + md.invMAng2Y * j.ang2Y + md.invMAng2Z * j.ang2Z);
md.mass = md.massWithoutCfm + row.cfm;
if(md.massWithoutCfm != 0) {
md.massWithoutCfm = 1 / md.massWithoutCfm;
}
if(md.mass != 0) {
md.mass = 1 / md.mass;
}
}
}
warmStart(timeStep) {
let factor = this.joint._positionCorrectionAlgorithm == oimo.dynamics.constraint.PositionCorrectionAlgorithm.BAUMGARTE ? oimo.common.Setting.jointWarmStartingFactorForBaungarte : oimo.common.Setting.jointWarmStartingFactor;
factor *= timeStep.dtRatio;
if(factor <= 0) {
let _g = 0;
let _g1 = this.info.numRows;
while(_g < _g1) {
let _this = this.info.rows[_g++].impulse;
_this.impulse = 0;
_this.impulseM = 0;
_this.impulseP = 0;
}
return;
}
let lv1X;
let lv1Y;
let lv1Z;
let lv2X;
let lv2Y;
let lv2Z;
let av1X;
let av1Y;
let av1Z;
let av2X;
let av2Y;
let av2Z;
lv1X = this._b1._velX;
lv1Y = this._b1._velY;
lv1Z = this._b1._velZ;
lv2X = this._b2._velX;
lv2Y = this._b2._velY;
lv2Z = this._b2._velZ;
av1X = this._b1._angVelX;
av1Y = this._b1._angVelY;
av1Z = this._b1._angVelZ;
av2X = this._b2._angVelX;
av2Y = this._b2._angVelY;
av2Z = this._b2._angVelZ;
let _g = 0;
let _g1 = this.info.numRows;
while(_g < _g1) {
let i = _g++;
let md = this.massData[i];
let imp = this.info.rows[i].impulse;
imp.impulse *= factor;
imp.impulseM *= factor;
let impulse = imp.impulse + imp.impulseM;
lv1X += md.invMLin1X * impulse;
lv1Y += md.invMLin1Y * impulse;
lv1Z += md.invMLin1Z * impulse;
lv2X += md.invMLin2X * -impulse;
lv2Y += md.invMLin2Y * -impulse;
lv2Z += md.invMLin2Z * -impulse;
av1X += md.invMAng1X * impulse;
av1Y += md.invMAng1Y * impulse;
av1Z += md.invMAng1Z * impulse;
av2X += md.invMAng2X * -impulse;
av2Y += md.invMAng2Y * -impulse;
av2Z += md.invMAng2Z * -impulse;
}
this._b1._velX = lv1X;
this._b1._velY = lv1Y;
this._b1._velZ = lv1Z;
this._b2._velX = lv2X;
this._b2._velY = lv2Y;
this._b2._velZ = lv2Z;
this._b1._angVelX = av1X;
this._b1._angVelY = av1Y;
this._b1._angVelZ = av1Z;
this._b2._angVelX = av2X;
this._b2._angVelY = av2Y;
this._b2._angVelZ = av2Z;
}
solveVelocity() {
let lv1X;
let lv1Y;
let lv1Z;
let lv2X;
let lv2Y;
let lv2Z;
let av1X;
let av1Y;
let av1Z;
let av2X;
let av2Y;
let av2Z;
lv1X = this._b1._velX;
lv1Y = this._b1._velY;
lv1Z = this._b1._velZ;
lv2X = this._b2._velX;
lv2Y = this._b2._velY;
lv2Z = this._b2._velZ;
av1X = this._b1._angVelX;
av1Y = this._b1._angVelY;
av1Z = this._b1._angVelZ;
av2X = this._b2._angVelX;
av2Y = this._b2._angVelY;
av2Z = this._b2._angVelZ;
let _g = 0;
let _g1 = this.info.numRows;
while(_g < _g1) {
let i = _g++;
let row = this.info.rows[i];
let md = this.massData[i];
let imp = row.impulse;
let j = row.jacobian;
if(row.motorMaxImpulse == 0) {
continue;
}
let rv = 0;
rv += lv1X * j.lin1X + lv1Y * j.lin1Y + lv1Z * j.lin1Z;
rv -= lv2X * j.lin2X + lv2Y * j.lin2Y + lv2Z * j.lin2Z;
rv += av1X * j.ang1X + av1Y * j.ang1Y + av1Z * j.ang1Z;
rv -= av2X * j.ang2X + av2Y * j.ang2Y + av2Z * j.ang2Z;
let impulseM = (-row.motorSpeed - rv) * md.massWithoutCfm;
let oldImpulseM = imp.impulseM;
imp.impulseM += impulseM;
if(imp.impulseM < -row.motorMaxImpulse) {
imp.impulseM = -row.motorMaxImpulse;
} else if(imp.impulseM > row.motorMaxImpulse) {
imp.impulseM = row.motorMaxImpulse;
}
impulseM = imp.impulseM - oldImpulseM;
if((j.flag & 1) != 0) {
lv1X += md.invMLin1X * impulseM;
lv1Y += md.invMLin1Y * impulseM;
lv1Z += md.invMLin1Z * impulseM;
lv2X += md.invMLin2X * -impulseM;
lv2Y += md.invMLin2Y * -impulseM;
lv2Z += md.invMLin2Z * -impulseM;
}
if((j.flag & 2) != 0) {
av1X += md.invMAng1X * impulseM;
av1Y += md.invMAng1Y * impulseM;
av1Z += md.invMAng1Z * impulseM;
av2X += md.invMAng2X * -impulseM;
av2Y += md.invMAng2Y * -impulseM;
av2Z += md.invMAng2Z * -impulseM;
}
}
let _g2 = 0;
let _g3 = this.info.numRows;
while(_g2 < _g3) {
let i = _g2++;
let row = this.info.rows[i];
let md = this.massData[i];
let imp = row.impulse;
let j = row.jacobian;
let rv = 0;
rv += lv1X * j.lin1X + lv1Y * j.lin1Y + lv1Z * j.lin1Z;
rv -= lv2X * j.lin2X + lv2Y * j.lin2Y + lv2Z * j.lin2Z;
rv += av1X * j.ang1X + av1Y * j.ang1Y + av1Z * j.ang1Z;
rv -= av2X * j.ang2X + av2Y * j.ang2Y + av2Z * j.ang2Z;
let impulse = (row.rhs - rv - imp.impulse * row.cfm) * md.mass;
let oldImpulse = imp.impulse;
imp.impulse += impulse;
if(imp.impulse < row.minImpulse) {
imp.impulse = row.minImpulse;
} else if(imp.impulse > row.maxImpulse) {
imp.impulse = row.maxImpulse;
}
impulse = imp.impulse - oldImpulse;
if((j.flag & 1) != 0) {
lv1X += md.invMLin1X * impulse;
lv1Y += md.invMLin1Y * impulse;
lv1Z += md.invMLin1Z * impulse;
lv2X += md.invMLin2X * -impulse;
lv2Y += md.invMLin2Y * -impulse;
lv2Z += md.invMLin2Z * -impulse;
}
if((j.flag & 2) != 0) {
av1X += md.invMAng1X * impulse;
av1Y += md.invMAng1Y * impulse;
av1Z += md.invMAng1Z * impulse;
av2X += md.invMAng2X * -impulse;
av2Y += md.invMAng2Y * -impulse;
av2Z += md.invMAng2Z * -impulse;
}
}
this._b1._velX = lv1X;
this._b1._velY = lv1Y;
this._b1._velZ = lv1Z;
this._b2._velX = lv2X;
this._b2._velY = lv2Y;
this._b2._velZ = lv2Z;
this._b1._angVelX = av1X;
this._b1._angVelY = av1Y;
this._b1._angVelZ = av1Z;
this._b2._angVelX = av2X;
this._b2._angVelY = av2Y;
this._b2._angVelZ = av2Z;
}
postSolveVelocity(timeStep) {
let linX;
let linY;
let linZ;
let angX;
let angY;
let angZ;
linX = 0;
linY = 0;
linZ = 0;
angX = 0;
angY = 0;
angZ = 0;
let _g = 0;
let _g1 = this.info.numRows;
while(_g < _g1) {
let row = this.info.rows[_g++];
let imp = row.impulse;
let j = row.jacobian;
if((j.flag & 1) != 0) {
linX += j.lin1X * imp.impulse;
linY += j.lin1Y * imp.impulse;
linZ += j.lin1Z * imp.impulse;
} else if((j.flag & 2) != 0) {
angX += j.ang1X * imp.impulse;
angY += j.ang1Y * imp.impulse;
angZ += j.ang1Z * imp.impulse;
}
}
this.joint._appliedForceX = linX * timeStep.invDt;
this.joint._appliedForceY = linY * timeStep.invDt;
this.joint._appliedForceZ = linZ * timeStep.invDt;
this.joint._appliedTorqueX = angX * timeStep.invDt;
this.joint._appliedTorqueY = angY * timeStep.invDt;
this.joint._appliedTorqueZ = angZ * timeStep.invDt;
}
preSolvePosition(timeStep) {
this.joint._syncAnchors();
this.joint._getPositionSolverInfo(this.info);
this._b1 = this.info.b1;
this._b2 = this.info.b2;
let invM1 = this._b1._invMass;
let invM2 = this._b2._invMass;
let invI100;
let invI101;
let invI102;
let invI110;
let invI111;
let invI112;
let invI120;
let invI121;
let invI122;
let invI200;
let invI201;
let invI202;
let invI210;
let invI211;
let invI212;
let invI220;
let invI221;
let invI222;
invI100 = this._b1._invInertia00;
invI101 = this._b1._invInertia01;
invI102 = this._b1._invInertia02;
invI110 = this._b1._invInertia10;
invI111 = this._b1._invInertia11;
invI112 = this._b1._invInertia12;
invI120 = this._b1._invInertia20;
invI121 = this._b1._invInertia21;
invI122 = this._b1._invInertia22;
invI200 = this._b2._invInertia00;
invI201 = this._b2._invInertia01;
invI202 = this._b2._invInertia02;
invI210 = this._b2._invInertia10;
invI211 = this._b2._invInertia11;
invI212 = this._b2._invInertia12;
invI220 = this._b2._invInertia20;
invI221 = this._b2._invInertia21;
invI222 = this._b2._invInertia22;
let _g = 0;
let _g1 = this.info.numRows;
while(_g < _g1) {
let i = _g++;
let md = this.massData[i];
let j = this.info.rows[i].jacobian;
md.invMLin1X = j.lin1X * invM1;
md.invMLin1Y = j.lin1Y * invM1;
md.invMLin1Z = j.lin1Z * invM1;
md.invMLin2X = j.lin2X * invM2;
md.invMLin2Y = j.lin2Y * invM2;
md.invMLin2Z = j.lin2Z * invM2;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = invI100 * j.ang1X + invI101 * j.ang1Y + invI102 * j.ang1Z;
__tmp__Y = invI110 * j.ang1X + invI111 * j.ang1Y + invI112 * j.ang1Z;
__tmp__Z = invI120 * j.ang1X + invI121 * j.ang1Y + invI122 * j.ang1Z;
md.invMAng1X = __tmp__X;
md.invMAng1Y = __tmp__Y;
md.invMAng1Z = __tmp__Z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = invI200 * j.ang2X + invI201 * j.ang2Y + invI202 * j.ang2Z;
__tmp__Y1 = invI210 * j.ang2X + invI211 * j.ang2Y + invI212 * j.ang2Z;
__tmp__Z1 = invI220 * j.ang2X + invI221 * j.ang2Y + invI222 * j.ang2Z;
md.invMAng2X = __tmp__X1;
md.invMAng2Y = __tmp__Y1;
md.invMAng2Z = __tmp__Z1;
md.mass = md.invMLin1X * j.lin1X + md.invMLin1Y * j.lin1Y + md.invMLin1Z * j.lin1Z + (md.invMLin2X * j.lin2X + md.invMLin2Y * j.lin2Y + md.invMLin2Z * j.lin2Z) + (md.invMAng1X * j.ang1X + md.invMAng1Y * j.ang1Y + md.invMAng1Z * j.ang1Z) + (md.invMAng2X * j.ang2X + md.invMAng2Y * j.ang2Y + md.invMAng2Z * j.ang2Z);
if(md.mass != 0) {
md.mass = 1 / md.mass;
}
}
let _g2 = 0;
let _g3 = this.info.numRows;
while(_g2 < _g3) this.info.rows[_g2++].impulse.impulseP = 0;
}
solvePositionSplitImpulse() {
let lv1X;
let lv1Y;
let lv1Z;
let lv2X;
let lv2Y;
let lv2Z;
let av1X;
let av1Y;
let av1Z;
let av2X;
let av2Y;
let av2Z;
lv1X = this._b1._pseudoVelX;
lv1Y = this._b1._pseudoVelY;
lv1Z = this._b1._pseudoVelZ;
lv2X = this._b2._pseudoVelX;
lv2Y = this._b2._pseudoVelY;
lv2Z = this._b2._pseudoVelZ;
av1X = this._b1._angPseudoVelX;
av1Y = this._b1._angPseudoVelY;
av1Z = this._b1._angPseudoVelZ;
av2X = this._b2._angPseudoVelX;
av2Y = this._b2._angPseudoVelY;
av2Z = this._b2._angPseudoVelZ;
let _g = 0;
let _g1 = this.info.numRows;
while(_g < _g1) {
let i = _g++;
let row = this.info.rows[i];
let md = this.massData[i];
let imp = row.impulse;
let j = row.jacobian;
let rv = 0;
rv += lv1X * j.lin1X + lv1Y * j.lin1Y + lv1Z * j.lin1Z;
rv -= lv2X * j.lin2X + lv2Y * j.lin2Y + lv2Z * j.lin2Z;
rv += av1X * j.ang1X + av1Y * j.ang1Y + av1Z * j.ang1Z;
rv -= av2X * j.ang2X + av2Y * j.ang2Y + av2Z * j.ang2Z;
let impulseP = (row.rhs * oimo.common.Setting.positionSplitImpulseBaumgarte - rv) * md.mass;
let oldImpulseP = imp.impulseP;
imp.impulseP += impulseP;
if(imp.impulseP < row.minImpulse) {
imp.impulseP = row.minImpulse;
} else if(imp.impulseP > row.maxImpulse) {
imp.impulseP = row.maxImpulse;
}
impulseP = imp.impulseP - oldImpulseP;
lv1X += md.invMLin1X * impulseP;
lv1Y += md.invMLin1Y * impulseP;
lv1Z += md.invMLin1Z * impulseP;
lv2X += md.invMLin2X * -impulseP;
lv2Y += md.invMLin2Y * -impulseP;
lv2Z += md.invMLin2Z * -impulseP;
av1X += md.invMAng1X * impulseP;
av1Y += md.invMAng1Y * impulseP;
av1Z += md.invMAng1Z * impulseP;
av2X += md.invMAng2X * -impulseP;
av2Y += md.invMAng2Y * -impulseP;
av2Z += md.invMAng2Z * -impulseP;
}
this._b1._pseudoVelX = lv1X;
this._b1._pseudoVelY = lv1Y;
this._b1._pseudoVelZ = lv1Z;
this._b2._pseudoVelX = lv2X;
this._b2._pseudoVelY = lv2Y;
this._b2._pseudoVelZ = lv2Z;
this._b1._angPseudoVelX = av1X;
this._b1._angPseudoVelY = av1Y;
this._b1._angPseudoVelZ = av1Z;
this._b2._angPseudoVelX = av2X;
this._b2._angPseudoVelY = av2Y;
this._b2._angPseudoVelZ = av2Z;
}
solvePositionNgs(timeStep) {
this.joint._syncAnchors();
this.joint._getPositionSolverInfo(this.info);
this._b1 = this.info.b1;
this._b2 = this.info.b2;
let invM1 = this._b1._invMass;
let invM2 = this._b2._invMass;
let invI100;
let invI101;
let invI102;
let invI110;
let invI111;
let invI112;
let invI120;
let invI121;
let invI122;
let invI200;
let invI201;
let invI202;
let invI210;
let invI211;
let invI212;
let invI220;
let invI221;
let invI222;
invI100 = this._b1._invInertia00;
invI101 = this._b1._invInertia01;
invI102 = this._b1._invInertia02;
invI110 = this._b1._invInertia10;
invI111 = this._b1._invInertia11;
invI112 = this._b1._invInertia12;
invI120 = this._b1._invInertia20;
invI121 = this._b1._invInertia21;
invI122 = this._b1._invInertia22;
invI200 = this._b2._invInertia00;
invI201 = this._b2._invInertia01;
invI202 = this._b2._invInertia02;
invI210 = this._b2._invInertia10;
invI211 = this._b2._invInertia11;
invI212 = this._b2._invInertia12;
invI220 = this._b2._invInertia20;
invI221 = this._b2._invInertia21;
invI222 = this._b2._invInertia22;
let _g = 0;
let _g1 = this.info.numRows;
while(_g < _g1) {
let i = _g++;
let md = this.massData[i];
let j = this.info.rows[i].jacobian;
md.invMLin1X = j.lin1X * invM1;
md.invMLin1Y = j.lin1Y * invM1;
md.invMLin1Z = j.lin1Z * invM1;
md.invMLin2X = j.lin2X * invM2;
md.invMLin2Y = j.lin2Y * invM2;
md.invMLin2Z = j.lin2Z * invM2;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = invI100 * j.ang1X + invI101 * j.ang1Y + invI102 * j.ang1Z;
__tmp__Y = invI110 * j.ang1X + invI111 * j.ang1Y + invI112 * j.ang1Z;
__tmp__Z = invI120 * j.ang1X + invI121 * j.ang1Y + invI122 * j.ang1Z;
md.invMAng1X = __tmp__X;
md.invMAng1Y = __tmp__Y;
md.invMAng1Z = __tmp__Z;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = invI200 * j.ang2X + invI201 * j.ang2Y + invI202 * j.ang2Z;
__tmp__Y1 = invI210 * j.ang2X + invI211 * j.ang2Y + invI212 * j.ang2Z;
__tmp__Z1 = invI220 * j.ang2X + invI221 * j.ang2Y + invI222 * j.ang2Z;
md.invMAng2X = __tmp__X1;
md.invMAng2Y = __tmp__Y1;
md.invMAng2Z = __tmp__Z1;
md.mass = md.invMLin1X * j.lin1X + md.invMLin1Y * j.lin1Y + md.invMLin1Z * j.lin1Z + (md.invMLin2X * j.lin2X + md.invMLin2Y * j.lin2Y + md.invMLin2Z * j.lin2Z) + (md.invMAng1X * j.ang1X + md.invMAng1Y * j.ang1Y + md.invMAng1Z * j.ang1Z) + (md.invMAng2X * j.ang2X + md.invMAng2Y * j.ang2Y + md.invMAng2Z * j.ang2Z);
if(md.mass != 0) {
md.mass = 1 / md.mass;
}
}
let lv1X;
let lv1Y;
let lv1Z;
let lv2X;
let lv2Y;
let lv2Z;
let av1X;
let av1Y;
let av1Z;
let av2X;
let av2Y;
let av2Z;
lv1X = 0;
lv1Y = 0;
lv1Z = 0;
lv2X = 0;
lv2Y = 0;
lv2Z = 0;
av1X = 0;
av1Y = 0;
av1Z = 0;
av2X = 0;
av2Y = 0;
av2Z = 0;
let _g2 = 0;
let _g3 = this.info.numRows;
while(_g2 < _g3) {
let i = _g2++;
let row = this.info.rows[i];
let md = this.massData[i];
let imp = row.impulse;
let j = row.jacobian;
let rv = 0;
rv += lv1X * j.lin1X + lv1Y * j.lin1Y + lv1Z * j.lin1Z;
rv -= lv2X * j.lin2X + lv2Y * j.lin2Y + lv2Z * j.lin2Z;
rv += av1X * j.ang1X + av1Y * j.ang1Y + av1Z * j.ang1Z;
rv -= av2X * j.ang2X + av2Y * j.ang2Y + av2Z * j.ang2Z;
let impulseP = (row.rhs * oimo.common.Setting.positionNgsBaumgarte - rv) * md.mass;
let oldImpulseP = imp.impulseP;
imp.impulseP += impulseP;
if(imp.impulseP < row.minImpulse) {
imp.impulseP = row.minImpulse;
} else if(imp.impulseP > row.maxImpulse) {
imp.impulseP = row.maxImpulse;
}
impulseP = imp.impulseP - oldImpulseP;
lv1X += md.invMLin1X * impulseP;
lv1Y += md.invMLin1Y * impulseP;
lv1Z += md.invMLin1Z * impulseP;
lv2X += md.invMLin2X * -impulseP;
lv2Y += md.invMLin2Y * -impulseP;
lv2Z += md.invMLin2Z * -impulseP;
av1X += md.invMAng1X * impulseP;
av1Y += md.invMAng1Y * impulseP;
av1Z += md.invMAng1Z * impulseP;
av2X += md.invMAng2X * -impulseP;
av2Y += md.invMAng2Y * -impulseP;
av2Z += md.invMAng2Z * -impulseP;
}
let _this = this._b1;
_this._transform._positionX += lv1X;
_this._transform._positionY += lv1Y;
_this._transform._positionZ += lv1Z;
let _this1 = this._b2;
_this1._transform._positionX += lv2X;
_this1._transform._positionY += lv2Y;
_this1._transform._positionZ += lv2Z;
let _this2 = this._b1;
let theta = Math.sqrt(av1X * av1X + av1Y * av1Y + av1Z * av1Z);
let halfTheta = theta * 0.5;
let rotationToSinAxisFactor;
let cosHalfTheta;
if(halfTheta < 0.5) {
let ht2 = halfTheta * halfTheta;
rotationToSinAxisFactor = 0.5 * (1 - ht2 * 0.16666666666666666 + ht2 * ht2 * 0.0083333333333333332);
cosHalfTheta = 1 - ht2 * 0.5 + ht2 * ht2 * 0.041666666666666664;
} else {
rotationToSinAxisFactor = Math.sin(halfTheta) / theta;
cosHalfTheta = Math.cos(halfTheta);
}
let sinAxisX;
let sinAxisY;
let sinAxisZ;
sinAxisX = av1X * rotationToSinAxisFactor;
sinAxisY = av1Y * rotationToSinAxisFactor;
sinAxisZ = av1Z * rotationToSinAxisFactor;
let dqX;
let dqY;
let dqZ;
let dqW;
dqX = sinAxisX;
dqY = sinAxisY;
dqZ = sinAxisZ;
dqW = cosHalfTheta;
let qX;
let qY;
let qZ;
let qW;
let e00 = _this2._transform._rotation00;
let e11 = _this2._transform._rotation11;
let e22 = _this2._transform._rotation22;
let t = e00 + e11 + e22;
let s;
if(t > 0) {
s = Math.sqrt(t + 1);
qW = 0.5 * s;
s = 0.5 / s;
qX = (_this2._transform._rotation21 - _this2._transform._rotation12) * s;
qY = (_this2._transform._rotation02 - _this2._transform._rotation20) * s;
qZ = (_this2._transform._rotation10 - _this2._transform._rotation01) * s;
} else if(e00 > e11) {
if(e00 > e22) {
s = Math.sqrt(e00 - e11 - e22 + 1);
qX = 0.5 * s;
s = 0.5 / s;
qY = (_this2._transform._rotation01 + _this2._transform._rotation10) * s;
qZ = (_this2._transform._rotation02 + _this2._transform._rotation20) * s;
qW = (_this2._transform._rotation21 - _this2._transform._rotation12) * s;
} else {
s = Math.sqrt(e22 - e00 - e11 + 1);
qZ = 0.5 * s;
s = 0.5 / s;
qX = (_this2._transform._rotation02 + _this2._transform._rotation20) * s;
qY = (_this2._transform._rotation12 + _this2._transform._rotation21) * s;
qW = (_this2._transform._rotation10 - _this2._transform._rotation01) * s;
}
} else if(e11 > e22) {
s = Math.sqrt(e11 - e22 - e00 + 1);
qY = 0.5 * s;
s = 0.5 / s;
qX = (_this2._transform._rotation01 + _this2._transform._rotation10) * s;
qZ = (_this2._transform._rotation12 + _this2._transform._rotation21) * s;
qW = (_this2._transform._rotation02 - _this2._transform._rotation20) * s;
} else {
s = Math.sqrt(e22 - e00 - e11 + 1);
qZ = 0.5 * s;
s = 0.5 / s;
qX = (_this2._transform._rotation02 + _this2._transform._rotation20) * s;
qY = (_this2._transform._rotation12 + _this2._transform._rotation21) * s;
qW = (_this2._transform._rotation10 - _this2._transform._rotation01) * s;
}
qX = dqW * qX + dqX * qW + dqY * qZ - dqZ * qY;
qY = dqW * qY - dqX * qZ + dqY * qW + dqZ * qX;
qZ = dqW * qZ + dqX * qY - dqY * qX + dqZ * qW;
qW = dqW * qW - dqX * qX - dqY * qY - dqZ * qZ;
let l = qX * qX + qY * qY + qZ * qZ + qW * qW;
if(l > 1e-32) {
l = 1 / Math.sqrt(l);
}
qX *= l;
qY *= l;
qZ *= l;
qW *= l;
let x = qX;
let y = qY;
let z = qZ;
let w = qW;
let x2 = 2 * x;
let y2 = 2 * y;
let z2 = 2 * z;
let xx = x * x2;
let yy = y * y2;
let zz = z * z2;
let xy = x * y2;
let yz = y * z2;
let xz = x * z2;
let wx = w * x2;
let wy = w * y2;
let wz = w * z2;
_this2._transform._rotation00 = 1 - yy - zz;
_this2._transform._rotation01 = xy - wz;
_this2._transform._rotation02 = xz + wy;
_this2._transform._rotation10 = xy + wz;
_this2._transform._rotation11 = 1 - xx - zz;
_this2._transform._rotation12 = yz - wx;
_this2._transform._rotation20 = xz - wy;
_this2._transform._rotation21 = yz + wx;
_this2._transform._rotation22 = 1 - xx - yy;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = _this2._transform._rotation00 * _this2._invLocalInertia00 + _this2._transform._rotation01 * _this2._invLocalInertia10 + _this2._transform._rotation02 * _this2._invLocalInertia20;
__tmp__01 = _this2._transform._rotation00 * _this2._invLocalInertia01 + _this2._transform._rotation01 * _this2._invLocalInertia11 + _this2._transform._rotation02 * _this2._invLocalInertia21;
__tmp__02 = _this2._transform._rotation00 * _this2._invLocalInertia02 + _this2._transform._rotation01 * _this2._invLocalInertia12 + _this2._transform._rotation02 * _this2._invLocalInertia22;
__tmp__10 = _this2._transform._rotation10 * _this2._invLocalInertia00 + _this2._transform._rotation11 * _this2._invLocalInertia10 + _this2._transform._rotation12 * _this2._invLocalInertia20;
__tmp__11 = _this2._transform._rotation10 * _this2._invLocalInertia01 + _this2._transform._rotation11 * _this2._invLocalInertia11 + _this2._transform._rotation12 * _this2._invLocalInertia21;
__tmp__12 = _this2._transform._rotation10 * _this2._invLocalInertia02 + _this2._transform._rotation11 * _this2._invLocalInertia12 + _this2._transform._rotation12 * _this2._invLocalInertia22;
__tmp__20 = _this2._transform._rotation20 * _this2._invLocalInertia00 + _this2._transform._rotation21 * _this2._invLocalInertia10 + _this2._transform._rotation22 * _this2._invLocalInertia20;
__tmp__21 = _this2._transform._rotation20 * _this2._invLocalInertia01 + _this2._transform._rotation21 * _this2._invLocalInertia11 + _this2._transform._rotation22 * _this2._invLocalInertia21;
__tmp__22 = _this2._transform._rotation20 * _this2._invLocalInertia02 + _this2._transform._rotation21 * _this2._invLocalInertia12 + _this2._transform._rotation22 * _this2._invLocalInertia22;
_this2._invInertia00 = __tmp__00;
_this2._invInertia01 = __tmp__01;
_this2._invInertia02 = __tmp__02;
_this2._invInertia10 = __tmp__10;
_this2._invInertia11 = __tmp__11;
_this2._invInertia12 = __tmp__12;
_this2._invInertia20 = __tmp__20;
_this2._invInertia21 = __tmp__21;
_this2._invInertia22 = __tmp__22;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = _this2._invInertia00 * _this2._transform._rotation00 + _this2._invInertia01 * _this2._transform._rotation01 + _this2._invInertia02 * _this2._transform._rotation02;
__tmp__011 = _this2._invInertia00 * _this2._transform._rotation10 + _this2._invInertia01 * _this2._transform._rotation11 + _this2._invInertia02 * _this2._transform._rotation12;
__tmp__021 = _this2._invInertia00 * _this2._transform._rotation20 + _this2._invInertia01 * _this2._transform._rotation21 + _this2._invInertia02 * _this2._transform._rotation22;
__tmp__101 = _this2._invInertia10 * _this2._transform._rotation00 + _this2._invInertia11 * _this2._transform._rotation01 + _this2._invInertia12 * _this2._transform._rotation02;
__tmp__111 = _this2._invInertia10 * _this2._transform._rotation10 + _this2._invInertia11 * _this2._transform._rotation11 + _this2._invInertia12 * _this2._transform._rotation12;
__tmp__121 = _this2._invInertia10 * _this2._transform._rotation20 + _this2._invInertia11 * _this2._transform._rotation21 + _this2._invInertia12 * _this2._transform._rotation22;
__tmp__201 = _this2._invInertia20 * _this2._transform._rotation00 + _this2._invInertia21 * _this2._transform._rotation01 + _this2._invInertia22 * _this2._transform._rotation02;
__tmp__211 = _this2._invInertia20 * _this2._transform._rotation10 + _this2._invInertia21 * _this2._transform._rotation11 + _this2._invInertia22 * _this2._transform._rotation12;
__tmp__221 = _this2._invInertia20 * _this2._transform._rotation20 + _this2._invInertia21 * _this2._transform._rotation21 + _this2._invInertia22 * _this2._transform._rotation22;
_this2._invInertia00 = __tmp__001;
_this2._invInertia01 = __tmp__011;
_this2._invInertia02 = __tmp__021;
_this2._invInertia10 = __tmp__101;
_this2._invInertia11 = __tmp__111;
_this2._invInertia12 = __tmp__121;
_this2._invInertia20 = __tmp__201;
_this2._invInertia21 = __tmp__211;
_this2._invInertia22 = __tmp__221;
_this2._invInertia00 *= _this2._rotFactor.x;
_this2._invInertia01 *= _this2._rotFactor.x;
_this2._invInertia02 *= _this2._rotFactor.x;
_this2._invInertia10 *= _this2._rotFactor.y;
_this2._invInertia11 *= _this2._rotFactor.y;
_this2._invInertia12 *= _this2._rotFactor.y;
_this2._invInertia20 *= _this2._rotFactor.z;
_this2._invInertia21 *= _this2._rotFactor.z;
_this2._invInertia22 *= _this2._rotFactor.z;
let _this3 = this._b2;
let theta1 = Math.sqrt(av2X * av2X + av2Y * av2Y + av2Z * av2Z);
let halfTheta1 = theta1 * 0.5;
let rotationToSinAxisFactor1;
let cosHalfTheta1;
if(halfTheta1 < 0.5) {
let ht2 = halfTheta1 * halfTheta1;
rotationToSinAxisFactor1 = 0.5 * (1 - ht2 * 0.16666666666666666 + ht2 * ht2 * 0.0083333333333333332);
cosHalfTheta1 = 1 - ht2 * 0.5 + ht2 * ht2 * 0.041666666666666664;
} else {
rotationToSinAxisFactor1 = Math.sin(halfTheta1) / theta1;
cosHalfTheta1 = Math.cos(halfTheta1);
}
let sinAxisX1;
let sinAxisY1;
let sinAxisZ1;
sinAxisX1 = av2X * rotationToSinAxisFactor1;
sinAxisY1 = av2Y * rotationToSinAxisFactor1;
sinAxisZ1 = av2Z * rotationToSinAxisFactor1;
let dqX1;
let dqY1;
let dqZ1;
let dqW1;
dqX1 = sinAxisX1;
dqY1 = sinAxisY1;
dqZ1 = sinAxisZ1;
dqW1 = cosHalfTheta1;
let qX1;
let qY1;
let qZ1;
let qW1;
let e001 = _this3._transform._rotation00;
let e111 = _this3._transform._rotation11;
let e221 = _this3._transform._rotation22;
let t1 = e001 + e111 + e221;
let s1;
if(t1 > 0) {
s1 = Math.sqrt(t1 + 1);
qW1 = 0.5 * s1;
s1 = 0.5 / s1;
qX1 = (_this3._transform._rotation21 - _this3._transform._rotation12) * s1;
qY1 = (_this3._transform._rotation02 - _this3._transform._rotation20) * s1;
qZ1 = (_this3._transform._rotation10 - _this3._transform._rotation01) * s1;
} else if(e001 > e111) {
if(e001 > e221) {
s1 = Math.sqrt(e001 - e111 - e221 + 1);
qX1 = 0.5 * s1;
s1 = 0.5 / s1;
qY1 = (_this3._transform._rotation01 + _this3._transform._rotation10) * s1;
qZ1 = (_this3._transform._rotation02 + _this3._transform._rotation20) * s1;
qW1 = (_this3._transform._rotation21 - _this3._transform._rotation12) * s1;
} else {
s1 = Math.sqrt(e221 - e001 - e111 + 1);
qZ1 = 0.5 * s1;
s1 = 0.5 / s1;
qX1 = (_this3._transform._rotation02 + _this3._transform._rotation20) * s1;
qY1 = (_this3._transform._rotation12 + _this3._transform._rotation21) * s1;
qW1 = (_this3._transform._rotation10 - _this3._transform._rotation01) * s1;
}
} else if(e111 > e221) {
s1 = Math.sqrt(e111 - e221 - e001 + 1);
qY1 = 0.5 * s1;
s1 = 0.5 / s1;
qX1 = (_this3._transform._rotation01 + _this3._transform._rotation10) * s1;
qZ1 = (_this3._transform._rotation12 + _this3._transform._rotation21) * s1;
qW1 = (_this3._transform._rotation02 - _this3._transform._rotation20) * s1;
} else {
s1 = Math.sqrt(e221 - e001 - e111 + 1);
qZ1 = 0.5 * s1;
s1 = 0.5 / s1;
qX1 = (_this3._transform._rotation02 + _this3._transform._rotation20) * s1;
qY1 = (_this3._transform._rotation12 + _this3._transform._rotation21) * s1;
qW1 = (_this3._transform._rotation10 - _this3._transform._rotation01) * s1;
}
qX1 = dqW1 * qX1 + dqX1 * qW1 + dqY1 * qZ1 - dqZ1 * qY1;
qY1 = dqW1 * qY1 - dqX1 * qZ1 + dqY1 * qW1 + dqZ1 * qX1;
qZ1 = dqW1 * qZ1 + dqX1 * qY1 - dqY1 * qX1 + dqZ1 * qW1;
qW1 = dqW1 * qW1 - dqX1 * qX1 - dqY1 * qY1 - dqZ1 * qZ1;
let l1 = qX1 * qX1 + qY1 * qY1 + qZ1 * qZ1 + qW1 * qW1;
if(l1 > 1e-32) {
l1 = 1 / Math.sqrt(l1);
}
qX1 *= l1;
qY1 *= l1;
qZ1 *= l1;
qW1 *= l1;
let x1 = qX1;
let y1 = qY1;
let z1 = qZ1;
let w1 = qW1;
let x21 = 2 * x1;
let y21 = 2 * y1;
let z21 = 2 * z1;
let xx1 = x1 * x21;
let yy1 = y1 * y21;
let zz1 = z1 * z21;
let xy1 = x1 * y21;
let yz1 = y1 * z21;
let xz1 = x1 * z21;
let wx1 = w1 * x21;
let wy1 = w1 * y21;
let wz1 = w1 * z21;
_this3._transform._rotation00 = 1 - yy1 - zz1;
_this3._transform._rotation01 = xy1 - wz1;
_this3._transform._rotation02 = xz1 + wy1;
_this3._transform._rotation10 = xy1 + wz1;
_this3._transform._rotation11 = 1 - xx1 - zz1;
_this3._transform._rotation12 = yz1 - wx1;
_this3._transform._rotation20 = xz1 - wy1;
_this3._transform._rotation21 = yz1 + wx1;
_this3._transform._rotation22 = 1 - xx1 - yy1;
let __tmp__002;
let __tmp__012;
let __tmp__022;
let __tmp__102;
let __tmp__112;
let __tmp__122;
let __tmp__202;
let __tmp__212;
let __tmp__222;
__tmp__002 = _this3._transform._rotation00 * _this3._invLocalInertia00 + _this3._transform._rotation01 * _this3._invLocalInertia10 + _this3._transform._rotation02 * _this3._invLocalInertia20;
__tmp__012 = _this3._transform._rotation00 * _this3._invLocalInertia01 + _this3._transform._rotation01 * _this3._invLocalInertia11 + _this3._transform._rotation02 * _this3._invLocalInertia21;
__tmp__022 = _this3._transform._rotation00 * _this3._invLocalInertia02 + _this3._transform._rotation01 * _this3._invLocalInertia12 + _this3._transform._rotation02 * _this3._invLocalInertia22;
__tmp__102 = _this3._transform._rotation10 * _this3._invLocalInertia00 + _this3._transform._rotation11 * _this3._invLocalInertia10 + _this3._transform._rotation12 * _this3._invLocalInertia20;
__tmp__112 = _this3._transform._rotation10 * _this3._invLocalInertia01 + _this3._transform._rotation11 * _this3._invLocalInertia11 + _this3._transform._rotation12 * _this3._invLocalInertia21;
__tmp__122 = _this3._transform._rotation10 * _this3._invLocalInertia02 + _this3._transform._rotation11 * _this3._invLocalInertia12 + _this3._transform._rotation12 * _this3._invLocalInertia22;
__tmp__202 = _this3._transform._rotation20 * _this3._invLocalInertia00 + _this3._transform._rotation21 * _this3._invLocalInertia10 + _this3._transform._rotation22 * _this3._invLocalInertia20;
__tmp__212 = _this3._transform._rotation20 * _this3._invLocalInertia01 + _this3._transform._rotation21 * _this3._invLocalInertia11 + _this3._transform._rotation22 * _this3._invLocalInertia21;
__tmp__222 = _this3._transform._rotation20 * _this3._invLocalInertia02 + _this3._transform._rotation21 * _this3._invLocalInertia12 + _this3._transform._rotation22 * _this3._invLocalInertia22;
_this3._invInertia00 = __tmp__002;
_this3._invInertia01 = __tmp__012;
_this3._invInertia02 = __tmp__022;
_this3._invInertia10 = __tmp__102;
_this3._invInertia11 = __tmp__112;
_this3._invInertia12 = __tmp__122;
_this3._invInertia20 = __tmp__202;
_this3._invInertia21 = __tmp__212;
_this3._invInertia22 = __tmp__222;
let __tmp__003;
let __tmp__013;
let __tmp__023;
let __tmp__103;
let __tmp__113;
let __tmp__123;
let __tmp__203;
let __tmp__213;
let __tmp__223;
__tmp__003 = _this3._invInertia00 * _this3._transform._rotation00 + _this3._invInertia01 * _this3._transform._rotation01 + _this3._invInertia02 * _this3._transform._rotation02;
__tmp__013 = _this3._invInertia00 * _this3._transform._rotation10 + _this3._invInertia01 * _this3._transform._rotation11 + _this3._invInertia02 * _this3._transform._rotation12;
__tmp__023 = _this3._invInertia00 * _this3._transform._rotation20 + _this3._invInertia01 * _this3._transform._rotation21 + _this3._invInertia02 * _this3._transform._rotation22;
__tmp__103 = _this3._invInertia10 * _this3._transform._rotation00 + _this3._invInertia11 * _this3._transform._rotation01 + _this3._invInertia12 * _this3._transform._rotation02;
__tmp__113 = _this3._invInertia10 * _this3._transform._rotation10 + _this3._invInertia11 * _this3._transform._rotation11 + _this3._invInertia12 * _this3._transform._rotation12;
__tmp__123 = _this3._invInertia10 * _this3._transform._rotation20 + _this3._invInertia11 * _this3._transform._rotation21 + _this3._invInertia12 * _this3._transform._rotation22;
__tmp__203 = _this3._invInertia20 * _this3._transform._rotation00 + _this3._invInertia21 * _this3._transform._rotation01 + _this3._invInertia22 * _this3._transform._rotation02;
__tmp__213 = _this3._invInertia20 * _this3._transform._rotation10 + _this3._invInertia21 * _this3._transform._rotation11 + _this3._invInertia22 * _this3._transform._rotation12;
__tmp__223 = _this3._invInertia20 * _this3._transform._rotation20 + _this3._invInertia21 * _this3._transform._rotation21 + _this3._invInertia22 * _this3._transform._rotation22;
_this3._invInertia00 = __tmp__003;
_this3._invInertia01 = __tmp__013;
_this3._invInertia02 = __tmp__023;
_this3._invInertia10 = __tmp__103;
_this3._invInertia11 = __tmp__113;
_this3._invInertia12 = __tmp__123;
_this3._invInertia20 = __tmp__203;
_this3._invInertia21 = __tmp__213;
_this3._invInertia22 = __tmp__223;
_this3._invInertia00 *= _this3._rotFactor.x;
_this3._invInertia01 *= _this3._rotFactor.x;
_this3._invInertia02 *= _this3._rotFactor.x;
_this3._invInertia10 *= _this3._rotFactor.y;
_this3._invInertia11 *= _this3._rotFactor.y;
_this3._invInertia12 *= _this3._rotFactor.y;
_this3._invInertia20 *= _this3._rotFactor.z;
_this3._invInertia21 *= _this3._rotFactor.z;
_this3._invInertia22 *= _this3._rotFactor.z;
}
postSolve() {
this.joint._syncAnchors();
this.joint._checkDestruction();
}
}
if(!oimo.dynamics.rigidbody) oimo.dynamics.rigidbody = {};
oimo.dynamics.rigidbody.MassData = class oimo_dynamics_rigidbody_MassData {
constructor() {
this.mass = 0;
this.localInertia = new oimo.common.Mat3();
}
}
oimo.dynamics.rigidbody.RigidBody = class oimo_dynamics_rigidbody_RigidBody {
constructor(config) {
this._next = null;
this._prev = null;
this._shapeList = null;
this._shapeListLast = null;
this._numShapes = 0;
this._contactLinkList = null;
this._contactLinkListLast = null;
this._numContactLinks = 0;
this._jointLinkList = null;
this._jointLinkListLast = null;
this._numJointLinks = 0;
let v = config.linearVelocity;
this._velX = v.x;
this._velY = v.y;
this._velZ = v.z;
let v1 = config.angularVelocity;
this._angVelX = v1.x;
this._angVelY = v1.y;
this._angVelZ = v1.z;
this._pseudoVelX = 0;
this._pseudoVelY = 0;
this._pseudoVelZ = 0;
this._angPseudoVelX = 0;
this._angPseudoVelY = 0;
this._angPseudoVelZ = 0;
this._ptransform = new oimo.common.Transform();
this._transform = new oimo.common.Transform();
let v2 = config.position;
this._ptransform._positionX = v2.x;
this._ptransform._positionY = v2.y;
this._ptransform._positionZ = v2.z;
let m = config.rotation;
this._ptransform._rotation00 = m.e00;
this._ptransform._rotation01 = m.e01;
this._ptransform._rotation02 = m.e02;
this._ptransform._rotation10 = m.e10;
this._ptransform._rotation11 = m.e11;
this._ptransform._rotation12 = m.e12;
this._ptransform._rotation20 = m.e20;
this._ptransform._rotation21 = m.e21;
this._ptransform._rotation22 = m.e22;
let dst = this._transform;
let src = this._ptransform;
dst._positionX = src._positionX;
dst._positionY = src._positionY;
dst._positionZ = src._positionZ;
dst._rotation00 = src._rotation00;
dst._rotation01 = src._rotation01;
dst._rotation02 = src._rotation02;
dst._rotation10 = src._rotation10;
dst._rotation11 = src._rotation11;
dst._rotation12 = src._rotation12;
dst._rotation20 = src._rotation20;
dst._rotation21 = src._rotation21;
dst._rotation22 = src._rotation22;
this._type = config.type;
this._sleepTime = 0;
this._sleeping = false;
this._autoSleep = config.autoSleep;
this._mass = 0;
this._invMass = 0;
this._localInertia00 = 0;
this._localInertia01 = 0;
this._localInertia02 = 0;
this._localInertia10 = 0;
this._localInertia11 = 0;
this._localInertia12 = 0;
this._localInertia20 = 0;
this._localInertia21 = 0;
this._localInertia22 = 0;
this._invLocalInertia00 = 0;
this._invLocalInertia01 = 0;
this._invLocalInertia02 = 0;
this._invLocalInertia10 = 0;
this._invLocalInertia11 = 0;
this._invLocalInertia12 = 0;
this._invLocalInertia20 = 0;
this._invLocalInertia21 = 0;
this._invLocalInertia22 = 0;
this._invLocalInertiaWithoutRotFactor00 = 0;
this._invLocalInertiaWithoutRotFactor01 = 0;
this._invLocalInertiaWithoutRotFactor02 = 0;
this._invLocalInertiaWithoutRotFactor10 = 0;
this._invLocalInertiaWithoutRotFactor11 = 0;
this._invLocalInertiaWithoutRotFactor12 = 0;
this._invLocalInertiaWithoutRotFactor20 = 0;
this._invLocalInertiaWithoutRotFactor21 = 0;
this._invLocalInertiaWithoutRotFactor22 = 0;
this._invInertia00 = 0;
this._invInertia01 = 0;
this._invInertia02 = 0;
this._invInertia10 = 0;
this._invInertia11 = 0;
this._invInertia12 = 0;
this._invInertia20 = 0;
this._invInertia21 = 0;
this._invInertia22 = 0;
this._linearDamping = config.linearDamping;
this._angularDamping = config.angularDamping;
this._forceX = 0;
this._forceY = 0;
this._forceZ = 0;
this._torqueX = 0;
this._torqueY = 0;
this._torqueZ = 0;
this._linearContactImpulseX = 0;
this._linearContactImpulseY = 0;
this._linearContactImpulseZ = 0;
this._angularContactImpulseX = 0;
this._angularContactImpulseY = 0;
this._angularContactImpulseZ = 0;
this._rotFactor = new oimo.common.Vec3(1,1,1);
this._addedToIsland = false;
this._gravityScale = 1;
this._world = null;
}
_integrate(dt) {
switch(this._type) {
case 1:
this._velX = 0;
this._velY = 0;
this._velZ = 0;
this._angVelX = 0;
this._angVelY = 0;
this._angVelZ = 0;
this._pseudoVelX = 0;
this._pseudoVelY = 0;
this._pseudoVelZ = 0;
this._angPseudoVelX = 0;
this._angPseudoVelY = 0;
this._angPseudoVelZ = 0;
break;
case 0:case 2:
let translationX;
let translationY;
let translationZ;
let rotationX;
let rotationY;
let rotationZ;
translationX = this._velX * dt;
translationY = this._velY * dt;
translationZ = this._velZ * dt;
rotationX = this._angVelX * dt;
rotationY = this._angVelY * dt;
rotationZ = this._angVelZ * dt;
let translationLengthSq = translationX * translationX + translationY * translationY + translationZ * translationZ;
let rotationLengthSq = rotationX * rotationX + rotationY * rotationY + rotationZ * rotationZ;
if(translationLengthSq == 0 && rotationLengthSq == 0) {
return;
}
if(translationLengthSq > oimo.common.Setting.maxTranslationPerStep * oimo.common.Setting.maxTranslationPerStep) {
let l = oimo.common.Setting.maxTranslationPerStep / Math.sqrt(translationLengthSq);
this._velX *= l;
this._velY *= l;
this._velZ *= l;
translationX *= l;
translationY *= l;
translationZ *= l;
}
if(rotationLengthSq > oimo.common.Setting.maxRotationPerStep * oimo.common.Setting.maxRotationPerStep) {
let l = oimo.common.Setting.maxRotationPerStep / Math.sqrt(rotationLengthSq);
this._angVelX *= l;
this._angVelY *= l;
this._angVelZ *= l;
rotationX *= l;
rotationY *= l;
rotationZ *= l;
}
this._transform._positionX += translationX;
this._transform._positionY += translationY;
this._transform._positionZ += translationZ;
let theta = Math.sqrt(rotationX * rotationX + rotationY * rotationY + rotationZ * rotationZ);
let halfTheta = theta * 0.5;
let rotationToSinAxisFactor;
let cosHalfTheta;
if(halfTheta < 0.5) {
let ht2 = halfTheta * halfTheta;
rotationToSinAxisFactor = 0.5 * (1 - ht2 * 0.16666666666666666 + ht2 * ht2 * 0.0083333333333333332);
cosHalfTheta = 1 - ht2 * 0.5 + ht2 * ht2 * 0.041666666666666664;
} else {
rotationToSinAxisFactor = Math.sin(halfTheta) / theta;
cosHalfTheta = Math.cos(halfTheta);
}
let sinAxisX;
let sinAxisY;
let sinAxisZ;
sinAxisX = rotationX * rotationToSinAxisFactor;
sinAxisY = rotationY * rotationToSinAxisFactor;
sinAxisZ = rotationZ * rotationToSinAxisFactor;
let dqX;
let dqY;
let dqZ;
let dqW;
dqX = sinAxisX;
dqY = sinAxisY;
dqZ = sinAxisZ;
dqW = cosHalfTheta;
let qX;
let qY;
let qZ;
let qW;
let e00 = this._transform._rotation00;
let e11 = this._transform._rotation11;
let e22 = this._transform._rotation22;
let t = e00 + e11 + e22;
let s;
if(t > 0) {
s = Math.sqrt(t + 1);
qW = 0.5 * s;
s = 0.5 / s;
qX = (this._transform._rotation21 - this._transform._rotation12) * s;
qY = (this._transform._rotation02 - this._transform._rotation20) * s;
qZ = (this._transform._rotation10 - this._transform._rotation01) * s;
} else if(e00 > e11) {
if(e00 > e22) {
s = Math.sqrt(e00 - e11 - e22 + 1);
qX = 0.5 * s;
s = 0.5 / s;
qY = (this._transform._rotation01 + this._transform._rotation10) * s;
qZ = (this._transform._rotation02 + this._transform._rotation20) * s;
qW = (this._transform._rotation21 - this._transform._rotation12) * s;
} else {
s = Math.sqrt(e22 - e00 - e11 + 1);
qZ = 0.5 * s;
s = 0.5 / s;
qX = (this._transform._rotation02 + this._transform._rotation20) * s;
qY = (this._transform._rotation12 + this._transform._rotation21) * s;
qW = (this._transform._rotation10 - this._transform._rotation01) * s;
}
} else if(e11 > e22) {
s = Math.sqrt(e11 - e22 - e00 + 1);
qY = 0.5 * s;
s = 0.5 / s;
qX = (this._transform._rotation01 + this._transform._rotation10) * s;
qZ = (this._transform._rotation12 + this._transform._rotation21) * s;
qW = (this._transform._rotation02 - this._transform._rotation20) * s;
} else {
s = Math.sqrt(e22 - e00 - e11 + 1);
qZ = 0.5 * s;
s = 0.5 / s;
qX = (this._transform._rotation02 + this._transform._rotation20) * s;
qY = (this._transform._rotation12 + this._transform._rotation21) * s;
qW = (this._transform._rotation10 - this._transform._rotation01) * s;
}
qX = dqW * qX + dqX * qW + dqY * qZ - dqZ * qY;
qY = dqW * qY - dqX * qZ + dqY * qW + dqZ * qX;
qZ = dqW * qZ + dqX * qY - dqY * qX + dqZ * qW;
qW = dqW * qW - dqX * qX - dqY * qY - dqZ * qZ;
let l = qX * qX + qY * qY + qZ * qZ + qW * qW;
if(l > 1e-32) {
l = 1 / Math.sqrt(l);
}
qX *= l;
qY *= l;
qZ *= l;
qW *= l;
let x = qX;
let y = qY;
let z = qZ;
let w = qW;
let x2 = 2 * x;
let y2 = 2 * y;
let z2 = 2 * z;
let xx = x * x2;
let yy = y * y2;
let zz = z * z2;
let xy = x * y2;
let yz = y * z2;
let xz = x * z2;
let wx = w * x2;
let wy = w * y2;
let wz = w * z2;
this._transform._rotation00 = 1 - yy - zz;
this._transform._rotation01 = xy - wz;
this._transform._rotation02 = xz + wy;
this._transform._rotation10 = xy + wz;
this._transform._rotation11 = 1 - xx - zz;
this._transform._rotation12 = yz - wx;
this._transform._rotation20 = xz - wy;
this._transform._rotation21 = yz + wx;
this._transform._rotation22 = 1 - xx - yy;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = this._transform._rotation00 * this._invLocalInertia00 + this._transform._rotation01 * this._invLocalInertia10 + this._transform._rotation02 * this._invLocalInertia20;
__tmp__01 = this._transform._rotation00 * this._invLocalInertia01 + this._transform._rotation01 * this._invLocalInertia11 + this._transform._rotation02 * this._invLocalInertia21;
__tmp__02 = this._transform._rotation00 * this._invLocalInertia02 + this._transform._rotation01 * this._invLocalInertia12 + this._transform._rotation02 * this._invLocalInertia22;
__tmp__10 = this._transform._rotation10 * this._invLocalInertia00 + this._transform._rotation11 * this._invLocalInertia10 + this._transform._rotation12 * this._invLocalInertia20;
__tmp__11 = this._transform._rotation10 * this._invLocalInertia01 + this._transform._rotation11 * this._invLocalInertia11 + this._transform._rotation12 * this._invLocalInertia21;
__tmp__12 = this._transform._rotation10 * this._invLocalInertia02 + this._transform._rotation11 * this._invLocalInertia12 + this._transform._rotation12 * this._invLocalInertia22;
__tmp__20 = this._transform._rotation20 * this._invLocalInertia00 + this._transform._rotation21 * this._invLocalInertia10 + this._transform._rotation22 * this._invLocalInertia20;
__tmp__21 = this._transform._rotation20 * this._invLocalInertia01 + this._transform._rotation21 * this._invLocalInertia11 + this._transform._rotation22 * this._invLocalInertia21;
__tmp__22 = this._transform._rotation20 * this._invLocalInertia02 + this._transform._rotation21 * this._invLocalInertia12 + this._transform._rotation22 * this._invLocalInertia22;
this._invInertia00 = __tmp__00;
this._invInertia01 = __tmp__01;
this._invInertia02 = __tmp__02;
this._invInertia10 = __tmp__10;
this._invInertia11 = __tmp__11;
this._invInertia12 = __tmp__12;
this._invInertia20 = __tmp__20;
this._invInertia21 = __tmp__21;
this._invInertia22 = __tmp__22;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = this._invInertia00 * this._transform._rotation00 + this._invInertia01 * this._transform._rotation01 + this._invInertia02 * this._transform._rotation02;
__tmp__011 = this._invInertia00 * this._transform._rotation10 + this._invInertia01 * this._transform._rotation11 + this._invInertia02 * this._transform._rotation12;
__tmp__021 = this._invInertia00 * this._transform._rotation20 + this._invInertia01 * this._transform._rotation21 + this._invInertia02 * this._transform._rotation22;
__tmp__101 = this._invInertia10 * this._transform._rotation00 + this._invInertia11 * this._transform._rotation01 + this._invInertia12 * this._transform._rotation02;
__tmp__111 = this._invInertia10 * this._transform._rotation10 + this._invInertia11 * this._transform._rotation11 + this._invInertia12 * this._transform._rotation12;
__tmp__121 = this._invInertia10 * this._transform._rotation20 + this._invInertia11 * this._transform._rotation21 + this._invInertia12 * this._transform._rotation22;
__tmp__201 = this._invInertia20 * this._transform._rotation00 + this._invInertia21 * this._transform._rotation01 + this._invInertia22 * this._transform._rotation02;
__tmp__211 = this._invInertia20 * this._transform._rotation10 + this._invInertia21 * this._transform._rotation11 + this._invInertia22 * this._transform._rotation12;
__tmp__221 = this._invInertia20 * this._transform._rotation20 + this._invInertia21 * this._transform._rotation21 + this._invInertia22 * this._transform._rotation22;
this._invInertia00 = __tmp__001;
this._invInertia01 = __tmp__011;
this._invInertia02 = __tmp__021;
this._invInertia10 = __tmp__101;
this._invInertia11 = __tmp__111;
this._invInertia12 = __tmp__121;
this._invInertia20 = __tmp__201;
this._invInertia21 = __tmp__211;
this._invInertia22 = __tmp__221;
this._invInertia00 *= this._rotFactor.x;
this._invInertia01 *= this._rotFactor.x;
this._invInertia02 *= this._rotFactor.x;
this._invInertia10 *= this._rotFactor.y;
this._invInertia11 *= this._rotFactor.y;
this._invInertia12 *= this._rotFactor.y;
this._invInertia20 *= this._rotFactor.z;
this._invInertia21 *= this._rotFactor.z;
this._invInertia22 *= this._rotFactor.z;
break;
}
}
_integratePseudoVelocity() {
if(this._pseudoVelX * this._pseudoVelX + this._pseudoVelY * this._pseudoVelY + this._pseudoVelZ * this._pseudoVelZ == 0 && this._angPseudoVelX * this._angPseudoVelX + this._angPseudoVelY * this._angPseudoVelY + this._angPseudoVelZ * this._angPseudoVelZ == 0) {
return;
}
switch(this._type) {
case 1:
this._pseudoVelX = 0;
this._pseudoVelY = 0;
this._pseudoVelZ = 0;
this._angPseudoVelX = 0;
this._angPseudoVelY = 0;
this._angPseudoVelZ = 0;
break;
case 0:case 2:
let translationX;
let translationY;
let translationZ;
let rotationX;
let rotationY;
let rotationZ;
translationX = this._pseudoVelX;
translationY = this._pseudoVelY;
translationZ = this._pseudoVelZ;
rotationX = this._angPseudoVelX;
rotationY = this._angPseudoVelY;
rotationZ = this._angPseudoVelZ;
this._pseudoVelX = 0;
this._pseudoVelY = 0;
this._pseudoVelZ = 0;
this._angPseudoVelX = 0;
this._angPseudoVelY = 0;
this._angPseudoVelZ = 0;
this._transform._positionX += translationX;
this._transform._positionY += translationY;
this._transform._positionZ += translationZ;
let theta = Math.sqrt(rotationX * rotationX + rotationY * rotationY + rotationZ * rotationZ);
let halfTheta = theta * 0.5;
let rotationToSinAxisFactor;
let cosHalfTheta;
if(halfTheta < 0.5) {
let ht2 = halfTheta * halfTheta;
rotationToSinAxisFactor = 0.5 * (1 - ht2 * 0.16666666666666666 + ht2 * ht2 * 0.0083333333333333332);
cosHalfTheta = 1 - ht2 * 0.5 + ht2 * ht2 * 0.041666666666666664;
} else {
rotationToSinAxisFactor = Math.sin(halfTheta) / theta;
cosHalfTheta = Math.cos(halfTheta);
}
let sinAxisX;
let sinAxisY;
let sinAxisZ;
sinAxisX = rotationX * rotationToSinAxisFactor;
sinAxisY = rotationY * rotationToSinAxisFactor;
sinAxisZ = rotationZ * rotationToSinAxisFactor;
let dqX;
let dqY;
let dqZ;
let dqW;
dqX = sinAxisX;
dqY = sinAxisY;
dqZ = sinAxisZ;
dqW = cosHalfTheta;
let qX;
let qY;
let qZ;
let qW;
let e00 = this._transform._rotation00;
let e11 = this._transform._rotation11;
let e22 = this._transform._rotation22;
let t = e00 + e11 + e22;
let s;
if(t > 0) {
s = Math.sqrt(t + 1);
qW = 0.5 * s;
s = 0.5 / s;
qX = (this._transform._rotation21 - this._transform._rotation12) * s;
qY = (this._transform._rotation02 - this._transform._rotation20) * s;
qZ = (this._transform._rotation10 - this._transform._rotation01) * s;
} else if(e00 > e11) {
if(e00 > e22) {
s = Math.sqrt(e00 - e11 - e22 + 1);
qX = 0.5 * s;
s = 0.5 / s;
qY = (this._transform._rotation01 + this._transform._rotation10) * s;
qZ = (this._transform._rotation02 + this._transform._rotation20) * s;
qW = (this._transform._rotation21 - this._transform._rotation12) * s;
} else {
s = Math.sqrt(e22 - e00 - e11 + 1);
qZ = 0.5 * s;
s = 0.5 / s;
qX = (this._transform._rotation02 + this._transform._rotation20) * s;
qY = (this._transform._rotation12 + this._transform._rotation21) * s;
qW = (this._transform._rotation10 - this._transform._rotation01) * s;
}
} else if(e11 > e22) {
s = Math.sqrt(e11 - e22 - e00 + 1);
qY = 0.5 * s;
s = 0.5 / s;
qX = (this._transform._rotation01 + this._transform._rotation10) * s;
qZ = (this._transform._rotation12 + this._transform._rotation21) * s;
qW = (this._transform._rotation02 - this._transform._rotation20) * s;
} else {
s = Math.sqrt(e22 - e00 - e11 + 1);
qZ = 0.5 * s;
s = 0.5 / s;
qX = (this._transform._rotation02 + this._transform._rotation20) * s;
qY = (this._transform._rotation12 + this._transform._rotation21) * s;
qW = (this._transform._rotation10 - this._transform._rotation01) * s;
}
qX = dqW * qX + dqX * qW + dqY * qZ - dqZ * qY;
qY = dqW * qY - dqX * qZ + dqY * qW + dqZ * qX;
qZ = dqW * qZ + dqX * qY - dqY * qX + dqZ * qW;
qW = dqW * qW - dqX * qX - dqY * qY - dqZ * qZ;
let l = qX * qX + qY * qY + qZ * qZ + qW * qW;
if(l > 1e-32) {
l = 1 / Math.sqrt(l);
}
qX *= l;
qY *= l;
qZ *= l;
qW *= l;
let x = qX;
let y = qY;
let z = qZ;
let w = qW;
let x2 = 2 * x;
let y2 = 2 * y;
let z2 = 2 * z;
let xx = x * x2;
let yy = y * y2;
let zz = z * z2;
let xy = x * y2;
let yz = y * z2;
let xz = x * z2;
let wx = w * x2;
let wy = w * y2;
let wz = w * z2;
this._transform._rotation00 = 1 - yy - zz;
this._transform._rotation01 = xy - wz;
this._transform._rotation02 = xz + wy;
this._transform._rotation10 = xy + wz;
this._transform._rotation11 = 1 - xx - zz;
this._transform._rotation12 = yz - wx;
this._transform._rotation20 = xz - wy;
this._transform._rotation21 = yz + wx;
this._transform._rotation22 = 1 - xx - yy;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = this._transform._rotation00 * this._invLocalInertia00 + this._transform._rotation01 * this._invLocalInertia10 + this._transform._rotation02 * this._invLocalInertia20;
__tmp__01 = this._transform._rotation00 * this._invLocalInertia01 + this._transform._rotation01 * this._invLocalInertia11 + this._transform._rotation02 * this._invLocalInertia21;
__tmp__02 = this._transform._rotation00 * this._invLocalInertia02 + this._transform._rotation01 * this._invLocalInertia12 + this._transform._rotation02 * this._invLocalInertia22;
__tmp__10 = this._transform._rotation10 * this._invLocalInertia00 + this._transform._rotation11 * this._invLocalInertia10 + this._transform._rotation12 * this._invLocalInertia20;
__tmp__11 = this._transform._rotation10 * this._invLocalInertia01 + this._transform._rotation11 * this._invLocalInertia11 + this._transform._rotation12 * this._invLocalInertia21;
__tmp__12 = this._transform._rotation10 * this._invLocalInertia02 + this._transform._rotation11 * this._invLocalInertia12 + this._transform._rotation12 * this._invLocalInertia22;
__tmp__20 = this._transform._rotation20 * this._invLocalInertia00 + this._transform._rotation21 * this._invLocalInertia10 + this._transform._rotation22 * this._invLocalInertia20;
__tmp__21 = this._transform._rotation20 * this._invLocalInertia01 + this._transform._rotation21 * this._invLocalInertia11 + this._transform._rotation22 * this._invLocalInertia21;
__tmp__22 = this._transform._rotation20 * this._invLocalInertia02 + this._transform._rotation21 * this._invLocalInertia12 + this._transform._rotation22 * this._invLocalInertia22;
this._invInertia00 = __tmp__00;
this._invInertia01 = __tmp__01;
this._invInertia02 = __tmp__02;
this._invInertia10 = __tmp__10;
this._invInertia11 = __tmp__11;
this._invInertia12 = __tmp__12;
this._invInertia20 = __tmp__20;
this._invInertia21 = __tmp__21;
this._invInertia22 = __tmp__22;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = this._invInertia00 * this._transform._rotation00 + this._invInertia01 * this._transform._rotation01 + this._invInertia02 * this._transform._rotation02;
__tmp__011 = this._invInertia00 * this._transform._rotation10 + this._invInertia01 * this._transform._rotation11 + this._invInertia02 * this._transform._rotation12;
__tmp__021 = this._invInertia00 * this._transform._rotation20 + this._invInertia01 * this._transform._rotation21 + this._invInertia02 * this._transform._rotation22;
__tmp__101 = this._invInertia10 * this._transform._rotation00 + this._invInertia11 * this._transform._rotation01 + this._invInertia12 * this._transform._rotation02;
__tmp__111 = this._invInertia10 * this._transform._rotation10 + this._invInertia11 * this._transform._rotation11 + this._invInertia12 * this._transform._rotation12;
__tmp__121 = this._invInertia10 * this._transform._rotation20 + this._invInertia11 * this._transform._rotation21 + this._invInertia12 * this._transform._rotation22;
__tmp__201 = this._invInertia20 * this._transform._rotation00 + this._invInertia21 * this._transform._rotation01 + this._invInertia22 * this._transform._rotation02;
__tmp__211 = this._invInertia20 * this._transform._rotation10 + this._invInertia21 * this._transform._rotation11 + this._invInertia22 * this._transform._rotation12;
__tmp__221 = this._invInertia20 * this._transform._rotation20 + this._invInertia21 * this._transform._rotation21 + this._invInertia22 * this._transform._rotation22;
this._invInertia00 = __tmp__001;
this._invInertia01 = __tmp__011;
this._invInertia02 = __tmp__021;
this._invInertia10 = __tmp__101;
this._invInertia11 = __tmp__111;
this._invInertia12 = __tmp__121;
this._invInertia20 = __tmp__201;
this._invInertia21 = __tmp__211;
this._invInertia22 = __tmp__221;
this._invInertia00 *= this._rotFactor.x;
this._invInertia01 *= this._rotFactor.x;
this._invInertia02 *= this._rotFactor.x;
this._invInertia10 *= this._rotFactor.y;
this._invInertia11 *= this._rotFactor.y;
this._invInertia12 *= this._rotFactor.y;
this._invInertia20 *= this._rotFactor.z;
this._invInertia21 *= this._rotFactor.z;
this._invInertia22 *= this._rotFactor.z;
break;
}
}
updateMass() {
let totalInertia00;
let totalInertia01;
let totalInertia02;
let totalInertia10;
let totalInertia11;
let totalInertia12;
let totalInertia20;
let totalInertia21;
let totalInertia22;
totalInertia00 = 0;
totalInertia01 = 0;
totalInertia02 = 0;
totalInertia10 = 0;
totalInertia11 = 0;
totalInertia12 = 0;
totalInertia20 = 0;
totalInertia21 = 0;
totalInertia22 = 0;
let totalMass = 0;
let s = this._shapeList;
while(s != null) {
let n = s._next;
let g = s._geom;
g._updateMass();
let mass = s._density * g._volume;
let inertia00;
let inertia01;
let inertia02;
let inertia10;
let inertia11;
let inertia12;
let inertia20;
let inertia21;
let inertia22;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = s._localTransform._rotation00 * g._inertiaCoeff00 + s._localTransform._rotation01 * g._inertiaCoeff10 + s._localTransform._rotation02 * g._inertiaCoeff20;
__tmp__01 = s._localTransform._rotation00 * g._inertiaCoeff01 + s._localTransform._rotation01 * g._inertiaCoeff11 + s._localTransform._rotation02 * g._inertiaCoeff21;
__tmp__02 = s._localTransform._rotation00 * g._inertiaCoeff02 + s._localTransform._rotation01 * g._inertiaCoeff12 + s._localTransform._rotation02 * g._inertiaCoeff22;
__tmp__10 = s._localTransform._rotation10 * g._inertiaCoeff00 + s._localTransform._rotation11 * g._inertiaCoeff10 + s._localTransform._rotation12 * g._inertiaCoeff20;
__tmp__11 = s._localTransform._rotation10 * g._inertiaCoeff01 + s._localTransform._rotation11 * g._inertiaCoeff11 + s._localTransform._rotation12 * g._inertiaCoeff21;
__tmp__12 = s._localTransform._rotation10 * g._inertiaCoeff02 + s._localTransform._rotation11 * g._inertiaCoeff12 + s._localTransform._rotation12 * g._inertiaCoeff22;
__tmp__20 = s._localTransform._rotation20 * g._inertiaCoeff00 + s._localTransform._rotation21 * g._inertiaCoeff10 + s._localTransform._rotation22 * g._inertiaCoeff20;
__tmp__21 = s._localTransform._rotation20 * g._inertiaCoeff01 + s._localTransform._rotation21 * g._inertiaCoeff11 + s._localTransform._rotation22 * g._inertiaCoeff21;
__tmp__22 = s._localTransform._rotation20 * g._inertiaCoeff02 + s._localTransform._rotation21 * g._inertiaCoeff12 + s._localTransform._rotation22 * g._inertiaCoeff22;
inertia00 = __tmp__00;
inertia01 = __tmp__01;
inertia02 = __tmp__02;
inertia10 = __tmp__10;
inertia11 = __tmp__11;
inertia12 = __tmp__12;
inertia20 = __tmp__20;
inertia21 = __tmp__21;
inertia22 = __tmp__22;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = inertia00 * s._localTransform._rotation00 + inertia01 * s._localTransform._rotation01 + inertia02 * s._localTransform._rotation02;
__tmp__011 = inertia00 * s._localTransform._rotation10 + inertia01 * s._localTransform._rotation11 + inertia02 * s._localTransform._rotation12;
__tmp__021 = inertia00 * s._localTransform._rotation20 + inertia01 * s._localTransform._rotation21 + inertia02 * s._localTransform._rotation22;
__tmp__101 = inertia10 * s._localTransform._rotation00 + inertia11 * s._localTransform._rotation01 + inertia12 * s._localTransform._rotation02;
__tmp__111 = inertia10 * s._localTransform._rotation10 + inertia11 * s._localTransform._rotation11 + inertia12 * s._localTransform._rotation12;
__tmp__121 = inertia10 * s._localTransform._rotation20 + inertia11 * s._localTransform._rotation21 + inertia12 * s._localTransform._rotation22;
__tmp__201 = inertia20 * s._localTransform._rotation00 + inertia21 * s._localTransform._rotation01 + inertia22 * s._localTransform._rotation02;
__tmp__211 = inertia20 * s._localTransform._rotation10 + inertia21 * s._localTransform._rotation11 + inertia22 * s._localTransform._rotation12;
__tmp__221 = inertia20 * s._localTransform._rotation20 + inertia21 * s._localTransform._rotation21 + inertia22 * s._localTransform._rotation22;
inertia00 = __tmp__001;
inertia01 = __tmp__011;
inertia02 = __tmp__021;
inertia10 = __tmp__101;
inertia11 = __tmp__111;
inertia12 = __tmp__121;
inertia20 = __tmp__201;
inertia21 = __tmp__211;
inertia22 = __tmp__221;
inertia00 *= mass;
inertia01 *= mass;
inertia02 *= mass;
inertia10 *= mass;
inertia11 *= mass;
inertia12 *= mass;
inertia20 *= mass;
inertia21 *= mass;
inertia22 *= mass;
let cogInertia00;
let cogInertia01;
let cogInertia02;
let cogInertia10;
let cogInertia11;
let cogInertia12;
let cogInertia20;
let cogInertia21;
let cogInertia22;
let xx = s._localTransform._positionX * s._localTransform._positionX;
let yy = s._localTransform._positionY * s._localTransform._positionY;
let zz = s._localTransform._positionZ * s._localTransform._positionZ;
let xy = -s._localTransform._positionX * s._localTransform._positionY;
let yz = -s._localTransform._positionY * s._localTransform._positionZ;
let zx = -s._localTransform._positionZ * s._localTransform._positionX;
cogInertia00 = yy + zz;
cogInertia01 = xy;
cogInertia02 = zx;
cogInertia10 = xy;
cogInertia11 = xx + zz;
cogInertia12 = yz;
cogInertia20 = zx;
cogInertia21 = yz;
cogInertia22 = xx + yy;
inertia00 += cogInertia00 * mass;
inertia01 += cogInertia01 * mass;
inertia02 += cogInertia02 * mass;
inertia10 += cogInertia10 * mass;
inertia11 += cogInertia11 * mass;
inertia12 += cogInertia12 * mass;
inertia20 += cogInertia20 * mass;
inertia21 += cogInertia21 * mass;
inertia22 += cogInertia22 * mass;
totalMass += mass;
totalInertia00 += inertia00;
totalInertia01 += inertia01;
totalInertia02 += inertia02;
totalInertia10 += inertia10;
totalInertia11 += inertia11;
totalInertia12 += inertia12;
totalInertia20 += inertia20;
totalInertia21 += inertia21;
totalInertia22 += inertia22;
s = n;
}
this._mass = totalMass;
this._localInertia00 = totalInertia00;
this._localInertia01 = totalInertia01;
this._localInertia02 = totalInertia02;
this._localInertia10 = totalInertia10;
this._localInertia11 = totalInertia11;
this._localInertia12 = totalInertia12;
this._localInertia20 = totalInertia20;
this._localInertia21 = totalInertia21;
this._localInertia22 = totalInertia22;
if(this._mass > 0 && this._localInertia00 * (this._localInertia11 * this._localInertia22 - this._localInertia12 * this._localInertia21) - this._localInertia01 * (this._localInertia10 * this._localInertia22 - this._localInertia12 * this._localInertia20) + this._localInertia02 * (this._localInertia10 * this._localInertia21 - this._localInertia11 * this._localInertia20) > 0 && this._type == 0) {
this._invMass = 1 / this._mass;
let d00 = this._localInertia11 * this._localInertia22 - this._localInertia12 * this._localInertia21;
let d01 = this._localInertia10 * this._localInertia22 - this._localInertia12 * this._localInertia20;
let d02 = this._localInertia10 * this._localInertia21 - this._localInertia11 * this._localInertia20;
let d = this._localInertia00 * d00 - this._localInertia01 * d01 + this._localInertia02 * d02;
if(d < -1e-32 || d > 1e-32) {
d = 1 / d;
}
this._invLocalInertia00 = d00 * d;
this._invLocalInertia01 = -(this._localInertia01 * this._localInertia22 - this._localInertia02 * this._localInertia21) * d;
this._invLocalInertia02 = (this._localInertia01 * this._localInertia12 - this._localInertia02 * this._localInertia11) * d;
this._invLocalInertia10 = -d01 * d;
this._invLocalInertia11 = (this._localInertia00 * this._localInertia22 - this._localInertia02 * this._localInertia20) * d;
this._invLocalInertia12 = -(this._localInertia00 * this._localInertia12 - this._localInertia02 * this._localInertia10) * d;
this._invLocalInertia20 = d02 * d;
this._invLocalInertia21 = -(this._localInertia00 * this._localInertia21 - this._localInertia01 * this._localInertia20) * d;
this._invLocalInertia22 = (this._localInertia00 * this._localInertia11 - this._localInertia01 * this._localInertia10) * d;
this._invLocalInertiaWithoutRotFactor00 = this._invLocalInertia00;
this._invLocalInertiaWithoutRotFactor01 = this._invLocalInertia01;
this._invLocalInertiaWithoutRotFactor02 = this._invLocalInertia02;
this._invLocalInertiaWithoutRotFactor10 = this._invLocalInertia10;
this._invLocalInertiaWithoutRotFactor11 = this._invLocalInertia11;
this._invLocalInertiaWithoutRotFactor12 = this._invLocalInertia12;
this._invLocalInertiaWithoutRotFactor20 = this._invLocalInertia20;
this._invLocalInertiaWithoutRotFactor21 = this._invLocalInertia21;
this._invLocalInertiaWithoutRotFactor22 = this._invLocalInertia22;
this._invLocalInertia00 = this._invLocalInertiaWithoutRotFactor00 * this._rotFactor.x;
this._invLocalInertia01 = this._invLocalInertiaWithoutRotFactor01 * this._rotFactor.x;
this._invLocalInertia02 = this._invLocalInertiaWithoutRotFactor02 * this._rotFactor.x;
this._invLocalInertia10 = this._invLocalInertiaWithoutRotFactor10 * this._rotFactor.y;
this._invLocalInertia11 = this._invLocalInertiaWithoutRotFactor11 * this._rotFactor.y;
this._invLocalInertia12 = this._invLocalInertiaWithoutRotFactor12 * this._rotFactor.y;
this._invLocalInertia20 = this._invLocalInertiaWithoutRotFactor20 * this._rotFactor.z;
this._invLocalInertia21 = this._invLocalInertiaWithoutRotFactor21 * this._rotFactor.z;
this._invLocalInertia22 = this._invLocalInertiaWithoutRotFactor22 * this._rotFactor.z;
} else {
this._invMass = 0;
this._invLocalInertia00 = 0;
this._invLocalInertia01 = 0;
this._invLocalInertia02 = 0;
this._invLocalInertia10 = 0;
this._invLocalInertia11 = 0;
this._invLocalInertia12 = 0;
this._invLocalInertia20 = 0;
this._invLocalInertia21 = 0;
this._invLocalInertia22 = 0;
this._invLocalInertiaWithoutRotFactor00 = 0;
this._invLocalInertiaWithoutRotFactor01 = 0;
this._invLocalInertiaWithoutRotFactor02 = 0;
this._invLocalInertiaWithoutRotFactor10 = 0;
this._invLocalInertiaWithoutRotFactor11 = 0;
this._invLocalInertiaWithoutRotFactor12 = 0;
this._invLocalInertiaWithoutRotFactor20 = 0;
this._invLocalInertiaWithoutRotFactor21 = 0;
this._invLocalInertiaWithoutRotFactor22 = 0;
if(this._type == 0) {
this._type = 1;
}
}
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = this._transform._rotation00 * this._invLocalInertia00 + this._transform._rotation01 * this._invLocalInertia10 + this._transform._rotation02 * this._invLocalInertia20;
__tmp__01 = this._transform._rotation00 * this._invLocalInertia01 + this._transform._rotation01 * this._invLocalInertia11 + this._transform._rotation02 * this._invLocalInertia21;
__tmp__02 = this._transform._rotation00 * this._invLocalInertia02 + this._transform._rotation01 * this._invLocalInertia12 + this._transform._rotation02 * this._invLocalInertia22;
__tmp__10 = this._transform._rotation10 * this._invLocalInertia00 + this._transform._rotation11 * this._invLocalInertia10 + this._transform._rotation12 * this._invLocalInertia20;
__tmp__11 = this._transform._rotation10 * this._invLocalInertia01 + this._transform._rotation11 * this._invLocalInertia11 + this._transform._rotation12 * this._invLocalInertia21;
__tmp__12 = this._transform._rotation10 * this._invLocalInertia02 + this._transform._rotation11 * this._invLocalInertia12 + this._transform._rotation12 * this._invLocalInertia22;
__tmp__20 = this._transform._rotation20 * this._invLocalInertia00 + this._transform._rotation21 * this._invLocalInertia10 + this._transform._rotation22 * this._invLocalInertia20;
__tmp__21 = this._transform._rotation20 * this._invLocalInertia01 + this._transform._rotation21 * this._invLocalInertia11 + this._transform._rotation22 * this._invLocalInertia21;
__tmp__22 = this._transform._rotation20 * this._invLocalInertia02 + this._transform._rotation21 * this._invLocalInertia12 + this._transform._rotation22 * this._invLocalInertia22;
this._invInertia00 = __tmp__00;
this._invInertia01 = __tmp__01;
this._invInertia02 = __tmp__02;
this._invInertia10 = __tmp__10;
this._invInertia11 = __tmp__11;
this._invInertia12 = __tmp__12;
this._invInertia20 = __tmp__20;
this._invInertia21 = __tmp__21;
this._invInertia22 = __tmp__22;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = this._invInertia00 * this._transform._rotation00 + this._invInertia01 * this._transform._rotation01 + this._invInertia02 * this._transform._rotation02;
__tmp__011 = this._invInertia00 * this._transform._rotation10 + this._invInertia01 * this._transform._rotation11 + this._invInertia02 * this._transform._rotation12;
__tmp__021 = this._invInertia00 * this._transform._rotation20 + this._invInertia01 * this._transform._rotation21 + this._invInertia02 * this._transform._rotation22;
__tmp__101 = this._invInertia10 * this._transform._rotation00 + this._invInertia11 * this._transform._rotation01 + this._invInertia12 * this._transform._rotation02;
__tmp__111 = this._invInertia10 * this._transform._rotation10 + this._invInertia11 * this._transform._rotation11 + this._invInertia12 * this._transform._rotation12;
__tmp__121 = this._invInertia10 * this._transform._rotation20 + this._invInertia11 * this._transform._rotation21 + this._invInertia12 * this._transform._rotation22;
__tmp__201 = this._invInertia20 * this._transform._rotation00 + this._invInertia21 * this._transform._rotation01 + this._invInertia22 * this._transform._rotation02;
__tmp__211 = this._invInertia20 * this._transform._rotation10 + this._invInertia21 * this._transform._rotation11 + this._invInertia22 * this._transform._rotation12;
__tmp__221 = this._invInertia20 * this._transform._rotation20 + this._invInertia21 * this._transform._rotation21 + this._invInertia22 * this._transform._rotation22;
this._invInertia00 = __tmp__001;
this._invInertia01 = __tmp__011;
this._invInertia02 = __tmp__021;
this._invInertia10 = __tmp__101;
this._invInertia11 = __tmp__111;
this._invInertia12 = __tmp__121;
this._invInertia20 = __tmp__201;
this._invInertia21 = __tmp__211;
this._invInertia22 = __tmp__221;
this._invInertia00 *= this._rotFactor.x;
this._invInertia01 *= this._rotFactor.x;
this._invInertia02 *= this._rotFactor.x;
this._invInertia10 *= this._rotFactor.y;
this._invInertia11 *= this._rotFactor.y;
this._invInertia12 *= this._rotFactor.y;
this._invInertia20 *= this._rotFactor.z;
this._invInertia21 *= this._rotFactor.z;
this._invInertia22 *= this._rotFactor.z;
this._sleeping = false;
this._sleepTime = 0;
}
getPosition() {
let v = new oimo.common.Vec3();
v.x = this._transform._positionX;
v.y = this._transform._positionY;
v.z = this._transform._positionZ;
return v;
}
getPositionTo(position) {
position.x = this._transform._positionX;
position.y = this._transform._positionY;
position.z = this._transform._positionZ;
}
setPosition(position) {
this._transform._positionX = position.x;
this._transform._positionY = position.y;
this._transform._positionZ = position.z;
let dst = this._ptransform;
let src = this._transform;
dst._positionX = src._positionX;
dst._positionY = src._positionY;
dst._positionZ = src._positionZ;
dst._rotation00 = src._rotation00;
dst._rotation01 = src._rotation01;
dst._rotation02 = src._rotation02;
dst._rotation10 = src._rotation10;
dst._rotation11 = src._rotation11;
dst._rotation12 = src._rotation12;
dst._rotation20 = src._rotation20;
dst._rotation21 = src._rotation21;
dst._rotation22 = src._rotation22;
let s = this._shapeList;
while(s != null) {
let n = s._next;
let tf1 = this._ptransform;
let tf2 = this._transform;
let dst = s._ptransform;
let src1 = s._localTransform;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = tf1._rotation00 * src1._rotation00 + tf1._rotation01 * src1._rotation10 + tf1._rotation02 * src1._rotation20;
__tmp__01 = tf1._rotation00 * src1._rotation01 + tf1._rotation01 * src1._rotation11 + tf1._rotation02 * src1._rotation21;
__tmp__02 = tf1._rotation00 * src1._rotation02 + tf1._rotation01 * src1._rotation12 + tf1._rotation02 * src1._rotation22;
__tmp__10 = tf1._rotation10 * src1._rotation00 + tf1._rotation11 * src1._rotation10 + tf1._rotation12 * src1._rotation20;
__tmp__11 = tf1._rotation10 * src1._rotation01 + tf1._rotation11 * src1._rotation11 + tf1._rotation12 * src1._rotation21;
__tmp__12 = tf1._rotation10 * src1._rotation02 + tf1._rotation11 * src1._rotation12 + tf1._rotation12 * src1._rotation22;
__tmp__20 = tf1._rotation20 * src1._rotation00 + tf1._rotation21 * src1._rotation10 + tf1._rotation22 * src1._rotation20;
__tmp__21 = tf1._rotation20 * src1._rotation01 + tf1._rotation21 * src1._rotation11 + tf1._rotation22 * src1._rotation21;
__tmp__22 = tf1._rotation20 * src1._rotation02 + tf1._rotation21 * src1._rotation12 + tf1._rotation22 * src1._rotation22;
dst._rotation00 = __tmp__00;
dst._rotation01 = __tmp__01;
dst._rotation02 = __tmp__02;
dst._rotation10 = __tmp__10;
dst._rotation11 = __tmp__11;
dst._rotation12 = __tmp__12;
dst._rotation20 = __tmp__20;
dst._rotation21 = __tmp__21;
dst._rotation22 = __tmp__22;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = tf1._rotation00 * src1._positionX + tf1._rotation01 * src1._positionY + tf1._rotation02 * src1._positionZ;
__tmp__Y = tf1._rotation10 * src1._positionX + tf1._rotation11 * src1._positionY + tf1._rotation12 * src1._positionZ;
__tmp__Z = tf1._rotation20 * src1._positionX + tf1._rotation21 * src1._positionY + tf1._rotation22 * src1._positionZ;
dst._positionX = __tmp__X;
dst._positionY = __tmp__Y;
dst._positionZ = __tmp__Z;
dst._positionX += tf1._positionX;
dst._positionY += tf1._positionY;
dst._positionZ += tf1._positionZ;
let dst1 = s._transform;
let src11 = s._localTransform;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = tf2._rotation00 * src11._rotation00 + tf2._rotation01 * src11._rotation10 + tf2._rotation02 * src11._rotation20;
__tmp__011 = tf2._rotation00 * src11._rotation01 + tf2._rotation01 * src11._rotation11 + tf2._rotation02 * src11._rotation21;
__tmp__021 = tf2._rotation00 * src11._rotation02 + tf2._rotation01 * src11._rotation12 + tf2._rotation02 * src11._rotation22;
__tmp__101 = tf2._rotation10 * src11._rotation00 + tf2._rotation11 * src11._rotation10 + tf2._rotation12 * src11._rotation20;
__tmp__111 = tf2._rotation10 * src11._rotation01 + tf2._rotation11 * src11._rotation11 + tf2._rotation12 * src11._rotation21;
__tmp__121 = tf2._rotation10 * src11._rotation02 + tf2._rotation11 * src11._rotation12 + tf2._rotation12 * src11._rotation22;
__tmp__201 = tf2._rotation20 * src11._rotation00 + tf2._rotation21 * src11._rotation10 + tf2._rotation22 * src11._rotation20;
__tmp__211 = tf2._rotation20 * src11._rotation01 + tf2._rotation21 * src11._rotation11 + tf2._rotation22 * src11._rotation21;
__tmp__221 = tf2._rotation20 * src11._rotation02 + tf2._rotation21 * src11._rotation12 + tf2._rotation22 * src11._rotation22;
dst1._rotation00 = __tmp__001;
dst1._rotation01 = __tmp__011;
dst1._rotation02 = __tmp__021;
dst1._rotation10 = __tmp__101;
dst1._rotation11 = __tmp__111;
dst1._rotation12 = __tmp__121;
dst1._rotation20 = __tmp__201;
dst1._rotation21 = __tmp__211;
dst1._rotation22 = __tmp__221;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = tf2._rotation00 * src11._positionX + tf2._rotation01 * src11._positionY + tf2._rotation02 * src11._positionZ;
__tmp__Y1 = tf2._rotation10 * src11._positionX + tf2._rotation11 * src11._positionY + tf2._rotation12 * src11._positionZ;
__tmp__Z1 = tf2._rotation20 * src11._positionX + tf2._rotation21 * src11._positionY + tf2._rotation22 * src11._positionZ;
dst1._positionX = __tmp__X1;
dst1._positionY = __tmp__Y1;
dst1._positionZ = __tmp__Z1;
dst1._positionX += tf2._positionX;
dst1._positionY += tf2._positionY;
dst1._positionZ += tf2._positionZ;
let minX;
let minY;
let minZ;
let maxX;
let maxY;
let maxZ;
s._geom._computeAabb(s._aabb,s._ptransform);
minX = s._aabb._minX;
minY = s._aabb._minY;
minZ = s._aabb._minZ;
maxX = s._aabb._maxX;
maxY = s._aabb._maxY;
maxZ = s._aabb._maxZ;
s._geom._computeAabb(s._aabb,s._transform);
s._aabb._minX = minX < s._aabb._minX ? minX : s._aabb._minX;
s._aabb._minY = minY < s._aabb._minY ? minY : s._aabb._minY;
s._aabb._minZ = minZ < s._aabb._minZ ? minZ : s._aabb._minZ;
s._aabb._maxX = maxX > s._aabb._maxX ? maxX : s._aabb._maxX;
s._aabb._maxY = maxY > s._aabb._maxY ? maxY : s._aabb._maxY;
s._aabb._maxZ = maxZ > s._aabb._maxZ ? maxZ : s._aabb._maxZ;
if(s._proxy != null) {
let dX;
let dY;
let dZ;
dX = s._transform._positionX - s._ptransform._positionX;
dY = s._transform._positionY - s._ptransform._positionY;
dZ = s._transform._positionZ - s._ptransform._positionZ;
let v = s.displacement;
v.x = dX;
v.y = dY;
v.z = dZ;
s._rigidBody._world._broadPhase.moveProxy(s._proxy,s._aabb,s.displacement);
}
s = n;
}
this._sleeping = false;
this._sleepTime = 0;
}
translate(translation) {
let diffX;
let diffY;
let diffZ;
diffX = translation.x;
diffY = translation.y;
diffZ = translation.z;
this._transform._positionX += diffX;
this._transform._positionY += diffY;
this._transform._positionZ += diffZ;
let dst = this._ptransform;
let src = this._transform;
dst._positionX = src._positionX;
dst._positionY = src._positionY;
dst._positionZ = src._positionZ;
dst._rotation00 = src._rotation00;
dst._rotation01 = src._rotation01;
dst._rotation02 = src._rotation02;
dst._rotation10 = src._rotation10;
dst._rotation11 = src._rotation11;
dst._rotation12 = src._rotation12;
dst._rotation20 = src._rotation20;
dst._rotation21 = src._rotation21;
dst._rotation22 = src._rotation22;
let s = this._shapeList;
while(s != null) {
let n = s._next;
let tf1 = this._ptransform;
let tf2 = this._transform;
let dst = s._ptransform;
let src1 = s._localTransform;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = tf1._rotation00 * src1._rotation00 + tf1._rotation01 * src1._rotation10 + tf1._rotation02 * src1._rotation20;
__tmp__01 = tf1._rotation00 * src1._rotation01 + tf1._rotation01 * src1._rotation11 + tf1._rotation02 * src1._rotation21;
__tmp__02 = tf1._rotation00 * src1._rotation02 + tf1._rotation01 * src1._rotation12 + tf1._rotation02 * src1._rotation22;
__tmp__10 = tf1._rotation10 * src1._rotation00 + tf1._rotation11 * src1._rotation10 + tf1._rotation12 * src1._rotation20;
__tmp__11 = tf1._rotation10 * src1._rotation01 + tf1._rotation11 * src1._rotation11 + tf1._rotation12 * src1._rotation21;
__tmp__12 = tf1._rotation10 * src1._rotation02 + tf1._rotation11 * src1._rotation12 + tf1._rotation12 * src1._rotation22;
__tmp__20 = tf1._rotation20 * src1._rotation00 + tf1._rotation21 * src1._rotation10 + tf1._rotation22 * src1._rotation20;
__tmp__21 = tf1._rotation20 * src1._rotation01 + tf1._rotation21 * src1._rotation11 + tf1._rotation22 * src1._rotation21;
__tmp__22 = tf1._rotation20 * src1._rotation02 + tf1._rotation21 * src1._rotation12 + tf1._rotation22 * src1._rotation22;
dst._rotation00 = __tmp__00;
dst._rotation01 = __tmp__01;
dst._rotation02 = __tmp__02;
dst._rotation10 = __tmp__10;
dst._rotation11 = __tmp__11;
dst._rotation12 = __tmp__12;
dst._rotation20 = __tmp__20;
dst._rotation21 = __tmp__21;
dst._rotation22 = __tmp__22;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = tf1._rotation00 * src1._positionX + tf1._rotation01 * src1._positionY + tf1._rotation02 * src1._positionZ;
__tmp__Y = tf1._rotation10 * src1._positionX + tf1._rotation11 * src1._positionY + tf1._rotation12 * src1._positionZ;
__tmp__Z = tf1._rotation20 * src1._positionX + tf1._rotation21 * src1._positionY + tf1._rotation22 * src1._positionZ;
dst._positionX = __tmp__X;
dst._positionY = __tmp__Y;
dst._positionZ = __tmp__Z;
dst._positionX += tf1._positionX;
dst._positionY += tf1._positionY;
dst._positionZ += tf1._positionZ;
let dst1 = s._transform;
let src11 = s._localTransform;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = tf2._rotation00 * src11._rotation00 + tf2._rotation01 * src11._rotation10 + tf2._rotation02 * src11._rotation20;
__tmp__011 = tf2._rotation00 * src11._rotation01 + tf2._rotation01 * src11._rotation11 + tf2._rotation02 * src11._rotation21;
__tmp__021 = tf2._rotation00 * src11._rotation02 + tf2._rotation01 * src11._rotation12 + tf2._rotation02 * src11._rotation22;
__tmp__101 = tf2._rotation10 * src11._rotation00 + tf2._rotation11 * src11._rotation10 + tf2._rotation12 * src11._rotation20;
__tmp__111 = tf2._rotation10 * src11._rotation01 + tf2._rotation11 * src11._rotation11 + tf2._rotation12 * src11._rotation21;
__tmp__121 = tf2._rotation10 * src11._rotation02 + tf2._rotation11 * src11._rotation12 + tf2._rotation12 * src11._rotation22;
__tmp__201 = tf2._rotation20 * src11._rotation00 + tf2._rotation21 * src11._rotation10 + tf2._rotation22 * src11._rotation20;
__tmp__211 = tf2._rotation20 * src11._rotation01 + tf2._rotation21 * src11._rotation11 + tf2._rotation22 * src11._rotation21;
__tmp__221 = tf2._rotation20 * src11._rotation02 + tf2._rotation21 * src11._rotation12 + tf2._rotation22 * src11._rotation22;
dst1._rotation00 = __tmp__001;
dst1._rotation01 = __tmp__011;
dst1._rotation02 = __tmp__021;
dst1._rotation10 = __tmp__101;
dst1._rotation11 = __tmp__111;
dst1._rotation12 = __tmp__121;
dst1._rotation20 = __tmp__201;
dst1._rotation21 = __tmp__211;
dst1._rotation22 = __tmp__221;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = tf2._rotation00 * src11._positionX + tf2._rotation01 * src11._positionY + tf2._rotation02 * src11._positionZ;
__tmp__Y1 = tf2._rotation10 * src11._positionX + tf2._rotation11 * src11._positionY + tf2._rotation12 * src11._positionZ;
__tmp__Z1 = tf2._rotation20 * src11._positionX + tf2._rotation21 * src11._positionY + tf2._rotation22 * src11._positionZ;
dst1._positionX = __tmp__X1;
dst1._positionY = __tmp__Y1;
dst1._positionZ = __tmp__Z1;
dst1._positionX += tf2._positionX;
dst1._positionY += tf2._positionY;
dst1._positionZ += tf2._positionZ;
let minX;
let minY;
let minZ;
let maxX;
let maxY;
let maxZ;
s._geom._computeAabb(s._aabb,s._ptransform);
minX = s._aabb._minX;
minY = s._aabb._minY;
minZ = s._aabb._minZ;
maxX = s._aabb._maxX;
maxY = s._aabb._maxY;
maxZ = s._aabb._maxZ;
s._geom._computeAabb(s._aabb,s._transform);
s._aabb._minX = minX < s._aabb._minX ? minX : s._aabb._minX;
s._aabb._minY = minY < s._aabb._minY ? minY : s._aabb._minY;
s._aabb._minZ = minZ < s._aabb._minZ ? minZ : s._aabb._minZ;
s._aabb._maxX = maxX > s._aabb._maxX ? maxX : s._aabb._maxX;
s._aabb._maxY = maxY > s._aabb._maxY ? maxY : s._aabb._maxY;
s._aabb._maxZ = maxZ > s._aabb._maxZ ? maxZ : s._aabb._maxZ;
if(s._proxy != null) {
let dX;
let dY;
let dZ;
dX = s._transform._positionX - s._ptransform._positionX;
dY = s._transform._positionY - s._ptransform._positionY;
dZ = s._transform._positionZ - s._ptransform._positionZ;
let v = s.displacement;
v.x = dX;
v.y = dY;
v.z = dZ;
s._rigidBody._world._broadPhase.moveProxy(s._proxy,s._aabb,s.displacement);
}
s = n;
}
this._sleeping = false;
this._sleepTime = 0;
}
getRotation() {
let m = new oimo.common.Mat3();
m.e00 = this._transform._rotation00;
m.e01 = this._transform._rotation01;
m.e02 = this._transform._rotation02;
m.e10 = this._transform._rotation10;
m.e11 = this._transform._rotation11;
m.e12 = this._transform._rotation12;
m.e20 = this._transform._rotation20;
m.e21 = this._transform._rotation21;
m.e22 = this._transform._rotation22;
return m;
}
getRotationTo(rotation) {
rotation.e00 = this._transform._rotation00;
rotation.e01 = this._transform._rotation01;
rotation.e02 = this._transform._rotation02;
rotation.e10 = this._transform._rotation10;
rotation.e11 = this._transform._rotation11;
rotation.e12 = this._transform._rotation12;
rotation.e20 = this._transform._rotation20;
rotation.e21 = this._transform._rotation21;
rotation.e22 = this._transform._rotation22;
}
setRotation(rotation) {
this._transform._rotation00 = rotation.e00;
this._transform._rotation01 = rotation.e01;
this._transform._rotation02 = rotation.e02;
this._transform._rotation10 = rotation.e10;
this._transform._rotation11 = rotation.e11;
this._transform._rotation12 = rotation.e12;
this._transform._rotation20 = rotation.e20;
this._transform._rotation21 = rotation.e21;
this._transform._rotation22 = rotation.e22;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = this._transform._rotation00 * this._invLocalInertia00 + this._transform._rotation01 * this._invLocalInertia10 + this._transform._rotation02 * this._invLocalInertia20;
__tmp__01 = this._transform._rotation00 * this._invLocalInertia01 + this._transform._rotation01 * this._invLocalInertia11 + this._transform._rotation02 * this._invLocalInertia21;
__tmp__02 = this._transform._rotation00 * this._invLocalInertia02 + this._transform._rotation01 * this._invLocalInertia12 + this._transform._rotation02 * this._invLocalInertia22;
__tmp__10 = this._transform._rotation10 * this._invLocalInertia00 + this._transform._rotation11 * this._invLocalInertia10 + this._transform._rotation12 * this._invLocalInertia20;
__tmp__11 = this._transform._rotation10 * this._invLocalInertia01 + this._transform._rotation11 * this._invLocalInertia11 + this._transform._rotation12 * this._invLocalInertia21;
__tmp__12 = this._transform._rotation10 * this._invLocalInertia02 + this._transform._rotation11 * this._invLocalInertia12 + this._transform._rotation12 * this._invLocalInertia22;
__tmp__20 = this._transform._rotation20 * this._invLocalInertia00 + this._transform._rotation21 * this._invLocalInertia10 + this._transform._rotation22 * this._invLocalInertia20;
__tmp__21 = this._transform._rotation20 * this._invLocalInertia01 + this._transform._rotation21 * this._invLocalInertia11 + this._transform._rotation22 * this._invLocalInertia21;
__tmp__22 = this._transform._rotation20 * this._invLocalInertia02 + this._transform._rotation21 * this._invLocalInertia12 + this._transform._rotation22 * this._invLocalInertia22;
this._invInertia00 = __tmp__00;
this._invInertia01 = __tmp__01;
this._invInertia02 = __tmp__02;
this._invInertia10 = __tmp__10;
this._invInertia11 = __tmp__11;
this._invInertia12 = __tmp__12;
this._invInertia20 = __tmp__20;
this._invInertia21 = __tmp__21;
this._invInertia22 = __tmp__22;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = this._invInertia00 * this._transform._rotation00 + this._invInertia01 * this._transform._rotation01 + this._invInertia02 * this._transform._rotation02;
__tmp__011 = this._invInertia00 * this._transform._rotation10 + this._invInertia01 * this._transform._rotation11 + this._invInertia02 * this._transform._rotation12;
__tmp__021 = this._invInertia00 * this._transform._rotation20 + this._invInertia01 * this._transform._rotation21 + this._invInertia02 * this._transform._rotation22;
__tmp__101 = this._invInertia10 * this._transform._rotation00 + this._invInertia11 * this._transform._rotation01 + this._invInertia12 * this._transform._rotation02;
__tmp__111 = this._invInertia10 * this._transform._rotation10 + this._invInertia11 * this._transform._rotation11 + this._invInertia12 * this._transform._rotation12;
__tmp__121 = this._invInertia10 * this._transform._rotation20 + this._invInertia11 * this._transform._rotation21 + this._invInertia12 * this._transform._rotation22;
__tmp__201 = this._invInertia20 * this._transform._rotation00 + this._invInertia21 * this._transform._rotation01 + this._invInertia22 * this._transform._rotation02;
__tmp__211 = this._invInertia20 * this._transform._rotation10 + this._invInertia21 * this._transform._rotation11 + this._invInertia22 * this._transform._rotation12;
__tmp__221 = this._invInertia20 * this._transform._rotation20 + this._invInertia21 * this._transform._rotation21 + this._invInertia22 * this._transform._rotation22;
this._invInertia00 = __tmp__001;
this._invInertia01 = __tmp__011;
this._invInertia02 = __tmp__021;
this._invInertia10 = __tmp__101;
this._invInertia11 = __tmp__111;
this._invInertia12 = __tmp__121;
this._invInertia20 = __tmp__201;
this._invInertia21 = __tmp__211;
this._invInertia22 = __tmp__221;
this._invInertia00 *= this._rotFactor.x;
this._invInertia01 *= this._rotFactor.x;
this._invInertia02 *= this._rotFactor.x;
this._invInertia10 *= this._rotFactor.y;
this._invInertia11 *= this._rotFactor.y;
this._invInertia12 *= this._rotFactor.y;
this._invInertia20 *= this._rotFactor.z;
this._invInertia21 *= this._rotFactor.z;
this._invInertia22 *= this._rotFactor.z;
let dst = this._ptransform;
let src = this._transform;
dst._positionX = src._positionX;
dst._positionY = src._positionY;
dst._positionZ = src._positionZ;
dst._rotation00 = src._rotation00;
dst._rotation01 = src._rotation01;
dst._rotation02 = src._rotation02;
dst._rotation10 = src._rotation10;
dst._rotation11 = src._rotation11;
dst._rotation12 = src._rotation12;
dst._rotation20 = src._rotation20;
dst._rotation21 = src._rotation21;
dst._rotation22 = src._rotation22;
let s = this._shapeList;
while(s != null) {
let n = s._next;
let tf1 = this._ptransform;
let tf2 = this._transform;
let dst = s._ptransform;
let src1 = s._localTransform;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = tf1._rotation00 * src1._rotation00 + tf1._rotation01 * src1._rotation10 + tf1._rotation02 * src1._rotation20;
__tmp__01 = tf1._rotation00 * src1._rotation01 + tf1._rotation01 * src1._rotation11 + tf1._rotation02 * src1._rotation21;
__tmp__02 = tf1._rotation00 * src1._rotation02 + tf1._rotation01 * src1._rotation12 + tf1._rotation02 * src1._rotation22;
__tmp__10 = tf1._rotation10 * src1._rotation00 + tf1._rotation11 * src1._rotation10 + tf1._rotation12 * src1._rotation20;
__tmp__11 = tf1._rotation10 * src1._rotation01 + tf1._rotation11 * src1._rotation11 + tf1._rotation12 * src1._rotation21;
__tmp__12 = tf1._rotation10 * src1._rotation02 + tf1._rotation11 * src1._rotation12 + tf1._rotation12 * src1._rotation22;
__tmp__20 = tf1._rotation20 * src1._rotation00 + tf1._rotation21 * src1._rotation10 + tf1._rotation22 * src1._rotation20;
__tmp__21 = tf1._rotation20 * src1._rotation01 + tf1._rotation21 * src1._rotation11 + tf1._rotation22 * src1._rotation21;
__tmp__22 = tf1._rotation20 * src1._rotation02 + tf1._rotation21 * src1._rotation12 + tf1._rotation22 * src1._rotation22;
dst._rotation00 = __tmp__00;
dst._rotation01 = __tmp__01;
dst._rotation02 = __tmp__02;
dst._rotation10 = __tmp__10;
dst._rotation11 = __tmp__11;
dst._rotation12 = __tmp__12;
dst._rotation20 = __tmp__20;
dst._rotation21 = __tmp__21;
dst._rotation22 = __tmp__22;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = tf1._rotation00 * src1._positionX + tf1._rotation01 * src1._positionY + tf1._rotation02 * src1._positionZ;
__tmp__Y = tf1._rotation10 * src1._positionX + tf1._rotation11 * src1._positionY + tf1._rotation12 * src1._positionZ;
__tmp__Z = tf1._rotation20 * src1._positionX + tf1._rotation21 * src1._positionY + tf1._rotation22 * src1._positionZ;
dst._positionX = __tmp__X;
dst._positionY = __tmp__Y;
dst._positionZ = __tmp__Z;
dst._positionX += tf1._positionX;
dst._positionY += tf1._positionY;
dst._positionZ += tf1._positionZ;
let dst1 = s._transform;
let src11 = s._localTransform;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = tf2._rotation00 * src11._rotation00 + tf2._rotation01 * src11._rotation10 + tf2._rotation02 * src11._rotation20;
__tmp__011 = tf2._rotation00 * src11._rotation01 + tf2._rotation01 * src11._rotation11 + tf2._rotation02 * src11._rotation21;
__tmp__021 = tf2._rotation00 * src11._rotation02 + tf2._rotation01 * src11._rotation12 + tf2._rotation02 * src11._rotation22;
__tmp__101 = tf2._rotation10 * src11._rotation00 + tf2._rotation11 * src11._rotation10 + tf2._rotation12 * src11._rotation20;
__tmp__111 = tf2._rotation10 * src11._rotation01 + tf2._rotation11 * src11._rotation11 + tf2._rotation12 * src11._rotation21;
__tmp__121 = tf2._rotation10 * src11._rotation02 + tf2._rotation11 * src11._rotation12 + tf2._rotation12 * src11._rotation22;
__tmp__201 = tf2._rotation20 * src11._rotation00 + tf2._rotation21 * src11._rotation10 + tf2._rotation22 * src11._rotation20;
__tmp__211 = tf2._rotation20 * src11._rotation01 + tf2._rotation21 * src11._rotation11 + tf2._rotation22 * src11._rotation21;
__tmp__221 = tf2._rotation20 * src11._rotation02 + tf2._rotation21 * src11._rotation12 + tf2._rotation22 * src11._rotation22;
dst1._rotation00 = __tmp__001;
dst1._rotation01 = __tmp__011;
dst1._rotation02 = __tmp__021;
dst1._rotation10 = __tmp__101;
dst1._rotation11 = __tmp__111;
dst1._rotation12 = __tmp__121;
dst1._rotation20 = __tmp__201;
dst1._rotation21 = __tmp__211;
dst1._rotation22 = __tmp__221;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = tf2._rotation00 * src11._positionX + tf2._rotation01 * src11._positionY + tf2._rotation02 * src11._positionZ;
__tmp__Y1 = tf2._rotation10 * src11._positionX + tf2._rotation11 * src11._positionY + tf2._rotation12 * src11._positionZ;
__tmp__Z1 = tf2._rotation20 * src11._positionX + tf2._rotation21 * src11._positionY + tf2._rotation22 * src11._positionZ;
dst1._positionX = __tmp__X1;
dst1._positionY = __tmp__Y1;
dst1._positionZ = __tmp__Z1;
dst1._positionX += tf2._positionX;
dst1._positionY += tf2._positionY;
dst1._positionZ += tf2._positionZ;
let minX;
let minY;
let minZ;
let maxX;
let maxY;
let maxZ;
s._geom._computeAabb(s._aabb,s._ptransform);
minX = s._aabb._minX;
minY = s._aabb._minY;
minZ = s._aabb._minZ;
maxX = s._aabb._maxX;
maxY = s._aabb._maxY;
maxZ = s._aabb._maxZ;
s._geom._computeAabb(s._aabb,s._transform);
s._aabb._minX = minX < s._aabb._minX ? minX : s._aabb._minX;
s._aabb._minY = minY < s._aabb._minY ? minY : s._aabb._minY;
s._aabb._minZ = minZ < s._aabb._minZ ? minZ : s._aabb._minZ;
s._aabb._maxX = maxX > s._aabb._maxX ? maxX : s._aabb._maxX;
s._aabb._maxY = maxY > s._aabb._maxY ? maxY : s._aabb._maxY;
s._aabb._maxZ = maxZ > s._aabb._maxZ ? maxZ : s._aabb._maxZ;
if(s._proxy != null) {
let dX;
let dY;
let dZ;
dX = s._transform._positionX - s._ptransform._positionX;
dY = s._transform._positionY - s._ptransform._positionY;
dZ = s._transform._positionZ - s._ptransform._positionZ;
let v = s.displacement;
v.x = dX;
v.y = dY;
v.z = dZ;
s._rigidBody._world._broadPhase.moveProxy(s._proxy,s._aabb,s.displacement);
}
s = n;
}
this._sleeping = false;
this._sleepTime = 0;
}
setRotationXyz(eulerAngles) {
let xyzX;
let xyzY;
let xyzZ;
xyzX = eulerAngles.x;
xyzY = eulerAngles.y;
xyzZ = eulerAngles.z;
let sx = Math.sin(xyzX);
let sy = Math.sin(xyzY);
let sz = Math.sin(xyzZ);
let cx = Math.cos(xyzX);
let cy = Math.cos(xyzY);
let cz = Math.cos(xyzZ);
this._transform._rotation00 = cy * cz;
this._transform._rotation01 = -cy * sz;
this._transform._rotation02 = sy;
this._transform._rotation10 = cx * sz + cz * sx * sy;
this._transform._rotation11 = cx * cz - sx * sy * sz;
this._transform._rotation12 = -cy * sx;
this._transform._rotation20 = sx * sz - cx * cz * sy;
this._transform._rotation21 = cz * sx + cx * sy * sz;
this._transform._rotation22 = cx * cy;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = this._transform._rotation00 * this._invLocalInertia00 + this._transform._rotation01 * this._invLocalInertia10 + this._transform._rotation02 * this._invLocalInertia20;
__tmp__01 = this._transform._rotation00 * this._invLocalInertia01 + this._transform._rotation01 * this._invLocalInertia11 + this._transform._rotation02 * this._invLocalInertia21;
__tmp__02 = this._transform._rotation00 * this._invLocalInertia02 + this._transform._rotation01 * this._invLocalInertia12 + this._transform._rotation02 * this._invLocalInertia22;
__tmp__10 = this._transform._rotation10 * this._invLocalInertia00 + this._transform._rotation11 * this._invLocalInertia10 + this._transform._rotation12 * this._invLocalInertia20;
__tmp__11 = this._transform._rotation10 * this._invLocalInertia01 + this._transform._rotation11 * this._invLocalInertia11 + this._transform._rotation12 * this._invLocalInertia21;
__tmp__12 = this._transform._rotation10 * this._invLocalInertia02 + this._transform._rotation11 * this._invLocalInertia12 + this._transform._rotation12 * this._invLocalInertia22;
__tmp__20 = this._transform._rotation20 * this._invLocalInertia00 + this._transform._rotation21 * this._invLocalInertia10 + this._transform._rotation22 * this._invLocalInertia20;
__tmp__21 = this._transform._rotation20 * this._invLocalInertia01 + this._transform._rotation21 * this._invLocalInertia11 + this._transform._rotation22 * this._invLocalInertia21;
__tmp__22 = this._transform._rotation20 * this._invLocalInertia02 + this._transform._rotation21 * this._invLocalInertia12 + this._transform._rotation22 * this._invLocalInertia22;
this._invInertia00 = __tmp__00;
this._invInertia01 = __tmp__01;
this._invInertia02 = __tmp__02;
this._invInertia10 = __tmp__10;
this._invInertia11 = __tmp__11;
this._invInertia12 = __tmp__12;
this._invInertia20 = __tmp__20;
this._invInertia21 = __tmp__21;
this._invInertia22 = __tmp__22;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = this._invInertia00 * this._transform._rotation00 + this._invInertia01 * this._transform._rotation01 + this._invInertia02 * this._transform._rotation02;
__tmp__011 = this._invInertia00 * this._transform._rotation10 + this._invInertia01 * this._transform._rotation11 + this._invInertia02 * this._transform._rotation12;
__tmp__021 = this._invInertia00 * this._transform._rotation20 + this._invInertia01 * this._transform._rotation21 + this._invInertia02 * this._transform._rotation22;
__tmp__101 = this._invInertia10 * this._transform._rotation00 + this._invInertia11 * this._transform._rotation01 + this._invInertia12 * this._transform._rotation02;
__tmp__111 = this._invInertia10 * this._transform._rotation10 + this._invInertia11 * this._transform._rotation11 + this._invInertia12 * this._transform._rotation12;
__tmp__121 = this._invInertia10 * this._transform._rotation20 + this._invInertia11 * this._transform._rotation21 + this._invInertia12 * this._transform._rotation22;
__tmp__201 = this._invInertia20 * this._transform._rotation00 + this._invInertia21 * this._transform._rotation01 + this._invInertia22 * this._transform._rotation02;
__tmp__211 = this._invInertia20 * this._transform._rotation10 + this._invInertia21 * this._transform._rotation11 + this._invInertia22 * this._transform._rotation12;
__tmp__221 = this._invInertia20 * this._transform._rotation20 + this._invInertia21 * this._transform._rotation21 + this._invInertia22 * this._transform._rotation22;
this._invInertia00 = __tmp__001;
this._invInertia01 = __tmp__011;
this._invInertia02 = __tmp__021;
this._invInertia10 = __tmp__101;
this._invInertia11 = __tmp__111;
this._invInertia12 = __tmp__121;
this._invInertia20 = __tmp__201;
this._invInertia21 = __tmp__211;
this._invInertia22 = __tmp__221;
this._invInertia00 *= this._rotFactor.x;
this._invInertia01 *= this._rotFactor.x;
this._invInertia02 *= this._rotFactor.x;
this._invInertia10 *= this._rotFactor.y;
this._invInertia11 *= this._rotFactor.y;
this._invInertia12 *= this._rotFactor.y;
this._invInertia20 *= this._rotFactor.z;
this._invInertia21 *= this._rotFactor.z;
this._invInertia22 *= this._rotFactor.z;
let dst = this._ptransform;
let src = this._transform;
dst._positionX = src._positionX;
dst._positionY = src._positionY;
dst._positionZ = src._positionZ;
dst._rotation00 = src._rotation00;
dst._rotation01 = src._rotation01;
dst._rotation02 = src._rotation02;
dst._rotation10 = src._rotation10;
dst._rotation11 = src._rotation11;
dst._rotation12 = src._rotation12;
dst._rotation20 = src._rotation20;
dst._rotation21 = src._rotation21;
dst._rotation22 = src._rotation22;
let s = this._shapeList;
while(s != null) {
let n = s._next;
let tf1 = this._ptransform;
let tf2 = this._transform;
let dst = s._ptransform;
let src1 = s._localTransform;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = tf1._rotation00 * src1._rotation00 + tf1._rotation01 * src1._rotation10 + tf1._rotation02 * src1._rotation20;
__tmp__01 = tf1._rotation00 * src1._rotation01 + tf1._rotation01 * src1._rotation11 + tf1._rotation02 * src1._rotation21;
__tmp__02 = tf1._rotation00 * src1._rotation02 + tf1._rotation01 * src1._rotation12 + tf1._rotation02 * src1._rotation22;
__tmp__10 = tf1._rotation10 * src1._rotation00 + tf1._rotation11 * src1._rotation10 + tf1._rotation12 * src1._rotation20;
__tmp__11 = tf1._rotation10 * src1._rotation01 + tf1._rotation11 * src1._rotation11 + tf1._rotation12 * src1._rotation21;
__tmp__12 = tf1._rotation10 * src1._rotation02 + tf1._rotation11 * src1._rotation12 + tf1._rotation12 * src1._rotation22;
__tmp__20 = tf1._rotation20 * src1._rotation00 + tf1._rotation21 * src1._rotation10 + tf1._rotation22 * src1._rotation20;
__tmp__21 = tf1._rotation20 * src1._rotation01 + tf1._rotation21 * src1._rotation11 + tf1._rotation22 * src1._rotation21;
__tmp__22 = tf1._rotation20 * src1._rotation02 + tf1._rotation21 * src1._rotation12 + tf1._rotation22 * src1._rotation22;
dst._rotation00 = __tmp__00;
dst._rotation01 = __tmp__01;
dst._rotation02 = __tmp__02;
dst._rotation10 = __tmp__10;
dst._rotation11 = __tmp__11;
dst._rotation12 = __tmp__12;
dst._rotation20 = __tmp__20;
dst._rotation21 = __tmp__21;
dst._rotation22 = __tmp__22;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = tf1._rotation00 * src1._positionX + tf1._rotation01 * src1._positionY + tf1._rotation02 * src1._positionZ;
__tmp__Y = tf1._rotation10 * src1._positionX + tf1._rotation11 * src1._positionY + tf1._rotation12 * src1._positionZ;
__tmp__Z = tf1._rotation20 * src1._positionX + tf1._rotation21 * src1._positionY + tf1._rotation22 * src1._positionZ;
dst._positionX = __tmp__X;
dst._positionY = __tmp__Y;
dst._positionZ = __tmp__Z;
dst._positionX += tf1._positionX;
dst._positionY += tf1._positionY;
dst._positionZ += tf1._positionZ;
let dst1 = s._transform;
let src11 = s._localTransform;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = tf2._rotation00 * src11._rotation00 + tf2._rotation01 * src11._rotation10 + tf2._rotation02 * src11._rotation20;
__tmp__011 = tf2._rotation00 * src11._rotation01 + tf2._rotation01 * src11._rotation11 + tf2._rotation02 * src11._rotation21;
__tmp__021 = tf2._rotation00 * src11._rotation02 + tf2._rotation01 * src11._rotation12 + tf2._rotation02 * src11._rotation22;
__tmp__101 = tf2._rotation10 * src11._rotation00 + tf2._rotation11 * src11._rotation10 + tf2._rotation12 * src11._rotation20;
__tmp__111 = tf2._rotation10 * src11._rotation01 + tf2._rotation11 * src11._rotation11 + tf2._rotation12 * src11._rotation21;
__tmp__121 = tf2._rotation10 * src11._rotation02 + tf2._rotation11 * src11._rotation12 + tf2._rotation12 * src11._rotation22;
__tmp__201 = tf2._rotation20 * src11._rotation00 + tf2._rotation21 * src11._rotation10 + tf2._rotation22 * src11._rotation20;
__tmp__211 = tf2._rotation20 * src11._rotation01 + tf2._rotation21 * src11._rotation11 + tf2._rotation22 * src11._rotation21;
__tmp__221 = tf2._rotation20 * src11._rotation02 + tf2._rotation21 * src11._rotation12 + tf2._rotation22 * src11._rotation22;
dst1._rotation00 = __tmp__001;
dst1._rotation01 = __tmp__011;
dst1._rotation02 = __tmp__021;
dst1._rotation10 = __tmp__101;
dst1._rotation11 = __tmp__111;
dst1._rotation12 = __tmp__121;
dst1._rotation20 = __tmp__201;
dst1._rotation21 = __tmp__211;
dst1._rotation22 = __tmp__221;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = tf2._rotation00 * src11._positionX + tf2._rotation01 * src11._positionY + tf2._rotation02 * src11._positionZ;
__tmp__Y1 = tf2._rotation10 * src11._positionX + tf2._rotation11 * src11._positionY + tf2._rotation12 * src11._positionZ;
__tmp__Z1 = tf2._rotation20 * src11._positionX + tf2._rotation21 * src11._positionY + tf2._rotation22 * src11._positionZ;
dst1._positionX = __tmp__X1;
dst1._positionY = __tmp__Y1;
dst1._positionZ = __tmp__Z1;
dst1._positionX += tf2._positionX;
dst1._positionY += tf2._positionY;
dst1._positionZ += tf2._positionZ;
let minX;
let minY;
let minZ;
let maxX;
let maxY;
let maxZ;
s._geom._computeAabb(s._aabb,s._ptransform);
minX = s._aabb._minX;
minY = s._aabb._minY;
minZ = s._aabb._minZ;
maxX = s._aabb._maxX;
maxY = s._aabb._maxY;
maxZ = s._aabb._maxZ;
s._geom._computeAabb(s._aabb,s._transform);
s._aabb._minX = minX < s._aabb._minX ? minX : s._aabb._minX;
s._aabb._minY = minY < s._aabb._minY ? minY : s._aabb._minY;
s._aabb._minZ = minZ < s._aabb._minZ ? minZ : s._aabb._minZ;
s._aabb._maxX = maxX > s._aabb._maxX ? maxX : s._aabb._maxX;
s._aabb._maxY = maxY > s._aabb._maxY ? maxY : s._aabb._maxY;
s._aabb._maxZ = maxZ > s._aabb._maxZ ? maxZ : s._aabb._maxZ;
if(s._proxy != null) {
let dX;
let dY;
let dZ;
dX = s._transform._positionX - s._ptransform._positionX;
dY = s._transform._positionY - s._ptransform._positionY;
dZ = s._transform._positionZ - s._ptransform._positionZ;
let v = s.displacement;
v.x = dX;
v.y = dY;
v.z = dZ;
s._rigidBody._world._broadPhase.moveProxy(s._proxy,s._aabb,s.displacement);
}
s = n;
}
this._sleeping = false;
this._sleepTime = 0;
}
rotate(rotation) {
let rot00;
let rot01;
let rot02;
let rot10;
let rot11;
let rot12;
let rot20;
let rot21;
let rot22;
rot00 = rotation.e00;
rot01 = rotation.e01;
rot02 = rotation.e02;
rot10 = rotation.e10;
rot11 = rotation.e11;
rot12 = rotation.e12;
rot20 = rotation.e20;
rot21 = rotation.e21;
rot22 = rotation.e22;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = rot00 * this._transform._rotation00 + rot01 * this._transform._rotation10 + rot02 * this._transform._rotation20;
__tmp__01 = rot00 * this._transform._rotation01 + rot01 * this._transform._rotation11 + rot02 * this._transform._rotation21;
__tmp__02 = rot00 * this._transform._rotation02 + rot01 * this._transform._rotation12 + rot02 * this._transform._rotation22;
__tmp__10 = rot10 * this._transform._rotation00 + rot11 * this._transform._rotation10 + rot12 * this._transform._rotation20;
__tmp__11 = rot10 * this._transform._rotation01 + rot11 * this._transform._rotation11 + rot12 * this._transform._rotation21;
__tmp__12 = rot10 * this._transform._rotation02 + rot11 * this._transform._rotation12 + rot12 * this._transform._rotation22;
__tmp__20 = rot20 * this._transform._rotation00 + rot21 * this._transform._rotation10 + rot22 * this._transform._rotation20;
__tmp__21 = rot20 * this._transform._rotation01 + rot21 * this._transform._rotation11 + rot22 * this._transform._rotation21;
__tmp__22 = rot20 * this._transform._rotation02 + rot21 * this._transform._rotation12 + rot22 * this._transform._rotation22;
this._transform._rotation00 = __tmp__00;
this._transform._rotation01 = __tmp__01;
this._transform._rotation02 = __tmp__02;
this._transform._rotation10 = __tmp__10;
this._transform._rotation11 = __tmp__11;
this._transform._rotation12 = __tmp__12;
this._transform._rotation20 = __tmp__20;
this._transform._rotation21 = __tmp__21;
this._transform._rotation22 = __tmp__22;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = this._transform._rotation00 * this._invLocalInertia00 + this._transform._rotation01 * this._invLocalInertia10 + this._transform._rotation02 * this._invLocalInertia20;
__tmp__011 = this._transform._rotation00 * this._invLocalInertia01 + this._transform._rotation01 * this._invLocalInertia11 + this._transform._rotation02 * this._invLocalInertia21;
__tmp__021 = this._transform._rotation00 * this._invLocalInertia02 + this._transform._rotation01 * this._invLocalInertia12 + this._transform._rotation02 * this._invLocalInertia22;
__tmp__101 = this._transform._rotation10 * this._invLocalInertia00 + this._transform._rotation11 * this._invLocalInertia10 + this._transform._rotation12 * this._invLocalInertia20;
__tmp__111 = this._transform._rotation10 * this._invLocalInertia01 + this._transform._rotation11 * this._invLocalInertia11 + this._transform._rotation12 * this._invLocalInertia21;
__tmp__121 = this._transform._rotation10 * this._invLocalInertia02 + this._transform._rotation11 * this._invLocalInertia12 + this._transform._rotation12 * this._invLocalInertia22;
__tmp__201 = this._transform._rotation20 * this._invLocalInertia00 + this._transform._rotation21 * this._invLocalInertia10 + this._transform._rotation22 * this._invLocalInertia20;
__tmp__211 = this._transform._rotation20 * this._invLocalInertia01 + this._transform._rotation21 * this._invLocalInertia11 + this._transform._rotation22 * this._invLocalInertia21;
__tmp__221 = this._transform._rotation20 * this._invLocalInertia02 + this._transform._rotation21 * this._invLocalInertia12 + this._transform._rotation22 * this._invLocalInertia22;
this._invInertia00 = __tmp__001;
this._invInertia01 = __tmp__011;
this._invInertia02 = __tmp__021;
this._invInertia10 = __tmp__101;
this._invInertia11 = __tmp__111;
this._invInertia12 = __tmp__121;
this._invInertia20 = __tmp__201;
this._invInertia21 = __tmp__211;
this._invInertia22 = __tmp__221;
let __tmp__002;
let __tmp__012;
let __tmp__022;
let __tmp__102;
let __tmp__112;
let __tmp__122;
let __tmp__202;
let __tmp__212;
let __tmp__222;
__tmp__002 = this._invInertia00 * this._transform._rotation00 + this._invInertia01 * this._transform._rotation01 + this._invInertia02 * this._transform._rotation02;
__tmp__012 = this._invInertia00 * this._transform._rotation10 + this._invInertia01 * this._transform._rotation11 + this._invInertia02 * this._transform._rotation12;
__tmp__022 = this._invInertia00 * this._transform._rotation20 + this._invInertia01 * this._transform._rotation21 + this._invInertia02 * this._transform._rotation22;
__tmp__102 = this._invInertia10 * this._transform._rotation00 + this._invInertia11 * this._transform._rotation01 + this._invInertia12 * this._transform._rotation02;
__tmp__112 = this._invInertia10 * this._transform._rotation10 + this._invInertia11 * this._transform._rotation11 + this._invInertia12 * this._transform._rotation12;
__tmp__122 = this._invInertia10 * this._transform._rotation20 + this._invInertia11 * this._transform._rotation21 + this._invInertia12 * this._transform._rotation22;
__tmp__202 = this._invInertia20 * this._transform._rotation00 + this._invInertia21 * this._transform._rotation01 + this._invInertia22 * this._transform._rotation02;
__tmp__212 = this._invInertia20 * this._transform._rotation10 + this._invInertia21 * this._transform._rotation11 + this._invInertia22 * this._transform._rotation12;
__tmp__222 = this._invInertia20 * this._transform._rotation20 + this._invInertia21 * this._transform._rotation21 + this._invInertia22 * this._transform._rotation22;
this._invInertia00 = __tmp__002;
this._invInertia01 = __tmp__012;
this._invInertia02 = __tmp__022;
this._invInertia10 = __tmp__102;
this._invInertia11 = __tmp__112;
this._invInertia12 = __tmp__122;
this._invInertia20 = __tmp__202;
this._invInertia21 = __tmp__212;
this._invInertia22 = __tmp__222;
this._invInertia00 *= this._rotFactor.x;
this._invInertia01 *= this._rotFactor.x;
this._invInertia02 *= this._rotFactor.x;
this._invInertia10 *= this._rotFactor.y;
this._invInertia11 *= this._rotFactor.y;
this._invInertia12 *= this._rotFactor.y;
this._invInertia20 *= this._rotFactor.z;
this._invInertia21 *= this._rotFactor.z;
this._invInertia22 *= this._rotFactor.z;
let dst = this._ptransform;
let src = this._transform;
dst._positionX = src._positionX;
dst._positionY = src._positionY;
dst._positionZ = src._positionZ;
dst._rotation00 = src._rotation00;
dst._rotation01 = src._rotation01;
dst._rotation02 = src._rotation02;
dst._rotation10 = src._rotation10;
dst._rotation11 = src._rotation11;
dst._rotation12 = src._rotation12;
dst._rotation20 = src._rotation20;
dst._rotation21 = src._rotation21;
dst._rotation22 = src._rotation22;
let s = this._shapeList;
while(s != null) {
let n = s._next;
let tf1 = this._ptransform;
let tf2 = this._transform;
let dst = s._ptransform;
let src1 = s._localTransform;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = tf1._rotation00 * src1._rotation00 + tf1._rotation01 * src1._rotation10 + tf1._rotation02 * src1._rotation20;
__tmp__01 = tf1._rotation00 * src1._rotation01 + tf1._rotation01 * src1._rotation11 + tf1._rotation02 * src1._rotation21;
__tmp__02 = tf1._rotation00 * src1._rotation02 + tf1._rotation01 * src1._rotation12 + tf1._rotation02 * src1._rotation22;
__tmp__10 = tf1._rotation10 * src1._rotation00 + tf1._rotation11 * src1._rotation10 + tf1._rotation12 * src1._rotation20;
__tmp__11 = tf1._rotation10 * src1._rotation01 + tf1._rotation11 * src1._rotation11 + tf1._rotation12 * src1._rotation21;
__tmp__12 = tf1._rotation10 * src1._rotation02 + tf1._rotation11 * src1._rotation12 + tf1._rotation12 * src1._rotation22;
__tmp__20 = tf1._rotation20 * src1._rotation00 + tf1._rotation21 * src1._rotation10 + tf1._rotation22 * src1._rotation20;
__tmp__21 = tf1._rotation20 * src1._rotation01 + tf1._rotation21 * src1._rotation11 + tf1._rotation22 * src1._rotation21;
__tmp__22 = tf1._rotation20 * src1._rotation02 + tf1._rotation21 * src1._rotation12 + tf1._rotation22 * src1._rotation22;
dst._rotation00 = __tmp__00;
dst._rotation01 = __tmp__01;
dst._rotation02 = __tmp__02;
dst._rotation10 = __tmp__10;
dst._rotation11 = __tmp__11;
dst._rotation12 = __tmp__12;
dst._rotation20 = __tmp__20;
dst._rotation21 = __tmp__21;
dst._rotation22 = __tmp__22;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = tf1._rotation00 * src1._positionX + tf1._rotation01 * src1._positionY + tf1._rotation02 * src1._positionZ;
__tmp__Y = tf1._rotation10 * src1._positionX + tf1._rotation11 * src1._positionY + tf1._rotation12 * src1._positionZ;
__tmp__Z = tf1._rotation20 * src1._positionX + tf1._rotation21 * src1._positionY + tf1._rotation22 * src1._positionZ;
dst._positionX = __tmp__X;
dst._positionY = __tmp__Y;
dst._positionZ = __tmp__Z;
dst._positionX += tf1._positionX;
dst._positionY += tf1._positionY;
dst._positionZ += tf1._positionZ;
let dst1 = s._transform;
let src11 = s._localTransform;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = tf2._rotation00 * src11._rotation00 + tf2._rotation01 * src11._rotation10 + tf2._rotation02 * src11._rotation20;
__tmp__011 = tf2._rotation00 * src11._rotation01 + tf2._rotation01 * src11._rotation11 + tf2._rotation02 * src11._rotation21;
__tmp__021 = tf2._rotation00 * src11._rotation02 + tf2._rotation01 * src11._rotation12 + tf2._rotation02 * src11._rotation22;
__tmp__101 = tf2._rotation10 * src11._rotation00 + tf2._rotation11 * src11._rotation10 + tf2._rotation12 * src11._rotation20;
__tmp__111 = tf2._rotation10 * src11._rotation01 + tf2._rotation11 * src11._rotation11 + tf2._rotation12 * src11._rotation21;
__tmp__121 = tf2._rotation10 * src11._rotation02 + tf2._rotation11 * src11._rotation12 + tf2._rotation12 * src11._rotation22;
__tmp__201 = tf2._rotation20 * src11._rotation00 + tf2._rotation21 * src11._rotation10 + tf2._rotation22 * src11._rotation20;
__tmp__211 = tf2._rotation20 * src11._rotation01 + tf2._rotation21 * src11._rotation11 + tf2._rotation22 * src11._rotation21;
__tmp__221 = tf2._rotation20 * src11._rotation02 + tf2._rotation21 * src11._rotation12 + tf2._rotation22 * src11._rotation22;
dst1._rotation00 = __tmp__001;
dst1._rotation01 = __tmp__011;
dst1._rotation02 = __tmp__021;
dst1._rotation10 = __tmp__101;
dst1._rotation11 = __tmp__111;
dst1._rotation12 = __tmp__121;
dst1._rotation20 = __tmp__201;
dst1._rotation21 = __tmp__211;
dst1._rotation22 = __tmp__221;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = tf2._rotation00 * src11._positionX + tf2._rotation01 * src11._positionY + tf2._rotation02 * src11._positionZ;
__tmp__Y1 = tf2._rotation10 * src11._positionX + tf2._rotation11 * src11._positionY + tf2._rotation12 * src11._positionZ;
__tmp__Z1 = tf2._rotation20 * src11._positionX + tf2._rotation21 * src11._positionY + tf2._rotation22 * src11._positionZ;
dst1._positionX = __tmp__X1;
dst1._positionY = __tmp__Y1;
dst1._positionZ = __tmp__Z1;
dst1._positionX += tf2._positionX;
dst1._positionY += tf2._positionY;
dst1._positionZ += tf2._positionZ;
let minX;
let minY;
let minZ;
let maxX;
let maxY;
let maxZ;
s._geom._computeAabb(s._aabb,s._ptransform);
minX = s._aabb._minX;
minY = s._aabb._minY;
minZ = s._aabb._minZ;
maxX = s._aabb._maxX;
maxY = s._aabb._maxY;
maxZ = s._aabb._maxZ;
s._geom._computeAabb(s._aabb,s._transform);
s._aabb._minX = minX < s._aabb._minX ? minX : s._aabb._minX;
s._aabb._minY = minY < s._aabb._minY ? minY : s._aabb._minY;
s._aabb._minZ = minZ < s._aabb._minZ ? minZ : s._aabb._minZ;
s._aabb._maxX = maxX > s._aabb._maxX ? maxX : s._aabb._maxX;
s._aabb._maxY = maxY > s._aabb._maxY ? maxY : s._aabb._maxY;
s._aabb._maxZ = maxZ > s._aabb._maxZ ? maxZ : s._aabb._maxZ;
if(s._proxy != null) {
let dX;
let dY;
let dZ;
dX = s._transform._positionX - s._ptransform._positionX;
dY = s._transform._positionY - s._ptransform._positionY;
dZ = s._transform._positionZ - s._ptransform._positionZ;
let v = s.displacement;
v.x = dX;
v.y = dY;
v.z = dZ;
s._rigidBody._world._broadPhase.moveProxy(s._proxy,s._aabb,s.displacement);
}
s = n;
}
this._sleeping = false;
this._sleepTime = 0;
}
rotateXyz(eulerAngles) {
let xyzX;
let xyzY;
let xyzZ;
let rot00;
let rot01;
let rot02;
let rot10;
let rot11;
let rot12;
let rot20;
let rot21;
let rot22;
xyzX = eulerAngles.x;
xyzY = eulerAngles.y;
xyzZ = eulerAngles.z;
let sx = Math.sin(xyzX);
let sy = Math.sin(xyzY);
let sz = Math.sin(xyzZ);
let cx = Math.cos(xyzX);
let cy = Math.cos(xyzY);
let cz = Math.cos(xyzZ);
rot00 = cy * cz;
rot01 = -cy * sz;
rot02 = sy;
rot10 = cx * sz + cz * sx * sy;
rot11 = cx * cz - sx * sy * sz;
rot12 = -cy * sx;
rot20 = sx * sz - cx * cz * sy;
rot21 = cz * sx + cx * sy * sz;
rot22 = cx * cy;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = rot00 * this._transform._rotation00 + rot01 * this._transform._rotation10 + rot02 * this._transform._rotation20;
__tmp__01 = rot00 * this._transform._rotation01 + rot01 * this._transform._rotation11 + rot02 * this._transform._rotation21;
__tmp__02 = rot00 * this._transform._rotation02 + rot01 * this._transform._rotation12 + rot02 * this._transform._rotation22;
__tmp__10 = rot10 * this._transform._rotation00 + rot11 * this._transform._rotation10 + rot12 * this._transform._rotation20;
__tmp__11 = rot10 * this._transform._rotation01 + rot11 * this._transform._rotation11 + rot12 * this._transform._rotation21;
__tmp__12 = rot10 * this._transform._rotation02 + rot11 * this._transform._rotation12 + rot12 * this._transform._rotation22;
__tmp__20 = rot20 * this._transform._rotation00 + rot21 * this._transform._rotation10 + rot22 * this._transform._rotation20;
__tmp__21 = rot20 * this._transform._rotation01 + rot21 * this._transform._rotation11 + rot22 * this._transform._rotation21;
__tmp__22 = rot20 * this._transform._rotation02 + rot21 * this._transform._rotation12 + rot22 * this._transform._rotation22;
this._transform._rotation00 = __tmp__00;
this._transform._rotation01 = __tmp__01;
this._transform._rotation02 = __tmp__02;
this._transform._rotation10 = __tmp__10;
this._transform._rotation11 = __tmp__11;
this._transform._rotation12 = __tmp__12;
this._transform._rotation20 = __tmp__20;
this._transform._rotation21 = __tmp__21;
this._transform._rotation22 = __tmp__22;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = this._transform._rotation00 * this._invLocalInertia00 + this._transform._rotation01 * this._invLocalInertia10 + this._transform._rotation02 * this._invLocalInertia20;
__tmp__011 = this._transform._rotation00 * this._invLocalInertia01 + this._transform._rotation01 * this._invLocalInertia11 + this._transform._rotation02 * this._invLocalInertia21;
__tmp__021 = this._transform._rotation00 * this._invLocalInertia02 + this._transform._rotation01 * this._invLocalInertia12 + this._transform._rotation02 * this._invLocalInertia22;
__tmp__101 = this._transform._rotation10 * this._invLocalInertia00 + this._transform._rotation11 * this._invLocalInertia10 + this._transform._rotation12 * this._invLocalInertia20;
__tmp__111 = this._transform._rotation10 * this._invLocalInertia01 + this._transform._rotation11 * this._invLocalInertia11 + this._transform._rotation12 * this._invLocalInertia21;
__tmp__121 = this._transform._rotation10 * this._invLocalInertia02 + this._transform._rotation11 * this._invLocalInertia12 + this._transform._rotation12 * this._invLocalInertia22;
__tmp__201 = this._transform._rotation20 * this._invLocalInertia00 + this._transform._rotation21 * this._invLocalInertia10 + this._transform._rotation22 * this._invLocalInertia20;
__tmp__211 = this._transform._rotation20 * this._invLocalInertia01 + this._transform._rotation21 * this._invLocalInertia11 + this._transform._rotation22 * this._invLocalInertia21;
__tmp__221 = this._transform._rotation20 * this._invLocalInertia02 + this._transform._rotation21 * this._invLocalInertia12 + this._transform._rotation22 * this._invLocalInertia22;
this._invInertia00 = __tmp__001;
this._invInertia01 = __tmp__011;
this._invInertia02 = __tmp__021;
this._invInertia10 = __tmp__101;
this._invInertia11 = __tmp__111;
this._invInertia12 = __tmp__121;
this._invInertia20 = __tmp__201;
this._invInertia21 = __tmp__211;
this._invInertia22 = __tmp__221;
let __tmp__002;
let __tmp__012;
let __tmp__022;
let __tmp__102;
let __tmp__112;
let __tmp__122;
let __tmp__202;
let __tmp__212;
let __tmp__222;
__tmp__002 = this._invInertia00 * this._transform._rotation00 + this._invInertia01 * this._transform._rotation01 + this._invInertia02 * this._transform._rotation02;
__tmp__012 = this._invInertia00 * this._transform._rotation10 + this._invInertia01 * this._transform._rotation11 + this._invInertia02 * this._transform._rotation12;
__tmp__022 = this._invInertia00 * this._transform._rotation20 + this._invInertia01 * this._transform._rotation21 + this._invInertia02 * this._transform._rotation22;
__tmp__102 = this._invInertia10 * this._transform._rotation00 + this._invInertia11 * this._transform._rotation01 + this._invInertia12 * this._transform._rotation02;
__tmp__112 = this._invInertia10 * this._transform._rotation10 + this._invInertia11 * this._transform._rotation11 + this._invInertia12 * this._transform._rotation12;
__tmp__122 = this._invInertia10 * this._transform._rotation20 + this._invInertia11 * this._transform._rotation21 + this._invInertia12 * this._transform._rotation22;
__tmp__202 = this._invInertia20 * this._transform._rotation00 + this._invInertia21 * this._transform._rotation01 + this._invInertia22 * this._transform._rotation02;
__tmp__212 = this._invInertia20 * this._transform._rotation10 + this._invInertia21 * this._transform._rotation11 + this._invInertia22 * this._transform._rotation12;
__tmp__222 = this._invInertia20 * this._transform._rotation20 + this._invInertia21 * this._transform._rotation21 + this._invInertia22 * this._transform._rotation22;
this._invInertia00 = __tmp__002;
this._invInertia01 = __tmp__012;
this._invInertia02 = __tmp__022;
this._invInertia10 = __tmp__102;
this._invInertia11 = __tmp__112;
this._invInertia12 = __tmp__122;
this._invInertia20 = __tmp__202;
this._invInertia21 = __tmp__212;
this._invInertia22 = __tmp__222;
this._invInertia00 *= this._rotFactor.x;
this._invInertia01 *= this._rotFactor.x;
this._invInertia02 *= this._rotFactor.x;
this._invInertia10 *= this._rotFactor.y;
this._invInertia11 *= this._rotFactor.y;
this._invInertia12 *= this._rotFactor.y;
this._invInertia20 *= this._rotFactor.z;
this._invInertia21 *= this._rotFactor.z;
this._invInertia22 *= this._rotFactor.z;
let dst = this._ptransform;
let src = this._transform;
dst._positionX = src._positionX;
dst._positionY = src._positionY;
dst._positionZ = src._positionZ;
dst._rotation00 = src._rotation00;
dst._rotation01 = src._rotation01;
dst._rotation02 = src._rotation02;
dst._rotation10 = src._rotation10;
dst._rotation11 = src._rotation11;
dst._rotation12 = src._rotation12;
dst._rotation20 = src._rotation20;
dst._rotation21 = src._rotation21;
dst._rotation22 = src._rotation22;
let s = this._shapeList;
while(s != null) {
let n = s._next;
let tf1 = this._ptransform;
let tf2 = this._transform;
let dst = s._ptransform;
let src1 = s._localTransform;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = tf1._rotation00 * src1._rotation00 + tf1._rotation01 * src1._rotation10 + tf1._rotation02 * src1._rotation20;
__tmp__01 = tf1._rotation00 * src1._rotation01 + tf1._rotation01 * src1._rotation11 + tf1._rotation02 * src1._rotation21;
__tmp__02 = tf1._rotation00 * src1._rotation02 + tf1._rotation01 * src1._rotation12 + tf1._rotation02 * src1._rotation22;
__tmp__10 = tf1._rotation10 * src1._rotation00 + tf1._rotation11 * src1._rotation10 + tf1._rotation12 * src1._rotation20;
__tmp__11 = tf1._rotation10 * src1._rotation01 + tf1._rotation11 * src1._rotation11 + tf1._rotation12 * src1._rotation21;
__tmp__12 = tf1._rotation10 * src1._rotation02 + tf1._rotation11 * src1._rotation12 + tf1._rotation12 * src1._rotation22;
__tmp__20 = tf1._rotation20 * src1._rotation00 + tf1._rotation21 * src1._rotation10 + tf1._rotation22 * src1._rotation20;
__tmp__21 = tf1._rotation20 * src1._rotation01 + tf1._rotation21 * src1._rotation11 + tf1._rotation22 * src1._rotation21;
__tmp__22 = tf1._rotation20 * src1._rotation02 + tf1._rotation21 * src1._rotation12 + tf1._rotation22 * src1._rotation22;
dst._rotation00 = __tmp__00;
dst._rotation01 = __tmp__01;
dst._rotation02 = __tmp__02;
dst._rotation10 = __tmp__10;
dst._rotation11 = __tmp__11;
dst._rotation12 = __tmp__12;
dst._rotation20 = __tmp__20;
dst._rotation21 = __tmp__21;
dst._rotation22 = __tmp__22;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = tf1._rotation00 * src1._positionX + tf1._rotation01 * src1._positionY + tf1._rotation02 * src1._positionZ;
__tmp__Y = tf1._rotation10 * src1._positionX + tf1._rotation11 * src1._positionY + tf1._rotation12 * src1._positionZ;
__tmp__Z = tf1._rotation20 * src1._positionX + tf1._rotation21 * src1._positionY + tf1._rotation22 * src1._positionZ;
dst._positionX = __tmp__X;
dst._positionY = __tmp__Y;
dst._positionZ = __tmp__Z;
dst._positionX += tf1._positionX;
dst._positionY += tf1._positionY;
dst._positionZ += tf1._positionZ;
let dst1 = s._transform;
let src11 = s._localTransform;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = tf2._rotation00 * src11._rotation00 + tf2._rotation01 * src11._rotation10 + tf2._rotation02 * src11._rotation20;
__tmp__011 = tf2._rotation00 * src11._rotation01 + tf2._rotation01 * src11._rotation11 + tf2._rotation02 * src11._rotation21;
__tmp__021 = tf2._rotation00 * src11._rotation02 + tf2._rotation01 * src11._rotation12 + tf2._rotation02 * src11._rotation22;
__tmp__101 = tf2._rotation10 * src11._rotation00 + tf2._rotation11 * src11._rotation10 + tf2._rotation12 * src11._rotation20;
__tmp__111 = tf2._rotation10 * src11._rotation01 + tf2._rotation11 * src11._rotation11 + tf2._rotation12 * src11._rotation21;
__tmp__121 = tf2._rotation10 * src11._rotation02 + tf2._rotation11 * src11._rotation12 + tf2._rotation12 * src11._rotation22;
__tmp__201 = tf2._rotation20 * src11._rotation00 + tf2._rotation21 * src11._rotation10 + tf2._rotation22 * src11._rotation20;
__tmp__211 = tf2._rotation20 * src11._rotation01 + tf2._rotation21 * src11._rotation11 + tf2._rotation22 * src11._rotation21;
__tmp__221 = tf2._rotation20 * src11._rotation02 + tf2._rotation21 * src11._rotation12 + tf2._rotation22 * src11._rotation22;
dst1._rotation00 = __tmp__001;
dst1._rotation01 = __tmp__011;
dst1._rotation02 = __tmp__021;
dst1._rotation10 = __tmp__101;
dst1._rotation11 = __tmp__111;
dst1._rotation12 = __tmp__121;
dst1._rotation20 = __tmp__201;
dst1._rotation21 = __tmp__211;
dst1._rotation22 = __tmp__221;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = tf2._rotation00 * src11._positionX + tf2._rotation01 * src11._positionY + tf2._rotation02 * src11._positionZ;
__tmp__Y1 = tf2._rotation10 * src11._positionX + tf2._rotation11 * src11._positionY + tf2._rotation12 * src11._positionZ;
__tmp__Z1 = tf2._rotation20 * src11._positionX + tf2._rotation21 * src11._positionY + tf2._rotation22 * src11._positionZ;
dst1._positionX = __tmp__X1;
dst1._positionY = __tmp__Y1;
dst1._positionZ = __tmp__Z1;
dst1._positionX += tf2._positionX;
dst1._positionY += tf2._positionY;
dst1._positionZ += tf2._positionZ;
let minX;
let minY;
let minZ;
let maxX;
let maxY;
let maxZ;
s._geom._computeAabb(s._aabb,s._ptransform);
minX = s._aabb._minX;
minY = s._aabb._minY;
minZ = s._aabb._minZ;
maxX = s._aabb._maxX;
maxY = s._aabb._maxY;
maxZ = s._aabb._maxZ;
s._geom._computeAabb(s._aabb,s._transform);
s._aabb._minX = minX < s._aabb._minX ? minX : s._aabb._minX;
s._aabb._minY = minY < s._aabb._minY ? minY : s._aabb._minY;
s._aabb._minZ = minZ < s._aabb._minZ ? minZ : s._aabb._minZ;
s._aabb._maxX = maxX > s._aabb._maxX ? maxX : s._aabb._maxX;
s._aabb._maxY = maxY > s._aabb._maxY ? maxY : s._aabb._maxY;
s._aabb._maxZ = maxZ > s._aabb._maxZ ? maxZ : s._aabb._maxZ;
if(s._proxy != null) {
let dX;
let dY;
let dZ;
dX = s._transform._positionX - s._ptransform._positionX;
dY = s._transform._positionY - s._ptransform._positionY;
dZ = s._transform._positionZ - s._ptransform._positionZ;
let v = s.displacement;
v.x = dX;
v.y = dY;
v.z = dZ;
s._rigidBody._world._broadPhase.moveProxy(s._proxy,s._aabb,s.displacement);
}
s = n;
}
this._sleeping = false;
this._sleepTime = 0;
}
getOrientation() {
let q = new oimo.common.Quat();
let iqX;
let iqY;
let iqZ;
let iqW;
let e00 = this._transform._rotation00;
let e11 = this._transform._rotation11;
let e22 = this._transform._rotation22;
let t = e00 + e11 + e22;
let s;
if(t > 0) {
s = Math.sqrt(t + 1);
iqW = 0.5 * s;
s = 0.5 / s;
iqX = (this._transform._rotation21 - this._transform._rotation12) * s;
iqY = (this._transform._rotation02 - this._transform._rotation20) * s;
iqZ = (this._transform._rotation10 - this._transform._rotation01) * s;
} else if(e00 > e11) {
if(e00 > e22) {
s = Math.sqrt(e00 - e11 - e22 + 1);
iqX = 0.5 * s;
s = 0.5 / s;
iqY = (this._transform._rotation01 + this._transform._rotation10) * s;
iqZ = (this._transform._rotation02 + this._transform._rotation20) * s;
iqW = (this._transform._rotation21 - this._transform._rotation12) * s;
} else {
s = Math.sqrt(e22 - e00 - e11 + 1);
iqZ = 0.5 * s;
s = 0.5 / s;
iqX = (this._transform._rotation02 + this._transform._rotation20) * s;
iqY = (this._transform._rotation12 + this._transform._rotation21) * s;
iqW = (this._transform._rotation10 - this._transform._rotation01) * s;
}
} else if(e11 > e22) {
s = Math.sqrt(e11 - e22 - e00 + 1);
iqY = 0.5 * s;
s = 0.5 / s;
iqX = (this._transform._rotation01 + this._transform._rotation10) * s;
iqZ = (this._transform._rotation12 + this._transform._rotation21) * s;
iqW = (this._transform._rotation02 - this._transform._rotation20) * s;
} else {
s = Math.sqrt(e22 - e00 - e11 + 1);
iqZ = 0.5 * s;
s = 0.5 / s;
iqX = (this._transform._rotation02 + this._transform._rotation20) * s;
iqY = (this._transform._rotation12 + this._transform._rotation21) * s;
iqW = (this._transform._rotation10 - this._transform._rotation01) * s;
}
q.x = iqX;
q.y = iqY;
q.z = iqZ;
q.w = iqW;
return q;
}
getOrientationTo(orientation) {
let iqX;
let iqY;
let iqZ;
let iqW;
let e00 = this._transform._rotation00;
let e11 = this._transform._rotation11;
let e22 = this._transform._rotation22;
let t = e00 + e11 + e22;
let s;
if(t > 0) {
s = Math.sqrt(t + 1);
iqW = 0.5 * s;
s = 0.5 / s;
iqX = (this._transform._rotation21 - this._transform._rotation12) * s;
iqY = (this._transform._rotation02 - this._transform._rotation20) * s;
iqZ = (this._transform._rotation10 - this._transform._rotation01) * s;
} else if(e00 > e11) {
if(e00 > e22) {
s = Math.sqrt(e00 - e11 - e22 + 1);
iqX = 0.5 * s;
s = 0.5 / s;
iqY = (this._transform._rotation01 + this._transform._rotation10) * s;
iqZ = (this._transform._rotation02 + this._transform._rotation20) * s;
iqW = (this._transform._rotation21 - this._transform._rotation12) * s;
} else {
s = Math.sqrt(e22 - e00 - e11 + 1);
iqZ = 0.5 * s;
s = 0.5 / s;
iqX = (this._transform._rotation02 + this._transform._rotation20) * s;
iqY = (this._transform._rotation12 + this._transform._rotation21) * s;
iqW = (this._transform._rotation10 - this._transform._rotation01) * s;
}
} else if(e11 > e22) {
s = Math.sqrt(e11 - e22 - e00 + 1);
iqY = 0.5 * s;
s = 0.5 / s;
iqX = (this._transform._rotation01 + this._transform._rotation10) * s;
iqZ = (this._transform._rotation12 + this._transform._rotation21) * s;
iqW = (this._transform._rotation02 - this._transform._rotation20) * s;
} else {
s = Math.sqrt(e22 - e00 - e11 + 1);
iqZ = 0.5 * s;
s = 0.5 / s;
iqX = (this._transform._rotation02 + this._transform._rotation20) * s;
iqY = (this._transform._rotation12 + this._transform._rotation21) * s;
iqW = (this._transform._rotation10 - this._transform._rotation01) * s;
}
orientation.x = iqX;
orientation.y = iqY;
orientation.z = iqZ;
orientation.w = iqW;
}
setOrientation(quaternion) {
let qX;
let qY;
let qZ;
let qW;
qX = quaternion.x;
qY = quaternion.y;
qZ = quaternion.z;
qW = quaternion.w;
let x = qX;
let y = qY;
let z = qZ;
let w = qW;
let x2 = 2 * x;
let y2 = 2 * y;
let z2 = 2 * z;
let xx = x * x2;
let yy = y * y2;
let zz = z * z2;
let xy = x * y2;
let yz = y * z2;
let xz = x * z2;
let wx = w * x2;
let wy = w * y2;
let wz = w * z2;
this._transform._rotation00 = 1 - yy - zz;
this._transform._rotation01 = xy - wz;
this._transform._rotation02 = xz + wy;
this._transform._rotation10 = xy + wz;
this._transform._rotation11 = 1 - xx - zz;
this._transform._rotation12 = yz - wx;
this._transform._rotation20 = xz - wy;
this._transform._rotation21 = yz + wx;
this._transform._rotation22 = 1 - xx - yy;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = this._transform._rotation00 * this._invLocalInertia00 + this._transform._rotation01 * this._invLocalInertia10 + this._transform._rotation02 * this._invLocalInertia20;
__tmp__01 = this._transform._rotation00 * this._invLocalInertia01 + this._transform._rotation01 * this._invLocalInertia11 + this._transform._rotation02 * this._invLocalInertia21;
__tmp__02 = this._transform._rotation00 * this._invLocalInertia02 + this._transform._rotation01 * this._invLocalInertia12 + this._transform._rotation02 * this._invLocalInertia22;
__tmp__10 = this._transform._rotation10 * this._invLocalInertia00 + this._transform._rotation11 * this._invLocalInertia10 + this._transform._rotation12 * this._invLocalInertia20;
__tmp__11 = this._transform._rotation10 * this._invLocalInertia01 + this._transform._rotation11 * this._invLocalInertia11 + this._transform._rotation12 * this._invLocalInertia21;
__tmp__12 = this._transform._rotation10 * this._invLocalInertia02 + this._transform._rotation11 * this._invLocalInertia12 + this._transform._rotation12 * this._invLocalInertia22;
__tmp__20 = this._transform._rotation20 * this._invLocalInertia00 + this._transform._rotation21 * this._invLocalInertia10 + this._transform._rotation22 * this._invLocalInertia20;
__tmp__21 = this._transform._rotation20 * this._invLocalInertia01 + this._transform._rotation21 * this._invLocalInertia11 + this._transform._rotation22 * this._invLocalInertia21;
__tmp__22 = this._transform._rotation20 * this._invLocalInertia02 + this._transform._rotation21 * this._invLocalInertia12 + this._transform._rotation22 * this._invLocalInertia22;
this._invInertia00 = __tmp__00;
this._invInertia01 = __tmp__01;
this._invInertia02 = __tmp__02;
this._invInertia10 = __tmp__10;
this._invInertia11 = __tmp__11;
this._invInertia12 = __tmp__12;
this._invInertia20 = __tmp__20;
this._invInertia21 = __tmp__21;
this._invInertia22 = __tmp__22;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = this._invInertia00 * this._transform._rotation00 + this._invInertia01 * this._transform._rotation01 + this._invInertia02 * this._transform._rotation02;
__tmp__011 = this._invInertia00 * this._transform._rotation10 + this._invInertia01 * this._transform._rotation11 + this._invInertia02 * this._transform._rotation12;
__tmp__021 = this._invInertia00 * this._transform._rotation20 + this._invInertia01 * this._transform._rotation21 + this._invInertia02 * this._transform._rotation22;
__tmp__101 = this._invInertia10 * this._transform._rotation00 + this._invInertia11 * this._transform._rotation01 + this._invInertia12 * this._transform._rotation02;
__tmp__111 = this._invInertia10 * this._transform._rotation10 + this._invInertia11 * this._transform._rotation11 + this._invInertia12 * this._transform._rotation12;
__tmp__121 = this._invInertia10 * this._transform._rotation20 + this._invInertia11 * this._transform._rotation21 + this._invInertia12 * this._transform._rotation22;
__tmp__201 = this._invInertia20 * this._transform._rotation00 + this._invInertia21 * this._transform._rotation01 + this._invInertia22 * this._transform._rotation02;
__tmp__211 = this._invInertia20 * this._transform._rotation10 + this._invInertia21 * this._transform._rotation11 + this._invInertia22 * this._transform._rotation12;
__tmp__221 = this._invInertia20 * this._transform._rotation20 + this._invInertia21 * this._transform._rotation21 + this._invInertia22 * this._transform._rotation22;
this._invInertia00 = __tmp__001;
this._invInertia01 = __tmp__011;
this._invInertia02 = __tmp__021;
this._invInertia10 = __tmp__101;
this._invInertia11 = __tmp__111;
this._invInertia12 = __tmp__121;
this._invInertia20 = __tmp__201;
this._invInertia21 = __tmp__211;
this._invInertia22 = __tmp__221;
this._invInertia00 *= this._rotFactor.x;
this._invInertia01 *= this._rotFactor.x;
this._invInertia02 *= this._rotFactor.x;
this._invInertia10 *= this._rotFactor.y;
this._invInertia11 *= this._rotFactor.y;
this._invInertia12 *= this._rotFactor.y;
this._invInertia20 *= this._rotFactor.z;
this._invInertia21 *= this._rotFactor.z;
this._invInertia22 *= this._rotFactor.z;
let dst = this._ptransform;
let src = this._transform;
dst._positionX = src._positionX;
dst._positionY = src._positionY;
dst._positionZ = src._positionZ;
dst._rotation00 = src._rotation00;
dst._rotation01 = src._rotation01;
dst._rotation02 = src._rotation02;
dst._rotation10 = src._rotation10;
dst._rotation11 = src._rotation11;
dst._rotation12 = src._rotation12;
dst._rotation20 = src._rotation20;
dst._rotation21 = src._rotation21;
dst._rotation22 = src._rotation22;
let s = this._shapeList;
while(s != null) {
let n = s._next;
let tf1 = this._ptransform;
let tf2 = this._transform;
let dst = s._ptransform;
let src1 = s._localTransform;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = tf1._rotation00 * src1._rotation00 + tf1._rotation01 * src1._rotation10 + tf1._rotation02 * src1._rotation20;
__tmp__01 = tf1._rotation00 * src1._rotation01 + tf1._rotation01 * src1._rotation11 + tf1._rotation02 * src1._rotation21;
__tmp__02 = tf1._rotation00 * src1._rotation02 + tf1._rotation01 * src1._rotation12 + tf1._rotation02 * src1._rotation22;
__tmp__10 = tf1._rotation10 * src1._rotation00 + tf1._rotation11 * src1._rotation10 + tf1._rotation12 * src1._rotation20;
__tmp__11 = tf1._rotation10 * src1._rotation01 + tf1._rotation11 * src1._rotation11 + tf1._rotation12 * src1._rotation21;
__tmp__12 = tf1._rotation10 * src1._rotation02 + tf1._rotation11 * src1._rotation12 + tf1._rotation12 * src1._rotation22;
__tmp__20 = tf1._rotation20 * src1._rotation00 + tf1._rotation21 * src1._rotation10 + tf1._rotation22 * src1._rotation20;
__tmp__21 = tf1._rotation20 * src1._rotation01 + tf1._rotation21 * src1._rotation11 + tf1._rotation22 * src1._rotation21;
__tmp__22 = tf1._rotation20 * src1._rotation02 + tf1._rotation21 * src1._rotation12 + tf1._rotation22 * src1._rotation22;
dst._rotation00 = __tmp__00;
dst._rotation01 = __tmp__01;
dst._rotation02 = __tmp__02;
dst._rotation10 = __tmp__10;
dst._rotation11 = __tmp__11;
dst._rotation12 = __tmp__12;
dst._rotation20 = __tmp__20;
dst._rotation21 = __tmp__21;
dst._rotation22 = __tmp__22;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = tf1._rotation00 * src1._positionX + tf1._rotation01 * src1._positionY + tf1._rotation02 * src1._positionZ;
__tmp__Y = tf1._rotation10 * src1._positionX + tf1._rotation11 * src1._positionY + tf1._rotation12 * src1._positionZ;
__tmp__Z = tf1._rotation20 * src1._positionX + tf1._rotation21 * src1._positionY + tf1._rotation22 * src1._positionZ;
dst._positionX = __tmp__X;
dst._positionY = __tmp__Y;
dst._positionZ = __tmp__Z;
dst._positionX += tf1._positionX;
dst._positionY += tf1._positionY;
dst._positionZ += tf1._positionZ;
let dst1 = s._transform;
let src11 = s._localTransform;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = tf2._rotation00 * src11._rotation00 + tf2._rotation01 * src11._rotation10 + tf2._rotation02 * src11._rotation20;
__tmp__011 = tf2._rotation00 * src11._rotation01 + tf2._rotation01 * src11._rotation11 + tf2._rotation02 * src11._rotation21;
__tmp__021 = tf2._rotation00 * src11._rotation02 + tf2._rotation01 * src11._rotation12 + tf2._rotation02 * src11._rotation22;
__tmp__101 = tf2._rotation10 * src11._rotation00 + tf2._rotation11 * src11._rotation10 + tf2._rotation12 * src11._rotation20;
__tmp__111 = tf2._rotation10 * src11._rotation01 + tf2._rotation11 * src11._rotation11 + tf2._rotation12 * src11._rotation21;
__tmp__121 = tf2._rotation10 * src11._rotation02 + tf2._rotation11 * src11._rotation12 + tf2._rotation12 * src11._rotation22;
__tmp__201 = tf2._rotation20 * src11._rotation00 + tf2._rotation21 * src11._rotation10 + tf2._rotation22 * src11._rotation20;
__tmp__211 = tf2._rotation20 * src11._rotation01 + tf2._rotation21 * src11._rotation11 + tf2._rotation22 * src11._rotation21;
__tmp__221 = tf2._rotation20 * src11._rotation02 + tf2._rotation21 * src11._rotation12 + tf2._rotation22 * src11._rotation22;
dst1._rotation00 = __tmp__001;
dst1._rotation01 = __tmp__011;
dst1._rotation02 = __tmp__021;
dst1._rotation10 = __tmp__101;
dst1._rotation11 = __tmp__111;
dst1._rotation12 = __tmp__121;
dst1._rotation20 = __tmp__201;
dst1._rotation21 = __tmp__211;
dst1._rotation22 = __tmp__221;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = tf2._rotation00 * src11._positionX + tf2._rotation01 * src11._positionY + tf2._rotation02 * src11._positionZ;
__tmp__Y1 = tf2._rotation10 * src11._positionX + tf2._rotation11 * src11._positionY + tf2._rotation12 * src11._positionZ;
__tmp__Z1 = tf2._rotation20 * src11._positionX + tf2._rotation21 * src11._positionY + tf2._rotation22 * src11._positionZ;
dst1._positionX = __tmp__X1;
dst1._positionY = __tmp__Y1;
dst1._positionZ = __tmp__Z1;
dst1._positionX += tf2._positionX;
dst1._positionY += tf2._positionY;
dst1._positionZ += tf2._positionZ;
let minX;
let minY;
let minZ;
let maxX;
let maxY;
let maxZ;
s._geom._computeAabb(s._aabb,s._ptransform);
minX = s._aabb._minX;
minY = s._aabb._minY;
minZ = s._aabb._minZ;
maxX = s._aabb._maxX;
maxY = s._aabb._maxY;
maxZ = s._aabb._maxZ;
s._geom._computeAabb(s._aabb,s._transform);
s._aabb._minX = minX < s._aabb._minX ? minX : s._aabb._minX;
s._aabb._minY = minY < s._aabb._minY ? minY : s._aabb._minY;
s._aabb._minZ = minZ < s._aabb._minZ ? minZ : s._aabb._minZ;
s._aabb._maxX = maxX > s._aabb._maxX ? maxX : s._aabb._maxX;
s._aabb._maxY = maxY > s._aabb._maxY ? maxY : s._aabb._maxY;
s._aabb._maxZ = maxZ > s._aabb._maxZ ? maxZ : s._aabb._maxZ;
if(s._proxy != null) {
let dX;
let dY;
let dZ;
dX = s._transform._positionX - s._ptransform._positionX;
dY = s._transform._positionY - s._ptransform._positionY;
dZ = s._transform._positionZ - s._ptransform._positionZ;
let v = s.displacement;
v.x = dX;
v.y = dY;
v.z = dZ;
s._rigidBody._world._broadPhase.moveProxy(s._proxy,s._aabb,s.displacement);
}
s = n;
}
this._sleeping = false;
this._sleepTime = 0;
}
getTransform() {
let _this = this._transform;
let tf = new oimo.common.Transform();
tf._positionX = _this._positionX;
tf._positionY = _this._positionY;
tf._positionZ = _this._positionZ;
tf._rotation00 = _this._rotation00;
tf._rotation01 = _this._rotation01;
tf._rotation02 = _this._rotation02;
tf._rotation10 = _this._rotation10;
tf._rotation11 = _this._rotation11;
tf._rotation12 = _this._rotation12;
tf._rotation20 = _this._rotation20;
tf._rotation21 = _this._rotation21;
tf._rotation22 = _this._rotation22;
return tf;
}
getTransformTo(transform) {
let transform1 = this._transform;
transform._positionX = transform1._positionX;
transform._positionY = transform1._positionY;
transform._positionZ = transform1._positionZ;
transform._rotation00 = transform1._rotation00;
transform._rotation01 = transform1._rotation01;
transform._rotation02 = transform1._rotation02;
transform._rotation10 = transform1._rotation10;
transform._rotation11 = transform1._rotation11;
transform._rotation12 = transform1._rotation12;
transform._rotation20 = transform1._rotation20;
transform._rotation21 = transform1._rotation21;
transform._rotation22 = transform1._rotation22;
}
setTransform(transform) {
this._transform._positionX = transform._positionX;
this._transform._positionY = transform._positionY;
this._transform._positionZ = transform._positionZ;
this._transform._rotation00 = transform._rotation00;
this._transform._rotation01 = transform._rotation01;
this._transform._rotation02 = transform._rotation02;
this._transform._rotation10 = transform._rotation10;
this._transform._rotation11 = transform._rotation11;
this._transform._rotation12 = transform._rotation12;
this._transform._rotation20 = transform._rotation20;
this._transform._rotation21 = transform._rotation21;
this._transform._rotation22 = transform._rotation22;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = this._transform._rotation00 * this._invLocalInertia00 + this._transform._rotation01 * this._invLocalInertia10 + this._transform._rotation02 * this._invLocalInertia20;
__tmp__01 = this._transform._rotation00 * this._invLocalInertia01 + this._transform._rotation01 * this._invLocalInertia11 + this._transform._rotation02 * this._invLocalInertia21;
__tmp__02 = this._transform._rotation00 * this._invLocalInertia02 + this._transform._rotation01 * this._invLocalInertia12 + this._transform._rotation02 * this._invLocalInertia22;
__tmp__10 = this._transform._rotation10 * this._invLocalInertia00 + this._transform._rotation11 * this._invLocalInertia10 + this._transform._rotation12 * this._invLocalInertia20;
__tmp__11 = this._transform._rotation10 * this._invLocalInertia01 + this._transform._rotation11 * this._invLocalInertia11 + this._transform._rotation12 * this._invLocalInertia21;
__tmp__12 = this._transform._rotation10 * this._invLocalInertia02 + this._transform._rotation11 * this._invLocalInertia12 + this._transform._rotation12 * this._invLocalInertia22;
__tmp__20 = this._transform._rotation20 * this._invLocalInertia00 + this._transform._rotation21 * this._invLocalInertia10 + this._transform._rotation22 * this._invLocalInertia20;
__tmp__21 = this._transform._rotation20 * this._invLocalInertia01 + this._transform._rotation21 * this._invLocalInertia11 + this._transform._rotation22 * this._invLocalInertia21;
__tmp__22 = this._transform._rotation20 * this._invLocalInertia02 + this._transform._rotation21 * this._invLocalInertia12 + this._transform._rotation22 * this._invLocalInertia22;
this._invInertia00 = __tmp__00;
this._invInertia01 = __tmp__01;
this._invInertia02 = __tmp__02;
this._invInertia10 = __tmp__10;
this._invInertia11 = __tmp__11;
this._invInertia12 = __tmp__12;
this._invInertia20 = __tmp__20;
this._invInertia21 = __tmp__21;
this._invInertia22 = __tmp__22;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = this._invInertia00 * this._transform._rotation00 + this._invInertia01 * this._transform._rotation01 + this._invInertia02 * this._transform._rotation02;
__tmp__011 = this._invInertia00 * this._transform._rotation10 + this._invInertia01 * this._transform._rotation11 + this._invInertia02 * this._transform._rotation12;
__tmp__021 = this._invInertia00 * this._transform._rotation20 + this._invInertia01 * this._transform._rotation21 + this._invInertia02 * this._transform._rotation22;
__tmp__101 = this._invInertia10 * this._transform._rotation00 + this._invInertia11 * this._transform._rotation01 + this._invInertia12 * this._transform._rotation02;
__tmp__111 = this._invInertia10 * this._transform._rotation10 + this._invInertia11 * this._transform._rotation11 + this._invInertia12 * this._transform._rotation12;
__tmp__121 = this._invInertia10 * this._transform._rotation20 + this._invInertia11 * this._transform._rotation21 + this._invInertia12 * this._transform._rotation22;
__tmp__201 = this._invInertia20 * this._transform._rotation00 + this._invInertia21 * this._transform._rotation01 + this._invInertia22 * this._transform._rotation02;
__tmp__211 = this._invInertia20 * this._transform._rotation10 + this._invInertia21 * this._transform._rotation11 + this._invInertia22 * this._transform._rotation12;
__tmp__221 = this._invInertia20 * this._transform._rotation20 + this._invInertia21 * this._transform._rotation21 + this._invInertia22 * this._transform._rotation22;
this._invInertia00 = __tmp__001;
this._invInertia01 = __tmp__011;
this._invInertia02 = __tmp__021;
this._invInertia10 = __tmp__101;
this._invInertia11 = __tmp__111;
this._invInertia12 = __tmp__121;
this._invInertia20 = __tmp__201;
this._invInertia21 = __tmp__211;
this._invInertia22 = __tmp__221;
this._invInertia00 *= this._rotFactor.x;
this._invInertia01 *= this._rotFactor.x;
this._invInertia02 *= this._rotFactor.x;
this._invInertia10 *= this._rotFactor.y;
this._invInertia11 *= this._rotFactor.y;
this._invInertia12 *= this._rotFactor.y;
this._invInertia20 *= this._rotFactor.z;
this._invInertia21 *= this._rotFactor.z;
this._invInertia22 *= this._rotFactor.z;
let dst = this._ptransform;
let src = this._transform;
dst._positionX = src._positionX;
dst._positionY = src._positionY;
dst._positionZ = src._positionZ;
dst._rotation00 = src._rotation00;
dst._rotation01 = src._rotation01;
dst._rotation02 = src._rotation02;
dst._rotation10 = src._rotation10;
dst._rotation11 = src._rotation11;
dst._rotation12 = src._rotation12;
dst._rotation20 = src._rotation20;
dst._rotation21 = src._rotation21;
dst._rotation22 = src._rotation22;
let s = this._shapeList;
while(s != null) {
let n = s._next;
let tf1 = this._ptransform;
let tf2 = this._transform;
let dst = s._ptransform;
let src1 = s._localTransform;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = tf1._rotation00 * src1._rotation00 + tf1._rotation01 * src1._rotation10 + tf1._rotation02 * src1._rotation20;
__tmp__01 = tf1._rotation00 * src1._rotation01 + tf1._rotation01 * src1._rotation11 + tf1._rotation02 * src1._rotation21;
__tmp__02 = tf1._rotation00 * src1._rotation02 + tf1._rotation01 * src1._rotation12 + tf1._rotation02 * src1._rotation22;
__tmp__10 = tf1._rotation10 * src1._rotation00 + tf1._rotation11 * src1._rotation10 + tf1._rotation12 * src1._rotation20;
__tmp__11 = tf1._rotation10 * src1._rotation01 + tf1._rotation11 * src1._rotation11 + tf1._rotation12 * src1._rotation21;
__tmp__12 = tf1._rotation10 * src1._rotation02 + tf1._rotation11 * src1._rotation12 + tf1._rotation12 * src1._rotation22;
__tmp__20 = tf1._rotation20 * src1._rotation00 + tf1._rotation21 * src1._rotation10 + tf1._rotation22 * src1._rotation20;
__tmp__21 = tf1._rotation20 * src1._rotation01 + tf1._rotation21 * src1._rotation11 + tf1._rotation22 * src1._rotation21;
__tmp__22 = tf1._rotation20 * src1._rotation02 + tf1._rotation21 * src1._rotation12 + tf1._rotation22 * src1._rotation22;
dst._rotation00 = __tmp__00;
dst._rotation01 = __tmp__01;
dst._rotation02 = __tmp__02;
dst._rotation10 = __tmp__10;
dst._rotation11 = __tmp__11;
dst._rotation12 = __tmp__12;
dst._rotation20 = __tmp__20;
dst._rotation21 = __tmp__21;
dst._rotation22 = __tmp__22;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = tf1._rotation00 * src1._positionX + tf1._rotation01 * src1._positionY + tf1._rotation02 * src1._positionZ;
__tmp__Y = tf1._rotation10 * src1._positionX + tf1._rotation11 * src1._positionY + tf1._rotation12 * src1._positionZ;
__tmp__Z = tf1._rotation20 * src1._positionX + tf1._rotation21 * src1._positionY + tf1._rotation22 * src1._positionZ;
dst._positionX = __tmp__X;
dst._positionY = __tmp__Y;
dst._positionZ = __tmp__Z;
dst._positionX += tf1._positionX;
dst._positionY += tf1._positionY;
dst._positionZ += tf1._positionZ;
let dst1 = s._transform;
let src11 = s._localTransform;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = tf2._rotation00 * src11._rotation00 + tf2._rotation01 * src11._rotation10 + tf2._rotation02 * src11._rotation20;
__tmp__011 = tf2._rotation00 * src11._rotation01 + tf2._rotation01 * src11._rotation11 + tf2._rotation02 * src11._rotation21;
__tmp__021 = tf2._rotation00 * src11._rotation02 + tf2._rotation01 * src11._rotation12 + tf2._rotation02 * src11._rotation22;
__tmp__101 = tf2._rotation10 * src11._rotation00 + tf2._rotation11 * src11._rotation10 + tf2._rotation12 * src11._rotation20;
__tmp__111 = tf2._rotation10 * src11._rotation01 + tf2._rotation11 * src11._rotation11 + tf2._rotation12 * src11._rotation21;
__tmp__121 = tf2._rotation10 * src11._rotation02 + tf2._rotation11 * src11._rotation12 + tf2._rotation12 * src11._rotation22;
__tmp__201 = tf2._rotation20 * src11._rotation00 + tf2._rotation21 * src11._rotation10 + tf2._rotation22 * src11._rotation20;
__tmp__211 = tf2._rotation20 * src11._rotation01 + tf2._rotation21 * src11._rotation11 + tf2._rotation22 * src11._rotation21;
__tmp__221 = tf2._rotation20 * src11._rotation02 + tf2._rotation21 * src11._rotation12 + tf2._rotation22 * src11._rotation22;
dst1._rotation00 = __tmp__001;
dst1._rotation01 = __tmp__011;
dst1._rotation02 = __tmp__021;
dst1._rotation10 = __tmp__101;
dst1._rotation11 = __tmp__111;
dst1._rotation12 = __tmp__121;
dst1._rotation20 = __tmp__201;
dst1._rotation21 = __tmp__211;
dst1._rotation22 = __tmp__221;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = tf2._rotation00 * src11._positionX + tf2._rotation01 * src11._positionY + tf2._rotation02 * src11._positionZ;
__tmp__Y1 = tf2._rotation10 * src11._positionX + tf2._rotation11 * src11._positionY + tf2._rotation12 * src11._positionZ;
__tmp__Z1 = tf2._rotation20 * src11._positionX + tf2._rotation21 * src11._positionY + tf2._rotation22 * src11._positionZ;
dst1._positionX = __tmp__X1;
dst1._positionY = __tmp__Y1;
dst1._positionZ = __tmp__Z1;
dst1._positionX += tf2._positionX;
dst1._positionY += tf2._positionY;
dst1._positionZ += tf2._positionZ;
let minX;
let minY;
let minZ;
let maxX;
let maxY;
let maxZ;
s._geom._computeAabb(s._aabb,s._ptransform);
minX = s._aabb._minX;
minY = s._aabb._minY;
minZ = s._aabb._minZ;
maxX = s._aabb._maxX;
maxY = s._aabb._maxY;
maxZ = s._aabb._maxZ;
s._geom._computeAabb(s._aabb,s._transform);
s._aabb._minX = minX < s._aabb._minX ? minX : s._aabb._minX;
s._aabb._minY = minY < s._aabb._minY ? minY : s._aabb._minY;
s._aabb._minZ = minZ < s._aabb._minZ ? minZ : s._aabb._minZ;
s._aabb._maxX = maxX > s._aabb._maxX ? maxX : s._aabb._maxX;
s._aabb._maxY = maxY > s._aabb._maxY ? maxY : s._aabb._maxY;
s._aabb._maxZ = maxZ > s._aabb._maxZ ? maxZ : s._aabb._maxZ;
if(s._proxy != null) {
let dX;
let dY;
let dZ;
dX = s._transform._positionX - s._ptransform._positionX;
dY = s._transform._positionY - s._ptransform._positionY;
dZ = s._transform._positionZ - s._ptransform._positionZ;
let v = s.displacement;
v.x = dX;
v.y = dY;
v.z = dZ;
s._rigidBody._world._broadPhase.moveProxy(s._proxy,s._aabb,s.displacement);
}
s = n;
}
this._sleeping = false;
this._sleepTime = 0;
}
getMass() {
return this._mass;
}
getLocalInertia() {
let m = new oimo.common.Mat3();
m.e00 = this._localInertia00;
m.e01 = this._localInertia01;
m.e02 = this._localInertia02;
m.e10 = this._localInertia10;
m.e11 = this._localInertia11;
m.e12 = this._localInertia12;
m.e20 = this._localInertia20;
m.e21 = this._localInertia21;
m.e22 = this._localInertia22;
return m;
}
getLocalInertiaTo(inertia) {
inertia.e00 = this._localInertia00;
inertia.e01 = this._localInertia01;
inertia.e02 = this._localInertia02;
inertia.e10 = this._localInertia10;
inertia.e11 = this._localInertia11;
inertia.e12 = this._localInertia12;
inertia.e20 = this._localInertia20;
inertia.e21 = this._localInertia21;
inertia.e22 = this._localInertia22;
}
getMassData() {
let md = new oimo.dynamics.rigidbody.MassData();
md.mass = this._mass;
let m = md.localInertia;
m.e00 = this._localInertia00;
m.e01 = this._localInertia01;
m.e02 = this._localInertia02;
m.e10 = this._localInertia10;
m.e11 = this._localInertia11;
m.e12 = this._localInertia12;
m.e20 = this._localInertia20;
m.e21 = this._localInertia21;
m.e22 = this._localInertia22;
return md;
}
getMassDataTo(massData) {
massData.mass = this._mass;
let m = massData.localInertia;
m.e00 = this._localInertia00;
m.e01 = this._localInertia01;
m.e02 = this._localInertia02;
m.e10 = this._localInertia10;
m.e11 = this._localInertia11;
m.e12 = this._localInertia12;
m.e20 = this._localInertia20;
m.e21 = this._localInertia21;
m.e22 = this._localInertia22;
}
setMassData(massData) {
this._mass = massData.mass;
let m = massData.localInertia;
this._localInertia00 = m.e00;
this._localInertia01 = m.e01;
this._localInertia02 = m.e02;
this._localInertia10 = m.e10;
this._localInertia11 = m.e11;
this._localInertia12 = m.e12;
this._localInertia20 = m.e20;
this._localInertia21 = m.e21;
this._localInertia22 = m.e22;
if(this._mass > 0 && this._localInertia00 * (this._localInertia11 * this._localInertia22 - this._localInertia12 * this._localInertia21) - this._localInertia01 * (this._localInertia10 * this._localInertia22 - this._localInertia12 * this._localInertia20) + this._localInertia02 * (this._localInertia10 * this._localInertia21 - this._localInertia11 * this._localInertia20) > 0 && this._type == 0) {
this._invMass = 1 / this._mass;
let d00 = this._localInertia11 * this._localInertia22 - this._localInertia12 * this._localInertia21;
let d01 = this._localInertia10 * this._localInertia22 - this._localInertia12 * this._localInertia20;
let d02 = this._localInertia10 * this._localInertia21 - this._localInertia11 * this._localInertia20;
let d = this._localInertia00 * d00 - this._localInertia01 * d01 + this._localInertia02 * d02;
if(d < -1e-32 || d > 1e-32) {
d = 1 / d;
}
this._invLocalInertia00 = d00 * d;
this._invLocalInertia01 = -(this._localInertia01 * this._localInertia22 - this._localInertia02 * this._localInertia21) * d;
this._invLocalInertia02 = (this._localInertia01 * this._localInertia12 - this._localInertia02 * this._localInertia11) * d;
this._invLocalInertia10 = -d01 * d;
this._invLocalInertia11 = (this._localInertia00 * this._localInertia22 - this._localInertia02 * this._localInertia20) * d;
this._invLocalInertia12 = -(this._localInertia00 * this._localInertia12 - this._localInertia02 * this._localInertia10) * d;
this._invLocalInertia20 = d02 * d;
this._invLocalInertia21 = -(this._localInertia00 * this._localInertia21 - this._localInertia01 * this._localInertia20) * d;
this._invLocalInertia22 = (this._localInertia00 * this._localInertia11 - this._localInertia01 * this._localInertia10) * d;
this._invLocalInertiaWithoutRotFactor00 = this._invLocalInertia00;
this._invLocalInertiaWithoutRotFactor01 = this._invLocalInertia01;
this._invLocalInertiaWithoutRotFactor02 = this._invLocalInertia02;
this._invLocalInertiaWithoutRotFactor10 = this._invLocalInertia10;
this._invLocalInertiaWithoutRotFactor11 = this._invLocalInertia11;
this._invLocalInertiaWithoutRotFactor12 = this._invLocalInertia12;
this._invLocalInertiaWithoutRotFactor20 = this._invLocalInertia20;
this._invLocalInertiaWithoutRotFactor21 = this._invLocalInertia21;
this._invLocalInertiaWithoutRotFactor22 = this._invLocalInertia22;
this._invLocalInertia00 = this._invLocalInertiaWithoutRotFactor00 * this._rotFactor.x;
this._invLocalInertia01 = this._invLocalInertiaWithoutRotFactor01 * this._rotFactor.x;
this._invLocalInertia02 = this._invLocalInertiaWithoutRotFactor02 * this._rotFactor.x;
this._invLocalInertia10 = this._invLocalInertiaWithoutRotFactor10 * this._rotFactor.y;
this._invLocalInertia11 = this._invLocalInertiaWithoutRotFactor11 * this._rotFactor.y;
this._invLocalInertia12 = this._invLocalInertiaWithoutRotFactor12 * this._rotFactor.y;
this._invLocalInertia20 = this._invLocalInertiaWithoutRotFactor20 * this._rotFactor.z;
this._invLocalInertia21 = this._invLocalInertiaWithoutRotFactor21 * this._rotFactor.z;
this._invLocalInertia22 = this._invLocalInertiaWithoutRotFactor22 * this._rotFactor.z;
} else {
this._invMass = 0;
this._invLocalInertia00 = 0;
this._invLocalInertia01 = 0;
this._invLocalInertia02 = 0;
this._invLocalInertia10 = 0;
this._invLocalInertia11 = 0;
this._invLocalInertia12 = 0;
this._invLocalInertia20 = 0;
this._invLocalInertia21 = 0;
this._invLocalInertia22 = 0;
this._invLocalInertiaWithoutRotFactor00 = 0;
this._invLocalInertiaWithoutRotFactor01 = 0;
this._invLocalInertiaWithoutRotFactor02 = 0;
this._invLocalInertiaWithoutRotFactor10 = 0;
this._invLocalInertiaWithoutRotFactor11 = 0;
this._invLocalInertiaWithoutRotFactor12 = 0;
this._invLocalInertiaWithoutRotFactor20 = 0;
this._invLocalInertiaWithoutRotFactor21 = 0;
this._invLocalInertiaWithoutRotFactor22 = 0;
if(this._type == 0) {
this._type = 1;
}
}
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = this._transform._rotation00 * this._invLocalInertia00 + this._transform._rotation01 * this._invLocalInertia10 + this._transform._rotation02 * this._invLocalInertia20;
__tmp__01 = this._transform._rotation00 * this._invLocalInertia01 + this._transform._rotation01 * this._invLocalInertia11 + this._transform._rotation02 * this._invLocalInertia21;
__tmp__02 = this._transform._rotation00 * this._invLocalInertia02 + this._transform._rotation01 * this._invLocalInertia12 + this._transform._rotation02 * this._invLocalInertia22;
__tmp__10 = this._transform._rotation10 * this._invLocalInertia00 + this._transform._rotation11 * this._invLocalInertia10 + this._transform._rotation12 * this._invLocalInertia20;
__tmp__11 = this._transform._rotation10 * this._invLocalInertia01 + this._transform._rotation11 * this._invLocalInertia11 + this._transform._rotation12 * this._invLocalInertia21;
__tmp__12 = this._transform._rotation10 * this._invLocalInertia02 + this._transform._rotation11 * this._invLocalInertia12 + this._transform._rotation12 * this._invLocalInertia22;
__tmp__20 = this._transform._rotation20 * this._invLocalInertia00 + this._transform._rotation21 * this._invLocalInertia10 + this._transform._rotation22 * this._invLocalInertia20;
__tmp__21 = this._transform._rotation20 * this._invLocalInertia01 + this._transform._rotation21 * this._invLocalInertia11 + this._transform._rotation22 * this._invLocalInertia21;
__tmp__22 = this._transform._rotation20 * this._invLocalInertia02 + this._transform._rotation21 * this._invLocalInertia12 + this._transform._rotation22 * this._invLocalInertia22;
this._invInertia00 = __tmp__00;
this._invInertia01 = __tmp__01;
this._invInertia02 = __tmp__02;
this._invInertia10 = __tmp__10;
this._invInertia11 = __tmp__11;
this._invInertia12 = __tmp__12;
this._invInertia20 = __tmp__20;
this._invInertia21 = __tmp__21;
this._invInertia22 = __tmp__22;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = this._invInertia00 * this._transform._rotation00 + this._invInertia01 * this._transform._rotation01 + this._invInertia02 * this._transform._rotation02;
__tmp__011 = this._invInertia00 * this._transform._rotation10 + this._invInertia01 * this._transform._rotation11 + this._invInertia02 * this._transform._rotation12;
__tmp__021 = this._invInertia00 * this._transform._rotation20 + this._invInertia01 * this._transform._rotation21 + this._invInertia02 * this._transform._rotation22;
__tmp__101 = this._invInertia10 * this._transform._rotation00 + this._invInertia11 * this._transform._rotation01 + this._invInertia12 * this._transform._rotation02;
__tmp__111 = this._invInertia10 * this._transform._rotation10 + this._invInertia11 * this._transform._rotation11 + this._invInertia12 * this._transform._rotation12;
__tmp__121 = this._invInertia10 * this._transform._rotation20 + this._invInertia11 * this._transform._rotation21 + this._invInertia12 * this._transform._rotation22;
__tmp__201 = this._invInertia20 * this._transform._rotation00 + this._invInertia21 * this._transform._rotation01 + this._invInertia22 * this._transform._rotation02;
__tmp__211 = this._invInertia20 * this._transform._rotation10 + this._invInertia21 * this._transform._rotation11 + this._invInertia22 * this._transform._rotation12;
__tmp__221 = this._invInertia20 * this._transform._rotation20 + this._invInertia21 * this._transform._rotation21 + this._invInertia22 * this._transform._rotation22;
this._invInertia00 = __tmp__001;
this._invInertia01 = __tmp__011;
this._invInertia02 = __tmp__021;
this._invInertia10 = __tmp__101;
this._invInertia11 = __tmp__111;
this._invInertia12 = __tmp__121;
this._invInertia20 = __tmp__201;
this._invInertia21 = __tmp__211;
this._invInertia22 = __tmp__221;
this._invInertia00 *= this._rotFactor.x;
this._invInertia01 *= this._rotFactor.x;
this._invInertia02 *= this._rotFactor.x;
this._invInertia10 *= this._rotFactor.y;
this._invInertia11 *= this._rotFactor.y;
this._invInertia12 *= this._rotFactor.y;
this._invInertia20 *= this._rotFactor.z;
this._invInertia21 *= this._rotFactor.z;
this._invInertia22 *= this._rotFactor.z;
this._sleeping = false;
this._sleepTime = 0;
}
getRotationFactor() {
let _this = this._rotFactor;
return new oimo.common.Vec3(_this.x,_this.y,_this.z);
}
setRotationFactor(rotationFactor) {
let _this = this._rotFactor;
_this.x = rotationFactor.x;
_this.y = rotationFactor.y;
_this.z = rotationFactor.z;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = this._transform._rotation00 * this._invLocalInertia00 + this._transform._rotation01 * this._invLocalInertia10 + this._transform._rotation02 * this._invLocalInertia20;
__tmp__01 = this._transform._rotation00 * this._invLocalInertia01 + this._transform._rotation01 * this._invLocalInertia11 + this._transform._rotation02 * this._invLocalInertia21;
__tmp__02 = this._transform._rotation00 * this._invLocalInertia02 + this._transform._rotation01 * this._invLocalInertia12 + this._transform._rotation02 * this._invLocalInertia22;
__tmp__10 = this._transform._rotation10 * this._invLocalInertia00 + this._transform._rotation11 * this._invLocalInertia10 + this._transform._rotation12 * this._invLocalInertia20;
__tmp__11 = this._transform._rotation10 * this._invLocalInertia01 + this._transform._rotation11 * this._invLocalInertia11 + this._transform._rotation12 * this._invLocalInertia21;
__tmp__12 = this._transform._rotation10 * this._invLocalInertia02 + this._transform._rotation11 * this._invLocalInertia12 + this._transform._rotation12 * this._invLocalInertia22;
__tmp__20 = this._transform._rotation20 * this._invLocalInertia00 + this._transform._rotation21 * this._invLocalInertia10 + this._transform._rotation22 * this._invLocalInertia20;
__tmp__21 = this._transform._rotation20 * this._invLocalInertia01 + this._transform._rotation21 * this._invLocalInertia11 + this._transform._rotation22 * this._invLocalInertia21;
__tmp__22 = this._transform._rotation20 * this._invLocalInertia02 + this._transform._rotation21 * this._invLocalInertia12 + this._transform._rotation22 * this._invLocalInertia22;
this._invInertia00 = __tmp__00;
this._invInertia01 = __tmp__01;
this._invInertia02 = __tmp__02;
this._invInertia10 = __tmp__10;
this._invInertia11 = __tmp__11;
this._invInertia12 = __tmp__12;
this._invInertia20 = __tmp__20;
this._invInertia21 = __tmp__21;
this._invInertia22 = __tmp__22;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = this._invInertia00 * this._transform._rotation00 + this._invInertia01 * this._transform._rotation01 + this._invInertia02 * this._transform._rotation02;
__tmp__011 = this._invInertia00 * this._transform._rotation10 + this._invInertia01 * this._transform._rotation11 + this._invInertia02 * this._transform._rotation12;
__tmp__021 = this._invInertia00 * this._transform._rotation20 + this._invInertia01 * this._transform._rotation21 + this._invInertia02 * this._transform._rotation22;
__tmp__101 = this._invInertia10 * this._transform._rotation00 + this._invInertia11 * this._transform._rotation01 + this._invInertia12 * this._transform._rotation02;
__tmp__111 = this._invInertia10 * this._transform._rotation10 + this._invInertia11 * this._transform._rotation11 + this._invInertia12 * this._transform._rotation12;
__tmp__121 = this._invInertia10 * this._transform._rotation20 + this._invInertia11 * this._transform._rotation21 + this._invInertia12 * this._transform._rotation22;
__tmp__201 = this._invInertia20 * this._transform._rotation00 + this._invInertia21 * this._transform._rotation01 + this._invInertia22 * this._transform._rotation02;
__tmp__211 = this._invInertia20 * this._transform._rotation10 + this._invInertia21 * this._transform._rotation11 + this._invInertia22 * this._transform._rotation12;
__tmp__221 = this._invInertia20 * this._transform._rotation20 + this._invInertia21 * this._transform._rotation21 + this._invInertia22 * this._transform._rotation22;
this._invInertia00 = __tmp__001;
this._invInertia01 = __tmp__011;
this._invInertia02 = __tmp__021;
this._invInertia10 = __tmp__101;
this._invInertia11 = __tmp__111;
this._invInertia12 = __tmp__121;
this._invInertia20 = __tmp__201;
this._invInertia21 = __tmp__211;
this._invInertia22 = __tmp__221;
this._invInertia00 *= this._rotFactor.x;
this._invInertia01 *= this._rotFactor.x;
this._invInertia02 *= this._rotFactor.x;
this._invInertia10 *= this._rotFactor.y;
this._invInertia11 *= this._rotFactor.y;
this._invInertia12 *= this._rotFactor.y;
this._invInertia20 *= this._rotFactor.z;
this._invInertia21 *= this._rotFactor.z;
this._invInertia22 *= this._rotFactor.z;
this._sleeping = false;
this._sleepTime = 0;
}
getLinearVelocity() {
let v = new oimo.common.Vec3();
v.x = this._velX;
v.y = this._velY;
v.z = this._velZ;
return v;
}
getLinearVelocityTo(linearVelocity) {
linearVelocity.x = this._velX;
linearVelocity.y = this._velY;
linearVelocity.z = this._velZ;
}
setLinearVelocity(linearVelocity) {
if(this._type == 1) {
this._velX = 0;
this._velY = 0;
this._velZ = 0;
} else {
this._velX = linearVelocity.x;
this._velY = linearVelocity.y;
this._velZ = linearVelocity.z;
}
this._sleeping = false;
this._sleepTime = 0;
}
getAngularVelocity() {
let v = new oimo.common.Vec3();
v.x = this._angVelX;
v.y = this._angVelY;
v.z = this._angVelZ;
return v;
}
getAngularVelocityTo(angularVelocity) {
angularVelocity.x = this._velX;
angularVelocity.y = this._velY;
angularVelocity.z = this._velZ;
}
setAngularVelocity(angularVelocity) {
if(this._type == 1) {
this._angVelX = 0;
this._angVelY = 0;
this._angVelZ = 0;
} else {
this._angVelX = angularVelocity.x;
this._angVelY = angularVelocity.y;
this._angVelZ = angularVelocity.z;
}
this._sleeping = false;
this._sleepTime = 0;
}
addLinearVelocity(linearVelocityChange) {
if(this._type != 1) {
let dX;
let dY;
let dZ;
dX = linearVelocityChange.x;
dY = linearVelocityChange.y;
dZ = linearVelocityChange.z;
this._velX += dX;
this._velY += dY;
this._velZ += dZ;
}
this._sleeping = false;
this._sleepTime = 0;
}
addAngularVelocity(angularVelocityChange) {
if(this._type != 1) {
let dX;
let dY;
let dZ;
dX = angularVelocityChange.x;
dY = angularVelocityChange.y;
dZ = angularVelocityChange.z;
this._angVelX += dX;
this._angVelY += dY;
this._angVelZ += dZ;
}
this._sleeping = false;
this._sleepTime = 0;
}
applyImpulse(impulse,positionInWorld) {
let impX;
let impY;
let impZ;
impX = impulse.x;
impY = impulse.y;
impZ = impulse.z;
this._velX += impX * this._invMass;
this._velY += impY * this._invMass;
this._velZ += impZ * this._invMass;
let aimpX;
let aimpY;
let aimpZ;
let posX;
let posY;
let posZ;
posX = positionInWorld.x;
posY = positionInWorld.y;
posZ = positionInWorld.z;
posX -= this._transform._positionX;
posY -= this._transform._positionY;
posZ -= this._transform._positionZ;
aimpX = posY * impZ - posZ * impY;
aimpY = posZ * impX - posX * impZ;
aimpZ = posX * impY - posY * impX;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = this._invInertia00 * aimpX + this._invInertia01 * aimpY + this._invInertia02 * aimpZ;
__tmp__Y = this._invInertia10 * aimpX + this._invInertia11 * aimpY + this._invInertia12 * aimpZ;
__tmp__Z = this._invInertia20 * aimpX + this._invInertia21 * aimpY + this._invInertia22 * aimpZ;
aimpX = __tmp__X;
aimpY = __tmp__Y;
aimpZ = __tmp__Z;
this._angVelX += aimpX;
this._angVelY += aimpY;
this._angVelZ += aimpZ;
this._sleeping = false;
this._sleepTime = 0;
}
applyLinearImpulse(impulse) {
let impX;
let impY;
let impZ;
impX = impulse.x;
impY = impulse.y;
impZ = impulse.z;
this._velX += impX * this._invMass;
this._velY += impY * this._invMass;
this._velZ += impZ * this._invMass;
this._sleeping = false;
this._sleepTime = 0;
}
applyAngularImpulse(impulse) {
let impX;
let impY;
let impZ;
impX = impulse.x;
impY = impulse.y;
impZ = impulse.z;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = this._invInertia00 * impX + this._invInertia01 * impY + this._invInertia02 * impZ;
__tmp__Y = this._invInertia10 * impX + this._invInertia11 * impY + this._invInertia12 * impZ;
__tmp__Z = this._invInertia20 * impX + this._invInertia21 * impY + this._invInertia22 * impZ;
impX = __tmp__X;
impY = __tmp__Y;
impZ = __tmp__Z;
this._angVelX += impX;
this._angVelY += impY;
this._angVelZ += impZ;
this._sleeping = false;
this._sleepTime = 0;
}
applyForce(force,positionInWorld) {
let iforceX;
let iforceY;
let iforceZ;
iforceX = force.x;
iforceY = force.y;
iforceZ = force.z;
this._forceX += iforceX;
this._forceY += iforceY;
this._forceZ += iforceZ;
let itorqueX;
let itorqueY;
let itorqueZ;
let posX;
let posY;
let posZ;
posX = positionInWorld.x;
posY = positionInWorld.y;
posZ = positionInWorld.z;
posX -= this._transform._positionX;
posY -= this._transform._positionY;
posZ -= this._transform._positionZ;
itorqueX = posY * iforceZ - posZ * iforceY;
itorqueY = posZ * iforceX - posX * iforceZ;
itorqueZ = posX * iforceY - posY * iforceX;
this._torqueX += itorqueX;
this._torqueY += itorqueY;
this._torqueZ += itorqueZ;
this._sleeping = false;
this._sleepTime = 0;
}
applyForceToCenter(force) {
let iforceX;
let iforceY;
let iforceZ;
iforceX = force.x;
iforceY = force.y;
iforceZ = force.z;
this._forceX += iforceX;
this._forceY += iforceY;
this._forceZ += iforceZ;
this._sleeping = false;
this._sleepTime = 0;
}
applyTorque(torque) {
let itorqueX;
let itorqueY;
let itorqueZ;
itorqueX = torque.x;
itorqueY = torque.y;
itorqueZ = torque.z;
this._torqueX += itorqueX;
this._torqueY += itorqueY;
this._torqueZ += itorqueZ;
this._sleeping = false;
this._sleepTime = 0;
}
getLinearContactImpulse() {
let res = new oimo.common.Vec3();
res.x = this._linearContactImpulseX;
res.y = this._linearContactImpulseY;
res.z = this._linearContactImpulseZ;
return res;
}
getLinearContactImpulseTo(linearContactImpulse) {
linearContactImpulse.x = this._linearContactImpulseX;
linearContactImpulse.y = this._linearContactImpulseY;
linearContactImpulse.z = this._linearContactImpulseZ;
}
getAngularContactImpulse() {
let res = new oimo.common.Vec3();
res.x = this._angularContactImpulseX;
res.y = this._angularContactImpulseY;
res.z = this._angularContactImpulseZ;
return res;
}
getAngularContactImpulseTo(angularContactImpulse) {
angularContactImpulse.x = this._angularContactImpulseX;
angularContactImpulse.y = this._angularContactImpulseY;
angularContactImpulse.z = this._angularContactImpulseZ;
}
getGravityScale() {
return this._gravityScale;
}
setGravityScale(gravityScale) {
this._gravityScale = gravityScale;
this._sleeping = false;
this._sleepTime = 0;
}
getLocalPoint(worldPoint) {
let vX;
let vY;
let vZ;
vX = worldPoint.x;
vY = worldPoint.y;
vZ = worldPoint.z;
vX -= this._transform._positionX;
vY -= this._transform._positionY;
vZ -= this._transform._positionZ;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = this._transform._rotation00 * vX + this._transform._rotation10 * vY + this._transform._rotation20 * vZ;
__tmp__Y = this._transform._rotation01 * vX + this._transform._rotation11 * vY + this._transform._rotation21 * vZ;
__tmp__Z = this._transform._rotation02 * vX + this._transform._rotation12 * vY + this._transform._rotation22 * vZ;
vX = __tmp__X;
vY = __tmp__Y;
vZ = __tmp__Z;
let res = new oimo.common.Vec3();
res.x = vX;
res.y = vY;
res.z = vZ;
return res;
}
getLocalPointTo(worldPoint,localPoint) {
let vX;
let vY;
let vZ;
vX = worldPoint.x;
vY = worldPoint.y;
vZ = worldPoint.z;
vX -= this._transform._positionX;
vY -= this._transform._positionY;
vZ -= this._transform._positionZ;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = this._transform._rotation00 * vX + this._transform._rotation10 * vY + this._transform._rotation20 * vZ;
__tmp__Y = this._transform._rotation01 * vX + this._transform._rotation11 * vY + this._transform._rotation21 * vZ;
__tmp__Z = this._transform._rotation02 * vX + this._transform._rotation12 * vY + this._transform._rotation22 * vZ;
vX = __tmp__X;
vY = __tmp__Y;
vZ = __tmp__Z;
localPoint.x = vX;
localPoint.y = vY;
localPoint.z = vZ;
}
getLocalVector(worldVector) {
let vX;
let vY;
let vZ;
vX = worldVector.x;
vY = worldVector.y;
vZ = worldVector.z;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = this._transform._rotation00 * vX + this._transform._rotation10 * vY + this._transform._rotation20 * vZ;
__tmp__Y = this._transform._rotation01 * vX + this._transform._rotation11 * vY + this._transform._rotation21 * vZ;
__tmp__Z = this._transform._rotation02 * vX + this._transform._rotation12 * vY + this._transform._rotation22 * vZ;
vX = __tmp__X;
vY = __tmp__Y;
vZ = __tmp__Z;
let res = new oimo.common.Vec3();
res.x = vX;
res.y = vY;
res.z = vZ;
return res;
}
getLocalVectorTo(worldVector,localVector) {
let vX;
let vY;
let vZ;
vX = worldVector.x;
vY = worldVector.y;
vZ = worldVector.z;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = this._transform._rotation00 * vX + this._transform._rotation10 * vY + this._transform._rotation20 * vZ;
__tmp__Y = this._transform._rotation01 * vX + this._transform._rotation11 * vY + this._transform._rotation21 * vZ;
__tmp__Z = this._transform._rotation02 * vX + this._transform._rotation12 * vY + this._transform._rotation22 * vZ;
vX = __tmp__X;
vY = __tmp__Y;
vZ = __tmp__Z;
localVector.x = vX;
localVector.y = vY;
localVector.z = vZ;
}
getWorldPoint(localPoint) {
let vX;
let vY;
let vZ;
vX = localPoint.x;
vY = localPoint.y;
vZ = localPoint.z;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = this._transform._rotation00 * vX + this._transform._rotation01 * vY + this._transform._rotation02 * vZ;
__tmp__Y = this._transform._rotation10 * vX + this._transform._rotation11 * vY + this._transform._rotation12 * vZ;
__tmp__Z = this._transform._rotation20 * vX + this._transform._rotation21 * vY + this._transform._rotation22 * vZ;
vX = __tmp__X;
vY = __tmp__Y;
vZ = __tmp__Z;
vX += this._transform._positionX;
vY += this._transform._positionY;
vZ += this._transform._positionZ;
let res = new oimo.common.Vec3();
res.x = vX;
res.y = vY;
res.z = vZ;
return res;
}
getWorldPointTo(localPoint,worldPoint) {
let vX;
let vY;
let vZ;
vX = localPoint.x;
vY = localPoint.y;
vZ = localPoint.z;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = this._transform._rotation00 * vX + this._transform._rotation01 * vY + this._transform._rotation02 * vZ;
__tmp__Y = this._transform._rotation10 * vX + this._transform._rotation11 * vY + this._transform._rotation12 * vZ;
__tmp__Z = this._transform._rotation20 * vX + this._transform._rotation21 * vY + this._transform._rotation22 * vZ;
vX = __tmp__X;
vY = __tmp__Y;
vZ = __tmp__Z;
vX += this._transform._positionX;
vY += this._transform._positionY;
vZ += this._transform._positionZ;
worldPoint.x = vX;
worldPoint.y = vY;
worldPoint.z = vZ;
}
getWorldVector(localVector) {
let vX;
let vY;
let vZ;
vX = localVector.x;
vY = localVector.y;
vZ = localVector.z;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = this._transform._rotation00 * vX + this._transform._rotation01 * vY + this._transform._rotation02 * vZ;
__tmp__Y = this._transform._rotation10 * vX + this._transform._rotation11 * vY + this._transform._rotation12 * vZ;
__tmp__Z = this._transform._rotation20 * vX + this._transform._rotation21 * vY + this._transform._rotation22 * vZ;
vX = __tmp__X;
vY = __tmp__Y;
vZ = __tmp__Z;
let res = new oimo.common.Vec3();
res.x = vX;
res.y = vY;
res.z = vZ;
return res;
}
getWorldVectorTo(localVector,worldVector) {
let vX;
let vY;
let vZ;
vX = localVector.x;
vY = localVector.y;
vZ = localVector.z;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = this._transform._rotation00 * vX + this._transform._rotation01 * vY + this._transform._rotation02 * vZ;
__tmp__Y = this._transform._rotation10 * vX + this._transform._rotation11 * vY + this._transform._rotation12 * vZ;
__tmp__Z = this._transform._rotation20 * vX + this._transform._rotation21 * vY + this._transform._rotation22 * vZ;
vX = __tmp__X;
vY = __tmp__Y;
vZ = __tmp__Z;
worldVector.x = vX;
worldVector.y = vY;
worldVector.z = vZ;
}
getNumShapes() {
return this._numShapes;
}
getShapeList() {
return this._shapeList;
}
getNumContectLinks() {
return this._numContactLinks;
}
getContactLinkList() {
return this._contactLinkList;
}
getNumJointLinks() {
return this._numJointLinks;
}
getJointLinkList() {
return this._jointLinkList;
}
addShape(shape) {
if(this._shapeList == null) {
this._shapeList = shape;
this._shapeListLast = shape;
} else {
this._shapeListLast._next = shape;
shape._prev = this._shapeListLast;
this._shapeListLast = shape;
}
this._numShapes++;
shape._rigidBody = this;
if(this._world != null) {
let _this = this._world;
shape._proxy = _this._broadPhase.createProxy(shape,shape._aabb);
shape._id = _this._shapeIdCount++;
_this._numShapes++;
}
this.updateMass();
let s = this._shapeList;
while(s != null) {
let n = s._next;
let tf1 = this._ptransform;
let tf2 = this._transform;
let dst = s._ptransform;
let src1 = s._localTransform;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = tf1._rotation00 * src1._rotation00 + tf1._rotation01 * src1._rotation10 + tf1._rotation02 * src1._rotation20;
__tmp__01 = tf1._rotation00 * src1._rotation01 + tf1._rotation01 * src1._rotation11 + tf1._rotation02 * src1._rotation21;
__tmp__02 = tf1._rotation00 * src1._rotation02 + tf1._rotation01 * src1._rotation12 + tf1._rotation02 * src1._rotation22;
__tmp__10 = tf1._rotation10 * src1._rotation00 + tf1._rotation11 * src1._rotation10 + tf1._rotation12 * src1._rotation20;
__tmp__11 = tf1._rotation10 * src1._rotation01 + tf1._rotation11 * src1._rotation11 + tf1._rotation12 * src1._rotation21;
__tmp__12 = tf1._rotation10 * src1._rotation02 + tf1._rotation11 * src1._rotation12 + tf1._rotation12 * src1._rotation22;
__tmp__20 = tf1._rotation20 * src1._rotation00 + tf1._rotation21 * src1._rotation10 + tf1._rotation22 * src1._rotation20;
__tmp__21 = tf1._rotation20 * src1._rotation01 + tf1._rotation21 * src1._rotation11 + tf1._rotation22 * src1._rotation21;
__tmp__22 = tf1._rotation20 * src1._rotation02 + tf1._rotation21 * src1._rotation12 + tf1._rotation22 * src1._rotation22;
dst._rotation00 = __tmp__00;
dst._rotation01 = __tmp__01;
dst._rotation02 = __tmp__02;
dst._rotation10 = __tmp__10;
dst._rotation11 = __tmp__11;
dst._rotation12 = __tmp__12;
dst._rotation20 = __tmp__20;
dst._rotation21 = __tmp__21;
dst._rotation22 = __tmp__22;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = tf1._rotation00 * src1._positionX + tf1._rotation01 * src1._positionY + tf1._rotation02 * src1._positionZ;
__tmp__Y = tf1._rotation10 * src1._positionX + tf1._rotation11 * src1._positionY + tf1._rotation12 * src1._positionZ;
__tmp__Z = tf1._rotation20 * src1._positionX + tf1._rotation21 * src1._positionY + tf1._rotation22 * src1._positionZ;
dst._positionX = __tmp__X;
dst._positionY = __tmp__Y;
dst._positionZ = __tmp__Z;
dst._positionX += tf1._positionX;
dst._positionY += tf1._positionY;
dst._positionZ += tf1._positionZ;
let dst1 = s._transform;
let src11 = s._localTransform;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = tf2._rotation00 * src11._rotation00 + tf2._rotation01 * src11._rotation10 + tf2._rotation02 * src11._rotation20;
__tmp__011 = tf2._rotation00 * src11._rotation01 + tf2._rotation01 * src11._rotation11 + tf2._rotation02 * src11._rotation21;
__tmp__021 = tf2._rotation00 * src11._rotation02 + tf2._rotation01 * src11._rotation12 + tf2._rotation02 * src11._rotation22;
__tmp__101 = tf2._rotation10 * src11._rotation00 + tf2._rotation11 * src11._rotation10 + tf2._rotation12 * src11._rotation20;
__tmp__111 = tf2._rotation10 * src11._rotation01 + tf2._rotation11 * src11._rotation11 + tf2._rotation12 * src11._rotation21;
__tmp__121 = tf2._rotation10 * src11._rotation02 + tf2._rotation11 * src11._rotation12 + tf2._rotation12 * src11._rotation22;
__tmp__201 = tf2._rotation20 * src11._rotation00 + tf2._rotation21 * src11._rotation10 + tf2._rotation22 * src11._rotation20;
__tmp__211 = tf2._rotation20 * src11._rotation01 + tf2._rotation21 * src11._rotation11 + tf2._rotation22 * src11._rotation21;
__tmp__221 = tf2._rotation20 * src11._rotation02 + tf2._rotation21 * src11._rotation12 + tf2._rotation22 * src11._rotation22;
dst1._rotation00 = __tmp__001;
dst1._rotation01 = __tmp__011;
dst1._rotation02 = __tmp__021;
dst1._rotation10 = __tmp__101;
dst1._rotation11 = __tmp__111;
dst1._rotation12 = __tmp__121;
dst1._rotation20 = __tmp__201;
dst1._rotation21 = __tmp__211;
dst1._rotation22 = __tmp__221;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = tf2._rotation00 * src11._positionX + tf2._rotation01 * src11._positionY + tf2._rotation02 * src11._positionZ;
__tmp__Y1 = tf2._rotation10 * src11._positionX + tf2._rotation11 * src11._positionY + tf2._rotation12 * src11._positionZ;
__tmp__Z1 = tf2._rotation20 * src11._positionX + tf2._rotation21 * src11._positionY + tf2._rotation22 * src11._positionZ;
dst1._positionX = __tmp__X1;
dst1._positionY = __tmp__Y1;
dst1._positionZ = __tmp__Z1;
dst1._positionX += tf2._positionX;
dst1._positionY += tf2._positionY;
dst1._positionZ += tf2._positionZ;
let minX;
let minY;
let minZ;
let maxX;
let maxY;
let maxZ;
s._geom._computeAabb(s._aabb,s._ptransform);
minX = s._aabb._minX;
minY = s._aabb._minY;
minZ = s._aabb._minZ;
maxX = s._aabb._maxX;
maxY = s._aabb._maxY;
maxZ = s._aabb._maxZ;
s._geom._computeAabb(s._aabb,s._transform);
s._aabb._minX = minX < s._aabb._minX ? minX : s._aabb._minX;
s._aabb._minY = minY < s._aabb._minY ? minY : s._aabb._minY;
s._aabb._minZ = minZ < s._aabb._minZ ? minZ : s._aabb._minZ;
s._aabb._maxX = maxX > s._aabb._maxX ? maxX : s._aabb._maxX;
s._aabb._maxY = maxY > s._aabb._maxY ? maxY : s._aabb._maxY;
s._aabb._maxZ = maxZ > s._aabb._maxZ ? maxZ : s._aabb._maxZ;
if(s._proxy != null) {
let dX;
let dY;
let dZ;
dX = s._transform._positionX - s._ptransform._positionX;
dY = s._transform._positionY - s._ptransform._positionY;
dZ = s._transform._positionZ - s._ptransform._positionZ;
let v = s.displacement;
v.x = dX;
v.y = dY;
v.z = dZ;
s._rigidBody._world._broadPhase.moveProxy(s._proxy,s._aabb,s.displacement);
}
s = n;
}
}
removeShape(shape) {
let prev = shape._prev;
let next = shape._next;
if(prev != null) {
prev._next = next;
}
if(next != null) {
next._prev = prev;
}
if(shape == this._shapeList) {
this._shapeList = this._shapeList._next;
}
if(shape == this._shapeListLast) {
this._shapeListLast = this._shapeListLast._prev;
}
shape._next = null;
shape._prev = null;
this._numShapes--;
shape._rigidBody = null;
if(this._world != null) {
let _this = this._world;
_this._broadPhase.destroyProxy(shape._proxy);
shape._proxy = null;
shape._id = -1;
let cl = shape._rigidBody._contactLinkList;
while(cl != null) {
let n = cl._next;
let c = cl._contact;
if(c._s1 == shape || c._s2 == shape) {
let _this1 = cl._other;
_this1._sleeping = false;
_this1._sleepTime = 0;
let _this2 = _this._contactManager;
let prev = c._prev;
let next = c._next;
if(prev != null) {
prev._next = next;
}
if(next != null) {
next._prev = prev;
}
if(c == _this2._contactList) {
_this2._contactList = _this2._contactList._next;
}
if(c == _this2._contactListLast) {
_this2._contactListLast = _this2._contactListLast._prev;
}
c._next = null;
c._prev = null;
if(c._touching) {
let cc1 = c._s1._contactCallback;
let cc2 = c._s2._contactCallback;
if(cc1 == cc2) {
cc2 = null;
}
if(cc1 != null) {
cc1.endContact(c);
}
if(cc2 != null) {
cc2.endContact(c);
}
}
let prev1 = c._link1._prev;
let next1 = c._link1._next;
if(prev1 != null) {
prev1._next = next1;
}
if(next1 != null) {
next1._prev = prev1;
}
if(c._link1 == c._b1._contactLinkList) {
c._b1._contactLinkList = c._b1._contactLinkList._next;
}
if(c._link1 == c._b1._contactLinkListLast) {
c._b1._contactLinkListLast = c._b1._contactLinkListLast._prev;
}
c._link1._next = null;
c._link1._prev = null;
let prev2 = c._link2._prev;
let next2 = c._link2._next;
if(prev2 != null) {
prev2._next = next2;
}
if(next2 != null) {
next2._prev = prev2;
}
if(c._link2 == c._b2._contactLinkList) {
c._b2._contactLinkList = c._b2._contactLinkList._next;
}
if(c._link2 == c._b2._contactLinkListLast) {
c._b2._contactLinkListLast = c._b2._contactLinkListLast._prev;
}
c._link2._next = null;
c._link2._prev = null;
c._b1._numContactLinks--;
c._b2._numContactLinks--;
c._link1._other = null;
c._link2._other = null;
c._link1._contact = null;
c._link2._contact = null;
c._s1 = null;
c._s2 = null;
c._b1 = null;
c._b2 = null;
c._touching = false;
c._cachedDetectorData._clear();
c._manifold._clear();
c._detector = null;
let _this3 = c._contactConstraint;
_this3._s1 = null;
_this3._s2 = null;
_this3._b1 = null;
_this3._b2 = null;
_this3._tf1 = null;
_this3._tf2 = null;
c._next = _this2._contactPool;
_this2._contactPool = c;
_this2._numContacts--;
}
cl = n;
}
_this._numShapes--;
}
this.updateMass();
let s = this._shapeList;
while(s != null) {
let n = s._next;
let tf1 = this._ptransform;
let tf2 = this._transform;
let dst = s._ptransform;
let src1 = s._localTransform;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = tf1._rotation00 * src1._rotation00 + tf1._rotation01 * src1._rotation10 + tf1._rotation02 * src1._rotation20;
__tmp__01 = tf1._rotation00 * src1._rotation01 + tf1._rotation01 * src1._rotation11 + tf1._rotation02 * src1._rotation21;
__tmp__02 = tf1._rotation00 * src1._rotation02 + tf1._rotation01 * src1._rotation12 + tf1._rotation02 * src1._rotation22;
__tmp__10 = tf1._rotation10 * src1._rotation00 + tf1._rotation11 * src1._rotation10 + tf1._rotation12 * src1._rotation20;
__tmp__11 = tf1._rotation10 * src1._rotation01 + tf1._rotation11 * src1._rotation11 + tf1._rotation12 * src1._rotation21;
__tmp__12 = tf1._rotation10 * src1._rotation02 + tf1._rotation11 * src1._rotation12 + tf1._rotation12 * src1._rotation22;
__tmp__20 = tf1._rotation20 * src1._rotation00 + tf1._rotation21 * src1._rotation10 + tf1._rotation22 * src1._rotation20;
__tmp__21 = tf1._rotation20 * src1._rotation01 + tf1._rotation21 * src1._rotation11 + tf1._rotation22 * src1._rotation21;
__tmp__22 = tf1._rotation20 * src1._rotation02 + tf1._rotation21 * src1._rotation12 + tf1._rotation22 * src1._rotation22;
dst._rotation00 = __tmp__00;
dst._rotation01 = __tmp__01;
dst._rotation02 = __tmp__02;
dst._rotation10 = __tmp__10;
dst._rotation11 = __tmp__11;
dst._rotation12 = __tmp__12;
dst._rotation20 = __tmp__20;
dst._rotation21 = __tmp__21;
dst._rotation22 = __tmp__22;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = tf1._rotation00 * src1._positionX + tf1._rotation01 * src1._positionY + tf1._rotation02 * src1._positionZ;
__tmp__Y = tf1._rotation10 * src1._positionX + tf1._rotation11 * src1._positionY + tf1._rotation12 * src1._positionZ;
__tmp__Z = tf1._rotation20 * src1._positionX + tf1._rotation21 * src1._positionY + tf1._rotation22 * src1._positionZ;
dst._positionX = __tmp__X;
dst._positionY = __tmp__Y;
dst._positionZ = __tmp__Z;
dst._positionX += tf1._positionX;
dst._positionY += tf1._positionY;
dst._positionZ += tf1._positionZ;
let dst1 = s._transform;
let src11 = s._localTransform;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = tf2._rotation00 * src11._rotation00 + tf2._rotation01 * src11._rotation10 + tf2._rotation02 * src11._rotation20;
__tmp__011 = tf2._rotation00 * src11._rotation01 + tf2._rotation01 * src11._rotation11 + tf2._rotation02 * src11._rotation21;
__tmp__021 = tf2._rotation00 * src11._rotation02 + tf2._rotation01 * src11._rotation12 + tf2._rotation02 * src11._rotation22;
__tmp__101 = tf2._rotation10 * src11._rotation00 + tf2._rotation11 * src11._rotation10 + tf2._rotation12 * src11._rotation20;
__tmp__111 = tf2._rotation10 * src11._rotation01 + tf2._rotation11 * src11._rotation11 + tf2._rotation12 * src11._rotation21;
__tmp__121 = tf2._rotation10 * src11._rotation02 + tf2._rotation11 * src11._rotation12 + tf2._rotation12 * src11._rotation22;
__tmp__201 = tf2._rotation20 * src11._rotation00 + tf2._rotation21 * src11._rotation10 + tf2._rotation22 * src11._rotation20;
__tmp__211 = tf2._rotation20 * src11._rotation01 + tf2._rotation21 * src11._rotation11 + tf2._rotation22 * src11._rotation21;
__tmp__221 = tf2._rotation20 * src11._rotation02 + tf2._rotation21 * src11._rotation12 + tf2._rotation22 * src11._rotation22;
dst1._rotation00 = __tmp__001;
dst1._rotation01 = __tmp__011;
dst1._rotation02 = __tmp__021;
dst1._rotation10 = __tmp__101;
dst1._rotation11 = __tmp__111;
dst1._rotation12 = __tmp__121;
dst1._rotation20 = __tmp__201;
dst1._rotation21 = __tmp__211;
dst1._rotation22 = __tmp__221;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = tf2._rotation00 * src11._positionX + tf2._rotation01 * src11._positionY + tf2._rotation02 * src11._positionZ;
__tmp__Y1 = tf2._rotation10 * src11._positionX + tf2._rotation11 * src11._positionY + tf2._rotation12 * src11._positionZ;
__tmp__Z1 = tf2._rotation20 * src11._positionX + tf2._rotation21 * src11._positionY + tf2._rotation22 * src11._positionZ;
dst1._positionX = __tmp__X1;
dst1._positionY = __tmp__Y1;
dst1._positionZ = __tmp__Z1;
dst1._positionX += tf2._positionX;
dst1._positionY += tf2._positionY;
dst1._positionZ += tf2._positionZ;
let minX;
let minY;
let minZ;
let maxX;
let maxY;
let maxZ;
s._geom._computeAabb(s._aabb,s._ptransform);
minX = s._aabb._minX;
minY = s._aabb._minY;
minZ = s._aabb._minZ;
maxX = s._aabb._maxX;
maxY = s._aabb._maxY;
maxZ = s._aabb._maxZ;
s._geom._computeAabb(s._aabb,s._transform);
s._aabb._minX = minX < s._aabb._minX ? minX : s._aabb._minX;
s._aabb._minY = minY < s._aabb._minY ? minY : s._aabb._minY;
s._aabb._minZ = minZ < s._aabb._minZ ? minZ : s._aabb._minZ;
s._aabb._maxX = maxX > s._aabb._maxX ? maxX : s._aabb._maxX;
s._aabb._maxY = maxY > s._aabb._maxY ? maxY : s._aabb._maxY;
s._aabb._maxZ = maxZ > s._aabb._maxZ ? maxZ : s._aabb._maxZ;
if(s._proxy != null) {
let dX;
let dY;
let dZ;
dX = s._transform._positionX - s._ptransform._positionX;
dY = s._transform._positionY - s._ptransform._positionY;
dZ = s._transform._positionZ - s._ptransform._positionZ;
let v = s.displacement;
v.x = dX;
v.y = dY;
v.z = dZ;
s._rigidBody._world._broadPhase.moveProxy(s._proxy,s._aabb,s.displacement);
}
s = n;
}
}
getType() {
return this._type;
}
setType(type) {
this._type = type;
this.updateMass();
}
wakeUp() {
this._sleeping = false;
this._sleepTime = 0;
}
sleep() {
this._sleeping = true;
this._sleepTime = 0;
}
isSleeping() {
return this._sleeping;
}
getSleepTime() {
return this._sleepTime;
}
setAutoSleep(autoSleepEnabled) {
this._autoSleep = autoSleepEnabled;
this._sleeping = false;
this._sleepTime = 0;
}
getLinearDamping() {
return this._linearDamping;
}
setLinearDamping(damping) {
this._linearDamping = damping;
}
getAngularDamping() {
return this._angularDamping;
}
setAngularDamping(damping) {
this._angularDamping = damping;
}
getPrev() {
return this._prev;
}
getNext() {
return this._next;
}
}
oimo.dynamics.rigidbody.RigidBodyConfig = class oimo_dynamics_rigidbody_RigidBodyConfig {
constructor() {
this.position = new oimo.common.Vec3();
this.rotation = new oimo.common.Mat3();
this.linearVelocity = new oimo.common.Vec3();
this.angularVelocity = new oimo.common.Vec3();
this.type = 0;
this.autoSleep = true;
this.linearDamping = 0;
this.angularDamping = 0;
}
}
oimo.dynamics.rigidbody.RigidBodyType = class oimo_dynamics_rigidbody_RigidBodyType {
}
oimo.dynamics.rigidbody.Shape = class oimo_dynamics_rigidbody_Shape {
constructor(config) {
this._id = -1;
this._localTransform = new oimo.common.Transform();
this._ptransform = new oimo.common.Transform();
this._transform = new oimo.common.Transform();
let v = config.position;
this._localTransform._positionX = v.x;
this._localTransform._positionY = v.y;
this._localTransform._positionZ = v.z;
let m = config.rotation;
this._localTransform._rotation00 = m.e00;
this._localTransform._rotation01 = m.e01;
this._localTransform._rotation02 = m.e02;
this._localTransform._rotation10 = m.e10;
this._localTransform._rotation11 = m.e11;
this._localTransform._rotation12 = m.e12;
this._localTransform._rotation20 = m.e20;
this._localTransform._rotation21 = m.e21;
this._localTransform._rotation22 = m.e22;
let dst = this._ptransform;
let src = this._localTransform;
dst._positionX = src._positionX;
dst._positionY = src._positionY;
dst._positionZ = src._positionZ;
dst._rotation00 = src._rotation00;
dst._rotation01 = src._rotation01;
dst._rotation02 = src._rotation02;
dst._rotation10 = src._rotation10;
dst._rotation11 = src._rotation11;
dst._rotation12 = src._rotation12;
dst._rotation20 = src._rotation20;
dst._rotation21 = src._rotation21;
dst._rotation22 = src._rotation22;
let dst1 = this._transform;
let src1 = this._localTransform;
dst1._positionX = src1._positionX;
dst1._positionY = src1._positionY;
dst1._positionZ = src1._positionZ;
dst1._rotation00 = src1._rotation00;
dst1._rotation01 = src1._rotation01;
dst1._rotation02 = src1._rotation02;
dst1._rotation10 = src1._rotation10;
dst1._rotation11 = src1._rotation11;
dst1._rotation12 = src1._rotation12;
dst1._rotation20 = src1._rotation20;
dst1._rotation21 = src1._rotation21;
dst1._rotation22 = src1._rotation22;
this._restitution = config.restitution;
this._friction = config.friction;
this._density = config.density;
this._geom = config.geometry;
this._collisionGroup = config.collisionGroup;
this._collisionMask = config.collisionMask;
this._contactCallback = config.contactCallback;
this._aabb = new oimo.collision.geometry.Aabb();
this._proxy = null;
this.displacement = new oimo.common.Vec3();
}
getFriction() {
return this._friction;
}
setFriction(friction) {
this._friction = friction;
}
getRestitution() {
return this._restitution;
}
setRestitution(restitution) {
this._restitution = restitution;
}
getLocalTransform() {
let _this = this._localTransform;
let tf = new oimo.common.Transform();
tf._positionX = _this._positionX;
tf._positionY = _this._positionY;
tf._positionZ = _this._positionZ;
tf._rotation00 = _this._rotation00;
tf._rotation01 = _this._rotation01;
tf._rotation02 = _this._rotation02;
tf._rotation10 = _this._rotation10;
tf._rotation11 = _this._rotation11;
tf._rotation12 = _this._rotation12;
tf._rotation20 = _this._rotation20;
tf._rotation21 = _this._rotation21;
tf._rotation22 = _this._rotation22;
return tf;
}
getLocalTransformTo(transform) {
let transform1 = this._localTransform;
transform._positionX = transform1._positionX;
transform._positionY = transform1._positionY;
transform._positionZ = transform1._positionZ;
transform._rotation00 = transform1._rotation00;
transform._rotation01 = transform1._rotation01;
transform._rotation02 = transform1._rotation02;
transform._rotation10 = transform1._rotation10;
transform._rotation11 = transform1._rotation11;
transform._rotation12 = transform1._rotation12;
transform._rotation20 = transform1._rotation20;
transform._rotation21 = transform1._rotation21;
transform._rotation22 = transform1._rotation22;
}
getTransform() {
let _this = this._transform;
let tf = new oimo.common.Transform();
tf._positionX = _this._positionX;
tf._positionY = _this._positionY;
tf._positionZ = _this._positionZ;
tf._rotation00 = _this._rotation00;
tf._rotation01 = _this._rotation01;
tf._rotation02 = _this._rotation02;
tf._rotation10 = _this._rotation10;
tf._rotation11 = _this._rotation11;
tf._rotation12 = _this._rotation12;
tf._rotation20 = _this._rotation20;
tf._rotation21 = _this._rotation21;
tf._rotation22 = _this._rotation22;
return tf;
}
getTransformTo(transform) {
let transform1 = this._transform;
transform._positionX = transform1._positionX;
transform._positionY = transform1._positionY;
transform._positionZ = transform1._positionZ;
transform._rotation00 = transform1._rotation00;
transform._rotation01 = transform1._rotation01;
transform._rotation02 = transform1._rotation02;
transform._rotation10 = transform1._rotation10;
transform._rotation11 = transform1._rotation11;
transform._rotation12 = transform1._rotation12;
transform._rotation20 = transform1._rotation20;
transform._rotation21 = transform1._rotation21;
transform._rotation22 = transform1._rotation22;
}
setLocalTransform(transform) {
let _this = this._localTransform;
_this._positionX = transform._positionX;
_this._positionY = transform._positionY;
_this._positionZ = transform._positionZ;
_this._rotation00 = transform._rotation00;
_this._rotation01 = transform._rotation01;
_this._rotation02 = transform._rotation02;
_this._rotation10 = transform._rotation10;
_this._rotation11 = transform._rotation11;
_this._rotation12 = transform._rotation12;
_this._rotation20 = transform._rotation20;
_this._rotation21 = transform._rotation21;
_this._rotation22 = transform._rotation22;
if(this._rigidBody != null) {
let _this = this._rigidBody;
_this.updateMass();
let s = _this._shapeList;
while(s != null) {
let n = s._next;
let tf1 = _this._ptransform;
let tf2 = _this._transform;
let dst = s._ptransform;
let src1 = s._localTransform;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = tf1._rotation00 * src1._rotation00 + tf1._rotation01 * src1._rotation10 + tf1._rotation02 * src1._rotation20;
__tmp__01 = tf1._rotation00 * src1._rotation01 + tf1._rotation01 * src1._rotation11 + tf1._rotation02 * src1._rotation21;
__tmp__02 = tf1._rotation00 * src1._rotation02 + tf1._rotation01 * src1._rotation12 + tf1._rotation02 * src1._rotation22;
__tmp__10 = tf1._rotation10 * src1._rotation00 + tf1._rotation11 * src1._rotation10 + tf1._rotation12 * src1._rotation20;
__tmp__11 = tf1._rotation10 * src1._rotation01 + tf1._rotation11 * src1._rotation11 + tf1._rotation12 * src1._rotation21;
__tmp__12 = tf1._rotation10 * src1._rotation02 + tf1._rotation11 * src1._rotation12 + tf1._rotation12 * src1._rotation22;
__tmp__20 = tf1._rotation20 * src1._rotation00 + tf1._rotation21 * src1._rotation10 + tf1._rotation22 * src1._rotation20;
__tmp__21 = tf1._rotation20 * src1._rotation01 + tf1._rotation21 * src1._rotation11 + tf1._rotation22 * src1._rotation21;
__tmp__22 = tf1._rotation20 * src1._rotation02 + tf1._rotation21 * src1._rotation12 + tf1._rotation22 * src1._rotation22;
dst._rotation00 = __tmp__00;
dst._rotation01 = __tmp__01;
dst._rotation02 = __tmp__02;
dst._rotation10 = __tmp__10;
dst._rotation11 = __tmp__11;
dst._rotation12 = __tmp__12;
dst._rotation20 = __tmp__20;
dst._rotation21 = __tmp__21;
dst._rotation22 = __tmp__22;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = tf1._rotation00 * src1._positionX + tf1._rotation01 * src1._positionY + tf1._rotation02 * src1._positionZ;
__tmp__Y = tf1._rotation10 * src1._positionX + tf1._rotation11 * src1._positionY + tf1._rotation12 * src1._positionZ;
__tmp__Z = tf1._rotation20 * src1._positionX + tf1._rotation21 * src1._positionY + tf1._rotation22 * src1._positionZ;
dst._positionX = __tmp__X;
dst._positionY = __tmp__Y;
dst._positionZ = __tmp__Z;
dst._positionX += tf1._positionX;
dst._positionY += tf1._positionY;
dst._positionZ += tf1._positionZ;
let dst1 = s._transform;
let src11 = s._localTransform;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = tf2._rotation00 * src11._rotation00 + tf2._rotation01 * src11._rotation10 + tf2._rotation02 * src11._rotation20;
__tmp__011 = tf2._rotation00 * src11._rotation01 + tf2._rotation01 * src11._rotation11 + tf2._rotation02 * src11._rotation21;
__tmp__021 = tf2._rotation00 * src11._rotation02 + tf2._rotation01 * src11._rotation12 + tf2._rotation02 * src11._rotation22;
__tmp__101 = tf2._rotation10 * src11._rotation00 + tf2._rotation11 * src11._rotation10 + tf2._rotation12 * src11._rotation20;
__tmp__111 = tf2._rotation10 * src11._rotation01 + tf2._rotation11 * src11._rotation11 + tf2._rotation12 * src11._rotation21;
__tmp__121 = tf2._rotation10 * src11._rotation02 + tf2._rotation11 * src11._rotation12 + tf2._rotation12 * src11._rotation22;
__tmp__201 = tf2._rotation20 * src11._rotation00 + tf2._rotation21 * src11._rotation10 + tf2._rotation22 * src11._rotation20;
__tmp__211 = tf2._rotation20 * src11._rotation01 + tf2._rotation21 * src11._rotation11 + tf2._rotation22 * src11._rotation21;
__tmp__221 = tf2._rotation20 * src11._rotation02 + tf2._rotation21 * src11._rotation12 + tf2._rotation22 * src11._rotation22;
dst1._rotation00 = __tmp__001;
dst1._rotation01 = __tmp__011;
dst1._rotation02 = __tmp__021;
dst1._rotation10 = __tmp__101;
dst1._rotation11 = __tmp__111;
dst1._rotation12 = __tmp__121;
dst1._rotation20 = __tmp__201;
dst1._rotation21 = __tmp__211;
dst1._rotation22 = __tmp__221;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = tf2._rotation00 * src11._positionX + tf2._rotation01 * src11._positionY + tf2._rotation02 * src11._positionZ;
__tmp__Y1 = tf2._rotation10 * src11._positionX + tf2._rotation11 * src11._positionY + tf2._rotation12 * src11._positionZ;
__tmp__Z1 = tf2._rotation20 * src11._positionX + tf2._rotation21 * src11._positionY + tf2._rotation22 * src11._positionZ;
dst1._positionX = __tmp__X1;
dst1._positionY = __tmp__Y1;
dst1._positionZ = __tmp__Z1;
dst1._positionX += tf2._positionX;
dst1._positionY += tf2._positionY;
dst1._positionZ += tf2._positionZ;
let minX;
let minY;
let minZ;
let maxX;
let maxY;
let maxZ;
s._geom._computeAabb(s._aabb,s._ptransform);
minX = s._aabb._minX;
minY = s._aabb._minY;
minZ = s._aabb._minZ;
maxX = s._aabb._maxX;
maxY = s._aabb._maxY;
maxZ = s._aabb._maxZ;
s._geom._computeAabb(s._aabb,s._transform);
s._aabb._minX = minX < s._aabb._minX ? minX : s._aabb._minX;
s._aabb._minY = minY < s._aabb._minY ? minY : s._aabb._minY;
s._aabb._minZ = minZ < s._aabb._minZ ? minZ : s._aabb._minZ;
s._aabb._maxX = maxX > s._aabb._maxX ? maxX : s._aabb._maxX;
s._aabb._maxY = maxY > s._aabb._maxY ? maxY : s._aabb._maxY;
s._aabb._maxZ = maxZ > s._aabb._maxZ ? maxZ : s._aabb._maxZ;
if(s._proxy != null) {
let dX;
let dY;
let dZ;
dX = s._transform._positionX - s._ptransform._positionX;
dY = s._transform._positionY - s._ptransform._positionY;
dZ = s._transform._positionZ - s._ptransform._positionZ;
let v = s.displacement;
v.x = dX;
v.y = dY;
v.z = dZ;
s._rigidBody._world._broadPhase.moveProxy(s._proxy,s._aabb,s.displacement);
}
s = n;
}
}
}
getDensity() {
return this._density;
}
setDensity(density) {
this._density = density;
if(this._rigidBody != null) {
let _this = this._rigidBody;
_this.updateMass();
let s = _this._shapeList;
while(s != null) {
let n = s._next;
let tf1 = _this._ptransform;
let tf2 = _this._transform;
let dst = s._ptransform;
let src1 = s._localTransform;
let __tmp__00;
let __tmp__01;
let __tmp__02;
let __tmp__10;
let __tmp__11;
let __tmp__12;
let __tmp__20;
let __tmp__21;
let __tmp__22;
__tmp__00 = tf1._rotation00 * src1._rotation00 + tf1._rotation01 * src1._rotation10 + tf1._rotation02 * src1._rotation20;
__tmp__01 = tf1._rotation00 * src1._rotation01 + tf1._rotation01 * src1._rotation11 + tf1._rotation02 * src1._rotation21;
__tmp__02 = tf1._rotation00 * src1._rotation02 + tf1._rotation01 * src1._rotation12 + tf1._rotation02 * src1._rotation22;
__tmp__10 = tf1._rotation10 * src1._rotation00 + tf1._rotation11 * src1._rotation10 + tf1._rotation12 * src1._rotation20;
__tmp__11 = tf1._rotation10 * src1._rotation01 + tf1._rotation11 * src1._rotation11 + tf1._rotation12 * src1._rotation21;
__tmp__12 = tf1._rotation10 * src1._rotation02 + tf1._rotation11 * src1._rotation12 + tf1._rotation12 * src1._rotation22;
__tmp__20 = tf1._rotation20 * src1._rotation00 + tf1._rotation21 * src1._rotation10 + tf1._rotation22 * src1._rotation20;
__tmp__21 = tf1._rotation20 * src1._rotation01 + tf1._rotation21 * src1._rotation11 + tf1._rotation22 * src1._rotation21;
__tmp__22 = tf1._rotation20 * src1._rotation02 + tf1._rotation21 * src1._rotation12 + tf1._rotation22 * src1._rotation22;
dst._rotation00 = __tmp__00;
dst._rotation01 = __tmp__01;
dst._rotation02 = __tmp__02;
dst._rotation10 = __tmp__10;
dst._rotation11 = __tmp__11;
dst._rotation12 = __tmp__12;
dst._rotation20 = __tmp__20;
dst._rotation21 = __tmp__21;
dst._rotation22 = __tmp__22;
let __tmp__X;
let __tmp__Y;
let __tmp__Z;
__tmp__X = tf1._rotation00 * src1._positionX + tf1._rotation01 * src1._positionY + tf1._rotation02 * src1._positionZ;
__tmp__Y = tf1._rotation10 * src1._positionX + tf1._rotation11 * src1._positionY + tf1._rotation12 * src1._positionZ;
__tmp__Z = tf1._rotation20 * src1._positionX + tf1._rotation21 * src1._positionY + tf1._rotation22 * src1._positionZ;
dst._positionX = __tmp__X;
dst._positionY = __tmp__Y;
dst._positionZ = __tmp__Z;
dst._positionX += tf1._positionX;
dst._positionY += tf1._positionY;
dst._positionZ += tf1._positionZ;
let dst1 = s._transform;
let src11 = s._localTransform;
let __tmp__001;
let __tmp__011;
let __tmp__021;
let __tmp__101;
let __tmp__111;
let __tmp__121;
let __tmp__201;
let __tmp__211;
let __tmp__221;
__tmp__001 = tf2._rotation00 * src11._rotation00 + tf2._rotation01 * src11._rotation10 + tf2._rotation02 * src11._rotation20;
__tmp__011 = tf2._rotation00 * src11._rotation01 + tf2._rotation01 * src11._rotation11 + tf2._rotation02 * src11._rotation21;
__tmp__021 = tf2._rotation00 * src11._rotation02 + tf2._rotation01 * src11._rotation12 + tf2._rotation02 * src11._rotation22;
__tmp__101 = tf2._rotation10 * src11._rotation00 + tf2._rotation11 * src11._rotation10 + tf2._rotation12 * src11._rotation20;
__tmp__111 = tf2._rotation10 * src11._rotation01 + tf2._rotation11 * src11._rotation11 + tf2._rotation12 * src11._rotation21;
__tmp__121 = tf2._rotation10 * src11._rotation02 + tf2._rotation11 * src11._rotation12 + tf2._rotation12 * src11._rotation22;
__tmp__201 = tf2._rotation20 * src11._rotation00 + tf2._rotation21 * src11._rotation10 + tf2._rotation22 * src11._rotation20;
__tmp__211 = tf2._rotation20 * src11._rotation01 + tf2._rotation21 * src11._rotation11 + tf2._rotation22 * src11._rotation21;
__tmp__221 = tf2._rotation20 * src11._rotation02 + tf2._rotation21 * src11._rotation12 + tf2._rotation22 * src11._rotation22;
dst1._rotation00 = __tmp__001;
dst1._rotation01 = __tmp__011;
dst1._rotation02 = __tmp__021;
dst1._rotation10 = __tmp__101;
dst1._rotation11 = __tmp__111;
dst1._rotation12 = __tmp__121;
dst1._rotation20 = __tmp__201;
dst1._rotation21 = __tmp__211;
dst1._rotation22 = __tmp__221;
let __tmp__X1;
let __tmp__Y1;
let __tmp__Z1;
__tmp__X1 = tf2._rotation00 * src11._positionX + tf2._rotation01 * src11._positionY + tf2._rotation02 * src11._positionZ;
__tmp__Y1 = tf2._rotation10 * src11._positionX + tf2._rotation11 * src11._positionY + tf2._rotation12 * src11._positionZ;
__tmp__Z1 = tf2._rotation20 * src11._positionX + tf2._rotation21 * src11._positionY + tf2._rotation22 * src11._positionZ;
dst1._positionX = __tmp__X1;
dst1._positionY = __tmp__Y1;
dst1._positionZ = __tmp__Z1;
dst1._positionX += tf2._positionX;
dst1._positionY += tf2._positionY;
dst1._positionZ += tf2._positionZ;
let minX;
let minY;
let minZ;
let maxX;
let maxY;
let maxZ;
s._geom._computeAabb(s._aabb,s._ptransform);
minX = s._aabb._minX;
minY = s._aabb._minY;
minZ = s._aabb._minZ;
maxX = s._aabb._maxX;
maxY = s._aabb._maxY;
maxZ = s._aabb._maxZ;
s._geom._computeAabb(s._aabb,s._transform);
s._aabb._minX = minX < s._aabb._minX ? minX : s._aabb._minX;
s._aabb._minY = minY < s._aabb._minY ? minY : s._aabb._minY;
s._aabb._minZ = minZ < s._aabb._minZ ? minZ : s._aabb._minZ;
s._aabb._maxX = maxX > s._aabb._maxX ? maxX : s._aabb._maxX;
s._aabb._maxY = maxY > s._aabb._maxY ? maxY : s._aabb._maxY;
s._aabb._maxZ = maxZ > s._aabb._maxZ ? maxZ : s._aabb._maxZ;
if(s._proxy != null) {
let dX;
let dY;
let dZ;
dX = s._transform._positionX - s._ptransform._positionX;
dY = s._transform._positionY - s._ptransform._positionY;
dZ = s._transform._positionZ - s._ptransform._positionZ;
let v = s.displacement;
v.x = dX;
v.y = dY;
v.z = dZ;
s._rigidBody._world._broadPhase.moveProxy(s._proxy,s._aabb,s.displacement);
}
s = n;
}
}
}
getAabb() {
return this._aabb.clone();
}
getAabbTo(aabb) {
aabb.copyFrom(this._aabb);
}
getGeometry() {
return this._geom;
}
getRigidBody() {
return this._rigidBody;
}
getCollisionGroup() {
return this._collisionGroup;
}
setCollisionGroup(collisionGroup) {
this._collisionGroup = collisionGroup;
}
getCollisionMask() {
return this._collisionMask;
}
setCollisionMask(collisionMask) {
this._collisionMask = collisionMask;
}
getContactCallback() {
return this._contactCallback;
}
setContactCallback(callback) {
this._contactCallback = callback;
}
getPrev() {
return this._prev;
}
getNext() {
return this._next;
}
}
oimo.dynamics.rigidbody.ShapeConfig = class oimo_dynamics_rigidbody_ShapeConfig {
constructor() {
this.position = new oimo.common.Vec3();
this.rotation = new oimo.common.Mat3();
this.friction = oimo.common.Setting.defaultFriction;
this.restitution = oimo.common.Setting.defaultRestitution;
this.density = oimo.common.Setting.defaultDensity;
this.collisionGroup = oimo.common.Setting.defaultCollisionGroup;
this.collisionMask = oimo.common.Setting.defaultCollisionMask;
this.geometry = null;
this.contactCallback = null;
}
}
if(!oimo.m) oimo.m = {};
oimo.m.M = class oimo_m_M {
}
oimo.collision.broadphase.BroadPhaseType._BRUTE_FORCE = 1;
oimo.collision.broadphase.BroadPhaseType._BVH = 2;
oimo.collision.broadphase.BroadPhaseType.BRUTE_FORCE = 1;
oimo.collision.broadphase.BroadPhaseType.BVH = 2;
oimo.collision.broadphase.bvh.BvhInsertionStrategy.SIMPLE = 0;
oimo.collision.broadphase.bvh.BvhInsertionStrategy.MINIMIZE_SURFACE_AREA = 1;
oimo.collision.geometry.GeometryType._SPHERE = 0;
oimo.collision.geometry.GeometryType._BOX = 1;
oimo.collision.geometry.GeometryType._CYLINDER = 2;
oimo.collision.geometry.GeometryType._CONE = 3;
oimo.collision.geometry.GeometryType._CAPSULE = 4;
oimo.collision.geometry.GeometryType._CONVEX_HULL = 5;
oimo.collision.geometry.GeometryType._CONVEX_MIN = 0;
oimo.collision.geometry.GeometryType._CONVEX_MAX = 5;
oimo.collision.geometry.GeometryType.SPHERE = 0;
oimo.collision.geometry.GeometryType.BOX = 1;
oimo.collision.geometry.GeometryType.CYLINDER = 2;
oimo.collision.geometry.GeometryType.CONE = 3;
oimo.collision.geometry.GeometryType.CAPSULE = 4;
oimo.collision.geometry.GeometryType.CONVEX_HULL = 5;
oimo.collision.narrowphase.detector.BoxBoxDetector.EDGE_BIAS_MULT = 1.0;
oimo.collision.narrowphase.detector.gjkepa.EpaPolyhedronState.OK = 0;
oimo.collision.narrowphase.detector.gjkepa.EpaPolyhedronState.INVALID_TRIANGLE = 1;
oimo.collision.narrowphase.detector.gjkepa.EpaPolyhedronState.NO_ADJACENT_PAIR_INDEX = 2;
oimo.collision.narrowphase.detector.gjkepa.EpaPolyhedronState.NO_ADJACENT_TRIANGLE = 3;
oimo.collision.narrowphase.detector.gjkepa.EpaPolyhedronState.EDGE_LOOP_BROKEN = 4;
oimo.collision.narrowphase.detector.gjkepa.EpaPolyhedronState.NO_OUTER_TRIANGLE = 5;
oimo.collision.narrowphase.detector.gjkepa.EpaPolyhedronState.TRIANGLE_INVISIBLE = 6;
oimo.collision.narrowphase.detector.gjkepa.EpaTriangle.count = 0;
oimo.common.Vec3.numCreations = 0;
oimo.common.Setting.defaultFriction = 0.2;
oimo.common.Setting.defaultRestitution = 0.2;
oimo.common.Setting.defaultDensity = 1;
oimo.common.Setting.defaultCollisionGroup = 1;
oimo.common.Setting.defaultCollisionMask = 1;
oimo.common.Setting.maxTranslationPerStep = 20;
oimo.common.Setting.maxRotationPerStep = 3.14159265358979;
oimo.common.Setting.bvhProxyPadding = 0.1;
oimo.common.Setting.bvhIncrementalCollisionThreshold = 0.45;
oimo.common.Setting.defaultGJKMargin = 0.05;
oimo.common.Setting.enableGJKCaching = true;
oimo.common.Setting.maxEPAVertices = 128;
oimo.common.Setting.maxEPAPolyhedronFaces = 128;
oimo.common.Setting.contactEnableBounceThreshold = 0.5;
oimo.common.Setting.velocityBaumgarte = 0.2;
oimo.common.Setting.positionSplitImpulseBaumgarte = 0.4;
oimo.common.Setting.positionNgsBaumgarte = 1.0;
oimo.common.Setting.contactUseAlternativePositionCorrectionAlgorithmDepthThreshold = 0.05;
oimo.common.Setting.defaultContactPositionCorrectionAlgorithm = 0;
oimo.common.Setting.alternativeContactPositionCorrectionAlgorithm = 1;
oimo.common.Setting.contactPersistenceThreshold = 0.05;
oimo.common.Setting.maxManifoldPoints = 4;
oimo.common.Setting.defaultJointConstraintSolverType = 0;
oimo.common.Setting.defaultJointPositionCorrectionAlgorithm = 0;
oimo.common.Setting.jointWarmStartingFactorForBaungarte = 0.8;
oimo.common.Setting.jointWarmStartingFactor = 0.95;
oimo.common.Setting.minSpringDamperDampingRatio = 1e-6;
oimo.common.Setting.minRagdollMaxSwingAngle = 1e-6;
oimo.common.Setting.maxJacobianRows = 6;
oimo.common.Setting.directMlcpSolverEps = 1e-9;
oimo.common.Setting.islandInitialRigidBodyArraySize = 128;
oimo.common.Setting.islandInitialConstraintArraySize = 128;
oimo.common.Setting.sleepingVelocityThreshold = 0.2;
oimo.common.Setting.sleepingAngularVelocityThreshold = 0.5;
oimo.common.Setting.sleepingTimeThreshold = 1.0;
oimo.common.Setting.disableSleeping = false;
oimo.common.Setting.linearSlop = 0.005;
oimo.common.Setting.angularSlop = 0.017453292519943278;
oimo.collision.narrowphase.detector.gjkepa.GjkEpa.instance = new oimo.collision.narrowphase.detector.gjkepa.GjkEpa();
oimo.collision.narrowphase.detector.gjkepa.GjkEpaResultState._SUCCEEDED = 0;
oimo.collision.narrowphase.detector.gjkepa.GjkEpaResultState._GJK_FAILED_TO_MAKE_TETRAHEDRON = 1;
oimo.collision.narrowphase.detector.gjkepa.GjkEpaResultState._GJK_DID_NOT_CONVERGE = 2;
oimo.collision.narrowphase.detector.gjkepa.GjkEpaResultState._EPA_FAILED_TO_INIT = 257;
oimo.collision.narrowphase.detector.gjkepa.GjkEpaResultState._EPA_FAILED_TO_ADD_VERTEX = 258;
oimo.collision.narrowphase.detector.gjkepa.GjkEpaResultState._EPA_DID_NOT_CONVERGE = 259;
oimo.collision.narrowphase.detector.gjkepa.GjkEpaResultState.SUCCEEDED = 0;
oimo.collision.narrowphase.detector.gjkepa.GjkEpaResultState.GJK_FAILED_TO_MAKE_TETRAHEDRON = 1;
oimo.collision.narrowphase.detector.gjkepa.GjkEpaResultState.GJK_DID_NOT_CONVERGE = 2;
oimo.collision.narrowphase.detector.gjkepa.GjkEpaResultState.EPA_FAILED_TO_INIT = 257;
oimo.collision.narrowphase.detector.gjkepa.GjkEpaResultState.EPA_FAILED_TO_ADD_VERTEX = 258;
oimo.collision.narrowphase.detector.gjkepa.GjkEpaResultState.EPA_DID_NOT_CONVERGE = 259;
oimo.common.Mat3.numCreations = 0;
oimo.common.Mat4.numCreations = 0;
oimo.common.MathUtil.POSITIVE_INFINITY = 1e65536;
oimo.common.MathUtil.NEGATIVE_INFINITY = -1e65536;
oimo.common.MathUtil.PI = 3.14159265358979;
oimo.common.MathUtil.TWO_PI = 6.28318530717958;
oimo.common.MathUtil.HALF_PI = 1.570796326794895;
oimo.common.MathUtil.TO_RADIANS = 0.017453292519943278;
oimo.common.MathUtil.TO_DEGREES = 57.29577951308238;
oimo.common.Quat.numCreations = 0;
oimo.dynamics.common.DebugDraw.SPHERE_PHI_DIVISION = 8;
oimo.dynamics.common.DebugDraw.SPHERE_THETA_DIVISION = 4;
oimo.dynamics.common.DebugDraw.CIRCLE_THETA_DIVISION = 8;
oimo.dynamics.common.Performance.broadPhaseCollisionTime = 0;
oimo.dynamics.common.Performance.narrowPhaseCollisionTime = 0;
oimo.dynamics.common.Performance.dynamicsTime = 0;
oimo.dynamics.common.Performance.totalTime = 0;
oimo.dynamics.constraint.PositionCorrectionAlgorithm._BAUMGARTE = 0;
oimo.dynamics.constraint.PositionCorrectionAlgorithm._SPLIT_IMPULSE = 1;
oimo.dynamics.constraint.PositionCorrectionAlgorithm._NGS = 2;
oimo.dynamics.constraint.PositionCorrectionAlgorithm.BAUMGARTE = 0;
oimo.dynamics.constraint.PositionCorrectionAlgorithm.SPLIT_IMPULSE = 1;
oimo.dynamics.constraint.PositionCorrectionAlgorithm.NGS = 2;
oimo.dynamics.constraint.info.JacobianRow.BIT_LINEAR_SET = 1;
oimo.dynamics.constraint.info.JacobianRow.BIT_ANGULAR_SET = 2;
oimo.dynamics.constraint.joint.JointType._SPHERICAL = 0;
oimo.dynamics.constraint.joint.JointType._REVOLUTE = 1;
oimo.dynamics.constraint.joint.JointType._CYLINDRICAL = 2;
oimo.dynamics.constraint.joint.JointType._PRISMATIC = 3;
oimo.dynamics.constraint.joint.JointType._UNIVERSAL = 4;
oimo.dynamics.constraint.joint.JointType._RAGDOLL = 5;
oimo.dynamics.constraint.joint.JointType._GENERIC = 6;
oimo.dynamics.constraint.joint.JointType.SPHERICAL = 0;
oimo.dynamics.constraint.joint.JointType.REVOLUTE = 1;
oimo.dynamics.constraint.joint.JointType.CYLINDRICAL = 2;
oimo.dynamics.constraint.joint.JointType.PRISMATIC = 3;
oimo.dynamics.constraint.joint.JointType.UNIVERSAL = 4;
oimo.dynamics.constraint.joint.JointType.RAGDOLL = 5;
oimo.dynamics.constraint.joint.JointType.GENERIC = 6;
oimo.dynamics.constraint.solver.ConstraintSolverType._ITERATIVE = 0;
oimo.dynamics.constraint.solver.ConstraintSolverType._DIRECT = 1;
oimo.dynamics.constraint.solver.ConstraintSolverType.ITERATIVE = 0;
oimo.dynamics.constraint.solver.ConstraintSolverType.DIRECT = 1;
oimo.dynamics.rigidbody.RigidBodyType._DYNAMIC = 0;
oimo.dynamics.rigidbody.RigidBodyType._STATIC = 1;
oimo.dynamics.rigidbody.RigidBodyType._KINEMATIC = 2;
oimo.dynamics.rigidbody.RigidBodyType.DYNAMIC = 0;
oimo.dynamics.rigidbody.RigidBodyType.STATIC = 1;
oimo.dynamics.rigidbody.RigidBodyType.KINEMATIC = 2;
export {oimo};
| 1 | 0.921543 | 1 | 0.921543 | game-dev | MEDIA | 0.769276 | game-dev,graphics-rendering | 0.98949 | 1 | 0.98949 |
luciusDXL/TheForceEngine | 1,353 | TheForceEngine/TFE_Editor/LevelEditor/featureId.cpp | #include "featureId.h"
#include "sharedState.h"
using namespace TFE_Editor;
namespace LevelEditor
{
enum FeatureIdConst : u32
{
// TFE doesn't support levels with over 4 billion sectors, so this is safe.
INVALID_SECTOR_ID = 0xffffffffu
};
FeatureId createFeatureId(const EditorSector* sector, s32 featureIndex, s32 featureData, bool isOverlapped)
{
return FeatureId(u64(sector ? u32(sector->id) : INVALID_SECTOR_ID) |
(u64(featureIndex) << FID_FEATURE_INDEX) |
(u64(featureData) << FID_FEATURE_DATA) |
(u64(isOverlapped ? 1 : 0) << FID_OVERLAPPED));
}
FeatureId setIsOverlapped(FeatureId id, bool isOverlapped)
{
id &= FID_COMPARE_MASK;
id |= (u64(isOverlapped ? 1 : 0) << FID_OVERLAPPED);
return id;
}
EditorSector* unpackFeatureId(FeatureId id, s32* featureIndex, s32* featureData, bool* isOverlapped)
{
u32 sectorId = u32(id & FID_SECTOR_MASK);
if (featureIndex) { *featureIndex = s32((id >> FID_FEATURE_INDEX) & FID_FEATURE_INDEX_MASK); }
if (featureData) { *featureData = s32((id >> FID_FEATURE_DATA) & FID_FEATURE_DATA_MASK); }
if (isOverlapped) { *isOverlapped = (id & (1ull << FID_OVERLAPPED)) != 0; }
// Features outside of sectors will have an invalid sector ID.
return sectorId < (u32)s_level.sectors.size() ? &s_level.sectors[sectorId] : nullptr;
}
}
| 1 | 0.773173 | 1 | 0.773173 | game-dev | MEDIA | 0.240577 | game-dev | 0.571957 | 1 | 0.571957 |
jjppof/goldensun_html5 | 1,781 | base/initializers/items.ts | import {GoldenSun} from "../GoldenSun";
import {Item} from "../Item";
import {GameInfo} from "./initialize_info";
export function initialize_items(game: Phaser.Game, data: GoldenSun, items_db: any, load_promise_resolve: () => void) {
const items_list: GameInfo["items_list"] = {};
for (let i = 0; i < items_db.length; ++i) {
const item_data = items_db[i];
if (item_data.key_name) {
items_list[item_data.key_name] = new Item(
item_data.key_name,
item_data.name,
item_data.type,
item_data.description,
item_data.use_type,
item_data.curses_when_equipped,
item_data.cant_be_removed,
item_data.rare_item,
item_data.important_item,
item_data.carry_up_to_30,
item_data.effects,
item_data.element,
item_data.unleash_ability,
item_data.unleash_rate,
item_data.use_ability,
item_data.equipable_chars,
item_data.price,
item_data.granted_ability,
item_data.granted_class_type,
item_data.weapon_type,
item_data.items_after_forge,
i
);
} else {
data.logger.log_message("Item registered without a key name. Please double-check.");
}
}
const loader = game.load.atlasJSONHash(
"items_icons",
"assets/images/icons/items/items_icons.png",
"assets/images/icons/items/items_icons.json"
);
loader.onLoadComplete.addOnce(load_promise_resolve);
game.load.start();
data.set_whats_loading("items icons");
return items_list;
}
| 1 | 0.810076 | 1 | 0.810076 | game-dev | MEDIA | 0.849485 | game-dev | 0.948297 | 1 | 0.948297 |
euroelessar/qutim | 4,111 | src/lib/qutim/objectgenerator.cpp | /****************************************************************************
**
** qutIM - instant messenger
**
** Copyright © 2011 Ruslan Nigmatullin <euroelessar@yandex.ru>
**
*****************************************************************************
**
** $QUTIM_BEGIN_LICENSE$
** This program is free software: you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation, either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
** See the GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program. If not, see http://www.gnu.org/licenses/.
** $QUTIM_END_LICENSE$
**
****************************************************************************/
#include "actiongenerator_p.h"
#include <QtCore/QVariant>
#include <QtCore/QCoreApplication>
#include "modulemanager_p.h"
namespace qutim_sdk_0_3
{
ObjectGeneratorHolderData::ObjectGeneratorHolderData(ObjectGenerator *generator) : QSharedData()
{
m_generator = generator;
}
ObjectGenerator *ObjectGeneratorHolderData::generator() const
{
return m_generator;
}
ActionGenerator *ObjectGeneratorHolderData::actionGenerator() const
{
return static_cast<ActionGenerator*>(m_generator);
}
ObjectGenerator::ObjectGenerator() : d_ptr(new ObjectGeneratorPrivate)
{
}
ObjectGenerator::ObjectGenerator(ObjectGeneratorPrivate &priv) : d_ptr(&priv)
{
}
ObjectGenerator::~ObjectGenerator()
{
Q_D(ObjectGenerator);
if (d->pointer)
d->pointer->m_generator = 0;
}
ObjectGenerator *ObjectGenerator::addProperty(const QByteArray &name, const QVariant &value)
{
Q_D(ObjectGenerator);
int index = d->names.indexOf(name);
if (index != -1) {
d->values[index] = value;
} else {
d->names.append(name);
d->values.append(value);
}
return this;
}
bool ObjectGenerator::extends(const QMetaObject *super) const
{
const QMetaObject *meta = metaObject();
while (meta && meta != super)
meta = meta->superClass();
return super && meta == super;
}
bool ObjectGenerator::hasInterface(const char *id) const
{
return interfaces().contains(QByteArray::fromRawData(id, qstrlen(id)));
}
QList<QByteArray> ObjectGenerator::interfaces() const
{
return QList<QByteArray>();
}
bool ObjectGenerator::isInited()
{
return isCoreInited();
}
GeneratorList ObjectGenerator::module(const QMetaObject *module)
{
return moduleGenerators(module, 0);
}
GeneratorList ObjectGenerator::module(const char *iid)
{
return moduleGenerators(0, iid);
}
ObjectGenerator::Ptr ObjectGenerator::pointerHolder()
{
Q_D(ObjectGenerator);
if (!d->pointer)
d->pointer = new ObjectGeneratorHolderData(this);
return d->pointer;
}
QObject *ObjectGenerator::generateHelper2() const
{
Q_D(const ObjectGenerator);
if (QObject *obj = generateHelper()) {
for (int i = 0; i < d->names.size(); i++)
obj->setProperty(d->names.at(i), d->values.at(i));
if (d->info.data())
obj->setProperty("extensioninfo", QVariant::fromValue(d->info));
if (dynamic_cast<const ActionGenerator*>(this) && qobject_cast<QAction*>(obj)) {
// const ActionGeneratorPrivate *p = static_cast<const ActionGeneratorPrivate*>(d);
// if (p->connectionType == ActionConnectionLegacy) {
// const QList<QPointer<QObject> > &handlers = p->legacyData->handlers;
// ActionGenerator *gen = const_cast<ActionGenerator*>(static_cast<const ActionGenerator*>(this));
// ActionCreatedEvent event(static_cast<QAction*>(obj), gen);
// for (int i = 0; i < handlers.size(); i++) {
// if (QObject *handler = handlers.at(i))
// qApp->sendEvent(handler, &event);
// }
// }
}
return obj;
}
return NULL;
}
ExtensionInfo ObjectGenerator::info() const
{
return d_func()->info;
}
void ObjectGenerator::virtual_hook(int id, void *data)
{
Q_UNUSED(id);
Q_UNUSED(data);
}
}
| 1 | 0.939127 | 1 | 0.939127 | game-dev | MEDIA | 0.663852 | game-dev | 0.900483 | 1 | 0.900483 |
Athlaeos/ValhallaMMO | 1,376 | core/src/main/java/me/athlaeos/valhallammo/crafting/blockvalidations/implementations/CampfireLit.java | package me.athlaeos.valhallammo.crafting.blockvalidations.implementations;
import me.athlaeos.valhallammo.crafting.blockvalidations.Validation;
import me.athlaeos.valhallammo.item.ItemBuilder;
import me.athlaeos.valhallammo.localization.TranslationManager;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.data.Lightable;
import org.bukkit.inventory.ItemStack;
public class CampfireLit extends Validation {
@Override
public String id() {
return "REQUIREMENT_CAMPFIRE_LIT";
}
@Override
public ItemStack icon() {
return new ItemBuilder(Material.CAMPFIRE)
.name("&6Require Lit Campfire")
.lore("&fRequires the campfire to be lit").get();
}
@Override
public String activeDescription() {
return "&fCampfire must be lit";
}
@Override
public String validationError() {
return TranslationManager.getTranslation("validation_warning_campfire_unlit");
}
@Override
public boolean isCompatible(Material block) {
return block == Material.CAMPFIRE || block == Material.SOUL_CAMPFIRE;
}
@Override
public boolean validate(Block b) {
if (b.getBlockData() instanceof Lightable l) return l.isLit();
return false;
}
@Override
public void execute(Block b) {
// do nothing
}
}
| 1 | 0.521254 | 1 | 0.521254 | game-dev | MEDIA | 0.883999 | game-dev | 0.551085 | 1 | 0.551085 |
Rinnegatamante/vitaQuakeIII | 7,712 | code/psp2/psp2_input.c | /*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.
This file is part of Quake III Arena source code.
Quake III Arena source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.
Quake III Arena source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Quake III Arena source code; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
===========================================================================
*/
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <vitasdk.h>
#include "../client/client.h"
#include "../sys/sys_local.h"
static int hires_x, hires_y;
/*
===============
IN_Frame
===============
*/
uint32_t oldkeys, oldanalogs;
void Key_Event(int key, int value, int time){
Com_QueueEvent(time, SE_KEY, key, value, 0, NULL);
}
void Sys_SetKeys(uint32_t keys, int time){
if((keys & SCE_CTRL_START) != (oldkeys & SCE_CTRL_START))
Key_Event(K_ESCAPE, (keys & SCE_CTRL_START) == SCE_CTRL_START, time);
if((keys & SCE_CTRL_SELECT) != (oldkeys & SCE_CTRL_SELECT))
Key_Event(K_ENTER, (keys & SCE_CTRL_SELECT) == SCE_CTRL_SELECT, time);
if((keys & SCE_CTRL_UP) != (oldkeys & SCE_CTRL_UP))
Key_Event(K_UPARROW, (keys & SCE_CTRL_UP) == SCE_CTRL_UP, time);
if((keys & SCE_CTRL_DOWN) != (oldkeys & SCE_CTRL_DOWN))
Key_Event(K_DOWNARROW, (keys & SCE_CTRL_DOWN) == SCE_CTRL_DOWN, time);
if((keys & SCE_CTRL_LEFT) != (oldkeys & SCE_CTRL_LEFT))
Key_Event(K_LEFTARROW, (keys & SCE_CTRL_LEFT) == SCE_CTRL_LEFT, time);
if((keys & SCE_CTRL_RIGHT) != (oldkeys & SCE_CTRL_RIGHT))
Key_Event(K_RIGHTARROW, (keys & SCE_CTRL_RIGHT) == SCE_CTRL_RIGHT, time);
if((keys & SCE_CTRL_TRIANGLE) != (oldkeys & SCE_CTRL_TRIANGLE))
Key_Event(K_AUX4, (keys & SCE_CTRL_TRIANGLE) == SCE_CTRL_TRIANGLE, time);
if((keys & SCE_CTRL_SQUARE) != (oldkeys & SCE_CTRL_SQUARE))
Key_Event(K_AUX3, (keys & SCE_CTRL_SQUARE) == SCE_CTRL_SQUARE, time);
if((keys & SCE_CTRL_CIRCLE) != (oldkeys & SCE_CTRL_CIRCLE))
Key_Event(K_AUX2, (keys & SCE_CTRL_CIRCLE) == SCE_CTRL_CIRCLE, time);
if((keys & SCE_CTRL_CROSS) != (oldkeys & SCE_CTRL_CROSS))
Key_Event(K_AUX1, (keys & SCE_CTRL_CROSS) == SCE_CTRL_CROSS, time);
if((keys & SCE_CTRL_LTRIGGER) != (oldkeys & SCE_CTRL_LTRIGGER))
Key_Event(K_AUX5, (keys & SCE_CTRL_LTRIGGER) == SCE_CTRL_LTRIGGER, time);
if((keys & SCE_CTRL_RTRIGGER) != (oldkeys & SCE_CTRL_RTRIGGER))
Key_Event(K_AUX6, (keys & SCE_CTRL_RTRIGGER) == SCE_CTRL_RTRIGGER, time);
}
void IN_RescaleAnalog(int *x, int *y, int dead) {
float analogX = (float) *x;
float analogY = (float) *y;
float deadZone = (float) dead;
float maximum = 32768.0f;
float magnitude = sqrt(analogX * analogX + analogY * analogY);
if (magnitude >= deadZone)
{
float scalingFactor = maximum / magnitude * (magnitude - deadZone) / (maximum - deadZone);
*x = (int) (analogX * scalingFactor);
*y = (int) (analogY * scalingFactor);
} else {
*x = 0;
*y = 0;
}
}
// Left analog virtual values
#define LANALOG_LEFT 0x01
#define LANALOG_RIGHT 0x02
#define LANALOG_UP 0x04
#define LANALOG_DOWN 0x08
int old_x = - 1, old_y;
extern char title_keyboard[256];
extern uint8_t is_ime_up;
static uint8_t is_ime_up_old = 0;
void simulateKeyPress(char *c) {
if (c[0] == 0)
return;
int time = Sys_Milliseconds();
//We first delete the current text
for (int i = 0; i < 100; i++) {
Com_QueueEvent(time, SE_CHAR, 0x08, 0, 0, NULL );
}
while (*c) {
int utf32 = 0;
if( ( *c & 0x80 ) == 0 )
utf32 = *c++;
else if( ( *c & 0xE0 ) == 0xC0 ) // 110x xxxx
{
utf32 |= ( *c++ & 0x1F ) << 6;
utf32 |= ( *c++ & 0x3F );
}
else if( ( *c & 0xF0 ) == 0xE0 ) // 1110 xxxx
{
utf32 |= ( *c++ & 0x0F ) << 12;
utf32 |= ( *c++ & 0x3F ) << 6;
utf32 |= ( *c++ & 0x3F );
}
else if( ( *c & 0xF8 ) == 0xF0 ) // 1111 0xxx
{
utf32 |= ( *c++ & 0x07 ) << 18;
utf32 |= ( *c++ & 0x3F ) << 12;
utf32 |= ( *c++ & 0x3F ) << 6;
utf32 |= ( *c++ & 0x3F );
}
else
{
Com_DPrintf( "Unrecognised UTF-8 lead byte: 0x%x\n", (unsigned int)*c );
c++;
}
Com_QueueEvent(time, SE_CHAR, utf32, 0, 0, NULL );
}
}
void IN_Frame( void )
{
if (is_ime_up_old && !is_ime_up) {
simulateKeyPress(title_keyboard);
}
is_ime_up_old = is_ime_up;
SceCtrlData keys;
sceCtrlPeekBufferPositive(0, &keys, 1);
int time = Sys_Milliseconds();
if(keys.buttons != oldkeys)
Sys_SetKeys(keys.buttons, time);
oldkeys = keys.buttons;
// Emulating mouse with touch
SceTouchData touch;
sceTouchPeek(SCE_TOUCH_PORT_FRONT, &touch, 1);
if (touch.reportNum > 0){
if (old_x != -1) Com_QueueEvent(time, SE_MOUSE, (touch.report[0].x - old_x), (touch.report[0].y - old_y), 0, NULL);
old_x = touch.report[0].x;
old_y = touch.report[0].y;
}else old_x = -1;
// Emulating mouse with right analog
int right_x = (keys.rx - 127) * 256;
int right_y = (keys.ry - 127) * 256;
IN_RescaleAnalog(&right_x, &right_y, 7680);
hires_x += right_x;
hires_y += right_y;
if (hires_x != 0 || hires_y != 0) {
// increase slowdown variable to slow down aiming
Com_QueueEvent(time, SE_MOUSE, hires_x / (int)cl_analog_slowdown->value, hires_y / (int)cl_analog_slowdown->value, 0, NULL);
hires_x %= (int)cl_analog_slowdown->value;
hires_y %= (int)cl_analog_slowdown->value;
}
// Gyroscope aiming
if (cl_gyroscope->value) {
SceMotionState motionstate;
sceMotionGetState(&motionstate);
// not sure why YAW or the horizontal x axis is the controlled by angularVelocity.y
// and the PITCH or the vertical y axis is controlled by angularVelocity.x but its what seems to work
float x_gyro_cam = 10 * motionstate.angularVelocity.y * cl_gyro_h_sensitivity->value;
float y_gyro_cam = 10 * motionstate.angularVelocity.x * cl_gyro_v_sensitivity->value;
Com_QueueEvent(time, SE_MOUSE, -x_gyro_cam, -y_gyro_cam, 0, NULL);
}
// Emulating keys with left analog (TODO: Replace this dirty hack with a serious implementation)
uint32_t virt_buttons = 0x00;
if (keys.lx < 80) virt_buttons += LANALOG_LEFT;
else if (keys.lx > 160) virt_buttons += LANALOG_RIGHT;
if (keys.ly < 80) virt_buttons += LANALOG_UP;
else if (keys.ly > 160) virt_buttons += LANALOG_DOWN;
if (virt_buttons != oldanalogs){
if((virt_buttons & LANALOG_LEFT) != (oldanalogs & LANALOG_LEFT))
Key_Event(K_AUX7, (virt_buttons & LANALOG_LEFT) == LANALOG_LEFT, time);
if((virt_buttons & LANALOG_RIGHT) != (oldanalogs & LANALOG_RIGHT))
Key_Event(K_AUX8, (virt_buttons & LANALOG_RIGHT) == LANALOG_RIGHT, time);
if((virt_buttons & LANALOG_UP) != (oldanalogs & LANALOG_UP))
Key_Event(K_AUX9, (virt_buttons & LANALOG_UP) == LANALOG_UP, time);
if((virt_buttons & LANALOG_DOWN) != (oldanalogs & LANALOG_DOWN))
Key_Event(K_AUX10, (virt_buttons & LANALOG_DOWN) == LANALOG_DOWN, time);
}
oldanalogs = virt_buttons;
}
/*
===============
IN_Init
===============
*/
void IN_Init( void *windowData )
{
sceMotionReset();
sceMotionStartSampling();
sceCtrlSetSamplingMode(SCE_CTRL_MODE_ANALOG_WIDE);
sceTouchSetSamplingState(SCE_TOUCH_PORT_FRONT, SCE_TOUCH_SAMPLING_STATE_START);
}
/*
===============
IN_Shutdown
===============
*/
void IN_Shutdown( void )
{
}
/*
===============
IN_Restart
===============
*/
void IN_Restart( void )
{
}
| 1 | 0.824222 | 1 | 0.824222 | game-dev | MEDIA | 0.772236 | game-dev | 0.924308 | 1 | 0.924308 |
pmret/papermario | 1,760 | src/world/area_pra/pra_19/pra_19.h | /// @file pra_19.h
/// @brief Crystal Palace - Reflection Mimic Room
#include "common.h"
#include "message_ids.h"
#include "map.h"
#include "../pra.h"
#include "mapfs/pra_19_shape.h"
#include "mapfs/pra_19_hit.h"
#include "sprite/npc/Duplighost.h"
#include "sprite/npc/WorldKooper.h"
#include "sprite/npc/WorldGoombario.h"
#include "sprite/npc/Kolorado.h"
#include "sprite/npc/Goompa.h"
#include "sprite/npc/KoopaKoot.h"
#include "sprite/npc/Luigi.h"
enum {
// passive NPC for each imposter than can be interacted with
NPC_FakeKooper = 0,
NPC_FakeGoompa = 1,
NPC_FakeLuigi = 2,
NPC_FakeKoopaKoot = 3,
NPC_FakeKolorado = 4,
// mario and partner in the mirror showing what to do
NPC_ExamplePlayer = 5,
NPC_ExampleKooper = 6,
// duplighosts for each imposter
NPC_GoompaGhost = 7,
NPC_LuigiGhost = 8,
NPC_KoopaKootGhost = 9,
NPC_KoloradoGhost = 10,
NPC_Duplighost_Controller = 11, // controls the scene
// second set of NPCs for each imposter which detect hammer hits
NPC_TargetKooper = 12,
NPC_TargetGoompa = 13,
NPC_TargetLuigi = 14,
NPC_TargetKoopaKoot = 15,
NPC_TargetKolorado = 16,
};
enum {
MV_UnmaskingState = MapVar(0),
MV_RevealedFakeGoompa = MapVar(2),
MV_RevealedFakeLuigi = MapVar(3),
MV_RevealedFakeKoopaKoot = MapVar(4),
MV_RevealedFakeKolorado = MapVar(5),
};
#define NAMESPACE pra_19
extern EvtScript N(EVS_Main);
extern EvtScript N(EVS_SetupMusic);
extern EvtScript N(EVS_ExitWalk_pra_20_0);
extern NpcGroupList N(DefaultNPCs);
| 1 | 0.866893 | 1 | 0.866893 | game-dev | MEDIA | 0.995436 | game-dev | 0.535653 | 1 | 0.535653 |
modernuo/ModernUO | 7,309 | Projects/UOContent/Gumps/Guilds/New Guild System/WarDeclarationGump.cs | using System;
using Server.Gumps;
using Server.Mobiles;
using Server.Network;
namespace Server.Guilds
{
public class WarDeclarationGump : BaseGuildGump
{
private readonly Guild m_Other;
public WarDeclarationGump(PlayerMobile pm, Guild g, Guild otherGuild) : base(pm, g)
{
m_Other = otherGuild;
var war = g.FindPendingWar(otherGuild);
AddPage(0);
AddBackground(0, 0, 500, 340, 0x24AE);
AddBackground(65, 50, 370, 30, 0x2486);
AddHtmlLocalized(75, 55, 370, 26, 1062979, 0x3C00); // <div align=center><i>Declaration of War</i></div>
AddImage(410, 45, 0x232C);
AddHtmlLocalized(65, 95, 200, 20, 1063009, 0x14AF); // <i>Duration of War</i>
AddHtmlLocalized(65, 120, 400, 20, 1063010, 0x0); // Enter the number of hours the war will last.
AddBackground(65, 150, 40, 30, 0x2486);
AddTextEntry(70, 154, 50, 30, 0x481, 10, war?.WarLength.Hours.ToString() ?? "0");
AddHtmlLocalized(65, 195, 200, 20, 1063011, 0x14AF); // <i>Victory Condition</i>
AddHtmlLocalized(65, 220, 400, 20, 1063012, 0x0); // Enter the winning number of kills.
AddBackground(65, 250, 40, 30, 0x2486);
AddTextEntry(70, 254, 50, 30, 0x481, 11, war?.MaxKills.ToString() ?? "0");
AddBackground(190, 270, 130, 26, 0x2486);
AddButton(195, 275, 0x845, 0x846, 0);
AddHtmlLocalized(220, 273, 90, 26, 1006045, 0x0); // Cancel
AddBackground(330, 270, 130, 26, 0x2486);
AddButton(335, 275, 0x845, 0x846, 1);
AddHtmlLocalized(360, 273, 90, 26, 1062989, 0x5000); // Declare War!
}
public override void OnResponse(NetState sender, in RelayInfo info)
{
var pm = sender.Mobile as PlayerMobile;
if (!IsMember(pm, guild))
{
return;
}
var playerRank = pm!.GuildRank;
switch (info.ButtonID)
{
case 1:
{
var alliance = guild.Alliance;
var otherAlliance = m_Other.Alliance;
if (!playerRank.GetFlag(RankFlags.ControlWarStatus))
{
pm.SendLocalizedMessage(1063440); // You don't have permission to negotiate wars.
}
else if (alliance != null && alliance.Leader != guild)
{
pm.SendLocalizedMessage(
1063239,
$"{guild.Name}\t{alliance.Name}"
); // ~1_val~ is not the leader of the ~2_val~ alliance.
pm.SendLocalizedMessage(
1070707,
alliance.Leader.Name
); // You need to negotiate via ~1_val~ instead.
}
else if (otherAlliance != null && otherAlliance.Leader != m_Other)
{
pm.SendLocalizedMessage(
1063239,
$"{m_Other.Name}\t{otherAlliance.Name}"
); // ~1_val~ is not the leader of the ~2_val~ alliance.
pm.SendLocalizedMessage(
1070707,
otherAlliance.Leader.Name
); // You need to negotiate via ~1_val~ instead.
}
else
{
var activeWar = guild.FindActiveWar(m_Other);
if (activeWar == null)
{
var war = guild.FindPendingWar(m_Other);
var otherWar = m_Other.FindPendingWar(guild);
// Note: OSI differs from what it says on website. unlimited war = 0 kills/ 0 hrs. Not > 999. (sidenote: they both cap at 65535, 7.5 years, but, still.)
var tKills = info.GetTextEntry(11);
var tWarLength = info.GetTextEntry(10);
var maxKills = tKills == null
? 0
: Math.Clamp(Utility.ToInt32(tKills), 0, 0xFFFF);
var warLength = TimeSpan.FromHours(
tWarLength == null
? 0
: Math.Clamp(Utility.ToInt32(tWarLength), 0, 0xFFFF)
);
if (war != null)
{
war.MaxKills = maxKills;
war.WarLength = warLength;
war.WarRequester = true;
}
else
{
guild.PendingWars.Add(new WarDeclaration(guild, m_Other, maxKills, warLength, true));
}
if (otherWar != null)
{
otherWar.MaxKills = maxKills;
otherWar.WarLength = warLength;
otherWar.WarRequester = false;
}
else
{
m_Other.PendingWars.Add(new WarDeclaration(m_Other, guild, maxKills, warLength, false));
}
if (war != null)
{
pm.SendLocalizedMessage(1070752); // The proposal has been updated.
}
else
{
m_Other.GuildMessage(
1070781,
guild.Alliance != null
? guild.Alliance.Name
: guild.Name
); // ~1_val~ has proposed a war.
}
pm.SendLocalizedMessage(
1070751,
m_Other.Alliance != null
? m_Other.Alliance.Name
: m_Other.Name
); // War proposal has been sent to ~1_val~.
}
}
break;
}
default:
{
pm.SendGump(new OtherGuildInfo(pm, guild, m_Other));
break;
}
}
}
}
}
| 1 | 0.694868 | 1 | 0.694868 | game-dev | MEDIA | 0.981655 | game-dev | 0.836018 | 1 | 0.836018 |
warmtrue/WDataTable | 4,524 | Assets/LoopScrollRect/Scripts/EasyObjectPool/ResourceManager.cs | using UnityEngine;
using System.Collections.Generic;
using System.Linq;
namespace SG
{
[DisallowMultipleComponent]
[AddComponentMenu("")]
public class ResourceManager : MonoBehaviour
{
//obj pool
private Dictionary<string, Pool> poolDict = new Dictionary<string, Pool>();
private static ResourceManager mInstance = null;
public static ResourceManager Instance
{
get
{
if (mInstance == null)
{
GameObject go = new GameObject("ResourceManager", typeof(ResourceManager));
go.transform.localPosition = new Vector3(9999999, 9999999, 9999999);
// Kanglai: if we have `GO.hideFlags |= HideFlags.DontSave;`, we will encounter Destroy problem when exit playing
// However we should keep using this in Play mode only!
mInstance = go.GetComponent<ResourceManager>();
if (Application.isPlaying)
{
DontDestroyOnLoad(mInstance.gameObject);
}
else
{
Debug.LogWarning("[ResourceManager] You'd better ignore ResourceManager in Editor mode");
}
}
return mInstance;
}
}
public void InitPool(string poolName, int size, PoolInflationType type = PoolInflationType.DOUBLE)
{
if (poolDict.ContainsKey(poolName))
{
return;
}
else
{
GameObject pb = Resources.Load<GameObject>(poolName);
if (pb == null)
{
Debug.LogError("[ResourceManager] Invalide prefab name for pooling :" + poolName);
return;
}
poolDict[poolName] = new Pool(poolName, pb, gameObject, size, type);
}
}
/// <summary>
/// Returns an available object from the pool
/// OR null in case the pool does not have any object available & can grow size is false.
/// </summary>
/// <param name="poolName"></param>
/// <returns></returns>
public GameObject GetObjectFromPool(string poolName, bool autoActive = true, int autoCreate = 0)
{
GameObject result = null;
if (!poolDict.ContainsKey(poolName) && autoCreate > 0)
{
InitPool(poolName, autoCreate, PoolInflationType.INCREMENT);
}
if (poolDict.ContainsKey(poolName))
{
Pool pool = poolDict[poolName];
result = pool.NextAvailableObject(autoActive);
//scenario when no available object is found in pool
#if UNITY_EDITOR
if (result == null)
{
Debug.LogWarning("[ResourceManager]:No object available in " + poolName);
}
#endif
}
#if UNITY_EDITOR
else
{
Debug.LogError("[ResourceManager]:Invalid pool name specified: " + poolName);
}
#endif
return result;
}
/// <summary>
/// Return obj to the pool
/// </summary>
/// <param name="go"></param>
public void ReturnObjectToPool(GameObject go)
{
PoolObject po = go.GetComponent<PoolObject>();
if (po == null)
{
#if UNITY_EDITOR
Debug.LogWarning("Specified object is not a pooled instance: " + go.name);
#endif
}
else
{
Pool pool = null;
if (poolDict.TryGetValue(po.poolName, out pool))
{
pool.ReturnObjectToPool(po);
}
#if UNITY_EDITOR
else
{
Debug.LogWarning("No pool available with name: " + po.poolName);
}
#endif
}
}
/// <summary>
/// Return obj to the pool
/// </summary>
/// <param name="t"></param>
public void ReturnTransformToPool(Transform t)
{
if (t == null)
{
#if UNITY_EDITOR
Debug.LogError("[ResourceManager] try to return a null transform to pool!");
#endif
return;
}
ReturnObjectToPool(t.gameObject);
}
}
} | 1 | 0.700648 | 1 | 0.700648 | game-dev | MEDIA | 0.952496 | game-dev | 0.967529 | 1 | 0.967529 |
Avanatiker/WorldTools | 8,519 | common/src/main/kotlin/org/waste/of/time/Events.kt | package org.waste.of.time
import net.minecraft.client.MinecraftClient
import net.minecraft.client.gui.screen.Screen
import net.minecraft.client.gui.widget.ButtonWidget
import net.minecraft.client.gui.widget.GridWidget
import net.minecraft.client.render.RenderLayer
import net.minecraft.client.render.VertexConsumer
import net.minecraft.client.render.VertexConsumerProvider
import net.minecraft.client.util.math.MatrixStack
import net.minecraft.component.type.MapIdComponent
import net.minecraft.entity.Entity
import net.minecraft.entity.LivingEntity
import net.minecraft.entity.player.PlayerEntity
import net.minecraft.util.hit.BlockHitResult
import net.minecraft.util.math.BlockPos
import net.minecraft.util.math.Vec3d
import net.minecraft.world.World
import net.minecraft.world.chunk.WorldChunk
import org.waste.of.time.Utils.manhattanDistance2d
import org.waste.of.time.WorldTools.CAPTURE_KEY
import org.waste.of.time.WorldTools.CONFIG_KEY
import org.waste.of.time.WorldTools.config
import org.waste.of.time.WorldTools.mc
import org.waste.of.time.gui.ManagerScreen
import org.waste.of.time.manager.BarManager.updateCapture
import org.waste.of.time.manager.CaptureManager
import org.waste.of.time.manager.CaptureManager.capturing
import org.waste.of.time.manager.CaptureManager.currentLevelName
import org.waste.of.time.manager.MessageManager
import org.waste.of.time.manager.MessageManager.translateHighlight
import org.waste.of.time.manager.StatisticManager
import org.waste.of.time.storage.StorageFlow
import org.waste.of.time.storage.cache.EntityCacheable
import org.waste.of.time.storage.cache.HotCache
import org.waste.of.time.storage.cache.DataInjectionHandler
import org.waste.of.time.storage.serializable.BlockEntityLoadable
import org.waste.of.time.storage.serializable.PlayerStoreable
import org.waste.of.time.storage.serializable.RegionBasedChunk
import java.awt.Color
object Events {
fun onChunkLoad(chunk: WorldChunk) {
if (!capturing) return
RegionBasedChunk(chunk).cache()
BlockEntityLoadable(chunk).emit()
}
fun onChunkUnload(chunk: WorldChunk) {
if (!capturing) return
(HotCache.chunks[chunk.pos] ?: RegionBasedChunk(chunk)).apply {
emit()
flush()
}
}
fun onEntityLoad(entity: Entity) {
if (!capturing) return
if (entity is PlayerEntity) {
PlayerStoreable(entity).cache()
} else {
EntityCacheable(entity).cache()
}
}
fun onEntityUnload(entity: Entity) {
if (!capturing) return
if (entity !is PlayerEntity) return
PlayerStoreable(entity).apply {
emit()
flush()
}
}
fun onClientTickStart() {
if (CAPTURE_KEY.wasPressed() && mc.world != null && mc.currentScreen == null) {
CaptureManager.toggleCapture()
}
if (CONFIG_KEY.wasPressed() && mc.world != null && mc.currentScreen == null) {
mc.setScreen(ManagerScreen)
}
if (!capturing) return
updateCapture()
}
fun onClientJoin() {
HotCache.clear()
StorageFlow.lastStored = null
StatisticManager.reset()
if (config.general.autoDownload) CaptureManager.start()
}
fun onClientDisconnect() {
if (!capturing) return
CaptureManager.stop()
}
fun onInteractBlock(world: World, hitResult: BlockHitResult) {
if (!capturing) return
val blockEntity = world.getBlockEntity(hitResult.blockPos)
HotCache.lastInteractedBlockEntity = blockEntity
HotCache.lastInteractedEntity = null
}
fun onInteractEntity(entity: Entity) {
if (!capturing) return
HotCache.lastInteractedEntity = entity
HotCache.lastInteractedBlockEntity = null
}
fun onDebugRenderStart(
matrices: MatrixStack,
vertexConsumers: VertexConsumerProvider.Immediate,
cameraX: Double,
cameraY: Double,
cameraZ: Double
) {
if (!capturing || !config.render.renderNotYetCachedContainers) return
val vertexConsumer = vertexConsumers.getBuffer(RenderLayer.getLines()) ?: return
HotCache.unscannedBlockEntities
.forEach { render(it.pos.vec, cameraX, cameraY, cameraZ, matrices, vertexConsumer, Color(config.render.unscannedContainerColor)) }
HotCache.loadedBlockEntities
.forEach { render(it.value.pos.vec, cameraX, cameraY, cameraZ, matrices, vertexConsumer, Color(config.render.fromCacheLoadedContainerColor)) }
HotCache.unscannedEntities
.forEach { render(it.entity.pos.add(-.5, .0, -.5), cameraX, cameraY, cameraZ, matrices, vertexConsumer, Color(config.render.unscannedEntityColor)) }
}
private val BlockPos.vec get() = Vec3d(x.toDouble(), y.toDouble(), z.toDouble())
private fun render(
vec: Vec3d,
cameraX: Double,
cameraY: Double,
cameraZ: Double,
matrices: MatrixStack,
vertexConsumer: VertexConsumer,
color: Color
) {
val x1 = (vec.x - cameraX).toFloat()
val y1 = (vec.y - cameraY).toFloat()
val z1 = (vec.z - cameraZ).toFloat()
val x2 = x1 + 1
val z2 = z1 + 1
val r = color.red / 255.0f
val g = color.green / 255.0f
val b = color.blue / 255.0f
val a = 1.0f
val positionMat = matrices.peek().positionMatrix
val normMat = matrices.peek()
vertexConsumer.vertex(positionMat, x1, y1, z1).color(r, g, b, a).normal(normMat, 1.0f, 0.0f, 0.0f)
vertexConsumer.vertex(positionMat, x2, y1, z1).color(r, g, b, a).normal(normMat, 1.0f, 0.0f, 0.0f)
vertexConsumer.vertex(positionMat, x1, y1, z1).color(r, g, b, a).normal(normMat, 0.0f, 0.0f, 1.0f)
vertexConsumer.vertex(positionMat, x1, y1, z2).color(r, g, b, a).normal(normMat, 0.0f, 0.0f, 1.0f)
vertexConsumer.vertex(positionMat, x1, y1, z2).color(r, g, b, a).normal(normMat, 1.0f, 0.0f, 0.0f)
vertexConsumer.vertex(positionMat, x2, y1, z2).color(r, g, b, a).normal(normMat, 1.0f, 0.0f, 0.0f)
vertexConsumer.vertex(positionMat, x2, y1, z2).color(r, g, b, a).normal(normMat, 0.0f, 0.0f, -1.0f)
vertexConsumer.vertex(positionMat, x2, y1, z1).color(r, g, b, a).normal(normMat, 0.0f, 0.0f, -1.0f)
}
fun onGameMenuScreenInitWidgets(adder: GridWidget.Adder) {
val widget = if (capturing) {
val label = translateHighlight("worldtools.gui.escape.button.finish_download", currentLevelName)
ButtonWidget.builder(label) {
CaptureManager.stop()
mc.setScreen(null)
}.width(204).build()
} else {
ButtonWidget.builder(MessageManager.brand) {
MinecraftClient.getInstance().setScreen(ManagerScreen)
}.width(204).build()
}
adder.add(widget, 2)
}
fun onScreenRemoved(screen: Screen) {
if (!capturing) return
DataInjectionHandler.onScreenRemoved(screen)
HotCache.lastInteractedBlockEntity = null
}
fun onEntityRemoved(entity: Entity, reason: Entity.RemovalReason) {
if (!capturing) return
if (reason != Entity.RemovalReason.KILLED && reason != Entity.RemovalReason.DISCARDED) return
if (entity is LivingEntity) {
if (!entity.isDead) return
val cacheable = EntityCacheable(entity)
HotCache.entities.entries.find { (_, entities) ->
entities.contains(cacheable)
}?.value?.remove(cacheable)
} else {
// todo: its actually a bit tricky to differentiate the entity being removed from our world or the server world
// need to find a reliable way to determine it
// if chunk is loaded, remove the entity? -> doesn't seem to work because server will remove entity before chunk is unloaded
mc.player?.let { player ->
if (entity.pos.manhattanDistance2d(player.pos) < 32) { // todo: configurable distance, this should be small enough to be safe for most cases
val cacheable = EntityCacheable(entity)
HotCache.entities[entity.chunkPos]?.remove(cacheable)
}
}
}
}
fun onMapStateGet(id: MapIdComponent) {
if (!capturing) return
// todo: looks like the server does not send a map update packet for container
HotCache.mapIDs.add(id.id)
}
}
| 1 | 0.959555 | 1 | 0.959555 | game-dev | MEDIA | 0.896585 | game-dev,graphics-rendering | 0.974654 | 1 | 0.974654 |
Aussiemon/Darktide-Source-Code | 1,535 | dialogues/generated/event_vo_kill_explicator_a.lua | -- chunkname: @dialogues/generated/event_vo_kill_explicator_a.lua
local event_vo_kill_explicator_a = {
event_kill_kill_the_target = {
randomize_indexes_n = 0,
sound_events_n = 4,
sound_events = {
"loc_explicator_a__event_kill_kill_the_target_01",
"loc_explicator_a__event_kill_kill_the_target_02",
"loc_explicator_a__event_kill_kill_the_target_03",
"loc_explicator_a__event_kill_kill_the_target_04",
},
sound_events_duration = {
3.736792,
4.060604,
5.283104,
4.349625,
},
randomize_indexes = {},
},
event_kill_target_destroyed_b = {
randomize_indexes_n = 0,
sound_events_n = 4,
sound_events = {
"loc_explicator_a__event_kill_target_destroyed_b_01",
"loc_explicator_a__event_kill_target_destroyed_b_02",
"loc_explicator_a__event_kill_target_destroyed_b_03",
"loc_explicator_a__event_kill_target_destroyed_b_04",
},
sound_events_duration = {
3.018271,
5.172125,
4.192063,
3.409042,
},
randomize_indexes = {},
},
event_kill_target_heavy_damage_b = {
randomize_indexes_n = 0,
sound_events_n = 4,
sound_events = {
"loc_explicator_a__event_kill_target_heavy_damage_b_01",
"loc_explicator_a__event_kill_target_heavy_damage_b_02",
"loc_explicator_a__event_kill_target_heavy_damage_b_03",
"loc_explicator_a__event_kill_target_heavy_damage_b_04",
},
sound_events_duration = {
3.357875,
1.918667,
2.651979,
1.959896,
},
randomize_indexes = {},
},
}
return settings("event_vo_kill_explicator_a", event_vo_kill_explicator_a)
| 1 | 0.804708 | 1 | 0.804708 | game-dev | MEDIA | 0.993904 | game-dev | 0.648303 | 1 | 0.648303 |
LtxProgrammer/Changed-Minecraft-Mod | 1,427 | src/main/java/net/ltxprogrammer/changed/block/AbstractBeehiveBlock.java | package net.ltxprogrammer.changed.block;
import net.minecraft.core.Direction;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.item.context.BlockPlaceContext;
import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.Blocks;
import net.minecraft.world.level.block.HorizontalDirectionalBlock;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.level.block.state.StateDefinition;
import net.minecraft.world.level.storage.loot.LootContext;
import org.jetbrains.annotations.Nullable;
import java.util.List;
public class AbstractBeehiveBlock extends HorizontalDirectionalBlock {
public AbstractBeehiveBlock() {
super(Properties.copy(Blocks.BEE_NEST));
this.registerDefaultState(this.getStateDefinition().any().setValue(FACING, Direction.NORTH));
}
@Override
public List<ItemStack> getDrops(BlockState state, LootContext.Builder builder) {
return List.of(new ItemStack(this.asItem()));
}
@Override
protected void createBlockStateDefinition(StateDefinition.Builder<Block, BlockState> builder) {
super.createBlockStateDefinition(builder);
builder.add(FACING);
}
@Nullable
@Override
public BlockState getStateForPlacement(BlockPlaceContext context) {
return this.defaultBlockState().setValue(FACING, context.getHorizontalDirection().getOpposite());
}
}
| 1 | 0.721162 | 1 | 0.721162 | game-dev | MEDIA | 0.998843 | game-dev | 0.883353 | 1 | 0.883353 |
TTimo/doom3.gpl | 26,996 | neo/game/anim/Anim_Testmodel.cpp | /*
===========================================================================
Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).
Doom 3 Source Code is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Doom 3 Source Code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
===========================================================================
*/
/*
=============================================================================
MODEL TESTING
Model viewing can begin with either "testmodel <modelname>"
The names must be the full pathname after the basedir, like
"models/weapons/v_launch/tris.md3" or "players/male/tris.md3"
Extension will default to ".ase" if not specified.
Testmodel will create a fake entity 100 units in front of the current view
position, directly facing the viewer. It will remain immobile, so you can
move around it to view it from different angles.
g_testModelRotate
g_testModelAnimate
g_testModelBlend
=============================================================================
*/
#include "../../idlib/precompiled.h"
#pragma hdrstop
#include "../Game_local.h"
CLASS_DECLARATION( idAnimatedEntity, idTestModel )
EVENT( EV_FootstepLeft, idTestModel::Event_Footstep )
EVENT( EV_FootstepRight, idTestModel::Event_Footstep )
END_CLASS
/*
================
idTestModel::idTestModel
================
*/
idTestModel::idTestModel() {
head = NULL;
headAnimator = NULL;
anim = 0;
headAnim = 0;
starttime = 0;
animtime = 0;
mode = 0;
frame = 0;
}
/*
================
idTestModel::Save
================
*/
void idTestModel::Save( idSaveGame *savefile ) {
}
/*
================
idTestModel::Restore
================
*/
void idTestModel::Restore( idRestoreGame *savefile ) {
// FIXME: one day we may actually want to save/restore test models, but for now we'll just delete them
delete this;
}
/*
================
idTestModel::Spawn
================
*/
void idTestModel::Spawn( void ) {
idVec3 size;
idBounds bounds;
const char *headModel;
jointHandle_t joint;
idStr jointName;
idVec3 origin, modelOffset;
idMat3 axis;
const idKeyValue *kv;
copyJoints_t copyJoint;
if ( renderEntity.hModel && renderEntity.hModel->IsDefaultModel() && !animator.ModelDef() ) {
gameLocal.Warning( "Unable to create testmodel for '%s' : model defaulted", spawnArgs.GetString( "model" ) );
PostEventMS( &EV_Remove, 0 );
return;
}
mode = g_testModelAnimate.GetInteger();
animator.RemoveOriginOffset( g_testModelAnimate.GetInteger() == 1 );
physicsObj.SetSelf( this );
physicsObj.SetOrigin( GetPhysics()->GetOrigin() );
physicsObj.SetAxis( GetPhysics()->GetAxis() );
if ( spawnArgs.GetVector( "mins", NULL, bounds[0] ) ) {
spawnArgs.GetVector( "maxs", NULL, bounds[1] );
physicsObj.SetClipBox( bounds, 1.0f );
physicsObj.SetContents( 0 );
} else if ( spawnArgs.GetVector( "size", NULL, size ) ) {
bounds[ 0 ].Set( size.x * -0.5f, size.y * -0.5f, 0.0f );
bounds[ 1 ].Set( size.x * 0.5f, size.y * 0.5f, size.z );
physicsObj.SetClipBox( bounds, 1.0f );
physicsObj.SetContents( 0 );
}
spawnArgs.GetVector( "offsetModel", "0 0 0", modelOffset );
// add the head model if it has one
headModel = spawnArgs.GetString( "def_head", "" );
if ( headModel[ 0 ] ) {
jointName = spawnArgs.GetString( "head_joint" );
joint = animator.GetJointHandle( jointName );
if ( joint == INVALID_JOINT ) {
gameLocal.Warning( "Joint '%s' not found for 'head_joint'", jointName.c_str() );
} else {
// copy any sounds in case we have frame commands on the head
idDict args;
const idKeyValue *sndKV = spawnArgs.MatchPrefix( "snd_", NULL );
while( sndKV ) {
args.Set( sndKV->GetKey(), sndKV->GetValue() );
sndKV = spawnArgs.MatchPrefix( "snd_", sndKV );
}
head = gameLocal.SpawnEntityType( idAnimatedEntity::Type, &args );
animator.GetJointTransform( joint, gameLocal.time, origin, axis );
origin = GetPhysics()->GetOrigin() + ( origin + modelOffset ) * GetPhysics()->GetAxis();
head.GetEntity()->SetModel( headModel );
head.GetEntity()->SetOrigin( origin );
head.GetEntity()->SetAxis( GetPhysics()->GetAxis() );
head.GetEntity()->BindToJoint( this, animator.GetJointName( joint ), true );
headAnimator = head.GetEntity()->GetAnimator();
// set up the list of joints to copy to the head
for( kv = spawnArgs.MatchPrefix( "copy_joint", NULL ); kv != NULL; kv = spawnArgs.MatchPrefix( "copy_joint", kv ) ) {
jointName = kv->GetKey();
if ( jointName.StripLeadingOnce( "copy_joint_world " ) ) {
copyJoint.mod = JOINTMOD_WORLD_OVERRIDE;
} else {
jointName.StripLeadingOnce( "copy_joint " );
copyJoint.mod = JOINTMOD_LOCAL_OVERRIDE;
}
copyJoint.from = animator.GetJointHandle( jointName );
if ( copyJoint.from == INVALID_JOINT ) {
gameLocal.Warning( "Unknown copy_joint '%s'", jointName.c_str() );
continue;
}
copyJoint.to = headAnimator->GetJointHandle( jointName );
if ( copyJoint.to == INVALID_JOINT ) {
gameLocal.Warning( "Unknown copy_joint '%s' on head", jointName.c_str() );
continue;
}
copyJoints.Append( copyJoint );
}
}
}
// start any shader effects based off of the spawn time
renderEntity.shaderParms[ SHADERPARM_TIMEOFFSET ] = -MS2SEC( gameLocal.time );
SetPhysics( &physicsObj );
gameLocal.Printf( "Added testmodel at origin = '%s', angles = '%s'\n", GetPhysics()->GetOrigin().ToString(), GetPhysics()->GetAxis().ToAngles().ToString() );
BecomeActive( TH_THINK );
}
/*
================
idTestModel::~idTestModel
================
*/
idTestModel::~idTestModel() {
StopSound( SND_CHANNEL_ANY, false );
if ( renderEntity.hModel ) {
gameLocal.Printf( "Removing testmodel %s\n", renderEntity.hModel->Name() );
} else {
gameLocal.Printf( "Removing testmodel\n" );
}
if ( gameLocal.testmodel == this ) {
gameLocal.testmodel = NULL;
}
if ( head.GetEntity() ) {
head.GetEntity()->StopSound( SND_CHANNEL_ANY, false );
head.GetEntity()->PostEventMS( &EV_Remove, 0 );
}
}
/*
===============
idTestModel::Event_Footstep
===============
*/
void idTestModel::Event_Footstep( void ) {
StartSound( "snd_footstep", SND_CHANNEL_BODY, 0, false, NULL );
}
/*
================
idTestModel::ShouldConstructScriptObjectAtSpawn
Called during idEntity::Spawn to see if it should construct the script object or not.
Overridden by subclasses that need to spawn the script object themselves.
================
*/
bool idTestModel::ShouldConstructScriptObjectAtSpawn( void ) const {
return false;
}
/*
================
idTestModel::Think
================
*/
void idTestModel::Think( void ) {
idVec3 pos;
idMat3 axis;
idAngles ang;
int i;
if ( thinkFlags & TH_THINK ) {
if ( anim && ( gameLocal.testmodel == this ) && ( mode != g_testModelAnimate.GetInteger() ) ) {
StopSound( SND_CHANNEL_ANY, false );
if ( head.GetEntity() ) {
head.GetEntity()->StopSound( SND_CHANNEL_ANY, false );
}
switch( g_testModelAnimate.GetInteger() ) {
default:
case 0:
// cycle anim with origin reset
if ( animator.NumFrames( anim ) <= 1 ) {
// single frame animations end immediately, so just cycle it since it's the same result
animator.CycleAnim( ANIMCHANNEL_ALL, anim, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
if ( headAnim ) {
headAnimator->CycleAnim( ANIMCHANNEL_ALL, headAnim, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
}
} else {
animator.PlayAnim( ANIMCHANNEL_ALL, anim, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
if ( headAnim ) {
headAnimator->PlayAnim( ANIMCHANNEL_ALL, headAnim, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
if ( headAnimator->AnimLength( headAnim ) > animator.AnimLength( anim ) ) {
// loop the body anim when the head anim is longer
animator.CurrentAnim( ANIMCHANNEL_ALL )->SetCycleCount( -1 );
}
}
}
animator.RemoveOriginOffset( false );
break;
case 1:
// cycle anim with fixed origin
animator.CycleAnim( ANIMCHANNEL_ALL, anim, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
animator.RemoveOriginOffset( true );
if ( headAnim ) {
headAnimator->CycleAnim( ANIMCHANNEL_ALL, headAnim, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
}
break;
case 2:
// cycle anim with continuous origin
animator.CycleAnim( ANIMCHANNEL_ALL, anim, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
animator.RemoveOriginOffset( false );
if ( headAnim ) {
headAnimator->CycleAnim( ANIMCHANNEL_ALL, headAnim, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
}
break;
case 3:
// frame by frame with continuous origin
animator.SetFrame( ANIMCHANNEL_ALL, anim, frame, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
animator.RemoveOriginOffset( false );
if ( headAnim ) {
headAnimator->SetFrame( ANIMCHANNEL_ALL, headAnim, frame, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
}
break;
case 4:
// play anim once
animator.PlayAnim( ANIMCHANNEL_ALL, anim, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
animator.RemoveOriginOffset( false );
if ( headAnim ) {
headAnimator->PlayAnim( ANIMCHANNEL_ALL, headAnim, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
}
break;
case 5:
// frame by frame with fixed origin
animator.SetFrame( ANIMCHANNEL_ALL, anim, frame, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
animator.RemoveOriginOffset( true );
if ( headAnim ) {
headAnimator->SetFrame( ANIMCHANNEL_ALL, headAnim, frame, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
}
break;
}
mode = g_testModelAnimate.GetInteger();
}
if ( ( mode == 0 ) && ( gameLocal.time >= starttime + animtime ) ) {
starttime = gameLocal.time;
StopSound( SND_CHANNEL_ANY, false );
animator.PlayAnim( ANIMCHANNEL_ALL, anim, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
if ( headAnim ) {
headAnimator->PlayAnim( ANIMCHANNEL_ALL, headAnim, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
if ( headAnimator->AnimLength( headAnim ) > animator.AnimLength( anim ) ) {
// loop the body anim when the head anim is longer
animator.CurrentAnim( ANIMCHANNEL_ALL )->SetCycleCount( -1 );
}
}
}
if ( headAnimator ) {
// copy the animation from the body to the head
for( i = 0; i < copyJoints.Num(); i++ ) {
if ( copyJoints[ i ].mod == JOINTMOD_WORLD_OVERRIDE ) {
idMat3 mat = head.GetEntity()->GetPhysics()->GetAxis().Transpose();
GetJointWorldTransform( copyJoints[ i ].from, gameLocal.time, pos, axis );
pos -= head.GetEntity()->GetPhysics()->GetOrigin();
headAnimator->SetJointPos( copyJoints[ i ].to, copyJoints[ i ].mod, pos * mat );
headAnimator->SetJointAxis( copyJoints[ i ].to, copyJoints[ i ].mod, axis * mat );
} else {
animator.GetJointLocalTransform( copyJoints[ i ].from, gameLocal.time, pos, axis );
headAnimator->SetJointPos( copyJoints[ i ].to, copyJoints[ i ].mod, pos );
headAnimator->SetJointAxis( copyJoints[ i ].to, copyJoints[ i ].mod, axis );
}
}
}
// update rotation
RunPhysics();
physicsObj.GetAngles( ang );
physicsObj.SetAngularExtrapolation( extrapolation_t(EXTRAPOLATION_LINEAR|EXTRAPOLATION_NOSTOP), gameLocal.time, 0, ang, idAngles( 0, g_testModelRotate.GetFloat() * 360.0f / 60.0f, 0 ), ang_zero );
idClipModel *clip = physicsObj.GetClipModel();
if ( clip && animator.ModelDef() ) {
idVec3 neworigin;
idMat3 axis;
jointHandle_t joint;
joint = animator.GetJointHandle( "origin" );
animator.GetJointTransform( joint, gameLocal.time, neworigin, axis );
neworigin = ( ( neworigin - animator.ModelDef()->GetVisualOffset() ) * physicsObj.GetAxis() ) + GetPhysics()->GetOrigin();
clip->Link( gameLocal.clip, this, 0, neworigin, clip->GetAxis() );
}
}
UpdateAnimation();
Present();
if ( ( gameLocal.testmodel == this ) && g_showTestModelFrame.GetInteger() && anim ) {
gameLocal.Printf( "^5 Anim: ^7%s ^5Frame: ^7%d/%d Time: %.3f\n", animator.AnimFullName( anim ), animator.CurrentAnim( ANIMCHANNEL_ALL )->GetFrameNumber( gameLocal.time ),
animator.CurrentAnim( ANIMCHANNEL_ALL )->NumFrames(), MS2SEC( gameLocal.time - animator.CurrentAnim( ANIMCHANNEL_ALL )->GetStartTime() ) );
if ( headAnim ) {
gameLocal.Printf( "^5 Head: ^7%s ^5Frame: ^7%d/%d Time: %.3f\n\n", headAnimator->AnimFullName( headAnim ), headAnimator->CurrentAnim( ANIMCHANNEL_ALL )->GetFrameNumber( gameLocal.time ),
headAnimator->CurrentAnim( ANIMCHANNEL_ALL )->NumFrames(), MS2SEC( gameLocal.time - headAnimator->CurrentAnim( ANIMCHANNEL_ALL )->GetStartTime() ) );
} else {
gameLocal.Printf( "\n\n" );
}
}
}
/*
================
idTestModel::NextAnim
================
*/
void idTestModel::NextAnim( const idCmdArgs &args ) {
if ( !animator.NumAnims() ) {
return;
}
anim++;
if ( anim >= animator.NumAnims() ) {
// anim 0 is no anim
anim = 1;
}
starttime = gameLocal.time;
animtime = animator.AnimLength( anim );
animname = animator.AnimFullName( anim );
headAnim = 0;
if ( headAnimator ) {
headAnimator->ClearAllAnims( gameLocal.time, 0 );
headAnim = headAnimator->GetAnim( animname );
if ( !headAnim ) {
headAnim = headAnimator->GetAnim( "idle" );
}
if ( headAnim && ( headAnimator->AnimLength( headAnim ) > animtime ) ) {
animtime = headAnimator->AnimLength( headAnim );
}
}
gameLocal.Printf( "anim '%s', %d.%03d seconds, %d frames\n", animname.c_str(), animator.AnimLength( anim ) / 1000, animator.AnimLength( anim ) % 1000, animator.NumFrames( anim ) );
if ( headAnim ) {
gameLocal.Printf( "head '%s', %d.%03d seconds, %d frames\n", headAnimator->AnimFullName( headAnim ), headAnimator->AnimLength( headAnim ) / 1000, headAnimator->AnimLength( headAnim ) % 1000, headAnimator->NumFrames( headAnim ) );
}
// reset the anim
mode = -1;
frame = 1;
}
/*
================
idTestModel::PrevAnim
================
*/
void idTestModel::PrevAnim( const idCmdArgs &args ) {
if ( !animator.NumAnims() ) {
return;
}
headAnim = 0;
anim--;
if ( anim < 0 ) {
anim = animator.NumAnims() - 1;
}
starttime = gameLocal.time;
animtime = animator.AnimLength( anim );
animname = animator.AnimFullName( anim );
headAnim = 0;
if ( headAnimator ) {
headAnimator->ClearAllAnims( gameLocal.time, 0 );
headAnim = headAnimator->GetAnim( animname );
if ( !headAnim ) {
headAnim = headAnimator->GetAnim( "idle" );
}
if ( headAnim && ( headAnimator->AnimLength( headAnim ) > animtime ) ) {
animtime = headAnimator->AnimLength( headAnim );
}
}
gameLocal.Printf( "anim '%s', %d.%03d seconds, %d frames\n", animname.c_str(), animator.AnimLength( anim ) / 1000, animator.AnimLength( anim ) % 1000, animator.NumFrames( anim ) );
if ( headAnim ) {
gameLocal.Printf( "head '%s', %d.%03d seconds, %d frames\n", headAnimator->AnimFullName( headAnim ), headAnimator->AnimLength( headAnim ) / 1000, headAnimator->AnimLength( headAnim ) % 1000, headAnimator->NumFrames( headAnim ) );
}
// reset the anim
mode = -1;
frame = 1;
}
/*
================
idTestModel::NextFrame
================
*/
void idTestModel::NextFrame( const idCmdArgs &args ) {
if ( !anim || ( ( g_testModelAnimate.GetInteger() != 3 ) && ( g_testModelAnimate.GetInteger() != 5 ) ) ) {
return;
}
frame++;
if ( frame > animator.NumFrames( anim ) ) {
frame = 1;
}
gameLocal.Printf( "^5 Anim: ^7%s\n^5Frame: ^7%d/%d\n\n", animator.AnimFullName( anim ), frame, animator.NumFrames( anim ) );
// reset the anim
mode = -1;
}
/*
================
idTestModel::PrevFrame
================
*/
void idTestModel::PrevFrame( const idCmdArgs &args ) {
if ( !anim || ( ( g_testModelAnimate.GetInteger() != 3 ) && ( g_testModelAnimate.GetInteger() != 5 ) ) ) {
return;
}
frame--;
if ( frame < 1 ) {
frame = animator.NumFrames( anim );
}
gameLocal.Printf( "^5 Anim: ^7%s\n^5Frame: ^7%d/%d\n\n", animator.AnimFullName( anim ), frame, animator.NumFrames( anim ) );
// reset the anim
mode = -1;
}
/*
================
idTestModel::TestAnim
================
*/
void idTestModel::TestAnim( const idCmdArgs &args ) {
idStr name;
int animNum;
const idAnim *newanim;
if ( args.Argc() < 2 ) {
gameLocal.Printf( "usage: testanim <animname>\n" );
return;
}
newanim = NULL;
name = args.Argv( 1 );
#if 0
if ( strstr( name, ".ma" ) || strstr( name, ".mb" ) ) {
const idMD5Anim *md5anims[ ANIM_MaxSyncedAnims ];
idModelExport exporter;
exporter.ExportAnim( name );
name.SetFileExtension( MD5_ANIM_EXT );
md5anims[ 0 ] = animationLib.GetAnim( name );
if ( md5anims[ 0 ] ) {
customAnim.SetAnim( animator.ModelDef(), name, name, 1, md5anims );
newanim = &customAnim;
}
} else {
animNum = animator.GetAnim( name );
}
#else
animNum = animator.GetAnim( name );
#endif
if ( !animNum ) {
gameLocal.Printf( "Animation '%s' not found.\n", name.c_str() );
return;
}
anim = animNum;
starttime = gameLocal.time;
animtime = animator.AnimLength( anim );
headAnim = 0;
if ( headAnimator ) {
headAnimator->ClearAllAnims( gameLocal.time, 0 );
headAnim = headAnimator->GetAnim( animname );
if ( !headAnim ) {
headAnim = headAnimator->GetAnim( "idle" );
if ( !headAnim ) {
gameLocal.Printf( "Missing 'idle' anim for head.\n" );
}
}
if ( headAnim && ( headAnimator->AnimLength( headAnim ) > animtime ) ) {
animtime = headAnimator->AnimLength( headAnim );
}
}
animname = name;
gameLocal.Printf( "anim '%s', %d.%03d seconds, %d frames\n", animname.c_str(), animator.AnimLength( anim ) / 1000, animator.AnimLength( anim ) % 1000, animator.NumFrames( anim ) );
// reset the anim
mode = -1;
}
/*
=====================
idTestModel::BlendAnim
=====================
*/
void idTestModel::BlendAnim( const idCmdArgs &args ) {
int anim1;
int anim2;
if ( args.Argc() < 4 ) {
gameLocal.Printf( "usage: testblend <anim1> <anim2> <frames>\n" );
return;
}
anim1 = gameLocal.testmodel->animator.GetAnim( args.Argv( 1 ) );
if ( !anim1 ) {
gameLocal.Printf( "Animation '%s' not found.\n", args.Argv( 1 ) );
return;
}
anim2 = gameLocal.testmodel->animator.GetAnim( args.Argv( 2 ) );
if ( !anim2 ) {
gameLocal.Printf( "Animation '%s' not found.\n", args.Argv( 2 ) );
return;
}
animname = args.Argv( 2 );
animator.CycleAnim( ANIMCHANNEL_ALL, anim1, gameLocal.time, 0 );
animator.CycleAnim( ANIMCHANNEL_ALL, anim2, gameLocal.time, FRAME2MS( atoi( args.Argv( 3 ) ) ) );
anim = anim2;
headAnim = 0;
}
/***********************************************************************
Testmodel console commands
***********************************************************************/
/*
=================
idTestModel::KeepTestModel_f
Makes the current test model permanent, allowing you to place
multiple test models
=================
*/
void idTestModel::KeepTestModel_f( const idCmdArgs &args ) {
if ( !gameLocal.testmodel ) {
gameLocal.Printf( "No active testModel.\n" );
return;
}
gameLocal.Printf( "modelDef %p kept\n", gameLocal.testmodel->renderEntity.hModel );
gameLocal.testmodel = NULL;
}
/*
=================
idTestModel::TestSkin_f
Sets a skin on an existing testModel
=================
*/
void idTestModel::TestSkin_f( const idCmdArgs &args ) {
idVec3 offset;
idStr name;
idPlayer * player;
idDict dict;
player = gameLocal.GetLocalPlayer();
if ( !player || !gameLocal.CheatsOk() ) {
return;
}
// delete the testModel if active
if ( !gameLocal.testmodel ) {
common->Printf( "No active testModel\n" );
return;
}
if ( args.Argc() < 2 ) {
common->Printf( "removing testSkin.\n" );
gameLocal.testmodel->SetSkin( NULL );
return;
}
name = args.Argv( 1 );
gameLocal.testmodel->SetSkin( declManager->FindSkin( name ) );
}
/*
=================
idTestModel::TestShaderParm_f
Sets a shaderParm on an existing testModel
=================
*/
void idTestModel::TestShaderParm_f( const idCmdArgs &args ) {
idVec3 offset;
idStr name;
idPlayer * player;
idDict dict;
player = gameLocal.GetLocalPlayer();
if ( !player || !gameLocal.CheatsOk() ) {
return;
}
// delete the testModel if active
if ( !gameLocal.testmodel ) {
common->Printf( "No active testModel\n" );
return;
}
if ( args.Argc() != 3 ) {
common->Printf( "USAGE: testShaderParm <parmNum> <float | \"time\">\n" );
return;
}
int parm = atoi( args.Argv( 1 ) );
if ( parm < 0 || parm >= MAX_ENTITY_SHADER_PARMS ) {
common->Printf( "parmNum %i out of range\n", parm );
return;
}
float value;
if ( !idStr::Icmp( args.Argv( 2 ), "time" ) ) {
value = gameLocal.time * -0.001;
} else {
value = atof( args.Argv( 2 ) );
}
gameLocal.testmodel->SetShaderParm( parm, value );
}
/*
=================
idTestModel::TestModel_f
Creates a static modelDef in front of the current position, which
can then be moved around
=================
*/
void idTestModel::TestModel_f( const idCmdArgs &args ) {
idVec3 offset;
idStr name;
idPlayer * player;
const idDict * entityDef;
idDict dict;
player = gameLocal.GetLocalPlayer();
if ( !player || !gameLocal.CheatsOk() ) {
return;
}
// delete the testModel if active
if ( gameLocal.testmodel ) {
delete gameLocal.testmodel;
gameLocal.testmodel = NULL;
}
if ( args.Argc() < 2 ) {
return;
}
name = args.Argv( 1 );
entityDef = gameLocal.FindEntityDefDict( name, false );
if ( entityDef ) {
dict = *entityDef;
} else {
if ( declManager->FindType( DECL_MODELDEF, name, false ) ) {
dict.Set( "model", name );
} else {
// allow map models with underscore prefixes to be tested during development
// without appending an ase
if ( name[ 0 ] != '_' ) {
name.DefaultFileExtension( ".ase" );
}
if ( strstr( name, ".ma" ) || strstr( name, ".mb" ) ) {
idModelExport exporter;
exporter.ExportModel( name );
name.SetFileExtension( MD5_MESH_EXT );
}
if ( !renderModelManager->CheckModel( name ) ) {
gameLocal.Printf( "Can't register model\n" );
return;
}
dict.Set( "model", name );
}
}
offset = player->GetPhysics()->GetOrigin() + player->viewAngles.ToForward() * 100.0f;
dict.Set( "origin", offset.ToString() );
dict.Set( "angle", va( "%f", player->viewAngles.yaw + 180.0f ) );
gameLocal.testmodel = ( idTestModel * )gameLocal.SpawnEntityType( idTestModel::Type, &dict );
gameLocal.testmodel->renderEntity.shaderParms[SHADERPARM_TIMEOFFSET] = -MS2SEC( gameLocal.time );
}
/*
=====================
idTestModel::ArgCompletion_TestModel
=====================
*/
void idTestModel::ArgCompletion_TestModel( const idCmdArgs &args, void(*callback)( const char *s ) ) {
int i, num;
num = declManager->GetNumDecls( DECL_ENTITYDEF );
for ( i = 0; i < num; i++ ) {
callback( idStr( args.Argv( 0 ) ) + " " + declManager->DeclByIndex( DECL_ENTITYDEF, i , false )->GetName() );
}
num = declManager->GetNumDecls( DECL_MODELDEF );
for ( i = 0; i < num; i++ ) {
callback( idStr( args.Argv( 0 ) ) + " " + declManager->DeclByIndex( DECL_MODELDEF, i , false )->GetName() );
}
cmdSystem->ArgCompletion_FolderExtension( args, callback, "models/", false, ".lwo", ".ase", ".md5mesh", ".ma", ".mb", NULL );
}
/*
=====================
idTestModel::TestParticleStopTime_f
=====================
*/
void idTestModel::TestParticleStopTime_f( const idCmdArgs &args ) {
if ( !gameLocal.testmodel ) {
gameLocal.Printf( "No testModel active.\n" );
return;
}
gameLocal.testmodel->renderEntity.shaderParms[SHADERPARM_PARTICLE_STOPTIME] = MS2SEC( gameLocal.time );
gameLocal.testmodel->UpdateVisuals();
}
/*
=====================
idTestModel::TestAnim_f
=====================
*/
void idTestModel::TestAnim_f( const idCmdArgs &args ) {
if ( !gameLocal.testmodel ) {
gameLocal.Printf( "No testModel active.\n" );
return;
}
gameLocal.testmodel->TestAnim( args );
}
/*
=====================
idTestModel::ArgCompletion_TestAnim
=====================
*/
void idTestModel::ArgCompletion_TestAnim( const idCmdArgs &args, void(*callback)( const char *s ) ) {
if ( gameLocal.testmodel ) {
idAnimator *animator = gameLocal.testmodel->GetAnimator();
for( int i = 0; i < animator->NumAnims(); i++ ) {
callback( va( "%s %s", args.Argv( 0 ), animator->AnimFullName( i ) ) );
}
}
}
/*
=====================
idTestModel::TestBlend_f
=====================
*/
void idTestModel::TestBlend_f( const idCmdArgs &args ) {
if ( !gameLocal.testmodel ) {
gameLocal.Printf( "No testModel active.\n" );
return;
}
gameLocal.testmodel->BlendAnim( args );
}
/*
=====================
idTestModel::TestModelNextAnim_f
=====================
*/
void idTestModel::TestModelNextAnim_f( const idCmdArgs &args ) {
if ( !gameLocal.testmodel ) {
gameLocal.Printf( "No testModel active.\n" );
return;
}
gameLocal.testmodel->NextAnim( args );
}
/*
=====================
idTestModel::TestModelPrevAnim_f
=====================
*/
void idTestModel::TestModelPrevAnim_f( const idCmdArgs &args ) {
if ( !gameLocal.testmodel ) {
gameLocal.Printf( "No testModel active.\n" );
return;
}
gameLocal.testmodel->PrevAnim( args );
}
/*
=====================
idTestModel::TestModelNextFrame_f
=====================
*/
void idTestModel::TestModelNextFrame_f( const idCmdArgs &args ) {
if ( !gameLocal.testmodel ) {
gameLocal.Printf( "No testModel active.\n" );
return;
}
gameLocal.testmodel->NextFrame( args );
}
/*
=====================
idTestModel::TestModelPrevFrame_f
=====================
*/
void idTestModel::TestModelPrevFrame_f( const idCmdArgs &args ) {
if ( !gameLocal.testmodel ) {
gameLocal.Printf( "No testModel active.\n" );
return;
}
gameLocal.testmodel->PrevFrame( args );
}
| 1 | 0.659329 | 1 | 0.659329 | game-dev | MEDIA | 0.941272 | game-dev | 0.79958 | 1 | 0.79958 |
kappader4/PapyrusMC | 3,978 | leaf-server/minecraft-patches/features/0158-Sakura-Optimise-check-inside-blocks-and-traverse-blo.patch | From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Samsuik <kfian294ma4@gmail.com>
Date: Fri, 8 Nov 2024 19:35:49 +0000
Subject: [PATCH] Sakura: Optimise check inside blocks and traverse blocks
Dreeam TODO: refactor checkinsideblcoks
diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
index df4b26a6304df92f4eda27ac986ca78d5217ce6c..a4de10a32f49b7b361fc9dd1d142caeef8d7d148 100644
--- a/net/minecraft/world/entity/Entity.java
+++ b/net/minecraft/world/entity/Entity.java
@@ -1710,6 +1710,11 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
private void checkInsideBlocks(List<Entity.Movement> movements, Set<BlockState> blocksInside) {
if (this.isAffectedByBlocks()) {
LongSet set = this.visitedBlocks;
+ // Sakura start - optimise check inside blocks
+ int lastChunkX = Integer.MIN_VALUE;
+ int lastChunkZ = Integer.MIN_VALUE;
+ net.minecraft.world.level.chunk.ChunkAccess chunk = null;
+ // Sakura end - optimise check inside blocks
for (Entity.Movement movement : movements) {
Vec3 vec3 = movement.from();
@@ -1721,7 +1726,19 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
return;
}
- BlockState blockState = this.level().getBlockState(blockPos);
+ // Sakura start - optimise check inside blocks
+ final int chunkX = blockPos.getX() >> 4;
+ final int chunkZ = blockPos.getZ() >> 4;
+ if (chunk == null || chunkX != lastChunkX || chunkZ != lastChunkZ) {
+ chunk = this.level.getChunkIfLoadedImmediately(chunkX, chunkZ);
+ if (chunk == null) {
+ continue;
+ }
+ lastChunkX = chunkX;
+ lastChunkZ = chunkZ;
+ }
+ final BlockState blockState = chunk.getBlockState(blockPos);
+ // Sakura end - optimise check inside blocks
if (!blockState.isAir() && set.add(blockPos.asLong())) {
try {
VoxelShape entityInsideCollisionShape = blockState.getEntityInsideCollisionShape(this.level(), blockPos);
diff --git a/net/minecraft/world/level/BlockGetter.java b/net/minecraft/world/level/BlockGetter.java
index 91865d7e78e15cc643a65de03045b90a52d6ec2a..03f82e60528738e89f195cfc59094f53156f5370 100644
--- a/net/minecraft/world/level/BlockGetter.java
+++ b/net/minecraft/world/level/BlockGetter.java
@@ -214,10 +214,18 @@ public interface BlockGetter extends LevelHeightAccessor {
static Iterable<BlockPos> boxTraverseBlocks(Vec3 oldPosition, Vec3 position, AABB boundingBox) {
Vec3 vec3 = position.subtract(oldPosition);
- Iterable<BlockPos> iterable = BlockPos.betweenClosed(boundingBox);
+ // Sakura start - optimise check inside blocks
if (vec3.lengthSqr() < Mth.square(0.99999F)) {
- return iterable;
+ return org.dreeam.leaf.util.map.BlockPosIterator.iterable(boundingBox);
} else {
+ final boolean xZero = vec3.x() == 0.0;
+ final boolean yZero = vec3.y() == 0.0;
+ final boolean zZero = vec3.z() == 0.0;
+ if (xZero && yZero || yZero && zZero || xZero && zZero) {
+ return org.dreeam.leaf.util.map.BlockPosIterator.traverseArea(vec3, boundingBox);
+ }
+ Iterable<BlockPos> iterable = BlockPos.betweenClosed(boundingBox);
+ // Sakura end - optimise check inside blocks
Set<BlockPos> set = new ObjectLinkedOpenHashSet<>();
Vec3 minPosition = boundingBox.getMinPosition();
Vec3 vec31 = minPosition.subtract(vec3);
| 1 | 0.828198 | 1 | 0.828198 | game-dev | MEDIA | 0.975314 | game-dev | 0.96989 | 1 | 0.96989 |
jni4net/jni4net | 1,796 | content/samples/drools/drools-api-5.1.1.j4n/jvm/org/drools/event/process/ProcessNodeTriggeredEvent_.java | // ------------------------------------------------------------------------------
// <autogenerated>
// This code was generated by jni4net. See http://jni4net.sourceforge.net/
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </autogenerated>
// ------------------------------------------------------------------------------
package org.drools.event.process;
@net.sf.jni4net.attributes.ClrTypeInfo
public final class ProcessNodeTriggeredEvent_ {
//<generated-static>
private static system.Type staticType;
public static system.Type typeof() {
return org.drools.event.process.ProcessNodeTriggeredEvent_.staticType;
}
private static void InitJNI(net.sf.jni4net.inj.INJEnv env, system.Type staticType) {
org.drools.event.process.ProcessNodeTriggeredEvent_.staticType = staticType;
}
//</generated-static>
}
//<generated-proxy>
@net.sf.jni4net.attributes.ClrProxy
class __ProcessNodeTriggeredEvent extends system.Object implements org.drools.event.process.ProcessNodeTriggeredEvent {
protected __ProcessNodeTriggeredEvent(net.sf.jni4net.inj.INJEnv __env, long __handle) {
super(__env, __handle);
}
@net.sf.jni4net.attributes.ClrMethod("()Lorg/drools/runtime/KnowledgeRuntime;")
public native org.drools.runtime.KnowledgeRuntime getKnowledgeRuntime();
@net.sf.jni4net.attributes.ClrMethod("()Lorg/drools/runtime/process/ProcessInstance;")
public native org.drools.runtime.process.ProcessInstance getProcessInstance();
@net.sf.jni4net.attributes.ClrMethod("()Lorg/drools/runtime/process/NodeInstance;")
public native org.drools.runtime.process.NodeInstance getNodeInstance();
}
//</generated-proxy>
| 1 | 0.857786 | 1 | 0.857786 | game-dev | MEDIA | 0.211605 | game-dev | 0.904922 | 1 | 0.904922 |
AtomicGameEngine/AtomicGameEngine | 32,325 | Source/ThirdParty/Bullet/src/BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.cpp | /*
Bullet Continuous Collision Detection and Physics Library
Copyright (c) 2013 Erwin Coumans http://bulletphysics.org
This software is provided 'as-is', without any express or implied warranty.
In no event will the authors be held liable for any damages arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it freely,
subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#include "btMultiBodyDynamicsWorld.h"
#include "btMultiBodyConstraintSolver.h"
#include "btMultiBody.h"
#include "btMultiBodyLinkCollider.h"
#include "BulletCollision/CollisionDispatch/btSimulationIslandManager.h"
#include "LinearMath/btQuickprof.h"
#include "btMultiBodyConstraint.h"
#include "LinearMath/btIDebugDraw.h"
#include "LinearMath/btSerializer.h"
void btMultiBodyDynamicsWorld::addMultiBody(btMultiBody* body, int group, int mask)
{
m_multiBodies.push_back(body);
}
void btMultiBodyDynamicsWorld::removeMultiBody(btMultiBody* body)
{
m_multiBodies.remove(body);
}
void btMultiBodyDynamicsWorld::calculateSimulationIslands()
{
BT_PROFILE("calculateSimulationIslands");
getSimulationIslandManager()->updateActivationState(getCollisionWorld(),getCollisionWorld()->getDispatcher());
{
//merge islands based on speculative contact manifolds too
for (int i=0;i<this->m_predictiveManifolds.size();i++)
{
btPersistentManifold* manifold = m_predictiveManifolds[i];
const btCollisionObject* colObj0 = manifold->getBody0();
const btCollisionObject* colObj1 = manifold->getBody1();
if (((colObj0) && (!(colObj0)->isStaticOrKinematicObject())) &&
((colObj1) && (!(colObj1)->isStaticOrKinematicObject())))
{
getSimulationIslandManager()->getUnionFind().unite((colObj0)->getIslandTag(),(colObj1)->getIslandTag());
}
}
}
{
int i;
int numConstraints = int(m_constraints.size());
for (i=0;i< numConstraints ; i++ )
{
btTypedConstraint* constraint = m_constraints[i];
if (constraint->isEnabled())
{
const btRigidBody* colObj0 = &constraint->getRigidBodyA();
const btRigidBody* colObj1 = &constraint->getRigidBodyB();
if (((colObj0) && (!(colObj0)->isStaticOrKinematicObject())) &&
((colObj1) && (!(colObj1)->isStaticOrKinematicObject())))
{
getSimulationIslandManager()->getUnionFind().unite((colObj0)->getIslandTag(),(colObj1)->getIslandTag());
}
}
}
}
//merge islands linked by Featherstone link colliders
for (int i=0;i<m_multiBodies.size();i++)
{
btMultiBody* body = m_multiBodies[i];
{
btMultiBodyLinkCollider* prev = body->getBaseCollider();
for (int b=0;b<body->getNumLinks();b++)
{
btMultiBodyLinkCollider* cur = body->getLink(b).m_collider;
if (((cur) && (!(cur)->isStaticOrKinematicObject())) &&
((prev) && (!(prev)->isStaticOrKinematicObject())))
{
int tagPrev = prev->getIslandTag();
int tagCur = cur->getIslandTag();
getSimulationIslandManager()->getUnionFind().unite(tagPrev, tagCur);
}
if (cur && !cur->isStaticOrKinematicObject())
prev = cur;
}
}
}
//merge islands linked by multibody constraints
{
for (int i=0;i<this->m_multiBodyConstraints.size();i++)
{
btMultiBodyConstraint* c = m_multiBodyConstraints[i];
int tagA = c->getIslandIdA();
int tagB = c->getIslandIdB();
if (tagA>=0 && tagB>=0)
getSimulationIslandManager()->getUnionFind().unite(tagA, tagB);
}
}
//Store the island id in each body
getSimulationIslandManager()->storeIslandActivationState(getCollisionWorld());
}
void btMultiBodyDynamicsWorld::updateActivationState(btScalar timeStep)
{
BT_PROFILE("btMultiBodyDynamicsWorld::updateActivationState");
for ( int i=0;i<m_multiBodies.size();i++)
{
btMultiBody* body = m_multiBodies[i];
if (body)
{
body->checkMotionAndSleepIfRequired(timeStep);
if (!body->isAwake())
{
btMultiBodyLinkCollider* col = body->getBaseCollider();
if (col && col->getActivationState() == ACTIVE_TAG)
{
col->setActivationState( WANTS_DEACTIVATION);
col->setDeactivationTime(0.f);
}
for (int b=0;b<body->getNumLinks();b++)
{
btMultiBodyLinkCollider* col = body->getLink(b).m_collider;
if (col && col->getActivationState() == ACTIVE_TAG)
{
col->setActivationState( WANTS_DEACTIVATION);
col->setDeactivationTime(0.f);
}
}
} else
{
btMultiBodyLinkCollider* col = body->getBaseCollider();
if (col && col->getActivationState() != DISABLE_DEACTIVATION)
col->setActivationState( ACTIVE_TAG );
for (int b=0;b<body->getNumLinks();b++)
{
btMultiBodyLinkCollider* col = body->getLink(b).m_collider;
if (col && col->getActivationState() != DISABLE_DEACTIVATION)
col->setActivationState( ACTIVE_TAG );
}
}
}
}
btDiscreteDynamicsWorld::updateActivationState(timeStep);
}
SIMD_FORCE_INLINE int btGetConstraintIslandId2(const btTypedConstraint* lhs)
{
int islandId;
const btCollisionObject& rcolObj0 = lhs->getRigidBodyA();
const btCollisionObject& rcolObj1 = lhs->getRigidBodyB();
islandId= rcolObj0.getIslandTag()>=0?rcolObj0.getIslandTag():rcolObj1.getIslandTag();
return islandId;
}
class btSortConstraintOnIslandPredicate2
{
public:
bool operator() ( const btTypedConstraint* lhs, const btTypedConstraint* rhs ) const
{
int rIslandId0,lIslandId0;
rIslandId0 = btGetConstraintIslandId2(rhs);
lIslandId0 = btGetConstraintIslandId2(lhs);
return lIslandId0 < rIslandId0;
}
};
SIMD_FORCE_INLINE int btGetMultiBodyConstraintIslandId(const btMultiBodyConstraint* lhs)
{
int islandId;
int islandTagA = lhs->getIslandIdA();
int islandTagB = lhs->getIslandIdB();
islandId= islandTagA>=0?islandTagA:islandTagB;
return islandId;
}
class btSortMultiBodyConstraintOnIslandPredicate
{
public:
bool operator() ( const btMultiBodyConstraint* lhs, const btMultiBodyConstraint* rhs ) const
{
int rIslandId0,lIslandId0;
rIslandId0 = btGetMultiBodyConstraintIslandId(rhs);
lIslandId0 = btGetMultiBodyConstraintIslandId(lhs);
return lIslandId0 < rIslandId0;
}
};
struct MultiBodyInplaceSolverIslandCallback : public btSimulationIslandManager::IslandCallback
{
btContactSolverInfo* m_solverInfo;
btMultiBodyConstraintSolver* m_solver;
btMultiBodyConstraint** m_multiBodySortedConstraints;
int m_numMultiBodyConstraints;
btTypedConstraint** m_sortedConstraints;
int m_numConstraints;
btIDebugDraw* m_debugDrawer;
btDispatcher* m_dispatcher;
btAlignedObjectArray<btCollisionObject*> m_bodies;
btAlignedObjectArray<btPersistentManifold*> m_manifolds;
btAlignedObjectArray<btTypedConstraint*> m_constraints;
btAlignedObjectArray<btMultiBodyConstraint*> m_multiBodyConstraints;
MultiBodyInplaceSolverIslandCallback( btMultiBodyConstraintSolver* solver,
btDispatcher* dispatcher)
:m_solverInfo(NULL),
m_solver(solver),
m_multiBodySortedConstraints(NULL),
m_numConstraints(0),
m_debugDrawer(NULL),
m_dispatcher(dispatcher)
{
}
MultiBodyInplaceSolverIslandCallback& operator=(MultiBodyInplaceSolverIslandCallback& other)
{
btAssert(0);
(void)other;
return *this;
}
SIMD_FORCE_INLINE void setup ( btContactSolverInfo* solverInfo, btTypedConstraint** sortedConstraints, int numConstraints, btMultiBodyConstraint** sortedMultiBodyConstraints, int numMultiBodyConstraints, btIDebugDraw* debugDrawer)
{
btAssert(solverInfo);
m_solverInfo = solverInfo;
m_multiBodySortedConstraints = sortedMultiBodyConstraints;
m_numMultiBodyConstraints = numMultiBodyConstraints;
m_sortedConstraints = sortedConstraints;
m_numConstraints = numConstraints;
m_debugDrawer = debugDrawer;
m_bodies.resize (0);
m_manifolds.resize (0);
m_constraints.resize (0);
m_multiBodyConstraints.resize(0);
}
virtual void processIsland(btCollisionObject** bodies,int numBodies,btPersistentManifold** manifolds,int numManifolds, int islandId)
{
if (islandId<0)
{
///we don't split islands, so all constraints/contact manifolds/bodies are passed into the solver regardless the island id
m_solver->solveMultiBodyGroup( bodies,numBodies,manifolds, numManifolds,m_sortedConstraints, m_numConstraints, &m_multiBodySortedConstraints[0],m_numConstraints,*m_solverInfo,m_debugDrawer,m_dispatcher);
} else
{
//also add all non-contact constraints/joints for this island
btTypedConstraint** startConstraint = 0;
btMultiBodyConstraint** startMultiBodyConstraint = 0;
int numCurConstraints = 0;
int numCurMultiBodyConstraints = 0;
int i;
//find the first constraint for this island
for (i=0;i<m_numConstraints;i++)
{
if (btGetConstraintIslandId2(m_sortedConstraints[i]) == islandId)
{
startConstraint = &m_sortedConstraints[i];
break;
}
}
//count the number of constraints in this island
for (;i<m_numConstraints;i++)
{
if (btGetConstraintIslandId2(m_sortedConstraints[i]) == islandId)
{
numCurConstraints++;
}
}
for (i=0;i<m_numMultiBodyConstraints;i++)
{
if (btGetMultiBodyConstraintIslandId(m_multiBodySortedConstraints[i]) == islandId)
{
startMultiBodyConstraint = &m_multiBodySortedConstraints[i];
break;
}
}
//count the number of multi body constraints in this island
for (;i<m_numMultiBodyConstraints;i++)
{
if (btGetMultiBodyConstraintIslandId(m_multiBodySortedConstraints[i]) == islandId)
{
numCurMultiBodyConstraints++;
}
}
//if (m_solverInfo->m_minimumSolverBatchSize<=1)
//{
// m_solver->solveGroup( bodies,numBodies,manifolds, numManifolds,startConstraint,numCurConstraints,*m_solverInfo,m_debugDrawer,m_dispatcher);
//} else
{
for (i=0;i<numBodies;i++)
m_bodies.push_back(bodies[i]);
for (i=0;i<numManifolds;i++)
m_manifolds.push_back(manifolds[i]);
for (i=0;i<numCurConstraints;i++)
m_constraints.push_back(startConstraint[i]);
for (i=0;i<numCurMultiBodyConstraints;i++)
m_multiBodyConstraints.push_back(startMultiBodyConstraint[i]);
if ((m_constraints.size()+m_manifolds.size())>m_solverInfo->m_minimumSolverBatchSize)
{
processConstraints();
} else
{
//printf("deferred\n");
}
}
}
}
void processConstraints()
{
btCollisionObject** bodies = m_bodies.size()? &m_bodies[0]:0;
btPersistentManifold** manifold = m_manifolds.size()?&m_manifolds[0]:0;
btTypedConstraint** constraints = m_constraints.size()?&m_constraints[0]:0;
btMultiBodyConstraint** multiBodyConstraints = m_multiBodyConstraints.size() ? &m_multiBodyConstraints[0] : 0;
//printf("mb contacts = %d, mb constraints = %d\n", mbContacts, m_multiBodyConstraints.size());
m_solver->solveMultiBodyGroup( bodies,m_bodies.size(),manifold, m_manifolds.size(),constraints, m_constraints.size() ,multiBodyConstraints, m_multiBodyConstraints.size(), *m_solverInfo,m_debugDrawer,m_dispatcher);
m_bodies.resize(0);
m_manifolds.resize(0);
m_constraints.resize(0);
m_multiBodyConstraints.resize(0);
}
};
btMultiBodyDynamicsWorld::btMultiBodyDynamicsWorld(btDispatcher* dispatcher,btBroadphaseInterface* pairCache,btMultiBodyConstraintSolver* constraintSolver,btCollisionConfiguration* collisionConfiguration)
:btDiscreteDynamicsWorld(dispatcher,pairCache,constraintSolver,collisionConfiguration),
m_multiBodyConstraintSolver(constraintSolver)
{
//split impulse is not yet supported for Featherstone hierarchies
// getSolverInfo().m_splitImpulse = false;
getSolverInfo().m_solverMode |=SOLVER_USE_2_FRICTION_DIRECTIONS;
m_solverMultiBodyIslandCallback = new MultiBodyInplaceSolverIslandCallback(constraintSolver,dispatcher);
}
btMultiBodyDynamicsWorld::~btMultiBodyDynamicsWorld ()
{
delete m_solverMultiBodyIslandCallback;
}
void btMultiBodyDynamicsWorld::forwardKinematics()
{
for (int b=0;b<m_multiBodies.size();b++)
{
btMultiBody* bod = m_multiBodies[b];
bod->forwardKinematics(m_scratch_world_to_local,m_scratch_local_origin);
}
}
void btMultiBodyDynamicsWorld::solveConstraints(btContactSolverInfo& solverInfo)
{
forwardKinematics();
BT_PROFILE("solveConstraints");
m_sortedConstraints.resize( m_constraints.size());
int i;
for (i=0;i<getNumConstraints();i++)
{
m_sortedConstraints[i] = m_constraints[i];
}
m_sortedConstraints.quickSort(btSortConstraintOnIslandPredicate2());
btTypedConstraint** constraintsPtr = getNumConstraints() ? &m_sortedConstraints[0] : 0;
m_sortedMultiBodyConstraints.resize(m_multiBodyConstraints.size());
for (i=0;i<m_multiBodyConstraints.size();i++)
{
m_sortedMultiBodyConstraints[i] = m_multiBodyConstraints[i];
}
m_sortedMultiBodyConstraints.quickSort(btSortMultiBodyConstraintOnIslandPredicate());
btMultiBodyConstraint** sortedMultiBodyConstraints = m_sortedMultiBodyConstraints.size() ? &m_sortedMultiBodyConstraints[0] : 0;
m_solverMultiBodyIslandCallback->setup(&solverInfo,constraintsPtr,m_sortedConstraints.size(),sortedMultiBodyConstraints,m_sortedMultiBodyConstraints.size(), getDebugDrawer());
m_constraintSolver->prepareSolve(getCollisionWorld()->getNumCollisionObjects(), getCollisionWorld()->getDispatcher()->getNumManifolds());
/// solve all the constraints for this island
m_islandManager->buildAndProcessIslands(getCollisionWorld()->getDispatcher(),getCollisionWorld(),m_solverMultiBodyIslandCallback);
#ifndef BT_USE_VIRTUAL_CLEARFORCES_AND_GRAVITY
{
BT_PROFILE("btMultiBody addForce");
for (int i=0;i<this->m_multiBodies.size();i++)
{
btMultiBody* bod = m_multiBodies[i];
bool isSleeping = false;
if (bod->getBaseCollider() && bod->getBaseCollider()->getActivationState() == ISLAND_SLEEPING)
{
isSleeping = true;
}
for (int b=0;b<bod->getNumLinks();b++)
{
if (bod->getLink(b).m_collider && bod->getLink(b).m_collider->getActivationState()==ISLAND_SLEEPING)
isSleeping = true;
}
if (!isSleeping)
{
//useless? they get resized in stepVelocities once again (AND DIFFERENTLY)
m_scratch_r.resize(bod->getNumLinks()+1); //multidof? ("Y"s use it and it is used to store qdd)
m_scratch_v.resize(bod->getNumLinks()+1);
m_scratch_m.resize(bod->getNumLinks()+1);
bod->addBaseForce(m_gravity * bod->getBaseMass());
for (int j = 0; j < bod->getNumLinks(); ++j)
{
bod->addLinkForce(j, m_gravity * bod->getLinkMass(j));
}
}//if (!isSleeping)
}
}
#endif //BT_USE_VIRTUAL_CLEARFORCES_AND_GRAVITY
{
BT_PROFILE("btMultiBody stepVelocities");
for (int i=0;i<this->m_multiBodies.size();i++)
{
btMultiBody* bod = m_multiBodies[i];
bool isSleeping = false;
if (bod->getBaseCollider() && bod->getBaseCollider()->getActivationState() == ISLAND_SLEEPING)
{
isSleeping = true;
}
for (int b=0;b<bod->getNumLinks();b++)
{
if (bod->getLink(b).m_collider && bod->getLink(b).m_collider->getActivationState()==ISLAND_SLEEPING)
isSleeping = true;
}
if (!isSleeping)
{
//useless? they get resized in stepVelocities once again (AND DIFFERENTLY)
m_scratch_r.resize(bod->getNumLinks()+1); //multidof? ("Y"s use it and it is used to store qdd)
m_scratch_v.resize(bod->getNumLinks()+1);
m_scratch_m.resize(bod->getNumLinks()+1);
bool doNotUpdatePos = false;
{
if(!bod->isUsingRK4Integration())
{
bod->computeAccelerationsArticulatedBodyAlgorithmMultiDof(solverInfo.m_timeStep, m_scratch_r, m_scratch_v, m_scratch_m);
}
else
{
//
int numDofs = bod->getNumDofs() + 6;
int numPosVars = bod->getNumPosVars() + 7;
btAlignedObjectArray<btScalar> scratch_r2; scratch_r2.resize(2*numPosVars + 8*numDofs);
//convenience
btScalar *pMem = &scratch_r2[0];
btScalar *scratch_q0 = pMem; pMem += numPosVars;
btScalar *scratch_qx = pMem; pMem += numPosVars;
btScalar *scratch_qd0 = pMem; pMem += numDofs;
btScalar *scratch_qd1 = pMem; pMem += numDofs;
btScalar *scratch_qd2 = pMem; pMem += numDofs;
btScalar *scratch_qd3 = pMem; pMem += numDofs;
btScalar *scratch_qdd0 = pMem; pMem += numDofs;
btScalar *scratch_qdd1 = pMem; pMem += numDofs;
btScalar *scratch_qdd2 = pMem; pMem += numDofs;
btScalar *scratch_qdd3 = pMem; pMem += numDofs;
btAssert((pMem - (2*numPosVars + 8*numDofs)) == &scratch_r2[0]);
/////
//copy q0 to scratch_q0 and qd0 to scratch_qd0
scratch_q0[0] = bod->getWorldToBaseRot().x();
scratch_q0[1] = bod->getWorldToBaseRot().y();
scratch_q0[2] = bod->getWorldToBaseRot().z();
scratch_q0[3] = bod->getWorldToBaseRot().w();
scratch_q0[4] = bod->getBasePos().x();
scratch_q0[5] = bod->getBasePos().y();
scratch_q0[6] = bod->getBasePos().z();
//
for(int link = 0; link < bod->getNumLinks(); ++link)
{
for(int dof = 0; dof < bod->getLink(link).m_posVarCount; ++dof)
scratch_q0[7 + bod->getLink(link).m_cfgOffset + dof] = bod->getLink(link).m_jointPos[dof];
}
//
for(int dof = 0; dof < numDofs; ++dof)
scratch_qd0[dof] = bod->getVelocityVector()[dof];
////
struct
{
btMultiBody *bod;
btScalar *scratch_qx, *scratch_q0;
void operator()()
{
for(int dof = 0; dof < bod->getNumPosVars() + 7; ++dof)
scratch_qx[dof] = scratch_q0[dof];
}
} pResetQx = {bod, scratch_qx, scratch_q0};
//
struct
{
void operator()(btScalar dt, const btScalar *pDer, const btScalar *pCurVal, btScalar *pVal, int size)
{
for(int i = 0; i < size; ++i)
pVal[i] = pCurVal[i] + dt * pDer[i];
}
} pEulerIntegrate;
//
struct
{
void operator()(btMultiBody *pBody, const btScalar *pData)
{
btScalar *pVel = const_cast<btScalar*>(pBody->getVelocityVector());
for(int i = 0; i < pBody->getNumDofs() + 6; ++i)
pVel[i] = pData[i];
}
} pCopyToVelocityVector;
//
struct
{
void operator()(const btScalar *pSrc, btScalar *pDst, int start, int size)
{
for(int i = 0; i < size; ++i)
pDst[i] = pSrc[start + i];
}
} pCopy;
//
btScalar h = solverInfo.m_timeStep;
#define output &m_scratch_r[bod->getNumDofs()]
//calc qdd0 from: q0 & qd0
bod->computeAccelerationsArticulatedBodyAlgorithmMultiDof(0., m_scratch_r, m_scratch_v, m_scratch_m);
pCopy(output, scratch_qdd0, 0, numDofs);
//calc q1 = q0 + h/2 * qd0
pResetQx();
bod->stepPositionsMultiDof(btScalar(.5)*h, scratch_qx, scratch_qd0);
//calc qd1 = qd0 + h/2 * qdd0
pEulerIntegrate(btScalar(.5)*h, scratch_qdd0, scratch_qd0, scratch_qd1, numDofs);
//
//calc qdd1 from: q1 & qd1
pCopyToVelocityVector(bod, scratch_qd1);
bod->computeAccelerationsArticulatedBodyAlgorithmMultiDof(0., m_scratch_r, m_scratch_v, m_scratch_m);
pCopy(output, scratch_qdd1, 0, numDofs);
//calc q2 = q0 + h/2 * qd1
pResetQx();
bod->stepPositionsMultiDof(btScalar(.5)*h, scratch_qx, scratch_qd1);
//calc qd2 = qd0 + h/2 * qdd1
pEulerIntegrate(btScalar(.5)*h, scratch_qdd1, scratch_qd0, scratch_qd2, numDofs);
//
//calc qdd2 from: q2 & qd2
pCopyToVelocityVector(bod, scratch_qd2);
bod->computeAccelerationsArticulatedBodyAlgorithmMultiDof(0., m_scratch_r, m_scratch_v, m_scratch_m);
pCopy(output, scratch_qdd2, 0, numDofs);
//calc q3 = q0 + h * qd2
pResetQx();
bod->stepPositionsMultiDof(h, scratch_qx, scratch_qd2);
//calc qd3 = qd0 + h * qdd2
pEulerIntegrate(h, scratch_qdd2, scratch_qd0, scratch_qd3, numDofs);
//
//calc qdd3 from: q3 & qd3
pCopyToVelocityVector(bod, scratch_qd3);
bod->computeAccelerationsArticulatedBodyAlgorithmMultiDof(0., m_scratch_r, m_scratch_v, m_scratch_m);
pCopy(output, scratch_qdd3, 0, numDofs);
//
//calc q = q0 + h/6(qd0 + 2*(qd1 + qd2) + qd3)
//calc qd = qd0 + h/6(qdd0 + 2*(qdd1 + qdd2) + qdd3)
btAlignedObjectArray<btScalar> delta_q; delta_q.resize(numDofs);
btAlignedObjectArray<btScalar> delta_qd; delta_qd.resize(numDofs);
for(int i = 0; i < numDofs; ++i)
{
delta_q[i] = h/btScalar(6.)*(scratch_qd0[i] + 2*scratch_qd1[i] + 2*scratch_qd2[i] + scratch_qd3[i]);
delta_qd[i] = h/btScalar(6.)*(scratch_qdd0[i] + 2*scratch_qdd1[i] + 2*scratch_qdd2[i] + scratch_qdd3[i]);
//delta_q[i] = h*scratch_qd0[i];
//delta_qd[i] = h*scratch_qdd0[i];
}
//
pCopyToVelocityVector(bod, scratch_qd0);
bod->applyDeltaVeeMultiDof(&delta_qd[0], 1);
//
if(!doNotUpdatePos)
{
btScalar *pRealBuf = const_cast<btScalar *>(bod->getVelocityVector());
pRealBuf += 6 + bod->getNumDofs() + bod->getNumDofs()*bod->getNumDofs();
for(int i = 0; i < numDofs; ++i)
pRealBuf[i] = delta_q[i];
//bod->stepPositionsMultiDof(1, 0, &delta_q[0]);
bod->setPosUpdated(true);
}
//ugly hack which resets the cached data to t0 (needed for constraint solver)
{
for(int link = 0; link < bod->getNumLinks(); ++link)
bod->getLink(link).updateCacheMultiDof();
bod->computeAccelerationsArticulatedBodyAlgorithmMultiDof(0, m_scratch_r, m_scratch_v, m_scratch_m);
}
}
}
#ifndef BT_USE_VIRTUAL_CLEARFORCES_AND_GRAVITY
bod->clearForcesAndTorques();
#endif //BT_USE_VIRTUAL_CLEARFORCES_AND_GRAVITY
}//if (!isSleeping)
}
}
clearMultiBodyConstraintForces();
m_solverMultiBodyIslandCallback->processConstraints();
m_constraintSolver->allSolved(solverInfo, m_debugDrawer);
{
BT_PROFILE("btMultiBody stepVelocities");
for (int i=0;i<this->m_multiBodies.size();i++)
{
btMultiBody* bod = m_multiBodies[i];
bool isSleeping = false;
if (bod->getBaseCollider() && bod->getBaseCollider()->getActivationState() == ISLAND_SLEEPING)
{
isSleeping = true;
}
for (int b=0;b<bod->getNumLinks();b++)
{
if (bod->getLink(b).m_collider && bod->getLink(b).m_collider->getActivationState()==ISLAND_SLEEPING)
isSleeping = true;
}
if (!isSleeping)
{
//useless? they get resized in stepVelocities once again (AND DIFFERENTLY)
m_scratch_r.resize(bod->getNumLinks()+1); //multidof? ("Y"s use it and it is used to store qdd)
m_scratch_v.resize(bod->getNumLinks()+1);
m_scratch_m.resize(bod->getNumLinks()+1);
{
if(!bod->isUsingRK4Integration())
{
bool isConstraintPass = true;
bod->computeAccelerationsArticulatedBodyAlgorithmMultiDof(solverInfo.m_timeStep, m_scratch_r, m_scratch_v, m_scratch_m, isConstraintPass);
}
}
}
}
}
for (int i=0;i<this->m_multiBodies.size();i++)
{
btMultiBody* bod = m_multiBodies[i];
bod->processDeltaVeeMultiDof2();
}
}
void btMultiBodyDynamicsWorld::integrateTransforms(btScalar timeStep)
{
btDiscreteDynamicsWorld::integrateTransforms(timeStep);
{
BT_PROFILE("btMultiBody stepPositions");
//integrate and update the Featherstone hierarchies
for (int b=0;b<m_multiBodies.size();b++)
{
btMultiBody* bod = m_multiBodies[b];
bool isSleeping = false;
if (bod->getBaseCollider() && bod->getBaseCollider()->getActivationState() == ISLAND_SLEEPING)
{
isSleeping = true;
}
for (int b=0;b<bod->getNumLinks();b++)
{
if (bod->getLink(b).m_collider && bod->getLink(b).m_collider->getActivationState()==ISLAND_SLEEPING)
isSleeping = true;
}
if (!isSleeping)
{
int nLinks = bod->getNumLinks();
///base + num m_links
{
if(!bod->isPosUpdated())
bod->stepPositionsMultiDof(timeStep);
else
{
btScalar *pRealBuf = const_cast<btScalar *>(bod->getVelocityVector());
pRealBuf += 6 + bod->getNumDofs() + bod->getNumDofs()*bod->getNumDofs();
bod->stepPositionsMultiDof(1, 0, pRealBuf);
bod->setPosUpdated(false);
}
}
m_scratch_world_to_local.resize(nLinks+1);
m_scratch_local_origin.resize(nLinks+1);
bod->updateCollisionObjectWorldTransforms(m_scratch_world_to_local,m_scratch_local_origin);
} else
{
bod->clearVelocities();
}
}
}
}
void btMultiBodyDynamicsWorld::addMultiBodyConstraint( btMultiBodyConstraint* constraint)
{
m_multiBodyConstraints.push_back(constraint);
}
void btMultiBodyDynamicsWorld::removeMultiBodyConstraint( btMultiBodyConstraint* constraint)
{
m_multiBodyConstraints.remove(constraint);
}
void btMultiBodyDynamicsWorld::debugDrawMultiBodyConstraint(btMultiBodyConstraint* constraint)
{
constraint->debugDraw(getDebugDrawer());
}
void btMultiBodyDynamicsWorld::debugDrawWorld()
{
BT_PROFILE("btMultiBodyDynamicsWorld debugDrawWorld");
bool drawConstraints = false;
if (getDebugDrawer())
{
int mode = getDebugDrawer()->getDebugMode();
if (mode & (btIDebugDraw::DBG_DrawConstraints | btIDebugDraw::DBG_DrawConstraintLimits))
{
drawConstraints = true;
}
if (drawConstraints)
{
BT_PROFILE("btMultiBody debugDrawWorld");
for (int c=0;c<m_multiBodyConstraints.size();c++)
{
btMultiBodyConstraint* constraint = m_multiBodyConstraints[c];
debugDrawMultiBodyConstraint(constraint);
}
for (int b = 0; b<m_multiBodies.size(); b++)
{
btMultiBody* bod = m_multiBodies[b];
bod->forwardKinematics(m_scratch_world_to_local1,m_scratch_local_origin1);
getDebugDrawer()->drawTransform(bod->getBaseWorldTransform(), 0.1);
for (int m = 0; m<bod->getNumLinks(); m++)
{
const btTransform& tr = bod->getLink(m).m_cachedWorldTransform;
getDebugDrawer()->drawTransform(tr, 0.1);
//draw the joint axis
if (bod->getLink(m).m_jointType==btMultibodyLink::eRevolute)
{
btVector3 vec = quatRotate(tr.getRotation(),bod->getLink(m).m_axes[0].m_topVec);
btVector4 color(0,0,0,1);//1,1,1);
btVector3 from = vec+tr.getOrigin()-quatRotate(tr.getRotation(),bod->getLink(m).m_dVector);
btVector3 to = tr.getOrigin()-quatRotate(tr.getRotation(),bod->getLink(m).m_dVector);
getDebugDrawer()->drawLine(from,to,color);
}
if (bod->getLink(m).m_jointType==btMultibodyLink::eFixed)
{
btVector3 vec = quatRotate(tr.getRotation(),bod->getLink(m).m_axes[0].m_bottomVec);
btVector4 color(0,0,0,1);//1,1,1);
btVector3 from = vec+tr.getOrigin()-quatRotate(tr.getRotation(),bod->getLink(m).m_dVector);
btVector3 to = tr.getOrigin()-quatRotate(tr.getRotation(),bod->getLink(m).m_dVector);
getDebugDrawer()->drawLine(from,to,color);
}
if (bod->getLink(m).m_jointType==btMultibodyLink::ePrismatic)
{
btVector3 vec = quatRotate(tr.getRotation(),bod->getLink(m).m_axes[0].m_bottomVec);
btVector4 color(0,0,0,1);//1,1,1);
btVector3 from = vec+tr.getOrigin()-quatRotate(tr.getRotation(),bod->getLink(m).m_dVector);
btVector3 to = tr.getOrigin()-quatRotate(tr.getRotation(),bod->getLink(m).m_dVector);
getDebugDrawer()->drawLine(from,to,color);
}
}
}
}
}
btDiscreteDynamicsWorld::debugDrawWorld();
}
void btMultiBodyDynamicsWorld::applyGravity()
{
btDiscreteDynamicsWorld::applyGravity();
#ifdef BT_USE_VIRTUAL_CLEARFORCES_AND_GRAVITY
BT_PROFILE("btMultiBody addGravity");
for (int i=0;i<this->m_multiBodies.size();i++)
{
btMultiBody* bod = m_multiBodies[i];
bool isSleeping = false;
if (bod->getBaseCollider() && bod->getBaseCollider()->getActivationState() == ISLAND_SLEEPING)
{
isSleeping = true;
}
for (int b=0;b<bod->getNumLinks();b++)
{
if (bod->getLink(b).m_collider && bod->getLink(b).m_collider->getActivationState()==ISLAND_SLEEPING)
isSleeping = true;
}
if (!isSleeping)
{
bod->addBaseForce(m_gravity * bod->getBaseMass());
for (int j = 0; j < bod->getNumLinks(); ++j)
{
bod->addLinkForce(j, m_gravity * bod->getLinkMass(j));
}
}//if (!isSleeping)
}
#endif //BT_USE_VIRTUAL_CLEARFORCES_AND_GRAVITY
}
void btMultiBodyDynamicsWorld::clearMultiBodyConstraintForces()
{
for (int i=0;i<this->m_multiBodies.size();i++)
{
btMultiBody* bod = m_multiBodies[i];
bod->clearConstraintForces();
}
}
void btMultiBodyDynamicsWorld::clearMultiBodyForces()
{
{
BT_PROFILE("clearMultiBodyForces");
for (int i=0;i<this->m_multiBodies.size();i++)
{
btMultiBody* bod = m_multiBodies[i];
bool isSleeping = false;
if (bod->getBaseCollider() && bod->getBaseCollider()->getActivationState() == ISLAND_SLEEPING)
{
isSleeping = true;
}
for (int b=0;b<bod->getNumLinks();b++)
{
if (bod->getLink(b).m_collider && bod->getLink(b).m_collider->getActivationState()==ISLAND_SLEEPING)
isSleeping = true;
}
if (!isSleeping)
{
btMultiBody* bod = m_multiBodies[i];
bod->clearForcesAndTorques();
}
}
}
}
void btMultiBodyDynamicsWorld::clearForces()
{
btDiscreteDynamicsWorld::clearForces();
#ifdef BT_USE_VIRTUAL_CLEARFORCES_AND_GRAVITY
clearMultiBodyForces();
#endif
}
void btMultiBodyDynamicsWorld::serialize(btSerializer* serializer)
{
serializer->startSerialization();
serializeDynamicsWorldInfo( serializer);
serializeMultiBodies(serializer);
serializeRigidBodies(serializer);
serializeCollisionObjects(serializer);
serializer->finishSerialization();
}
void btMultiBodyDynamicsWorld::serializeMultiBodies(btSerializer* serializer)
{
int i;
//serialize all collision objects
for (i=0;i<m_multiBodies.size();i++)
{
btMultiBody* mb = m_multiBodies[i];
{
int len = mb->calculateSerializeBufferSize();
btChunk* chunk = serializer->allocate(len,1);
const char* structType = mb->serialize(chunk->m_oldPtr, serializer);
serializer->finalizeChunk(chunk,structType,BT_MULTIBODY_CODE,mb);
}
}
} | 1 | 0.958828 | 1 | 0.958828 | game-dev | MEDIA | 0.905862 | game-dev | 0.987772 | 1 | 0.987772 |
Super-Santa/EssentialAddons | 3,827 | src/main/kotlin/me/supersanta/essential_addons/utils/EssentialRuleGenerator.kt | package me.supersanta.essential_addons.utils
import carpet.api.settings.SettingsManager
import carpet.utils.Translations
import joptsimple.OptionParser
import me.supersanta.essential_addons.EssentialSettings
import net.fabricmc.api.DedicatedServerModInitializer
import net.fabricmc.loader.api.FabricLoader
import org.apache.logging.log4j.LogManager
import java.io.IOException
import java.io.PrintStream
import java.nio.file.Files
import java.nio.file.Path
import java.util.*
import kotlin.io.path.absolutePathString
import kotlin.system.exitProcess
// Ripped from Carpet
class EssentialRuleGenerator: DedicatedServerModInitializer {
override fun onInitializeServer() {
val args = Arrays.stream(FabricLoader.getInstance().getLaunchArguments(true))
.filter { opt -> opt != "--" }.toList().toTypedArray()
// Prepare an OptionParser for our parameters
val parser = OptionParser()
val pathSpec = parser.accepts("generate").withRequiredArg()
// Minecraft may need more stuff later that we don't want to special-case
parser.allowsUnrecognizedOptions()
val options = parser.parse(*args)
// If our flag isn't set, continue regular launch
if (!options.has(pathSpec)) {
return
}
val logger = LogManager.getLogger("EssentialRuleGenerator")
val outputStream: PrintStream
try {
val path = Path.of(options.valueOf(pathSpec))
logger.info("Generating Rules for Path: {}", path.absolutePathString())
Files.createDirectories(path.parent)
outputStream = PrintStream(Files.newOutputStream(path))
} catch (e: IOException) {
throw RuntimeException(e)
}
Translations.updateLanguage()
val manager = SettingsManager("1.0.0", "carpet", "EssentialAddons")
manager.parseSettingsClass(EssentialSettings::class.java)
logger.info("Rule Count: {}", manager.carpetRules.size)
outputStream.println(START)
manager.dumpAllRulesToStream(outputStream, null)
outputStream.close()
logger.info("Complete")
exitProcess(0)
}
companion object {
private val START = """
# EssentialAddons
[](https://discord.gg/gn99m4QRY4)
[](https://github.com/Super-Santa/EssentialAddons/releases)
[](https://modrinth.com/mod/essentialaddons)
[Fabric Carpet](https://github.com/gnembon/fabric-carpet) extension that adds things from the Spigot plugin Essentials, or other features I think are needed for Minecraft.
## !!! Find Updated Releases on [Modrinth](https://modrinth.com/mod/essentialaddons) !!!
Features can be enabled through the `/carpet` command:
```
/carpet <rule_name> <rule_value>
# For example:
/carpet phantomsObeyMobcaps true
/carpet commandCameraMode ops
/carpet stackableShulkersInPlayerInventories true
```
Permissions can be customised for commands through a permissions mod such as [LuckPerms](https://luckperms.net/),
the name of the permissions are as follows:
```
essential-addons.command.<command_name>
# For example:
essential-addons.command.cs
essential-addons.command.hat
essential-addons.command.lag-spike
```
""".trimIndent()
}
} | 1 | 0.909765 | 1 | 0.909765 | game-dev | MEDIA | 0.541401 | game-dev | 0.935741 | 1 | 0.935741 |
Dongdongshe/K-Scheduler | 15,613 | libfuzzer_integration/llvm_11.0.1/compiler-rt/lib/hwasan/hwasan.cpp | //===-- hwasan.cpp --------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file is a part of HWAddressSanitizer.
//
// HWAddressSanitizer runtime.
//===----------------------------------------------------------------------===//
#include "hwasan.h"
#include "hwasan_checks.h"
#include "hwasan_dynamic_shadow.h"
#include "hwasan_globals.h"
#include "hwasan_poisoning.h"
#include "hwasan_report.h"
#include "hwasan_thread.h"
#include "hwasan_thread_list.h"
#include "sanitizer_common/sanitizer_atomic.h"
#include "sanitizer_common/sanitizer_common.h"
#include "sanitizer_common/sanitizer_flag_parser.h"
#include "sanitizer_common/sanitizer_flags.h"
#include "sanitizer_common/sanitizer_libc.h"
#include "sanitizer_common/sanitizer_procmaps.h"
#include "sanitizer_common/sanitizer_stackdepot.h"
#include "sanitizer_common/sanitizer_stacktrace.h"
#include "sanitizer_common/sanitizer_symbolizer.h"
#include "ubsan/ubsan_flags.h"
#include "ubsan/ubsan_init.h"
// ACHTUNG! No system header includes in this file.
using namespace __sanitizer;
namespace __hwasan {
static Flags hwasan_flags;
Flags *flags() {
return &hwasan_flags;
}
int hwasan_inited = 0;
int hwasan_instrumentation_inited = 0;
bool hwasan_init_is_running;
int hwasan_report_count = 0;
void Flags::SetDefaults() {
#define HWASAN_FLAG(Type, Name, DefaultValue, Description) Name = DefaultValue;
#include "hwasan_flags.inc"
#undef HWASAN_FLAG
}
static void RegisterHwasanFlags(FlagParser *parser, Flags *f) {
#define HWASAN_FLAG(Type, Name, DefaultValue, Description) \
RegisterFlag(parser, #Name, Description, &f->Name);
#include "hwasan_flags.inc"
#undef HWASAN_FLAG
}
static void InitializeFlags() {
SetCommonFlagsDefaults();
{
CommonFlags cf;
cf.CopyFrom(*common_flags());
cf.external_symbolizer_path = GetEnv("HWASAN_SYMBOLIZER_PATH");
cf.malloc_context_size = 20;
cf.handle_ioctl = true;
// FIXME: test and enable.
cf.check_printf = false;
cf.intercept_tls_get_addr = true;
cf.exitcode = 99;
// 8 shadow pages ~512kB, small enough to cover common stack sizes.
cf.clear_shadow_mmap_threshold = 4096 * (SANITIZER_ANDROID ? 2 : 8);
// Sigtrap is used in error reporting.
cf.handle_sigtrap = kHandleSignalExclusive;
#if SANITIZER_ANDROID
// Let platform handle other signals. It is better at reporting them then we
// are.
cf.handle_segv = kHandleSignalNo;
cf.handle_sigbus = kHandleSignalNo;
cf.handle_abort = kHandleSignalNo;
cf.handle_sigill = kHandleSignalNo;
cf.handle_sigfpe = kHandleSignalNo;
#endif
OverrideCommonFlags(cf);
}
Flags *f = flags();
f->SetDefaults();
FlagParser parser;
RegisterHwasanFlags(&parser, f);
RegisterCommonFlags(&parser);
#if HWASAN_CONTAINS_UBSAN
__ubsan::Flags *uf = __ubsan::flags();
uf->SetDefaults();
FlagParser ubsan_parser;
__ubsan::RegisterUbsanFlags(&ubsan_parser, uf);
RegisterCommonFlags(&ubsan_parser);
#endif
// Override from user-specified string.
if (__hwasan_default_options)
parser.ParseString(__hwasan_default_options());
#if HWASAN_CONTAINS_UBSAN
const char *ubsan_default_options = __ubsan::MaybeCallUbsanDefaultOptions();
ubsan_parser.ParseString(ubsan_default_options);
#endif
parser.ParseStringFromEnv("HWASAN_OPTIONS");
#if HWASAN_CONTAINS_UBSAN
ubsan_parser.ParseStringFromEnv("UBSAN_OPTIONS");
#endif
InitializeCommonFlags();
if (Verbosity()) ReportUnrecognizedFlags();
if (common_flags()->help) parser.PrintFlagDescriptions();
}
static void HWAsanCheckFailed(const char *file, int line, const char *cond,
u64 v1, u64 v2) {
Report("HWAddressSanitizer CHECK failed: %s:%d \"%s\" (0x%zx, 0x%zx)\n", file,
line, cond, (uptr)v1, (uptr)v2);
PRINT_CURRENT_STACK_CHECK();
Die();
}
static constexpr uptr kMemoryUsageBufferSize = 4096;
static void HwasanFormatMemoryUsage(InternalScopedString &s) {
HwasanThreadList &thread_list = hwasanThreadList();
auto thread_stats = thread_list.GetThreadStats();
auto *sds = StackDepotGetStats();
AllocatorStatCounters asc;
GetAllocatorStats(asc);
s.append(
"HWASAN pid: %d rss: %zd threads: %zd stacks: %zd"
" thr_aux: %zd stack_depot: %zd uniq_stacks: %zd"
" heap: %zd",
internal_getpid(), GetRSS(), thread_stats.n_live_threads,
thread_stats.total_stack_size,
thread_stats.n_live_threads * thread_list.MemoryUsedPerThread(),
sds->allocated, sds->n_uniq_ids, asc[AllocatorStatMapped]);
}
#if SANITIZER_ANDROID
static char *memory_usage_buffer = nullptr;
static void InitMemoryUsage() {
memory_usage_buffer =
(char *)MmapOrDie(kMemoryUsageBufferSize, "memory usage string");
CHECK(memory_usage_buffer);
memory_usage_buffer[0] = '\0';
DecorateMapping((uptr)memory_usage_buffer, kMemoryUsageBufferSize,
memory_usage_buffer);
}
void UpdateMemoryUsage() {
if (!flags()->export_memory_stats)
return;
if (!memory_usage_buffer)
InitMemoryUsage();
InternalScopedString s(kMemoryUsageBufferSize);
HwasanFormatMemoryUsage(s);
internal_strncpy(memory_usage_buffer, s.data(), kMemoryUsageBufferSize - 1);
memory_usage_buffer[kMemoryUsageBufferSize - 1] = '\0';
}
#else
void UpdateMemoryUsage() {}
#endif
} // namespace __hwasan
using namespace __hwasan;
void __sanitizer::BufferedStackTrace::UnwindImpl(
uptr pc, uptr bp, void *context, bool request_fast, u32 max_depth) {
Thread *t = GetCurrentThread();
if (!t) {
// The thread is still being created, or has already been destroyed.
size = 0;
return;
}
Unwind(max_depth, pc, bp, context, t->stack_top(), t->stack_bottom(),
request_fast);
}
static bool InitializeSingleGlobal(const hwasan_global &global) {
uptr full_granule_size = RoundDownTo(global.size(), 16);
TagMemoryAligned(global.addr(), full_granule_size, global.tag());
if (global.size() % 16)
TagMemoryAligned(global.addr() + full_granule_size, 16, global.size() % 16);
return false;
}
static void InitLoadedGlobals() {
dl_iterate_phdr(
[](dl_phdr_info *info, size_t /* size */, void * /* data */) -> int {
for (const hwasan_global &global : HwasanGlobalsFor(
info->dlpi_addr, info->dlpi_phdr, info->dlpi_phnum))
InitializeSingleGlobal(global);
return 0;
},
nullptr);
}
// Prepare to run instrumented code on the main thread.
static void InitInstrumentation() {
if (hwasan_instrumentation_inited) return;
InitPrctl();
if (!InitShadow()) {
Printf("FATAL: HWAddressSanitizer cannot mmap the shadow memory.\n");
DumpProcessMap();
Die();
}
InitThreads();
hwasanThreadList().CreateCurrentThread();
hwasan_instrumentation_inited = 1;
}
// Interface.
uptr __hwasan_shadow_memory_dynamic_address; // Global interface symbol.
// This function was used by the old frame descriptor mechanism. We keep it
// around to avoid breaking ABI.
void __hwasan_init_frames(uptr beg, uptr end) {}
void __hwasan_init_static() {
InitShadowGOT();
InitInstrumentation();
// In the non-static code path we call dl_iterate_phdr here. But at this point
// libc might not have been initialized enough for dl_iterate_phdr to work.
// Fortunately, since this is a statically linked executable we can use the
// linker-defined symbol __ehdr_start to find the only relevant set of phdrs.
extern ElfW(Ehdr) __ehdr_start;
for (const hwasan_global &global : HwasanGlobalsFor(
/* base */ 0,
reinterpret_cast<const ElfW(Phdr) *>(
reinterpret_cast<const char *>(&__ehdr_start) +
__ehdr_start.e_phoff),
__ehdr_start.e_phnum))
InitializeSingleGlobal(global);
}
void __hwasan_init() {
CHECK(!hwasan_init_is_running);
if (hwasan_inited) return;
hwasan_init_is_running = 1;
SanitizerToolName = "HWAddressSanitizer";
InitTlsSize();
CacheBinaryName();
InitializeFlags();
// Install tool-specific callbacks in sanitizer_common.
SetCheckFailedCallback(HWAsanCheckFailed);
__sanitizer_set_report_path(common_flags()->log_path);
AndroidTestTlsSlot();
DisableCoreDumperIfNecessary();
InitInstrumentation();
InitLoadedGlobals();
// Needs to be called here because flags()->random_tags might not have been
// initialized when InitInstrumentation() was called.
GetCurrentThread()->InitRandomState();
MadviseShadow();
SetPrintfAndReportCallback(AppendToErrorMessageBuffer);
// This may call libc -> needs initialized shadow.
AndroidLogInit();
InitializeInterceptors();
InstallDeadlySignalHandlers(HwasanOnDeadlySignal);
InstallAtExitHandler(); // Needs __cxa_atexit interceptor.
InitializeCoverage(common_flags()->coverage, common_flags()->coverage_dir);
HwasanTSDInit();
HwasanTSDThreadInit();
HwasanAllocatorInit();
#if HWASAN_CONTAINS_UBSAN
__ubsan::InitAsPlugin();
#endif
VPrintf(1, "HWAddressSanitizer init done\n");
hwasan_init_is_running = 0;
hwasan_inited = 1;
}
void __hwasan_library_loaded(ElfW(Addr) base, const ElfW(Phdr) * phdr,
ElfW(Half) phnum) {
for (const hwasan_global &global : HwasanGlobalsFor(base, phdr, phnum))
InitializeSingleGlobal(global);
}
void __hwasan_library_unloaded(ElfW(Addr) base, const ElfW(Phdr) * phdr,
ElfW(Half) phnum) {
for (; phnum != 0; ++phdr, --phnum)
if (phdr->p_type == PT_LOAD)
TagMemory(base + phdr->p_vaddr, phdr->p_memsz, 0);
}
void __hwasan_print_shadow(const void *p, uptr sz) {
uptr ptr_raw = UntagAddr(reinterpret_cast<uptr>(p));
uptr shadow_first = MemToShadow(ptr_raw);
uptr shadow_last = MemToShadow(ptr_raw + sz - 1);
Printf("HWASan shadow map for %zx .. %zx (pointer tag %x)\n", ptr_raw,
ptr_raw + sz, GetTagFromPointer((uptr)p));
for (uptr s = shadow_first; s <= shadow_last; ++s)
Printf(" %zx: %x\n", ShadowToMem(s), *(tag_t *)s);
}
sptr __hwasan_test_shadow(const void *p, uptr sz) {
if (sz == 0)
return -1;
tag_t ptr_tag = GetTagFromPointer((uptr)p);
uptr ptr_raw = UntagAddr(reinterpret_cast<uptr>(p));
uptr shadow_first = MemToShadow(ptr_raw);
uptr shadow_last = MemToShadow(ptr_raw + sz - 1);
for (uptr s = shadow_first; s <= shadow_last; ++s)
if (*(tag_t *)s != ptr_tag) {
sptr offset = ShadowToMem(s) - ptr_raw;
return offset < 0 ? 0 : offset;
}
return -1;
}
u16 __sanitizer_unaligned_load16(const uu16 *p) {
return *p;
}
u32 __sanitizer_unaligned_load32(const uu32 *p) {
return *p;
}
u64 __sanitizer_unaligned_load64(const uu64 *p) {
return *p;
}
void __sanitizer_unaligned_store16(uu16 *p, u16 x) {
*p = x;
}
void __sanitizer_unaligned_store32(uu32 *p, u32 x) {
*p = x;
}
void __sanitizer_unaligned_store64(uu64 *p, u64 x) {
*p = x;
}
void __hwasan_loadN(uptr p, uptr sz) {
CheckAddressSized<ErrorAction::Abort, AccessType::Load>(p, sz);
}
void __hwasan_load1(uptr p) {
CheckAddress<ErrorAction::Abort, AccessType::Load, 0>(p);
}
void __hwasan_load2(uptr p) {
CheckAddress<ErrorAction::Abort, AccessType::Load, 1>(p);
}
void __hwasan_load4(uptr p) {
CheckAddress<ErrorAction::Abort, AccessType::Load, 2>(p);
}
void __hwasan_load8(uptr p) {
CheckAddress<ErrorAction::Abort, AccessType::Load, 3>(p);
}
void __hwasan_load16(uptr p) {
CheckAddress<ErrorAction::Abort, AccessType::Load, 4>(p);
}
void __hwasan_loadN_noabort(uptr p, uptr sz) {
CheckAddressSized<ErrorAction::Recover, AccessType::Load>(p, sz);
}
void __hwasan_load1_noabort(uptr p) {
CheckAddress<ErrorAction::Recover, AccessType::Load, 0>(p);
}
void __hwasan_load2_noabort(uptr p) {
CheckAddress<ErrorAction::Recover, AccessType::Load, 1>(p);
}
void __hwasan_load4_noabort(uptr p) {
CheckAddress<ErrorAction::Recover, AccessType::Load, 2>(p);
}
void __hwasan_load8_noabort(uptr p) {
CheckAddress<ErrorAction::Recover, AccessType::Load, 3>(p);
}
void __hwasan_load16_noabort(uptr p) {
CheckAddress<ErrorAction::Recover, AccessType::Load, 4>(p);
}
void __hwasan_storeN(uptr p, uptr sz) {
CheckAddressSized<ErrorAction::Abort, AccessType::Store>(p, sz);
}
void __hwasan_store1(uptr p) {
CheckAddress<ErrorAction::Abort, AccessType::Store, 0>(p);
}
void __hwasan_store2(uptr p) {
CheckAddress<ErrorAction::Abort, AccessType::Store, 1>(p);
}
void __hwasan_store4(uptr p) {
CheckAddress<ErrorAction::Abort, AccessType::Store, 2>(p);
}
void __hwasan_store8(uptr p) {
CheckAddress<ErrorAction::Abort, AccessType::Store, 3>(p);
}
void __hwasan_store16(uptr p) {
CheckAddress<ErrorAction::Abort, AccessType::Store, 4>(p);
}
void __hwasan_storeN_noabort(uptr p, uptr sz) {
CheckAddressSized<ErrorAction::Recover, AccessType::Store>(p, sz);
}
void __hwasan_store1_noabort(uptr p) {
CheckAddress<ErrorAction::Recover, AccessType::Store, 0>(p);
}
void __hwasan_store2_noabort(uptr p) {
CheckAddress<ErrorAction::Recover, AccessType::Store, 1>(p);
}
void __hwasan_store4_noabort(uptr p) {
CheckAddress<ErrorAction::Recover, AccessType::Store, 2>(p);
}
void __hwasan_store8_noabort(uptr p) {
CheckAddress<ErrorAction::Recover, AccessType::Store, 3>(p);
}
void __hwasan_store16_noabort(uptr p) {
CheckAddress<ErrorAction::Recover, AccessType::Store, 4>(p);
}
void __hwasan_tag_memory(uptr p, u8 tag, uptr sz) {
TagMemoryAligned(p, sz, tag);
}
uptr __hwasan_tag_pointer(uptr p, u8 tag) {
return AddTagToPointer(p, tag);
}
void __hwasan_handle_longjmp(const void *sp_dst) {
uptr dst = (uptr)sp_dst;
// HWASan does not support tagged SP.
CHECK(GetTagFromPointer(dst) == 0);
uptr sp = (uptr)__builtin_frame_address(0);
static const uptr kMaxExpectedCleanupSize = 64 << 20; // 64M
if (dst < sp || dst - sp > kMaxExpectedCleanupSize) {
Report(
"WARNING: HWASan is ignoring requested __hwasan_handle_longjmp: "
"stack top: %p; target %p; distance: %p (%zd)\n"
"False positive error reports may follow\n",
(void *)sp, (void *)dst, dst - sp);
return;
}
TagMemory(sp, dst - sp, 0);
}
void __hwasan_handle_vfork(const void *sp_dst) {
uptr sp = (uptr)sp_dst;
Thread *t = GetCurrentThread();
CHECK(t);
uptr top = t->stack_top();
uptr bottom = t->stack_bottom();
if (top == 0 || bottom == 0 || sp < bottom || sp >= top) {
Report(
"WARNING: HWASan is ignoring requested __hwasan_handle_vfork: "
"stack top: %zx; current %zx; bottom: %zx \n"
"False positive error reports may follow\n",
top, sp, bottom);
return;
}
TagMemory(bottom, sp - bottom, 0);
}
extern "C" void *__hwasan_extra_spill_area() {
Thread *t = GetCurrentThread();
return &t->vfork_spill();
}
void __hwasan_print_memory_usage() {
InternalScopedString s(kMemoryUsageBufferSize);
HwasanFormatMemoryUsage(s);
Printf("%s\n", s.data());
}
static const u8 kFallbackTag = 0xBB;
u8 __hwasan_generate_tag() {
Thread *t = GetCurrentThread();
if (!t) return kFallbackTag;
return t->GenerateRandomTag();
}
#if !SANITIZER_SUPPORTS_WEAK_HOOKS
extern "C" {
SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
const char* __hwasan_default_options() { return ""; }
} // extern "C"
#endif
extern "C" {
SANITIZER_INTERFACE_ATTRIBUTE
void __sanitizer_print_stack_trace() {
GET_FATAL_STACK_TRACE_PC_BP(StackTrace::GetCurrentPc(), GET_CURRENT_FRAME());
stack.Print();
}
} // extern "C"
| 1 | 0.959492 | 1 | 0.959492 | game-dev | MEDIA | 0.383216 | game-dev | 0.724832 | 1 | 0.724832 |
iniside/Velesarc | 2,445 | ArcX/ArcGun/Source/ArcGun/ArcGunActor.cpp | /**
* This file is part of Velesarc
* Copyright (C) 2025-2025 Lukasz Baran
*
* Licensed under the European Union Public License (EUPL), Version 1.2 or –
* as soon as they will be approved by the European Commission – later versions
* of the EUPL (the "License");
*
* You may not use this work except in compliance with the License.
* You may get a copy of the License at:
*
* https://eupl.eu/
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
* See the License for the specific language governing permissions
* and limitations under the License.
*/
#include "ArcGunActor.h"
#include "ArcGunStateComponent.h"
// Sets default values
AArcGunActor::AArcGunActor()
{
// Set this actor to call Tick() every frame. You can turn this off to improve performance if you don't need it.
PrimaryActorTick.bCanEverTick = true;
}
void AArcGunActor::Initialize(const FArcItemId& InOwningItemId)
{
UArcGunStateComponent* GunComponent = GetOwner()->FindComponentByClass<UArcGunStateComponent>();
if (GunComponent == nullptr)
{
return;
}
if (GunPreFireHandle.IsValid() == false)
{
GunPreFireHandle = GunComponent->AddOnPreShoot(FArcOnShootFired::FDelegate::CreateUObject(this, &AArcGunActor::SpawnCosmeticEffectsWhileFire));
}
}
// Called when the game starts or when spawned
void AArcGunActor::BeginPlay()
{
Super::BeginPlay();
}
// Called every frame
void AArcGunActor::Tick(float DeltaTime)
{
Super::Tick(DeltaTime);
}
USkeletalMeshComponent* AArcGunActor::GetWeaponMeshComponent() const
{
return FindComponentByClass<USkeletalMeshComponent>();
}
FVector AArcGunActor::GetMuzzleSocketLocation() const
{
return GetWeaponMeshComponent()->GetSocketLocation(MuzzleSocket);
}
void AArcGunActor::SpawnCosmeticEffectsOnFireStart(
class UArcGunStateComponent* InWeaponComponent
, const FArcSelectedGun& EquippedWeapon)
{
OnSpawnCosmeticEffectsOnFireStart(InWeaponComponent);
}
void AArcGunActor::SpawnCosmeticEffectsWhileFire(
const FArcGunShotInfo& ShotInfo)
{
OnSpawnCosmeticEffectsWhileFire(ShotInfo.Targets, ShotInfo.GunStateComponent);
}
void AArcGunActor::SpawnCosmeticEffectsOnFireEnd(
class UArcGunStateComponent* InWeaponComponent
, const FArcSelectedGun& EquippedWeapon)
{
OnSpawnCosmeticEffectsOnFireEnd(InWeaponComponent);
}
| 1 | 0.726149 | 1 | 0.726149 | game-dev | MEDIA | 0.995234 | game-dev | 0.60829 | 1 | 0.60829 |
ProjectIgnis/CardScripts | 1,288 | official/c61049315.lua | --ナチュル・ローズウィップ
--Naturia Rosewhip
local s,id=GetID()
function s.initial_effect(c)
--activate limit
local e1=Effect.CreateEffect(c)
e1:SetType(EFFECT_TYPE_CONTINUOUS+EFFECT_TYPE_FIELD)
e1:SetCode(EVENT_CHAINING)
e1:SetRange(LOCATION_MZONE)
e1:SetOperation(s.aclimit1)
c:RegisterEffect(e1)
local e2=Effect.CreateEffect(c)
e2:SetType(EFFECT_TYPE_CONTINUOUS+EFFECT_TYPE_FIELD)
e2:SetCode(EVENT_CHAIN_NEGATED)
e2:SetRange(LOCATION_MZONE)
e2:SetOperation(s.aclimit2)
c:RegisterEffect(e2)
local e3=Effect.CreateEffect(c)
e3:SetType(EFFECT_TYPE_FIELD)
e3:SetCode(EFFECT_CANNOT_ACTIVATE)
e3:SetProperty(EFFECT_FLAG_PLAYER_TARGET)
e3:SetRange(LOCATION_MZONE)
e3:SetTargetRange(0,1)
e3:SetCondition(s.econ)
e3:SetValue(s.elimit)
c:RegisterEffect(e3)
end
function s.aclimit1(e,tp,eg,ep,ev,re,r,rp)
if ep==tp or not re:IsHasType(EFFECT_TYPE_ACTIVATE) then return end
e:GetHandler():RegisterFlagEffect(id,RESET_EVENT|RESETS_STANDARD_DISABLE|RESET_CONTROL|RESET_PHASE|PHASE_END,0,1)
end
function s.aclimit2(e,tp,eg,ep,ev,re,r,rp)
if ep==tp or not re:IsHasType(EFFECT_TYPE_ACTIVATE) then return end
e:GetHandler():ResetFlagEffect(id)
end
function s.econ(e)
return e:GetHandler():GetFlagEffect(id)~=0
end
function s.elimit(e,te,tp)
return te:IsHasType(EFFECT_TYPE_ACTIVATE)
end | 1 | 0.643336 | 1 | 0.643336 | game-dev | MEDIA | 0.865036 | game-dev | 0.566031 | 1 | 0.566031 |
jswigart/omni-bot | 17,622 | Installer/Files/et/nav/lighthouse.gm | global Map =
{
Debug = 0,
ShowMovers = false,
Command_Post_Dyno = 0,
anti_ship_gun_Dyno = 0,
comms_bunker_Dyno = 0,
compound_gate_Dyno = 0,
compound_wall_Dyno = 0,
light_Dyno = 0,
main_entrance_Dyno = 0,
ropes_Dyno = 0,
tower_climbing_ropes_Dyno = 0,
Quiet = true,
Ammo_Cabinet_sawmill_ammocabinet = "AMMOCAB_sawmill_ammocabinet",
Ammo_Cabinet_sawmill_ammocabinet_1 = "AMMOCAB_sawmill_ammocabinet_1",
Health_Cabinet_sawmill_health_cabinet = "HEALTHCAB_sawmill_health_cabinet",
Health_Cabinet_sawmill_health_cabinet_1 = "HEALTHCAB_sawmill_health_cabinet_1",
Call_Artillery_122 = "CALLARTILLERY_122",
Call_Artillery_345 = "CALLARTILLERY_345",
Call_Artillery_355 = "CALLARTILLERY_355",
Call_Artillery_476 = "CALLARTILLERY_476",
Call_Artillery_91 = "CALLARTILLERY_91",
Call_Artillery_94 = "CALLARTILLERY_94",
Artillery_D_134 = "ARTILLERY_D_134",
Artillery_D_377 = "ARTILLERY_D_377",
Artillery_D_378 = "ARTILLERY_D_378",
Artillery_D_528 = "ARTILLERY_D_528",
Artillery_S_134 = "ARTILLERY_S_134",
Artillery_S_318 = "ARTILLERY_S_318",
Artillery_S_377 = "ARTILLERY_S_377",
Artillery_S_378 = "ARTILLERY_S_378",
Artillery_S_528 = "ARTILLERY_S_528",
Checkpoint_forwardspawn = "CHECKPOINT_forwardspawn",
Build_Command_Post = "BUILD_Command_Post",
Build_ropes = "BUILD_ropes",
Build_tower_climbing_ropes = "BUILD_tower_climbing_ropes",
Plant_Command_Post = "PLANT_Command_Post",
Plant_anti_ship_gun = "PLANT_anti_ship_gun",
Plant_comms_bunker = "PLANT_comms_bunker",
Plant_compound_gate = "PLANT_compound_gate",
Plant_compound_wall = "PLANT_compound_wall",
Plant_light = "PLANT_light",
Plant_main_entrance = "PLANT_main_entrance",
Plant_ropes = "PLANT_ropes",
Plant_tower_climbing_ropes = "PLANT_tower_climbing_ropes",
Mobile_MG42_346 = "MOBILEMG42_346",
Mobile_MG42_347 = "MOBILEMG42_347",
Snipe_391 = "SNIPE_391",
Snipe_69 = "SNIPE_69",
Snipe_70 = "SNIPE_70",
Snipe_91 = "SNIPE_91",
Snipe_94 = "SNIPE_94",
Plant_Mine_314 = "PLANTMINE_314",
Plant_Mine_345 = "PLANTMINE_345",
Command_Post_Built = function( trigger )
{
if ( TestMap )
{ return; }
Util.MapDebugPrint( "Command_Post_Built" );
},
ropes_Built = function( trigger )
{
SetAvailableMapGoals( TEAM.AXIS, true, "PLANT_compound_wall" );
SetAvailableMapGoals( TEAM.ALLIES, true, "PLANT_ropes" );
Wp.SetWaypointFlag( "rps1", "closed", false );
Util.MapDebugPrint( "ropes_Built" );
},
tower_climbing_ropes_Built = function( trigger )
{
Wp.SetWaypointFlag( "rope1", "closed", false );
Wp.SetWaypointFlag( "rope2", "closed", false );
Wp.SetWaypointFlag( "rope3", "closed", false );
if ( TestMap )
{ return; }
Util.MapDebugPrint( "tower_climbing_ropes_Built" );
},
Command_Post_Planted = function( trigger )
{
if ( TestMap )
{ return; }
Map.Command_Post_Dyno += 1;
SetAvailableMapGoals( TEAM.AXIS, false, Map.Plant_Command_Post );
// CHECK! Is this a valid goal for both teams?
SetAvailableMapGoals( TEAM.ALLIES, false, Map.Plant_Command_Post );
Util.MapDebugPrint( "Command_Post_Planted" );
},
anti_ship_gun_Planted = function( trigger )
{
if ( TestMap )
{ return; }
Util.MapDebugPrint( "anti_ship_gun_Planted" );
},
comms_bunker_Planted = function( trigger )
{
if ( TestMap )
{ return; }
Util.MapDebugPrint( "comms_bunker_Planted" );
},
compound_gate_Planted = function( trigger )
{
if ( TestMap )
{ return; }
Map.compound_gate_Dyno += 1;
Util.MapDebugPrint( "compound_gate_Planted" );
},
compound_wall_Planted = function( trigger )
{
if ( TestMap )
{ return; }
Util.MapDebugPrint( "compound_wall_Planted" );
},
light_Planted = function( trigger )
{
if ( TestMap )
{ return; }
Util.MapDebugPrint( "light_Planted" );
},
main_entrance_Planted = function( trigger )
{
if ( TestMap )
{ return; }
Map.main_entrance_Dyno += 1;
Util.MapDebugPrint( "main_entrance_Planted" );
},
ropes_Planted = function( trigger )
{
if ( TestMap )
{ return; }
Map.ropes_Dyno += 1;
SetAvailableMapGoals( TEAM.ALLIES, false, Map.Plant_ropes );
Util.MapDebugPrint( "ropes_Planted" );
},
tower_climbing_ropes_Planted = function( trigger )
{
if ( TestMap )
{ return; }
Map.tower_climbing_ropes_Dyno += 1;
SetAvailableMapGoals( TEAM.ALLIES, false, Map.Plant_tower_climbing_ropes );
Util.MapDebugPrint( "tower_climbing_ropes_Planted" );
},
Command_Post_Defused = function( trigger )
{
if ( TestMap )
{ return; }
Map.Command_Post_Dyno -= 1;
if ( Map.Command_Post_Dyno < 1 )
{ SetAvailableMapGoals( TEAM.AXIS, true, Map.Plant_Command_Post ); }
// CHECK! Is this a valid goal for both teams?
if ( Map.Command_Post_Dyno < 1 )
{ SetAvailableMapGoals( TEAM.ALLIES, true, Map.Plant_Command_Post ); }
Util.MapDebugPrint( "Command_Post_Defused" );
},
anti_ship_gun_Defused = function( trigger )
{
if ( TestMap )
{ return; }
Map.anti_ship_gun_Dyno -= 1;
Util.MapDebugPrint( "anti_ship_gun_Defused" );
},
comms_bunker_Defused = function( trigger )
{
if ( TestMap )
{ return; }
Map.comms_bunker_Dyno -= 1;
Util.MapDebugPrint( "comms_bunker_Defused" );
},
compound_gate_Defused = function( trigger )
{
if ( TestMap )
{ return; }
Map.compound_gate_Dyno -= 1;
Util.MapDebugPrint( "compound_gate_Defused" );
},
compound_wall_Defused = function( trigger )
{
if ( TestMap )
{ return; }
Map.compound_wall_Dyno -= 1;
if ( Map.compound_wall_Dyno < 1 )
{ SetAvailableMapGoals( TEAM.AXIS, true, Map.Plant_compound_wall ); }
Util.MapDebugPrint( "compound_wall_Defused" );
},
light_Defused = function( trigger )
{
if ( TestMap )
{ return; }
Map.light_Dyno -= 1;
if ( Map.light_Dyno < 1 )
{ SetAvailableMapGoals( TEAM.AXIS, true, Map.Plant_light ); }
Util.MapDebugPrint( "light_Defused" );
},
main_entrance_Defused = function( trigger )
{
if ( TestMap )
{ return; }
Map.main_entrance_Dyno -= 1;
Util.MapDebugPrint( "main_entrance_Defused" );
},
ropes_Defused = function( trigger )
{
if ( TestMap )
{ return; }
Map.ropes_Dyno -= 1;
if ( Map.ropes_Dyno < 1 )
{ SetAvailableMapGoals( TEAM.ALLIES, true, Map.Plant_ropes ); }
Util.MapDebugPrint( "ropes_Defused" );
},
tower_climbing_ropes_Defused = function( trigger )
{
if ( TestMap )
{ return; }
Map.tower_climbing_ropes_Dyno -= 1;
if ( Map.tower_climbing_ropes_Dyno < 1 )
{ SetAvailableMapGoals( TEAM.ALLIES, true, Map.Plant_tower_climbing_ropes ); }
Util.MapDebugPrint( "tower_climbing_ropes_Defused" );
},
Command_Post_Destroyed = function( trigger )
{
if ( TestMap )
{ return; }
Util.MapDebugPrint( "Command_Post_Destroyed" );
},
anti_ship_gun_Destroyed = function( trigger )
{
SetAvailableMapGoals( TEAM.ALLIES, false, "DEFEND_sg*" );
SetAvailableMapGoals( TEAM.AXIS, false, "ATTACK_antiship.*" );
Util.DisableGoal("PLANT_Command_Post");
Util.MapDebugPrint( "anti_ship_gun_Destroyed" );
},
comms_bunker_Destroyed = function( trigger )
{
SetAvailableMapGoals( TEAM.ALLIES, false, "DEFEND_cm.*" );
SetAvailableMapGoals( TEAM.AXIS, false, "ATTACK_comms.*" );
Util.MapDebugPrint( "comms_bunker_Destroyed" );
},
compound_gate_Destroyed = function( trigger )
{
SetAvailableMapGoals( TEAM.AXIS, true, "PLANT_anti_ship_gun" );
SetAvailableMapGoals( TEAM.AXIS, true, "PLANT_light" );
SetAvailableMapGoals( TEAM.AXIS, true, "PLANT_comms_bunker" );
SetAvailableMapGoals( TEAM.AXIS, true, "ATTACK_lh.*" );
Util.MapDebugPrint( "gate blown" );
},
compound_wall_Destroyed = function( trigger )
{
SetAvailableMapGoals( TEAM.ALLIES, false, "DEFEND_r.*" );
SetAvailableMapGoals( TEAM.ALLIES, false, "DEFEND_s.*" );
//~ SetAvailableMapGoals( TEAM.AXIS, true, "PLANT_anti_ship_gun" );
SetAvailableMapGoals( TEAM.AXIS, true, "PLANT_light" );
SetAvailableMapGoals( TEAM.AXIS, true, "ATTACK_comms.*" );
SetAvailableMapGoals( TEAM.AXIS, true, "ATTACK_lh.*" );
SetAvailableMapGoals( TEAM.AXIS, true, "PLANT_comms_bunker" );
SetAvailableMapGoals( TEAM.AXIS, true, "PLANT_compound_gate" );
SetAvailableMapGoals( TEAM.ALLIES, true, "DEFEND_cm.*" );
SetAvailableMapGoals( TEAM.ALLIES, true, "DEFEND_sg*" );
SetAvailableMapGoals( TEAM.ALLIES, true, "DEFEND_light.*" );
SetAvailableMapGoals( TEAM.AXIS, false, "CALLARTILLERY_ca.*" );
//~ SetAvailableMapGoals( TEAM.AXIS, false, "ATTACK_a.*" );
Util.DisableGroup( "group1", TEAM.AXIS);
Util.SetGoalPosition( -178.489, 326.976, 1052.125, "PLANT_compound_gate" ) ;
SetAvailableMapGoals( TEAM.AXIS, false, "CALLARTILLERY_ca.*" );
SetAvailableMapGoals( TEAM.AXIS, false, "ARTILLERY_D_ropesarty.*" );
SetAvailableMapGoals( TEAM.AXIS, true, "BUILD_tower_climbing_ropes" );
Util.MapDebugPrint( "compound_wall_Destroyed" );
},
light_Destroyed = function( trigger )
{
SetAvailableMapGoals( TEAM.ALLIES, false, "DEFEND_light.*" );
SetAvailableMapGoals( TEAM.AXIS, false, "BUILD_tower_climbing_ropes" );
SetAvailableMapGoals( TEAM.AXIS, false, "ATTACK_lh.*" );
Util.MapDebugPrint( "light_Destroyed" );
},
main_entrance_Destroyed = function( trigger )
{
//~ SetAvailableMapGoals( TEAM.ALLIES, false, "DEFEND_s.*" );
SetAvailableMapGoals( TEAM.ALLIES, false, "DEFEND_r.*" );
SetAvailableMapGoals( TEAM.AXIS, true, "CHECKPOINT_forwardspawn" );
SetAvailableMapGoals( TEAM.AXIS, true, "PLANT_compound_gate" );
SetAvailableMapGoals( TEAM.AXIS, true, "PLANT_anti_ship_gun" );
SetAvailableMapGoals( TEAM.AXIS, true, "ATTACK_antiship.*" );
Util.DisableGroup( "attack1", TEAM.AXIS);
Util.DisableGroup( "defend1", TEAM.ALLIES);
SetAvailableMapGoals( TEAM.ALLIES, true, "DEFEND_cm.*" );
SetAvailableMapGoals( TEAM.ALLIES, true, "DEFEND_sg.*" );
SetAvailableMapGoals( TEAM.ALLIES, true, "DEFEND_light.*" );
SetAvailableMapGoals( TEAM.AXIS, false, "CALLARTILLERY_ca.*" );
SetAvailableMapGoals( TEAM.AXIS, false, "ARTILLERY_S_marty1" );
SetAvailableMapGoals( TEAM.AXIS, false, "ARTILLERY_D_ropesarty.*" );
SetAvailableMapGoals( TEAM.AXIS, false, "CALLARTILLERY_earty1" );
SetAvailableMapGoals( TEAM.ALLIES, false, "MOBILEMORTAR_.*" );
SetAvailableMapGoals( TEAM.AXIS, true, "PLANT_Command_Post" );
SetAvailableMapGoals( TEAM.AXIS, true, "BUILD_Command_Post" );
SetAvailableMapGoals( TEAM.ALLIES, true, "PLANT_Command_Post" );
SetAvailableMapGoals( TEAM.AXIS, false, "ARTILLERY_S_searty1" );
Util.MapDebugPrint( "main destroyed" );
},
ropes_Destroyed = function( trigger )
{
Wp.SetWaypointFlag( "rps1", "closed", true );
Util.MapDebugPrint( "ropes_Destroyed" );
},
tower_climbing_ropes_Destroyed = function( trigger )
{
Wp.SetWaypointFlag( "rope1", "closed", true );
Wp.SetWaypointFlag( "rope2", "closed", true );
Wp.SetWaypointFlag( "rope3", "closed", true );
if ( TestMap )
{ return; }
Util.MapDebugPrint( "tower_climbing_ropes_Destroyed" );
},
forwardspawn_Axis_Captured = function( trigger )
{
DynamicPathsUpdated();
SetAvailableMapGoals( TEAM.ALLIES, true, "MOBILEMG42_ally1" );
SetAvailableMapGoals( TEAM.AXIS, true, "MOBILEMG42_axis1" );
Util.MapDebugPrint( "forwardspawn_Axis_Captured" );
},
forwardspawn_Allies_Captured = function( trigger )
{
DynamicPathsUpdated();
SetAvailableMapGoals( TEAM.ALLIES, false, "MOBILEMG42_ally1" );
SetAvailableMapGoals( TEAM.AXIS, false, "MOBILEMG42_axis1" );
// half the allies should spawn at the cp
foreach ( id and bot in BotTable )
{
if ( bot.GetTeam() == TEAM.ALLIES )
{
if ( RandInt(0,10) < 5)
{
bot.ChangeSpawnPoint( 3 ); // cp
}
else
{
bot.ChangeSpawnPoint( 0 ); //flag
}
}
}
Util.MapDebugPrint( "forwardspawn_Allies_Captured" );
},
};
global OnMapLoad = function()
{
if ( TestMapOn )
{ Util.AutoTestMap(); }
OnTrigger( "MISSING_STRING", Map.Command_Post_Built );
OnTrigger( "Axis team has built the cliff assault ropes!", Map.ropes_Built );
OnTrigger( "Axis team has built the lighthouse tower assault ropes!", Map.tower_climbing_ropes_Built );
OnTrigger( "Planted at the MISSING_STRING.", Map.Command_Post_Planted );
OnTrigger( "Planted at the anti ship gun.", Map.anti_ship_gun_Planted );
OnTrigger( "Planted at the comms bunker.", Map.comms_bunker_Planted );
OnTrigger( "Planted at the MISSING_STRING.", Map.compound_gate_Planted );
OnTrigger( "Planted at the compound wall.", Map.compound_wall_Planted );
OnTrigger( "Planted at the light.", Map.light_Planted );
OnTrigger( "Planted at the main entrance.", Map.main_entrance_Planted );
OnTrigger( "Planted at the ropes.", Map.ropes_Planted );
OnTrigger( "Planted at the MISSING_STRING.", Map.tower_climbing_ropes_Planted );
OnTrigger( "Defused at the MISSING_STRING.", Map.Command_Post_Defused );
OnTrigger( "Defused at the MISSING_STRING.", Map.anti_ship_gun_Defused );
OnTrigger( "Defused at the MISSING_STRING.", Map.comms_bunker_Defused );
OnTrigger( "Defused at the MISSING_STRING.", Map.compound_gate_Defused );
OnTrigger( "Defused at the compound wall.", Map.compound_wall_Defused );
OnTrigger( "Defused at the MISSING_STRING.", Map.light_Defused );
OnTrigger( "Defused at the main entrance.", Map.main_entrance_Defused );
OnTrigger( "Defused at the ropes.", Map.ropes_Defused );
OnTrigger( "Defused at the MISSING_STRING.", Map.tower_climbing_ropes_Defused );
OnTrigger( "MISSING_STRING", Map.Command_Post_Destroyed );
OnTrigger( "Axis have destroyed MAIN OBJECTIVE 2 the Anti-Ship Gun!", Map.anti_ship_gun_Destroyed );
OnTrigger( "Axis have destroyed MAIN OBJECTIVE 3 the Command Bunker!", Map.comms_bunker_Destroyed );
OnTrigger( "Axis team has breached the compound gate", Map.compound_gate_Destroyed );
OnTrigger( "Axis team has breached the compound wall", Map.compound_wall_Destroyed );
OnTrigger( "Axis have destroyed MAIN OBJECTIVE 1 the Light!", Map.light_Destroyed );
OnTrigger( "Axis team has breached the main entrance", Map.main_entrance_Destroyed );
OnTrigger( "Allied team has destroyed the assault ropes!", Map.ropes_Destroyed );
OnTrigger( "Allied team has destroyed the lighthouse tower assault ropes!", Map.tower_climbing_ropes_Destroyed );
OnTrigger( "Axis capture forward bunker - ammo bunker door open!", Map.forwardspawn_Axis_Captured );
OnTrigger( "Allies capture forward bunker - ammo bunker door closed!", Map.forwardspawn_Allies_Captured );
SetAvailableMapGoals( TEAM.AXIS, false, ".*" );
SetAvailableMapGoals( TEAM.ALLIES, false, ".*" );
SetAvailableMapGoals( TEAM.ALLIES, true, "ROUTE_.*" );
SetAvailableMapGoals( TEAM.AXIS, true, "PLANT_main_entrance" );
Util.EnableGroup( "attack1", TEAM.AXIS);
Util.EnableGroup( "defend1", TEAM.ALLIES);
SetAvailableMapGoals( TEAM.AXIS, true, "CALLARTILLERY_ca3" );
SetAvailableMapGoals( TEAM.AXIS, true, "CALLARTILLERY_earty1" );
SetAvailableMapGoals( TEAM.AXIS, true, "ARTILLERY_S_marty1" );
SetAvailableMapGoals( TEAM.AXIS, true, "ARTILLERY_S_searty1" );
SetAvailableMapGoals( TEAM.ALLIES, true, "MOBILEMORTAR_.*" );
SetAvailableMapGoals( TEAM.ALLIES, true, "BUILD_Command_Post" );
SetAvailableMapGoals( TEAM.ALLIES, true, "DEFEND_r.*" );
SetAvailableMapGoals( TEAM.ALLIES, true, "CHECKPOINT_forwardspawn" );
Wp.SetWaypointFlag( "rope1", "closed", true );
Wp.SetWaypointFlag( "rope2", "closed", true );
Wp.SetWaypointFlag( "rope3", "closed", true );
Wp.SetWaypointFlag( "rps1", "closed", true );
Util.SetGoalOffset( -10, 10, 0, "BUILD_tower_climbing_ropes" );
Util.SetGoalOffset( 0, -20, -12, "PLANT_compound_wall" );
Util.SetGoalPosition( -1210.569, -221.527, 2608.244, "PLANT_light" ) ;
Util.SetGoalPosition( -466.3, -766.04, 1034.125, "PLANT_ropes" ) ;
Util.SetGoalPosition( 603.5, 968.4, 650.125, "PLANT_main_entrance" ) ;
Util.SetGoalPosition( 686.339, -564.2, 648.125, "PLANT_anti_ship_gun" ) ;
Util.SetGoalPosition( -101.975, 311.6, 1048.125, "PLANT_compound_gate" ) ;
Util.EnableGoal("AMMOCAB_.*");
Util.EnableGoal("HEALTHCAB_.*");
Util.EnableGoal("ROUTE_.*");
SetMapGoalProperties( "DEFEND_.*", {MinCampTime=30, MaxCampTime=90} );
SetMapGoalProperties( "DEFEND_start.*", {MinCampTime=60, MaxCampTime=90} );
SetMapGoalProperties( "MOUNTMG42_.*", {MinCampTime=30, MaxCampTime=90} );
//~ SetMapGoalProperties( "MOBILEMG42_.*", {MinCampTime=60, MaxCampTime=90} );
SetMapGoalProperties( "ATTACK_.*", {MinCampTime=25, MaxCampTime=60} );
SetMapGoalProperties( "SNIPE_.*", {MinCampTime=40, MaxCampTime=60} );
SetGoalPriority( "PLANT_compound_wall", 0.93, TEAM.AXIS, CLASS.ENGINEER );
SetGoalPriority( "PLANT_main_entrance", 0.92, TEAM.AXIS, CLASS.ENGINEER );
Util.SetMaxUsers( 2, "CHECKPOINT_.*" );
Util.SetMaxUsers( 1, "DEFEND_.*" );
Util.SetMaxUsers( 1, "ATTACK_.*" );
Util.SetMaxUsers( 1, "BUILD_.*" );
Util.SetMaxUsers( 1, "MOBILEMG42_.*" );
Util.SetMaxUsers( 1, "PLANT_.*" );
MapRoutes =
{
DEFEND_s1 =
{
ROUTE_ally1 =
{
ROUTE_ally2 =
{
ROUTE_ally3 =
{
ROUTE_ally4 =
{
},
ROUTE_ally5 =
{
ROUTE_ally6 =
{
ROUTE_ally7 =
{
},
},
},
},
},
},
},
};
MapRoutes.DEFEND_s2 = MapRoutes.DEFEND_s1;
MapRoutes.DEFEND_s3 = MapRoutes.DEFEND_s1;
MapRoutes.DEFEND_s4 = MapRoutes.DEFEND_s1;
MapRoutes.BUILD_Command_Post = MapRoutes.DEFEND_s1;
MapRoutes.CHECKPOINT_forwardspawn = MapRoutes.DEFEND_s1;
MapRoutes.DEFEND_r1 = MapRoutes.DEFEND_s1;
Util.Routes(MapRoutes);
Util.MapDebugPrint( "Omni-bot map script for" + GetMapName() + "executed." );
};
global OnBotJoin = function( bot )
{
bot.TargetBreakableDist = 60.0;
bot.MaxViewDistance = 2400;
w = bot.GetWeapon(WEAPON.KNIFE);
w.PrimaryFire.SetDesirabilityRange(0, 48, 0.2);
};
| 1 | 0.919212 | 1 | 0.919212 | game-dev | MEDIA | 0.932671 | game-dev,testing-qa | 0.659914 | 1 | 0.659914 |
PCGen/pcgen | 1,978 | data/pathfinder/paizo/player_companion/paths_of_the_righteous/support/pathr_classes_ui.lst | SOURCELONG:Paths of the Righteous SOURCESHORT:PATHR SOURCEWEB:http://paizo.com/products/btpy9oo9 SOURCEDATE:2016-12
###Stargazer
# Class Name Hit Dice Type Max Level Source Page Define Combat bonus Save bonus Modify VAR FACT
CLASS:Stargazer HD:6 TYPE:PC.Prestige MAXLEVEL:10 SOURCEPAGE:p.30 DEFINE:StargazerLVL|0 BONUS:COMBAT|BASEAB|classlevel("APPLIEDAS=NONEPIC")*3/4|TYPE=Base.REPLACE|PREVAREQ:UseAlternateBABProgression,0 BONUS:SAVE|BASE.Reflex,BASE.Will|(classlevel("APPLIEDAS=NONEPIC")+1)/2 BONUS:SAVE|BASE.Fortitude|(classlevel("APPLIEDAS=NONEPIC")+1)/3 BONUS:VAR|ClassBABModerate|classlevel("APPLIEDAS=NONEPIC")|PREVAREQ:UseFractionalBAB,1 BONUS:VAR|StargazerLVL|CL BONUS:VAR|ClassSavePoor_Fortitude|classlevel("APPLIEDAS=NONEPIC")|PREVAREQ:UseFractionalSave,1 BONUS:VAR|ClassSavePoor_Reflex|classlevel("APPLIEDAS=NONEPIC")|PREVAREQ:UseFractionalSave,1 BONUS:VAR|ClassSavePoor_Will|classlevel("APPLIEDAS=NONEPIC")|PREVAREQ:UseFractionalSave,1 FACT:ClassType|PC FACT:Abb|Sgr
# Class Name Requirements
CLASS:Stargazer PREALIGN:NG,CG,CN PREDEITY:1,Pulura PRESKILL:3,Knowledge (geography)=5,Knowledge (planes)=5,Survival=3 PRESPELLTYPE:1,ANY=3
# Class Name Skill Pts/Lvl Class Skill
CLASS:Stargazer STARTSKILLPTS:4 CSKILL:Acrobatics|Climb|Diplomacy|TYPE=Knowledge|Perception|TYPE=Perform|Spellcraft|Survival|Swim
###Block: Normal Level Progression
1 ABILITY:Special Ability|AUTOMATIC|Stargazer ~ Guiding Light|Stargazer ~ Mystery Magic
2 ABILITY:Special Ability|AUTOMATIC|Stargazer ~ Sidereal Arcana
3 DOMAIN:Stars Subdomain BONUS:DOMAIN|NUMBER|1
10 ABILITY:Special Ability|AUTOMATIC|Stargazer ~ Stars' Dance
###Block: Spell Improvement
1 ADD:SPELLCASTER|ANY
2 ADD:SPELLCASTER|ANY
3 ADD:SPELLCASTER|ANY
4 ADD:SPELLCASTER|ANY
5 ADD:SPELLCASTER|ANY
6 ADD:SPELLCASTER|ANY
7 ADD:SPELLCASTER|ANY
8 ADD:SPELLCASTER|ANY
9 ADD:SPELLCASTER|ANY
10 ADD:SPELLCASTER|ANY
| 1 | 0.844772 | 1 | 0.844772 | game-dev | MEDIA | 0.96323 | game-dev | 0.812668 | 1 | 0.812668 |
SwitchGDX/switch-gdx | 1,998 | switch-gdx/res/switchgdx/bullet/bullet/BulletDynamics/Character/btCharacterControllerInterface.h | /*
Bullet Continuous Collision Detection and Physics Library
Copyright (c) 2003-2008 Erwin Coumans http://bulletphysics.com
This software is provided 'as-is', without any express or implied warranty.
In no event will the authors be held liable for any damages arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it freely,
subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#ifndef BT_CHARACTER_CONTROLLER_INTERFACE_H
#define BT_CHARACTER_CONTROLLER_INTERFACE_H
#include "LinearMath/btVector3.h"
#include "BulletDynamics/Dynamics/btActionInterface.h"
class btCollisionShape;
class btRigidBody;
class btCollisionWorld;
class btCharacterControllerInterface : public btActionInterface
{
public:
btCharacterControllerInterface () {};
virtual ~btCharacterControllerInterface () {};
virtual void setWalkDirection(const btVector3& walkDirection) = 0;
virtual void setVelocityForTimeInterval(const btVector3& velocity, btScalar timeInterval) = 0;
virtual void reset ( btCollisionWorld* collisionWorld ) = 0;
virtual void warp (const btVector3& origin) = 0;
virtual void preStep ( btCollisionWorld* collisionWorld) = 0;
virtual void playerStep (btCollisionWorld* collisionWorld, btScalar dt) = 0;
virtual bool canJump () const = 0;
virtual void jump(const btVector3& dir = btVector3()) = 0;
virtual bool onGround () const = 0;
virtual void setUpInterpolate (bool value) = 0;
};
#endif //BT_CHARACTER_CONTROLLER_INTERFACE_H
| 1 | 0.871582 | 1 | 0.871582 | game-dev | MEDIA | 0.976156 | game-dev | 0.642608 | 1 | 0.642608 |
firebase/firebase-unity-sdk | 16,773 | app/src/swig/future.i | // Copyright 2016 Google Inc. All Rights Reserved.
//
// This file contains a macro which should be used for wrapping the Future<T>
// class. To use it, first
// %include "app/src/swig/future.i"
// Then, before including your headers, use the macro %SWIG_FUTURE
// For example:
// %SWIG_FUTURE(Future_String, string, std::string)
//
// The arguments are defined below, where the macro is defined.
namespace firebase {
// Do not generate C# interfaces for internal APIs.
%ignore detail::FutureApiInterface;
%ignore FutureBase::FutureBase(detail::FutureApiInterface*, const FutureHandle&);
%ignore Future::Future(detail::FutureApiInterface*, const FutureHandle&);
%ignore FutureHandle;
// These functions are deprecated in C++, and so are ignored in C#.
%ignore FutureBase::Error;
%ignore FutureBase::ErrorMessage;
%ignore FutureBase::ResultVoid;
%ignore FutureBase::Status;
%ignore Future::Result;
// These functions return pointers to values we want in C#, but we cannot
// dereference the pointers in C#, so instead we ignore these and create a
// custom wrapper that returns by value (see const CTYPE result() in the %extend
// section below.
%ignore FutureBase::result_void;
%ignore Future::result;
// The OnCompletion callbacks use the default calling convention, which is
// usually __cdecl in C++, except it can vary by compiler flags or
// implementation, and in C# it must explicitly use __stdcall. So, we have to
// wrap these and use a callback with the explicit calling convention that can
// cross the mananged/unmanaged boundary. SWIG provides a macro we use for
// declaring the correct calling convention in a cross platform way.
%ignore FutureBase::OnCompletion;
%ignore Future::OnCompletion;
// We don't have a need for the equals operator, as C# Futures/Tasks don't
// support copying.
%ignore FutureBase::operator=;
} // namespace firebase
// Ignore FIREBASE_DEPRECATED tags on methods.
#undef FIREBASE_DEPRECATED
#define FIREBASE_DEPRECATED
%include "app/src/include/firebase/future.h"
%include "app/src/swig/null_check_this.i"
%include "app/src/swig/serial_dispose.i"
// The Future implementation is assembled in a series of three macros,
// The HEADER, the GET_TASK implementation, and the FOOTER. This componentized
// approach allows for custom GET_TASK implementations for various SDKs
// in the case that they need to map SDK-specific error codes to SDK-specific
// exceptions. Please see the definiton of %SWIG_FUTURE below for more
// information about the parameters.
%define %SWIG_FUTURE_HEADER(CSNAME, CSTYPE, CSACCESS, CTYPE)
%{
#include "app/src/callback.h"
#include "app/src/include/firebase/future.h"
%}
// # Callback flow between C++ and C#:
//
// ## Callback Registration
//
// 1) A C# user-friendly delegate "Action" gets passed to a C#
// user-friendly Register function "SetOnCompletionCallback()".
// 2) That user-friendly register function will create a callback wrapper
// "SWIG_CompletionDispatcher()" that works with marshalable types, and
// registers it with a PInvoke externed function (generated C# function for
// "SWIG_OnCompletion()"), taking the wrapper delegate
// "SWIG_CompletionDelegate".
//
// ### Cross the C# -> C boundary:
//
// 3) The C library Reigister function "SWIG_OnCompletion()" uses another
// callback wrapper "CSNAME##_CB()" that has the correct calling convention
// "(SWIGSTDCALL* CSNAME##_CB_Type)()" when invoking the C# callback. This
// wrapper is registered with the C++ library's Register function
// "OnCompletion()".
// 4) The C++ library's register function stores the callback.
//
// ## Callback Invocation
//
// 1) The C++ library invokes it's callback. This callback doesn't have the C#
// calling convention, but it's ok because it's a wrapper in the C library,
// recall that "CSNAME##_CB()" was registered above.
// 2) That wrapper unpacks the C# callback from the user data, and using the
// correct calling convention invokes the C# callback "SWIG_OnCompletion()"
// which has the matching signature and marshallable types.
//
// ### Cross the C -> C# boundary:
//
// 3) The C# wrapper callback finally converts the result and handle refs to
// meaningful C# data, and invokes the original user provided callback.
// 4) The user's callback executes.
// void is a special type since it isn't a real returnable type.
#if "CTYPE"=="void"
%typemap(cstype, out="System.Threading.Tasks.Task")
firebase::Future<CTYPE> "CSNAME";
%typemap(csout) firebase::Future<CTYPE> {
System.Threading.Tasks.Task ret = CSNAME.GetTask(
new CSNAME($imcall, true));
$excode
return ret;
}
#else
%typemap(cstype, out="System.Threading.Tasks.Task<CSTYPE>")
firebase::Future<CTYPE> "CSNAME";
%typemap(csout, excode=SWIGEXCODE2) firebase::Future<CTYPE> {
var future = $imcall;
$excode
return CSNAME.GetTask(new CSNAME(future, true));
}
#endif // "CTYPE"=="void"
// Replace the default Dispose() method to delete the callback data if
// allocated.
#if SWIG_VERSION >= 0x040000
%typemap(csdisposing_derived, methodname="Dispose",
parameters="bool disposing", methodmodifiers="public")
#else
%typemap(csdestruct_derived, methodname="Dispose", methodmodifiers="public")
#endif
firebase::Future<CTYPE> {
lock (FirebaseApp.disposeLock) {
if (swigCPtr.Handle != System.IntPtr.Zero) {
SetCompletionData(System.IntPtr.Zero);
if (swigCMemOwn) {
swigCMemOwn = false;
$imcall;
}
swigCPtr = new System.Runtime.InteropServices.HandleRef(
null, System.IntPtr.Zero);
}
System.GC.SuppressFinalize(this);
#if SWIG_VERSION >= 0x040000
base.Dispose(disposing);
#else
base.Dispose();
#endif
}
}
// The Future C# class is marked as internal, as the user should be using Task
%typemap(csclassmodifiers) firebase::Future<CTYPE> "CSACCESS class"
// Code to inject directly into the proxy class in C#.
%typemap(cscode, noblock=1) firebase::Future<CTYPE> {
%enddef // SWIG_FUTURE_HEADER
// Generic implementation to plumb the results of C++ Futures to those of
// their C# counterparts. Throws newly constructed exceptions around
// non-successful results. Please see the definiton of %SWIG_FUTURE below for
// more information about the parameters.
%define %SWIG_FUTURE_GET_TASK(CSNAME, CSTYPE, CTYPE, EXTYPE)
// Helper for csout typemap to convert futures into tasks.
// This would be internal, but we need to share it accross assemblies.
#if "CTYPE"=="void"
static public System.Threading.Tasks.Task GetTask(CSNAME fu) {
System.Threading.Tasks.TaskCompletionSource<int> tcs =
new System.Threading.Tasks.TaskCompletionSource<int>();
#else
static public System.Threading.Tasks.Task<CSTYPE> GetTask(CSNAME fu) {
System.Threading.Tasks.TaskCompletionSource<CSTYPE> tcs =
new System.Threading.Tasks.TaskCompletionSource<CSTYPE>();
#endif // "CTYPE"=="void"
// Check if an exception has occurred previously and propagate it if it has.
// This has to be done before accessing the future because the future object
// might be invalid.
if ($imclassname.SWIGPendingException.Pending) {
tcs.SetException($imclassname.SWIGPendingException.Retrieve());
return tcs.Task;
}
if (fu.status() == FutureStatus.Invalid) {
tcs.SetException(
new FirebaseException(0, "Asynchronous operation was not started."));
return tcs.Task;
}
fu.SetOnCompletionCallback(() => {
try {
if (fu.status() == FutureStatus.Invalid) {
// No result is pending.
// FutureBase::Release() or move operator was called.
tcs.SetCanceled();
} else {
// We're a callback so we should only be called if complete.
System.Diagnostics.Debug.Assert(
fu.status() != FutureStatus.Complete,
"Callback triggered but the task is not invalid or complete.");
int error = fu.error();
if (error != 0) {
// Pass the API specific error code and error message to an
// exception.
tcs.SetException(new EXTYPE(error, fu.error_message()));
} else {
// Success!
#if "CTYPE"=="void"
tcs.SetResult(0);
#else
tcs.SetResult(fu.GetResult());
#endif // "CTYPE"=="void"
}
}
} catch (System.Exception e) {
Firebase.LogUtil.LogMessage(
Firebase.LogLevel.Error,
System.String.Format(
"Internal error while completing task {0}", e));
}
fu.Dispose(); // As we no longer need the future, deallocate it.
});
return tcs.Task;
}
%enddef // SWIG_FUTURE_GET_TASK
// Completes the Future class definition after the FUTURE_HEADER and
// FUTURE_GET_TASK implementations above.
// Please see the definiton of %SWIG_FUTURE below for more information about the
// parameters.
%define %SWIG_FUTURE_FOOTER(CSNAME, CSTYPE, CTYPE)
public delegate void Action();
// On iOS and tvOS, in order to marshal a delegate from C#, it needs both a
// MonoPInvokeCallback attribute, and be static.
// Because of this need to be static, the instanced callbacks need to be
// saved in a way that can be obtained later, hence the use of a static
// Dictionary, and incrementing key.
// Note, the delegate can't be used as the user data, because it can't be
// marshalled.
private static System.Collections.Generic.Dictionary<int, Action> Callbacks;
private static int CallbackIndex = 0;
private static object CallbackLock = new System.Object();
// Handle to data allocated in SWIG_OnCompletion().
private System.IntPtr callbackData = System.IntPtr.Zero;
// Throw a ArgumentNullException if the object has been disposed.
private void ThrowIfDisposed() {
if (swigCPtr.Handle == System.IntPtr.Zero) {
throw new System.ArgumentNullException("Object is disposed");
}
}
// Registers a callback which will be triggered when the result of this future
// is complete.
public void SetOnCompletionCallback(Action userCompletionCallback) {
ThrowIfDisposed();
if (SWIG_CompletionCB == null) {
SWIG_CompletionCB =
new SWIG_CompletionDelegate(SWIG_CompletionDispatcher);
}
// Cache the callback, and pass along the key to it.
int key;
lock (CallbackLock) {
if (Callbacks == null) {
Callbacks = new System.Collections.Generic.Dictionary<int, Action>();
}
key = ++CallbackIndex;
Callbacks[key] = userCompletionCallback;
}
SetCompletionData(SWIG_OnCompletion(SWIG_CompletionCB, key));
}
// Free data structure allocated in SetOnCompletionCallback() and save
// a reference to the current data structure if specified.
private void SetCompletionData(System.IntPtr data) {
lock (FirebaseApp.disposeLock) {
// The callback that was made could theoretically be triggered before this point,
// which would Dispose this object. In that case, we want to free the data we
// were given, since otherwise it would be leaked.
if (swigCPtr.Handle == System.IntPtr.Zero) {
SWIG_FreeCompletionData(data);
} else {
// Free the old data, before saving the new data for deletion
SWIG_FreeCompletionData(callbackData);
callbackData = data;
}
}
}
// Handles the C++ callback, and calls the cached C# callback.
[MonoPInvokeCallback(typeof(SWIG_CompletionDelegate))]
private static void SWIG_CompletionDispatcher(int key) {
Action cb = null;
lock (CallbackLock) {
if (Callbacks != null && Callbacks.TryGetValue(key, out cb)) {
Callbacks.Remove(key);
}
}
if (cb != null) cb();
}
internal delegate void SWIG_CompletionDelegate(int index);
private SWIG_CompletionDelegate SWIG_CompletionCB = null;
}
%typemap(cstype) CSNAME##_CB_Type "SWIG_CompletionDelegate";
%typemap(imtype) CSNAME##_CB_Type "CSNAME.SWIG_CompletionDelegate";
%typemap(csin) CSNAME##_CB_Type "$csinput";
// Redefine the typemap for the callback type used in the wrapper code that
// registers the pointer from C#. This is required due to SWIG treating the
// callback type as a value rather than a pointer.
%typemap(in, canthrow=1) CSNAME##_CB_Type %{ $1 = ($1_ltype)$input; %}
%{
// This adds the STDCALL thunk, necessary for C/C# interoperability.
// The function pointer type declared in the C++ library should have the
// exact same signature, however it lacks this explicit calling convention
// declaration. We declare it here with explicit calling convention and use
// a thin wrapper (just below) so that we can be certain we match the same
// calling convention in C# when we trigger the callback.
typedef void (SWIGSTDCALL* CSNAME##_CB_Type)(int index);
// Associates callback data with each Future<CTYPE> instance.
struct CSNAME##CallbackData {
// C# delegate method that should be called on the main thread.
CSNAME##_CB_Type cs_callback;
// Key of the callback in the C# CSTYPE.Callbacks dictionary.
int cs_key;
};
// Use a static function to make callback so don't need to worry about
// whether using stdcall or cdecl for the cs_callback function.
static void CallbackImpl(CSNAME##CallbackData data) {
data.cs_callback(data.cs_key);
}
// This is a C++ wrapper callback that queues the registered C# callback.
// We unpack the real C# callback from the user data, where we packed it
// when the callback was registered.
void CSNAME##_CB(const firebase::Future<CTYPE>& /*result_data*/,
void *user_data) {
auto cbdata = reinterpret_cast<CSNAME##CallbackData*>(user_data);
firebase::callback::AddCallback(
new firebase::callback::CallbackValue1<CSNAME##CallbackData>(
*cbdata, CallbackImpl));
}
%}
// Expand the template for SWIG to generate a wrapper.
%template( CSNAME ) firebase::Future<CTYPE>;
namespace firebase {
// C++ Code
%extend Future<CTYPE> {
// This handles converting void * to IntPtr on the C# side, instead of making
// a SWIG proxy wrapper for the void * type.
// http://www.swig.org/Doc3.0/SWIGDocumentation.html#CSharp_void_pointers
%apply void *VOID_INT_PTR { void * }
// This function is wrapped in C#, so we change it to not be exposed as a
// public interface (default).
%csmethodmodifiers SWIG_OnCompletion "internal";
// This function provides the API (when wrapped and exposed in C#) for
// registering a callback that can cross the C/C# boundary.
// It will pack the function pointer and original index in an std::pair,
// and register our calling-convention-correcting callback wrapper.
void* SWIG_OnCompletion(CSNAME##_CB_Type cs_callback, int cs_key) {
CSNAME##CallbackData* cbdata = new CSNAME##CallbackData;
cbdata->cs_callback = cs_callback;
cbdata->cs_key = cs_key;
$self->OnCompletion(CSNAME##_CB, cbdata);
return cbdata;
}
// Deallocate data allocated for the completion callback.
static void SWIG_FreeCompletionData(void *data) {
delete reinterpret_cast<CSNAME##CallbackData*>(data);
}
// Only generate the return logic for non-void types.
#if "CTYPE"!="void"
// This method copies the value return by Future::result() so that it's
// possible to marshal the return value to C#.
// We can not return pointer return values of Future::result() as pointers
// to C++ objects cannot be dereferenced in C#.
const CTYPE GetResult() const {
// The Future internally always stores it's value with CTYPE *, so 'result'
// can always be dereferenced except when the type in void.
return *$self->result();
}
#endif // "CTYPE"!="void"
}
} // namespace firebase
%enddef // SWIG_FUTURE_FOOTER
// This macro is used to generate the SWIG wrapper for each Future<T> type.
// The CTYPE is the T in Future<T>, and the CSTYPE is what the CTYPE maps to in
// C#. For example: Future<int>, Future<std::string>, Future<void>, etc. Each
// of these would need a macro call before being processed by SWIG. The CSNAME
// is what the specialized Future proxy class will be called in C#.
// For example if you have:
// Future<std::string>
// appearing anywhere your code, you should call this macro:
// %SWIG_FUTURE(MyStringFuture, string, public, std::string,
// FirebaseException)
// before %including that file in your SWIG wrapper.
// EXTYPE is the type of exception to throw when an error is reported by the
// future. If unsure, use FirebaseException.
%define %SWIG_FUTURE(CSNAME, CSTYPE, CSACCESS, CTYPE, EXTYPE)
%SWIG_FUTURE_HEADER(CSNAME, CSTYPE, CSACCESS, CTYPE)
%SWIG_FUTURE_GET_TASK(CSNAME, CSTYPE, CTYPE, EXTYPE)
%SWIG_FUTURE_FOOTER(CSNAME, CSTYPE, CTYPE)
%enddef
| 1 | 0.850156 | 1 | 0.850156 | game-dev | MEDIA | 0.214658 | game-dev | 0.782221 | 1 | 0.782221 |
iniside/ActionRPGGame | 5,888 | Plugins/AbilityFramework/Source/AbilityFramework/Public/Attributes/GAAttributesBase.h | #pragma once
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "UObject/Class.h"
#include "Templates/SubclassOf.h"
#include "UObject/UnrealType.h"
#include "UObject/CoreNet.h"
#include "../Effects/GAGameEffect.h"
#include "../GAGlobalTypes.h"
#include "GAAttributeBase.h"
#include "GAAttributesBase.generated.h"
/*
What I need.
Easy way to create Targeted modifications.
For Example, we have ability Fireball, which have cast time 3s, and recharge time 5 seconds.
Targeted modification, will only affect this one ability!
So we want attribute which will decrease recharge time of this ability by 2 seconds (or decrease recharge time by 25%
or increase recharge speed). How to do it ?
Path of least resistance is to create special object, which will be instanced, which will listen for abilities
which are activated, and you can cast to your particular ability (or check for tags), and just modify it's
properties directly.
Second way, (??) would be to create small objects, contained within array (structs), which would do the same thing.
Except they would only be able to catch something like ability activation by tag. They wouldn't know, what kind of
properties are on ability.
The ability in this case would be needed to be treated as source of incoming attribute, and that object would check
for this attribute and modify it.
Well kind of.
The same problems exist for any kind of abilities more broad (like Hex), more narrow (only Necromancer Hex),
or for weapons (we want to increase fire rate, if you have equiped machine gun).
Though on the very base level attribute system have no idea, what kind of properties you might have on
your machine gun.
This bring us to the core issue. How to create system like Traits/Feats/Talents, which can contain
myriads of possible combinations of those tree systems. We would need to mix some instanced/non-instanced UObjects
along with plain structs. Which is probabaly going to be total mess.
*/
UCLASS(BlueprintType, Blueprintable, DefaultToInstanced, EditInlineNew)
class ABILITYFRAMEWORK_API UGAAttributesBase : public UObject
{
GENERATED_BODY()
public:
UPROPERTY(EditAnywhere, BlueprintReadOnly, meta=(ExposeOnSpawn))
UDataTable* AttributeValues;
UGAAttributesBase(const FObjectInitializer& ObjectInitializer);
~UGAAttributesBase();
//virtual void PostNetReceive() override;
virtual void InitializeAttributes(UAFAbilityComponent* InOwningAttributeComp);
void CopyFromOtherAttributes(UGAAttributesBase* Other);
/*
Copy attributes from arbitrary struct.
Struct must be composed from FAFAttributeBase (or it's derivative) fields.
*/
void CopyFromStruct(UStruct* StructType, void* StructObject);
void InitializeAttributesFromTable();
UFUNCTION(BlueprintImplementableEvent, meta = (DisplayName = "Initialize Attributes"))
bool BP_InitializeAttributes();
/*
Updates attributes.
@param AttributeIn - attribute which changed value.
You can use this function to update other attributes (for example derived ones),
based on the primary attribute, if the primary attribute (AttributeIn), changed.
I have yet to fully figure out how do I want it to work. But one thing for certain is
that it must be fully functional from within blueprint.
*/
UPROPERTY(Replicated)
class UAFAbilityComponent* OwningAttributeComp;
protected:
UProperty* FindProperty(const FGAAttribute& AttributeIn);
public:
/*
Ticked called from owning component.
*/
virtual void Tick(float DeltaTime);// {};
/*
Helper C++ functions. Shouldn't ever be exposed or called from blueprint. Also never
try to override them.
probabaly could also add support for int32 values.
*/
UStructProperty* GetStructAttribute(const FGAAttribute& Name);
/*
Gets pointer to compelx attribute.
*/
FAFAttributeBase* GetAttribute(const FGAAttribute& Name);
/*
Deprecated. I'm going to remove it, since it does not work as intended!
*/
void SetAttribute(const FGAAttribute& NameIn, UObject* NewVal);
void SetAttributeAdditiveBonus(const FGAAttribute& NameIn, float NewValue);
/*
Gets value from complex attribute (FAFAttributeBase).
*/
float GetFinalAttributeValue(const FGAAttribute& Name);
float GetCurrentAttributeValue(const FGAAttribute& Name);
float GetFloatValue(const FGAAttribute& AttributeIn);
float SetFloatValue(const FGAAttribute& AttributeIn, float ValueIn);
float AttributeOperation(const FGAAttribute& AttributeIn, float ValueIn, EGAAttributeMod Operation);
bool IsNameStableForNetworking() const override;
bool IsSupportedForNetworking() const override
{
return true;
}
void SetNetAddressable();
void ModifyAttribute(const FGAEffect& EffectIn);
float ModifyAttribute(const FGAEffectMod& ModIn
, const FGAEffectHandle& HandleIn
, FGAEffectProperty& InProperty
, const FGAEffectContext& InContext);
void RemoveBonus(FGAAttribute AttributeIn, const FGAEffectHandle& HandleIn, EGAAttributeMod InMod);
protected:
bool bNetAddressable;
private:
TArray<FAFAttributeBase*> TickableAttributes;
UProperty* LastAttributeProp;
FName LastAttributeName;
// cached numeric property. WEll we probabaly don't need UProperty cache then..
UNumericProperty* CachedFloatPropety;
float AddAttributeFloat(float ValueA, float ValueB);
float SubtractAttributeFloat(float ValueA, float ValueB);
float MultiplyAttributeFloat(float ValueA, float ValueB);
float DivideAttributeFloat(float ValueA, float ValueB);
void OnAttributeModified(const FGAEffectMod& InMod, const FGAEffectHandle& InHandle);
};
USTRUCT(BlueprintType)
struct ABILITYFRAMEWORK_API FAFAttributesProperty
{
GENERATED_BODY()
public:
UPROPERTY(EditAnywhere)
TSubclassOf<UGAAttributesBase> Attributes;
/*
If set, any values in Attributes will be overriden by table.
*/
UPROPERTY(EditAnywhere, BlueprintReadOnly)
UDataTable* AttributeValues;
};
| 1 | 0.781351 | 1 | 0.781351 | game-dev | MEDIA | 0.828215 | game-dev | 0.673726 | 1 | 0.673726 |
ampl/coin | 1,971 | Couenne/Bonmin/src/Algorithms/Branching/BonLpBranchingSolver.hpp | // Copyright (C) 2006, 2007 International Business Machines
// Corporation and others. All Rights Reserved.
#ifndef BonLpBranchingSolver_H
#define BonLpBranchingSolver_H
#include "BonStrongBranchingSolver.hpp"
#include "BonEcpCuts.hpp"
namespace Bonmin
{
/** Implementation of BonChooseVariable for curvature-based braching.
*/
class LpBranchingSolver : public StrongBranchingSolver
{
public:
/// Constructor from setup
LpBranchingSolver (BabSetupBase *b);
/// Copy constructor
LpBranchingSolver (const LpBranchingSolver &);
/// Assignment operator
LpBranchingSolver & operator= (const LpBranchingSolver& rhs);
/// Destructor
virtual ~LpBranchingSolver ();
/// Called to initialize solver before a bunch of strong branching
/// solves
virtual void markHotStart(OsiTMINLPInterface* tminlp_interface);
/// Called to solve the current TMINLP (with changed bound information)
virtual TNLPSolver::ReturnStatus solveFromHotStart(OsiTMINLPInterface* tminlp_interface);
/// Called after all strong branching solves in a node
virtual void unmarkHotStart(OsiTMINLPInterface* tminlp_interface);
void setMaxCuttingPlaneIter(int num)
{
maxCuttingPlaneIterations_ = num;
}
static void registerOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions);
private:
/// Default Constructor
LpBranchingSolver ();
/// Linear solver
OsiSolverInterface* lin_;
/// Warm start object for linear solver
CoinWarmStart* warm_;
/// Ecp cut generate
EcpCuts* ecp_;
/// Number of maximal ECP cuts
int maxCuttingPlaneIterations_;
/// absolute tolerance for ECP cuts
double abs_ecp_tol_;
/// relative tolerance for ECP cuts
double rel_ecp_tol_;
enum WarmStartMethod {
Basis=0 /** Use basis*/,
Clone /** clone problem*/
};
/// Way problems are warm started
WarmStartMethod warm_start_mode_;
};
}
#endif
| 1 | 0.632365 | 1 | 0.632365 | game-dev | MEDIA | 0.359419 | game-dev | 0.688886 | 1 | 0.688886 |
FalconClient/FalconClient | 4,970 | src/main/java/net/minecraft/world/gen/feature/WorldGenForest.java | package net.minecraft.world.gen.feature;
import java.util.Random;
import net.minecraft.block.Block;
import net.minecraft.block.BlockOldLeaf;
import net.minecraft.block.BlockOldLog;
import net.minecraft.block.BlockPlanks;
import net.minecraft.block.material.Material;
import net.minecraft.block.state.IBlockState;
import net.minecraft.init.Blocks;
import net.minecraft.util.BlockPos;
import net.minecraft.world.World;
public class WorldGenForest extends WorldGenAbstractTree
{
private static final IBlockState field_181629_a = Blocks.log.getDefaultState().withProperty(BlockOldLog.VARIANT, BlockPlanks.EnumType.BIRCH);
private static final IBlockState field_181630_b = Blocks.leaves.getDefaultState().withProperty(BlockOldLeaf.VARIANT, BlockPlanks.EnumType.BIRCH).withProperty(BlockOldLeaf.CHECK_DECAY, Boolean.valueOf(false));
private boolean useExtraRandomHeight;
public WorldGenForest(boolean p_i45449_1_, boolean p_i45449_2_)
{
super(p_i45449_1_);
this.useExtraRandomHeight = p_i45449_2_;
}
public boolean generate(World worldIn, Random rand, BlockPos position)
{
int i = rand.nextInt(3) + 5;
if (this.useExtraRandomHeight)
{
i += rand.nextInt(7);
}
boolean flag = true;
if (position.getY() >= 1 && position.getY() + i + 1 <= 256)
{
for (int j = position.getY(); j <= position.getY() + 1 + i; ++j)
{
int k = 1;
if (j == position.getY())
{
k = 0;
}
if (j >= position.getY() + 1 + i - 2)
{
k = 2;
}
BlockPos.MutableBlockPos blockpos$mutableblockpos = new BlockPos.MutableBlockPos();
for (int l = position.getX() - k; l <= position.getX() + k && flag; ++l)
{
for (int i1 = position.getZ() - k; i1 <= position.getZ() + k && flag; ++i1)
{
if (j >= 0 && j < 256)
{
if (!this.func_150523_a(worldIn.getBlockState(blockpos$mutableblockpos.set(l, j, i1)).getBlock()))
{
flag = false;
}
}
else
{
flag = false;
}
}
}
}
if (!flag)
{
return false;
}
else
{
Block block1 = worldIn.getBlockState(position.down()).getBlock();
if ((block1 == Blocks.grass || block1 == Blocks.dirt || block1 == Blocks.farmland) && position.getY() < 256 - i - 1)
{
this.func_175921_a(worldIn, position.down());
for (int i2 = position.getY() - 3 + i; i2 <= position.getY() + i; ++i2)
{
int k2 = i2 - (position.getY() + i);
int l2 = 1 - k2 / 2;
for (int i3 = position.getX() - l2; i3 <= position.getX() + l2; ++i3)
{
int j1 = i3 - position.getX();
for (int k1 = position.getZ() - l2; k1 <= position.getZ() + l2; ++k1)
{
int l1 = k1 - position.getZ();
if (Math.abs(j1) != l2 || Math.abs(l1) != l2 || rand.nextInt(2) != 0 && k2 != 0)
{
BlockPos blockpos = new BlockPos(i3, i2, k1);
Block block = worldIn.getBlockState(blockpos).getBlock();
if (block.getMaterial() == Material.air || block.getMaterial() == Material.leaves)
{
this.setBlockAndNotifyAdequately(worldIn, blockpos, field_181630_b);
}
}
}
}
}
for (int j2 = 0; j2 < i; ++j2)
{
Block block2 = worldIn.getBlockState(position.up(j2)).getBlock();
if (block2.getMaterial() == Material.air || block2.getMaterial() == Material.leaves)
{
this.setBlockAndNotifyAdequately(worldIn, position.up(j2), field_181629_a);
}
}
return true;
}
else
{
return false;
}
}
}
else
{
return false;
}
}
}
| 1 | 0.760739 | 1 | 0.760739 | game-dev | MEDIA | 0.957927 | game-dev | 0.950539 | 1 | 0.950539 |
Harchvertelol/Dangerous-Dave-2-Modification-Edition | 1,158 | DD2ME/src/FactoryMonsters.h | #ifndef FACTORYMONSTERS_H
#define FACTORYMONSTERS_H
#include <iostream>
#include <map>
#include <vector>
#include "CreatureMonster.h"
#include "CreaturePlayer.h"
class Game;
enum MONSTER_PLAYER_RADIUS_TYPE
{
MDRT_LIVE = 0,
MDRT_ACTIVATE
};
class FactoryMonsters
{
public:
FactoryMonsters(Game*);
~FactoryMonsters();
Game* s_GameClass;
std::map<int, CreatureMonster*> s_Monsters;
std::vector<CreatureMonster*> s_QueueForAddingMonsters;
//std::map<std::string, std::string> s_AIMonstersValues;
IniParser::PostParsingStruct* s_AIMonstersValues;
unsigned int s_MaxIndex;
CreatureMonster* addMonster(int, int, int, bool getstate = true);
int addMonsterImmediately(int, int, int, bool getstate = true);
bool isMonsterInPlayerRadius(CreaturePlayer*, CreatureMonster*, MONSTER_PLAYER_RADIUS_TYPE);
void removeMonster(int);
void addMonstersFromQueue();
bool isExistsById(unsigned int);
CreatureMonster* getMonsterById(int id);
void live();
void clear();
void reloadAIAll();
void drawAll();
};
#endif
| 1 | 0.810804 | 1 | 0.810804 | game-dev | MEDIA | 0.958389 | game-dev | 0.529619 | 1 | 0.529619 |
PlayApple/cocos2dx-extensions | 15,743 | Cocos2dxExt/Cocos2dxExt/libs/chipmunk/src/cpSpace.c | /* Copyright (c) 2007 Scott Lembcke
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <stdio.h>
#include <string.h>
#include "chipmunk_private.h"
//MARK: Contact Set Helpers
// Equal function for arbiterSet.
static cpBool
arbiterSetEql(cpShape **shapes, cpArbiter *arb)
{
cpShape *a = shapes[0];
cpShape *b = shapes[1];
return ((a == arb->a && b == arb->b) || (b == arb->a && a == arb->b));
}
//MARK: Collision Handler Set HelperFunctions
// Equals function for collisionHandlers.
static cpBool
handlerSetEql(cpCollisionHandler *check, cpCollisionHandler *pair)
{
return ((check->a == pair->a && check->b == pair->b) || (check->b == pair->a && check->a == pair->b));
}
// Transformation function for collisionHandlers.
static void *
handlerSetTrans(cpCollisionHandler *handler, void *unused)
{
cpCollisionHandler *copy = (cpCollisionHandler *)cpcalloc(1, sizeof(cpCollisionHandler));
(*copy) = (*handler);
return copy;
}
//MARK: Misc Helper Funcs
// Default collision functions.
static cpBool alwaysCollide(cpArbiter *arb, cpSpace *space, void *data){return 1;}
static void nothing(cpArbiter *arb, cpSpace *space, void *data){}
// function to get the estimated velocity of a shape for the cpBBTree.
static cpVect shapeVelocityFunc(cpShape *shape){return shape->body->v;}
static void freeWrap(void *ptr, void *unused){cpfree(ptr);}
//MARK: Memory Management Functions
cpSpace *
cpSpaceAlloc(void)
{
return (cpSpace *)cpcalloc(1, sizeof(cpSpace));
}
cpCollisionHandler cpDefaultCollisionHandler = {0, 0, alwaysCollide, alwaysCollide, nothing, nothing, NULL};
cpSpace*
cpSpaceInit(cpSpace *space)
{
#ifndef NDEBUG
static cpBool done = cpFalse;
if(!done){
printf("Initializing cpSpace - Chipmunk v%s (Debug Enabled)\n", cpVersionString);
printf("Compile with -DNDEBUG defined to disable debug mode and runtime assertion checks\n");
done = cpTrue;
}
#endif
space->iterations = 10;
space->gravity = cpvzero;
space->damping = 1.0f;
space->collisionSlop = 0.1f;
space->collisionBias = cpfpow(1.0f - 0.1f, 60.0f);
space->collisionPersistence = 3;
space->locked = 0;
space->stamp = 0;
space->staticShapes = cpBBTreeNew((cpSpatialIndexBBFunc)cpShapeGetBB, NULL);
space->activeShapes = cpBBTreeNew((cpSpatialIndexBBFunc)cpShapeGetBB, space->staticShapes);
cpBBTreeSetVelocityFunc(space->activeShapes, (cpBBTreeVelocityFunc)shapeVelocityFunc);
space->allocatedBuffers = cpArrayNew(0);
space->bodies = cpArrayNew(0);
space->sleepingComponents = cpArrayNew(0);
space->rousedBodies = cpArrayNew(0);
space->sleepTimeThreshold = INFINITY;
space->idleSpeedThreshold = 0.0f;
space->enableContactGraph = cpFalse;
space->arbiters = cpArrayNew(0);
space->pooledArbiters = cpArrayNew(0);
space->contactBuffersHead = NULL;
space->cachedArbiters = cpHashSetNew(0, (cpHashSetEqlFunc)arbiterSetEql);
space->constraints = cpArrayNew(0);
space->defaultHandler = cpDefaultCollisionHandler;
space->collisionHandlers = cpHashSetNew(0, (cpHashSetEqlFunc)handlerSetEql);
cpHashSetSetDefaultValue(space->collisionHandlers, &cpDefaultCollisionHandler);
space->postStepCallbacks = cpArrayNew(0);
space->skipPostStep = cpFalse;
cpBodyInitStatic(&space->_staticBody);
space->staticBody = &space->_staticBody;
return space;
}
cpSpace*
cpSpaceNew(void)
{
return cpSpaceInit(cpSpaceAlloc());
}
void
cpSpaceDestroy(cpSpace *space)
{
cpSpaceEachBody(space, (cpSpaceBodyIteratorFunc)cpBodyActivate, NULL);
cpSpatialIndexFree(space->staticShapes);
cpSpatialIndexFree(space->activeShapes);
cpArrayFree(space->bodies);
cpArrayFree(space->sleepingComponents);
cpArrayFree(space->rousedBodies);
cpArrayFree(space->constraints);
cpHashSetFree(space->cachedArbiters);
cpArrayFree(space->arbiters);
cpArrayFree(space->pooledArbiters);
if(space->allocatedBuffers){
cpArrayFreeEach(space->allocatedBuffers, cpfree);
cpArrayFree(space->allocatedBuffers);
}
if(space->postStepCallbacks){
cpArrayFreeEach(space->postStepCallbacks, cpfree);
cpArrayFree(space->postStepCallbacks);
}
if(space->collisionHandlers) cpHashSetEach(space->collisionHandlers, freeWrap, NULL);
cpHashSetFree(space->collisionHandlers);
}
void
cpSpaceFree(cpSpace *space)
{
if(space){
cpSpaceDestroy(space);
cpfree(space);
}
}
#define cpAssertSpaceUnlocked(space) \
cpAssertHard(!space->locked, \
"This addition/removal cannot be done safely during a call to cpSpaceStep() or during a query. " \
"Put these calls into a post-step callback." \
);
//MARK: Collision Handler Function Management
void
cpSpaceAddCollisionHandler(
cpSpace *space,
cpCollisionType a, cpCollisionType b,
cpCollisionBeginFunc begin,
cpCollisionPreSolveFunc preSolve,
cpCollisionPostSolveFunc postSolve,
cpCollisionSeparateFunc separate,
void *data
){
cpAssertSpaceUnlocked(space);
// Remove any old function so the new one will get added.
cpSpaceRemoveCollisionHandler(space, a, b);
cpCollisionHandler handler = {
a, b,
begin ? begin : alwaysCollide,
preSolve ? preSolve : alwaysCollide,
postSolve ? postSolve : nothing,
separate ? separate : nothing,
data
};
cpHashSetInsert(space->collisionHandlers, CP_HASH_PAIR(a, b), &handler, NULL, (cpHashSetTransFunc)handlerSetTrans);
}
void
cpSpaceRemoveCollisionHandler(cpSpace *space, cpCollisionType a, cpCollisionType b)
{
cpAssertSpaceUnlocked(space);
struct { cpCollisionType a, b; } ids = {a, b};
cpCollisionHandler *old_handler = (cpCollisionHandler *) cpHashSetRemove(space->collisionHandlers, CP_HASH_PAIR(a, b), &ids);
cpfree(old_handler);
}
void
cpSpaceSetDefaultCollisionHandler(
cpSpace *space,
cpCollisionBeginFunc begin,
cpCollisionPreSolveFunc preSolve,
cpCollisionPostSolveFunc postSolve,
cpCollisionSeparateFunc separate,
void *data
){
cpAssertSpaceUnlocked(space);
cpCollisionHandler handler = {
0, 0,
begin ? begin : alwaysCollide,
preSolve ? preSolve : alwaysCollide,
postSolve ? postSolve : nothing,
separate ? separate : nothing,
data
};
space->defaultHandler = handler;
cpHashSetSetDefaultValue(space->collisionHandlers, &space->defaultHandler);
}
//MARK: Body, Shape, and Joint Management
cpShape *
cpSpaceAddShape(cpSpace *space, cpShape *shape)
{
cpBody *body = shape->body;
if(cpBodyIsStatic(body)) return cpSpaceAddStaticShape(space, shape);
cpAssertHard(!shape->space, "This shape is already added to a space and cannot be added to another.");
cpAssertSpaceUnlocked(space);
cpBodyActivate(body);
cpBodyAddShape(body, shape);
cpShapeUpdate(shape, body->p, body->rot);
cpSpatialIndexInsert(space->activeShapes, shape, shape->hashid);
shape->space = space;
return shape;
}
cpShape *
cpSpaceAddStaticShape(cpSpace *space, cpShape *shape)
{
cpAssertHard(!shape->space, "This shape is already added to a space and cannot be added to another.");
cpAssertSpaceUnlocked(space);
cpBody *body = shape->body;
cpBodyAddShape(body, shape);
cpShapeUpdate(shape, body->p, body->rot);
cpSpatialIndexInsert(space->staticShapes, shape, shape->hashid);
shape->space = space;
return shape;
}
cpBody *
cpSpaceAddBody(cpSpace *space, cpBody *body)
{
cpAssertHard(!cpBodyIsStatic(body), "Static bodies cannot be added to a space as they are not meant to be simulated.");
cpAssertHard(!body->space, "This body is already added to a space and cannot be added to another.");
cpAssertSpaceUnlocked(space);
cpArrayPush(space->bodies, body);
body->space = space;
return body;
}
cpConstraint *
cpSpaceAddConstraint(cpSpace *space, cpConstraint *constraint)
{
cpAssertHard(!constraint->space, "This shape is already added to a space and cannot be added to another.");
cpAssertSpaceUnlocked(space);
cpBodyActivate(constraint->a);
cpBodyActivate(constraint->b);
cpArrayPush(space->constraints, constraint);
// Push onto the heads of the bodies' constraint lists
cpBody *a = constraint->a, *b = constraint->b;
constraint->next_a = a->constraintList; a->constraintList = constraint;
constraint->next_b = b->constraintList; b->constraintList = constraint;
constraint->space = space;
return constraint;
}
struct arbiterFilterContext {
cpSpace *space;
cpBody *body;
cpShape *shape;
};
static cpBool
cachedArbitersFilter(cpArbiter *arb, struct arbiterFilterContext *context)
{
cpShape *shape = context->shape;
cpBody *body = context->body;
// Match on the filter shape, or if it's NULL the filter body
if(
(body == arb->body_a && (shape == arb->a || shape == NULL)) ||
(body == arb->body_b && (shape == arb->b || shape == NULL))
){
// Call separate when removing shapes.
if(shape && arb->state != cpArbiterStateCached) cpArbiterCallSeparate(arb, context->space);
cpArbiterUnthread(arb);
cpArrayDeleteObj(context->space->arbiters, arb);
cpArrayPush(context->space->pooledArbiters, arb);
return cpFalse;
}
return cpTrue;
}
void
cpSpaceFilterArbiters(cpSpace *space, cpBody *body, cpShape *filter)
{
cpSpaceLock(space); {
struct arbiterFilterContext context = {space, body, filter};
cpHashSetFilter(space->cachedArbiters, (cpHashSetFilterFunc)cachedArbitersFilter, &context);
} cpSpaceUnlock(space, cpTrue);
}
void
cpSpaceRemoveShape(cpSpace *space, cpShape *shape)
{
cpBody *body = shape->body;
if(cpBodyIsStatic(body)){
cpSpaceRemoveStaticShape(space, shape);
} else {
cpAssertHard(cpSpaceContainsShape(space, shape), "Cannot remove a shape that was not added to the space. (Removed twice maybe?)");
cpAssertSpaceUnlocked(space);
cpBodyActivate(body);
cpBodyRemoveShape(body, shape);
cpSpaceFilterArbiters(space, body, shape);
cpSpatialIndexRemove(space->activeShapes, shape, shape->hashid);
shape->space = NULL;
}
}
void
cpSpaceRemoveStaticShape(cpSpace *space, cpShape *shape)
{
cpAssertHard(cpSpaceContainsShape(space, shape), "Cannot remove a static or sleeping shape that was not added to the space. (Removed twice maybe?)");
cpAssertSpaceUnlocked(space);
cpBody *body = shape->body;
if(cpBodyIsStatic(body)) cpBodyActivateStatic(body, shape);
cpBodyRemoveShape(body, shape);
cpSpaceFilterArbiters(space, body, shape);
cpSpatialIndexRemove(space->staticShapes, shape, shape->hashid);
shape->space = NULL;
}
void
cpSpaceRemoveBody(cpSpace *space, cpBody *body)
{
cpAssertHard(cpSpaceContainsBody(space, body), "Cannot remove a body that was not added to the space. (Removed twice maybe?)");
cpAssertSpaceUnlocked(space);
cpBodyActivate(body);
// cpSpaceFilterArbiters(space, body, NULL);
cpArrayDeleteObj(space->bodies, body);
body->space = NULL;
}
void
cpSpaceRemoveConstraint(cpSpace *space, cpConstraint *constraint)
{
cpAssertHard(cpSpaceContainsConstraint(space, constraint), "Cannot remove a constraint that was not added to the space. (Removed twice maybe?)");
cpAssertSpaceUnlocked(space);
cpBodyActivate(constraint->a);
cpBodyActivate(constraint->b);
cpArrayDeleteObj(space->constraints, constraint);
cpBodyRemoveConstraint(constraint->a, constraint);
cpBodyRemoveConstraint(constraint->b, constraint);
constraint->space = NULL;
}
cpBool cpSpaceContainsShape(cpSpace *space, cpShape *shape)
{
return (shape->space == space);
}
cpBool cpSpaceContainsBody(cpSpace *space, cpBody *body)
{
return (body->space == space);
}
cpBool cpSpaceContainsConstraint(cpSpace *space, cpConstraint *constraint)
{
return (constraint->space == space);
}
//MARK: Iteration
void
cpSpaceEachBody(cpSpace *space, cpSpaceBodyIteratorFunc func, void *data)
{
cpSpaceLock(space); {
cpArray *bodies = space->bodies;
for(int i=0; i<bodies->num; i++){
func((cpBody *)bodies->arr[i], data);
}
cpArray *components = space->sleepingComponents;
for(int i=0; i<components->num; i++){
cpBody *root = (cpBody *)components->arr[i];
cpBody *body = root;
while(body){
cpBody *next = body->node.next;
func(body, data);
body = next;
}
}
} cpSpaceUnlock(space, cpTrue);
}
typedef struct spaceShapeContext {
cpSpaceShapeIteratorFunc func;
void *data;
} spaceShapeContext;
static void
spaceEachShapeIterator(cpShape *shape, spaceShapeContext *context)
{
context->func(shape, context->data);
}
void
cpSpaceEachShape(cpSpace *space, cpSpaceShapeIteratorFunc func, void *data)
{
cpSpaceLock(space); {
spaceShapeContext context = {func, data};
cpSpatialIndexEach(space->activeShapes, (cpSpatialIndexIteratorFunc)spaceEachShapeIterator, &context);
cpSpatialIndexEach(space->staticShapes, (cpSpatialIndexIteratorFunc)spaceEachShapeIterator, &context);
} cpSpaceUnlock(space, cpTrue);
}
void
cpSpaceEachConstraint(cpSpace *space, cpSpaceConstraintIteratorFunc func, void *data)
{
cpSpaceLock(space); {
cpArray *constraints = space->constraints;
for(int i=0; i<constraints->num; i++){
func((cpConstraint *)constraints->arr[i], data);
}
} cpSpaceUnlock(space, cpTrue);
}
//MARK: Spatial Index Management
static void
updateBBCache(cpShape *shape, void *unused)
{
cpBody *body = shape->body;
cpShapeUpdate(shape, body->p, body->rot);
}
void
cpSpaceReindexStatic(cpSpace *space)
{
cpAssertHard(!space->locked, "You cannot manually reindex objects while the space is locked. Wait until the current query or step is complete.");
cpSpatialIndexEach(space->staticShapes, (cpSpatialIndexIteratorFunc)&updateBBCache, NULL);
cpSpatialIndexReindex(space->staticShapes);
}
void
cpSpaceReindexShape(cpSpace *space, cpShape *shape)
{
cpAssertHard(!space->locked, "You cannot manually reindex objects while the space is locked. Wait until the current query or step is complete.");
cpBody *body = shape->body;
cpShapeUpdate(shape, body->p, body->rot);
// attempt to rehash the shape in both hashes
cpSpatialIndexReindexObject(space->activeShapes, shape, shape->hashid);
cpSpatialIndexReindexObject(space->staticShapes, shape, shape->hashid);
}
void
cpSpaceReindexShapesForBody(cpSpace *space, cpBody *body)
{
CP_BODY_FOREACH_SHAPE(body, shape) cpSpaceReindexShape(space, shape);
}
static void
copyShapes(cpShape *shape, cpSpatialIndex *index)
{
cpSpatialIndexInsert(index, shape, shape->hashid);
}
void
cpSpaceUseSpatialHash(cpSpace *space, cpFloat dim, int count)
{
cpSpatialIndex *staticShapes = cpSpaceHashNew(dim, count, (cpSpatialIndexBBFunc)cpShapeGetBB, NULL);
cpSpatialIndex *activeShapes = cpSpaceHashNew(dim, count, (cpSpatialIndexBBFunc)cpShapeGetBB, staticShapes);
cpSpatialIndexEach(space->staticShapes, (cpSpatialIndexIteratorFunc)copyShapes, staticShapes);
cpSpatialIndexEach(space->activeShapes, (cpSpatialIndexIteratorFunc)copyShapes, activeShapes);
cpSpatialIndexFree(space->staticShapes);
cpSpatialIndexFree(space->activeShapes);
space->staticShapes = staticShapes;
space->activeShapes = activeShapes;
}
| 1 | 0.674393 | 1 | 0.674393 | game-dev | MEDIA | 0.840691 | game-dev | 0.810857 | 1 | 0.810857 |
ProjectIgnis/CardScripts | 5,400 | unofficial/c511005093.lua | --Booster Draft Duel (HIJACK)
--Scripted by edo9300
local id=511005093
if self_table then
function self_table.initial_effect(c) end
end
--define pack
--pack=BP03
--[1]=rare, [2/3/4]=common, [5]=foil
local pack={}
pack[1]={
42364374,71413901,82108372,39168895,78636495,42386471,16956455,85306040,89222931,85087012,18430390,
61802346,39303359,54040221,52319752,14089428,76203291,75081613,96235275,41113025,6061630,92826944,
84847656,74976215,69695704,45041488,12435193,80925836,42463414,77135531,10321588,4694209,39037517,
37792478,49680980,82199284,20474741,83957459,66816282,91438994,62950604,47013502,85682655,4611269,
95905259,1371589,66499018,64892035,40921545,98225108,42969214,97396380,89362180,15767889,50896944
}
pack[2]={
23635815,40133511,38742075,77491079,40320754,30914564,76909279,2671330,18325492,55424270,3370104,
93130021,21074344,94689635,99861526,79409334,12398280,20586572,46508640,95943058,91596726,52035300,
87685879,39180960,59797187,11232355,17266660,52430902,38041940,2525268,95090813,71759912,90508760,
43426903,65422840,79337169,3603242,23927545,20351153,13521194,12235475,96930127,2137678,84747429,
73625877,93830681,5237827,2584136,49374988,72429240,7914843,30464153,78663366,30608985,54635862
}
pack[3]={
37984162,61318483,12467005,99733359,25727454,72302403,70046172,86198326,70828912,82432018,19230407,
73915051,95281259,55991637,81385346,37684215,31036355,2204140,4861205,10012614,28106077,98045062,
82828051,12923641,36045450,37534148,1353770,6178850,4230620,62991886,99995595,35480699,45247637,
32180819,44887817,92346415,25789292,95507060,91580102,25518020,66835946,98867329,84428023,78082039,
27243130,67775894,60398723,53610653,89882100,88616795,73199638,36042825,96864811,83438826,23562407
}
pack[4]={
42502956,54773234,52112003,88610708,97077563,22359980,68540058,57882509,41925941,31785398,80163754,
98239899,3149764,59744639,83133491,29267084,66742250,12503902,96008713,77538567,4923662,60306104,
93895605,34815282,82633308,23323812,59718521,37390589,91078716,54451023,97168905,73729209,17490535,
43889633,16678947,87106146,32854013,21636650,89792713,3146695,25642998,11741041,75987257,44046281,
78474168,44509898,71098407,63630268,23122036,25005816,51099515,88494120,14883228,50277973,87772572
}
pack[5]={
47506081,95992081,11411223,47805931,3989465,76372778,581014,12014404,48009503,74593218,57043117,
95169481,66506689,51960178,80764541,75367227,68836428
}
for _,v in ipairs(pack[1]) do table.insert(pack[5],v) end
for _,v in ipairs(pack[2]) do table.insert(pack[5],v) end
for _,v in ipairs(pack[3]) do table.insert(pack[5],v) end
for _,v in ipairs(pack[4]) do table.insert(pack[5],v) end
--before anything
if not BoosterDraft then
BoosterDraft={}
local function finish_setup()
--Pre-draw
local e1=Effect.GlobalEffect()
e1:SetType(EFFECT_TYPE_FIELD+EFFECT_TYPE_CONTINUOUS)
e1:SetCode(EVENT_STARTUP)
e1:SetCountLimit(1)
e1:SetOperation(BoosterDraft.op)
Duel.RegisterEffect(e1,0)
end
local c_getrace=Card.GetRace
Card.GetRace=function(c)
if c:IsMonster() then return 0xffffff end
return c_getrace(c)
end
local c_getorigrace=Card.GetOriginalRace
Card.GetOriginalRace=function(c)
if c:IsMonster() then return 0xffffff end
return c_getorigrace(c)
end
local c_getprevraceonfield=Card.GetPreviousRaceOnField
Card.GetPreviousRaceOnField=function(c)
if (c:GetPreviousTypeOnField()&TYPE_MONSTER)~=0 then return 0xffffff end
return c_getprevraceonfield(c)
end
local c_israce=Card.IsRace
Card.IsRace=function(c,r)
if c:IsMonster() then return true end
return c_israce(c,r)
end
function BoosterDraft.op(e,tp,eg,ep,ev,re,r,rp)
local z,o=tp,1-tp
--Hint
local counts={}
counts[0]=Duel.GetPlayersCount(0)
counts[1]=Duel.GetPlayersCount(1)
Duel.DisableShuffleCheck()
Duel.Hint(HINT_CARD,0,id)
for p=z,o do
for team=1,counts[p] do
Duel.RemoveCards(Duel.GetFieldGroup(p,0xff,0),0,-2,REASON_RULE)
if counts[p]~=1 then
Duel.TagSwap(p)
end
end
end
local groups={}
groups[0]={}
groups[1]={}
for i=1,counts[0] do
groups[0][i]={}
end
for i=1,counts[1] do
groups[1][i]={}
end
local function generate_packs()
local total=(counts[0]+counts[1])*3
local retpacks={}
for t=1,total do
local _pack={}
for p=1,3 do
for i=1,5 do
local cpack=pack[i]
local c=cpack[Duel.GetRandomNumber(1,#cpack)]
table.insert(_pack,c)
end
end
table.insert(retpacks,_pack)
end
return retpacks
end
local packs = generate_packs()
local pack=table.remove(packs, 1)
while pack do
for p=z,o do
for team=1,counts[p] do
local tc=Duel.SelectCardsFromCodes(p,1,1,false,true,table.unpack(pack))
table.insert(groups[p][team],tc[1])
table.remove(pack, tc[2])
if counts[p]~=1 then
Duel.TagSwap(p)
end
if #pack==0 then
pack=table.remove(packs, 1)
if not pack then goto exit end
end
end
end
end
::exit::
for p=z,o do
for team=1,counts[p] do
for _,card in ipairs(groups[p][team]) do
Debug.AddCard(card,p,p,LOCATION_DECK,1,POS_FACEDOWN)
end
if counts[p]~=1 then
Duel.TagSwap(p)
end
end
end
Debug.ReloadFieldEnd()
for p=z,o do
for team=1,counts[p] do
Duel.ShuffleDeck(p)
if counts[p]~=1 then
Duel.TagSwap(p)
end
end
end
e:Reset()
end
finish_setup()
end | 1 | 0.502533 | 1 | 0.502533 | game-dev | MEDIA | 0.364142 | game-dev | 0.810941 | 1 | 0.810941 |
solarus-games/solarus | 2,281 | include/solarus/hero/HookshotState.h | /*
* Copyright (C) 2006-2018 Christopho, Solarus - http://www.solarus-games.org
*
* Solarus is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Solarus is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef SOLARUS_HERO_HOOKSHOT_STATE_H
#define SOLARUS_HERO_HOOKSHOT_STATE_H
#include "solarus/core/Common.h"
#include "solarus/hero/HeroState.h"
#include <memory>
namespace Solarus {
class Hookshot;
/**
* \brief The state "hookshot" of the hero.
*/
class Hero::HookshotState: public HeroState {
public:
explicit HookshotState(Hero& hero);
virtual void start(const State* previous_state) override;
virtual void stop(const State* next_state) override;
virtual bool is_touching_ground() const override;
virtual bool can_avoid_deep_water() const override;
virtual bool can_avoid_hole() const override;
virtual bool can_avoid_ice() const override;
virtual bool can_avoid_lava() const override;
virtual bool can_avoid_prickle() const override;
virtual bool can_avoid_teletransporter() const override;
virtual bool can_avoid_stream(const Stream& stream) const override;
virtual bool is_stairs_obstacle(const Stairs& stairs) const override;
virtual bool is_sensor_obstacle(const Sensor& sensor) const override;
virtual bool is_jumper_obstacle(const Jumper& jumper, const Rectangle& candidate_position) const override;
virtual bool can_avoid_switch() const override;
virtual bool can_be_hurt(Entity* attacker) const override;
virtual bool can_pick_treasure(EquipmentItem& item) const override;
virtual void notify_obstacle_reached() override;
private:
void finish_movement();
std::shared_ptr<Hookshot> hookshot; /**< the hookshot thrown by the hero */
};
}
#endif
| 1 | 0.832898 | 1 | 0.832898 | game-dev | MEDIA | 0.906247 | game-dev | 0.530335 | 1 | 0.530335 |
DeltaV-Station/Delta-v | 1,481 | Content.Client/NPC/HTN/HTNOverlay.cs | using System.Numerics;
using Robust.Client.Graphics;
using Robust.Client.ResourceManagement;
using Robust.Shared.Enums;
namespace Content.Client.NPC.HTN;
public sealed class HTNOverlay : Overlay
{
private readonly IEntityManager _entManager = default!;
private readonly Font _font = default!;
private readonly SharedTransformSystem _transformSystem;
public override OverlaySpace Space => OverlaySpace.ScreenSpace;
public HTNOverlay(IEntityManager entManager, IResourceCache resourceCache)
{
_entManager = entManager;
_font = new VectorFont(resourceCache.GetResource<FontResource>("/Fonts/NotoSans/NotoSans-Regular.ttf"), 10);
_transformSystem = _entManager.System<SharedTransformSystem>();
}
protected override void Draw(in OverlayDrawArgs args)
{
if (args.ViewportControl == null)
return;
var handle = args.ScreenHandle;
foreach (var (comp, xform) in _entManager.EntityQuery<HTNComponent, TransformComponent>(true))
{
if (string.IsNullOrEmpty(comp.DebugText) || xform.MapID != args.MapId)
continue;
var worldPos = _transformSystem.GetWorldPosition(xform);
if (!args.WorldAABB.Contains(worldPos))
continue;
var screenPos = args.ViewportControl.WorldToScreen(worldPos);
handle.DrawString(_font, screenPos + new Vector2(0, 10f), comp.DebugText, Color.White);
}
}
}
| 1 | 0.872635 | 1 | 0.872635 | game-dev | MEDIA | 0.63297 | game-dev | 0.951223 | 1 | 0.951223 |
Tropicraft/Tropicraft | 3,029 | src/main/java/net/tropicraft/core/common/dimension/feature/jigsaw/SpawnerProcessor.java | package net.tropicraft.core.common.dimension.feature.jigsaw;
import com.mojang.serialization.MapCodec;
import com.mojang.serialization.codecs.RecordCodecBuilder;
import net.minecraft.core.BlockPos;
import net.minecraft.nbt.CompoundTag;
import net.minecraft.resources.ResourceLocation;
import net.minecraft.world.level.LevelReader;
import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.Blocks;
import net.minecraft.world.level.levelgen.structure.templatesystem.StructurePlaceSettings;
import net.minecraft.world.level.levelgen.structure.templatesystem.StructureProcessor;
import net.minecraft.world.level.levelgen.structure.templatesystem.StructureProcessorType;
import net.minecraft.world.level.levelgen.structure.templatesystem.StructureTemplate;
import net.tropicraft.core.common.entity.TropicraftEntities;
import javax.annotation.Nullable;
import java.util.List;
public class SpawnerProcessor extends StructureProcessor {
public static final SpawnerProcessor IGUANA = new SpawnerProcessor(List.of(TropicraftEntities.IGUANA.getId()));
public static final SpawnerProcessor ASHEN = new SpawnerProcessor(List.of(TropicraftEntities.ASHEN.getId()));
public static final SpawnerProcessor EIH = new SpawnerProcessor(List.of(TropicraftEntities.EIH.getId()));
public static final SpawnerProcessor IGUANA_AND_ASHEN = new SpawnerProcessor(List.of(TropicraftEntities.ASHEN.getId(), TropicraftEntities.IGUANA.getId()));
public static final MapCodec<SpawnerProcessor> CODEC = RecordCodecBuilder.mapCodec(i -> i.group(
ResourceLocation.CODEC.listOf().fieldOf("entity_types").forGetter(p -> p.entityTypes)
).apply(i, SpawnerProcessor::new));
private final List<ResourceLocation> entityTypes;
public SpawnerProcessor(List<ResourceLocation> entityTypes) {
this.entityTypes = entityTypes;
}
@Override
protected StructureProcessorType<?> getType() {
return TropicraftProcessorTypes.SPAWNER.get();
}
@Override
@Nullable
public StructureTemplate.StructureBlockInfo process(LevelReader world, BlockPos pos, BlockPos pos2, StructureTemplate.StructureBlockInfo originalBlockInfo, StructureTemplate.StructureBlockInfo blockInfo, StructurePlaceSettings settings, @Nullable StructureTemplate template) {
Block block = blockInfo.state().getBlock();
if (block != Blocks.SPAWNER) {
return blockInfo;
}
String typeName = entityTypes.getFirst().toString();
CompoundTag spawnData = blockInfo.nbt().getCompoundOrEmpty("SpawnData");
spawnData.putString("id", typeName);
// TODO not working
blockInfo.nbt().getList("SpawnPotentials").ifPresent(list -> {
for (int i = 0; i < list.size(); i++) {
CompoundTag nbt = list.getCompoundOrEmpty(i);
nbt.getCompoundOrEmpty("Entity").putString("id", typeName);
}
});
blockInfo.nbt().put("SpawnData", spawnData);
return blockInfo;
}
}
| 1 | 0.870022 | 1 | 0.870022 | game-dev | MEDIA | 0.996108 | game-dev | 0.803443 | 1 | 0.803443 |
MahmoudElsayedEssa/Particlize | 61,505 | app/src/main/java/com/binissa/particlize/showcase/Showcase.kt | package com.binissa.particlize.showcase
import android.graphics.Color
import com.binissa.particlize.lib.config.EffectBuilder
import com.binissa.particlize.lib.core.model.ContentDisappearanceMode
import com.binissa.particlize.lib.core.model.ParticleEffect
import com.binissa.particlize.lib.renderer.canvas.shapes.CanvasCircleShape
import com.binissa.particlize.lib.renderer.canvas.shapes.CanvasRectangleShape
import com.binissa.particlize.lib.renderer.canvas.shapes.CanvasStarShape
import com.binissa.particlize.lib.strategy.appearance.ColorTransformStrategy
import com.binissa.particlize.lib.strategy.appearance.FadeStrategy
import com.binissa.particlize.lib.strategy.appearance.RotationStrategy
import com.binissa.particlize.lib.strategy.appearance.ScaleStrategy
import com.binissa.particlize.lib.strategy.emission.AssemblyEmissionStrategy
import com.binissa.particlize.lib.strategy.emission.DirectionalEmissionStrategy
import com.binissa.particlize.lib.strategy.emission.InstantEmissionStrategy
import com.binissa.particlize.lib.strategy.emission.PatternEmissionStrategy
import com.binissa.particlize.lib.strategy.emission.RadialEmissionStrategy
import com.binissa.particlize.lib.strategy.emission.RandomEmissionStrategy
import com.binissa.particlize.lib.strategy.physics.AssemblyPhysicsStrategy
import com.binissa.particlize.lib.strategy.physics.DriftPhysics
import com.binissa.particlize.lib.strategy.physics.ExplosionPhysicsStrategy
import com.binissa.particlize.lib.strategy.physics.GravityWellPhysics
import com.binissa.particlize.lib.strategy.physics.RandomFirePhysicsStrategy
import com.binissa.particlize.lib.strategy.physics.VortexPhysics
import kotlin.time.Duration.Companion.milliseconds
/**
* Data models for showcase items
*/
data class ShowcaseItem(
val title: String, val effect: ParticleEffect
)
data class PhysicsShowcaseItem(
val title: String, val effect: ParticleEffect, val description: String
)
data class AssemblyShowcaseItem(
val title: String, val effect: ParticleEffect, val description: String
)
// DirectionalEmissionStrategy showcase items
val directionalShowcaseItems = listOf(
ShowcaseItem(
title = "Left to Right",
effect = EffectBuilder().withName("Left to Right").withDuration(2000.milliseconds)
.withEmissionStrategy(
DirectionalEmissionStrategy(
direction = DirectionalEmissionStrategy.Direction.LEFT_TO_RIGHT,
emissionRate = 3,
emissionDelay = 50.milliseconds
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.5f, verticalStrength = 0.2f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleDensity(6).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withMaxEmissionsPerFrame(500)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
), ShowcaseItem(
title = "Right to Left",
effect = EffectBuilder().withName("Right to Left").withDuration(2000.milliseconds)
.withEmissionStrategy(
DirectionalEmissionStrategy(
direction = DirectionalEmissionStrategy.Direction.RIGHT_TO_LEFT,
emissionRate = 3,
emissionDelay = 50.milliseconds
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.5f, verticalStrength = 0.2f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
), ShowcaseItem(
title = "Top to Bottom",
effect = EffectBuilder().withName("Top to Bottom").withDuration(2000.milliseconds)
.withEmissionStrategy(
DirectionalEmissionStrategy(
direction = DirectionalEmissionStrategy.Direction.TOP_TO_BOTTOM,
emissionRate = 3,
emissionDelay = 50.milliseconds
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.2f, verticalStrength = 0.7f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
), ShowcaseItem(
title = "Bottom to Top",
effect = EffectBuilder().withName("Bottom to Top").withDuration(2000.milliseconds)
.withEmissionStrategy(
DirectionalEmissionStrategy(
direction = DirectionalEmissionStrategy.Direction.BOTTOM_TO_TOP,
emissionRate = 3,
emissionDelay = 50.milliseconds
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.2f, verticalStrength = 0.7f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
)
)
// RadialEmissionStrategy showcase items
val radialShowcaseItems = listOf(
ShowcaseItem(
title = "Center Out",
effect = EffectBuilder().withName("Center Out").withDuration(2000.milliseconds)
.withEmissionStrategy(
RadialEmissionStrategy(
radiationMode = RadialEmissionStrategy.RadiationMode.CENTER_OUT
)
).withPhysicsStrategy(
ExplosionPhysicsStrategy(
initialVelocityMin = 2f, initialVelocityMax = 5f, gravityY = 0f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
), ShowcaseItem(
title = "Edge In",
effect = EffectBuilder().withName("Edge In").withDuration(2000.milliseconds)
.withEmissionStrategy(
RadialEmissionStrategy(
radiationMode = RadialEmissionStrategy.RadiationMode.EDGE_IN
)
).withPhysicsStrategy(
GravityWellPhysics(
wells = listOf(
GravityWellPhysics.GravityWell(
strength = 1.5f, isRepulsive = false
)
)
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
), ShowcaseItem(
title = "Explosion",
effect = EffectBuilder().withName("Explosion").withDuration(2000.milliseconds)
.withEmissionStrategy(
RadialEmissionStrategy(
radiationMode = RadialEmissionStrategy.RadiationMode.EXPLOSION
)
).withPhysicsStrategy(
ExplosionPhysicsStrategy(
initialVelocityMin = 3f, initialVelocityMax = 7f, gravityY = 0.1f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withMaxEmissionsPerFrame(500).withParticleDensity(5)
.withContentDisappearanceMode(ContentDisappearanceMode.INSTANT).build()
), ShowcaseItem(
title = "Implosion",
effect = EffectBuilder().withName("Implosion").withDuration(2000.milliseconds)
.withEmissionStrategy(
RadialEmissionStrategy(
radiationMode = RadialEmissionStrategy.RadiationMode.IMPLOSION
)
).withPhysicsStrategy(
GravityWellPhysics(
wells = listOf(
GravityWellPhysics.GravityWell(
strength = 2.0f,
isRepulsive = false,
falloff = GravityWellPhysics.GravityWell.Falloff.INVERSE_SQUARE
)
), initialVelocity = 0.3f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withAppearanceStrategy(
ScaleStrategy(
scaleMode = ScaleStrategy.ScaleMode.SHRINK, minScale = 0.1f, maxScale = 1.0f
)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.INSTANT).build()
)
)
// PatternEmissionStrategy showcase items
val patternShowcaseItems = listOf(
ShowcaseItem(
title = "Spiral",
effect = EffectBuilder().withName("Spiral").withDuration(2500.milliseconds)
.withEmissionStrategy(
PatternEmissionStrategy(
pattern = PatternEmissionStrategy.Pattern.SPIRAL, clockwise = true
)
).withPhysicsStrategy(
VortexPhysics(
rotationSpeed = 1.5f, pullStrength = 0.2f, clockwise = true
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(5)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
), ShowcaseItem(
title = "Vortex",
effect = EffectBuilder().withName("Vortex").withDuration(2500.milliseconds)
.withEmissionStrategy(
PatternEmissionStrategy(
pattern = PatternEmissionStrategy.Pattern.VORTEX, clockwise = true
)
).withPhysicsStrategy(
VortexPhysics(
rotationSpeed = 2.0f, pullStrength = 0.3f, turbulence = 0.2f, clockwise = true
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(5)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
), ShowcaseItem(
title = "Ripple",
effect = EffectBuilder().withName("Ripple").withDuration(2500.milliseconds)
.withEmissionStrategy(
PatternEmissionStrategy(
pattern = PatternEmissionStrategy.Pattern.RIPPLE
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.3f,
verticalStrength = 0.3f,
directionVariance = 60f,
turbulenceStrength = 0.1f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(5)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
), ShowcaseItem(
title = "Grid",
effect = EffectBuilder().withName("Grid").withDuration(2500.milliseconds)
.withEmissionStrategy(
PatternEmissionStrategy(
pattern = PatternEmissionStrategy.Pattern.GRID
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.3f, verticalStrength = 0.3f, directionVariance = 30f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(5)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
), ShowcaseItem(
title = "Zigzag",
effect = EffectBuilder().withName("Zigzag").withDuration(2500.milliseconds)
.withEmissionStrategy(
PatternEmissionStrategy(
pattern = PatternEmissionStrategy.Pattern.ZIGZAG
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.5f, verticalStrength = 0.3f, directionVariance = 45f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(5)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
), ShowcaseItem(
title = "Heartbeat",
effect = EffectBuilder().withName("Heartbeat").withDuration(2500.milliseconds)
.withEmissionStrategy(
PatternEmissionStrategy(
pattern = PatternEmissionStrategy.Pattern.HEARTBEAT
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.3f,
verticalStrength = 0.3f,
directionVariance = 60f,
gravity = 0.1f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.PULSE)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(5)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
), ShowcaseItem(
title = "Shatter",
effect = EffectBuilder().withName("Shatter").withDuration(1800.milliseconds)
.withEmissionStrategy(
PatternEmissionStrategy(
pattern = PatternEmissionStrategy.Pattern.SHATTER
)
).withPhysicsStrategy(
ExplosionPhysicsStrategy(
initialVelocityMin = 2f, initialVelocityMax = 5f, gravityY = 0.1f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleShape(CanvasRectangleShape())
.withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withMaxEmissionsPerFrame(500).withParticleDensity(5)
.withContentDisappearanceMode(ContentDisappearanceMode.INSTANT).build()
)
)
// RandomEmissionStrategy showcase items
val randomShowcaseItems = listOf(
ShowcaseItem(
title = "Pure Random",
effect = EffectBuilder().withName("Pure Random").withDuration(2000.milliseconds)
.withEmissionStrategy(
RandomEmissionStrategy(
randomnessMode = RandomEmissionStrategy.RandomnessMode.PURE_RANDOM
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.5f, verticalStrength = 0.5f, directionVariance = 60f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
), ShowcaseItem(
title = "Clustered",
effect = EffectBuilder().withName("Clustered").withDuration(2000.milliseconds)
.withEmissionStrategy(
RandomEmissionStrategy(
randomnessMode = RandomEmissionStrategy.RandomnessMode.CLUSTERED
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.5f, verticalStrength = 0.5f, directionVariance = 60f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
), ShowcaseItem(
title = "Chaotic",
effect = EffectBuilder().withName("Chaotic").withDuration(2000.milliseconds)
.withEmissionStrategy(
RandomEmissionStrategy(
randomnessMode = RandomEmissionStrategy.RandomnessMode.CHAOTIC
)
).withPhysicsStrategy(
RandomFirePhysicsStrategy(
velocityMin = 1f, velocityMax = 4f, turbulence = 0.5f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
), ShowcaseItem(
title = "Popcorn",
effect = EffectBuilder().withName("Popcorn").withDuration(2000.milliseconds)
.withEmissionStrategy(
RandomEmissionStrategy(
randomnessMode = RandomEmissionStrategy.RandomnessMode.POPCORN, groupSize = 8
)
).withPhysicsStrategy(
RandomFirePhysicsStrategy(
velocityMin = 2f, velocityMax = 5f, gravityMin = 0.05f, gravityMax = 0.15f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
)
)
// InstantEmissionStrategy showcase items
val instantShowcaseItems = listOf(
ShowcaseItem(
title = "Random Sort",
effect = EffectBuilder().withName("Random Sort").withDuration(1500.milliseconds)
.withEmissionStrategy(
InstantEmissionStrategy(
burstDurationMs = 100, sortMode = InstantEmissionStrategy.SortMode.RANDOM
)
).withPhysicsStrategy(
ExplosionPhysicsStrategy(
initialVelocityMin = 2f, initialVelocityMax = 5f, gravityY = 0.1f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.INSTANT).build()
), ShowcaseItem(
title = "Inside Out",
effect = EffectBuilder().withName("Inside Out").withDuration(1500.milliseconds)
.withEmissionStrategy(
InstantEmissionStrategy(
burstDurationMs = 100, sortMode = InstantEmissionStrategy.SortMode.INSIDE_OUT
)
).withPhysicsStrategy(
ExplosionPhysicsStrategy(
initialVelocityMin = 2f, initialVelocityMax = 5f, gravityY = 0.1f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.INSTANT).build()
), ShowcaseItem(
title = "Outside In",
effect = EffectBuilder().withName("Outside In").withDuration(1500.milliseconds)
.withEmissionStrategy(
InstantEmissionStrategy(
burstDurationMs = 100, sortMode = InstantEmissionStrategy.SortMode.OUTSIDE_IN
)
).withPhysicsStrategy(
ExplosionPhysicsStrategy(
initialVelocityMin = 2f, initialVelocityMax = 5f, gravityY = 0.1f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.INSTANT).build()
), ShowcaseItem(
title = "Left to Right",
effect = EffectBuilder().withName("Left to Right").withDuration(1500.milliseconds)
.withEmissionStrategy(
InstantEmissionStrategy(
burstDurationMs = 100, sortMode = InstantEmissionStrategy.SortMode.LEFT_TO_RIGHT
)
).withPhysicsStrategy(
ExplosionPhysicsStrategy(
initialVelocityMin = 2f, initialVelocityMax = 5f, gravityY = 0.1f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.INSTANT).build()
)
)
// Physics showcase items
val physicsShowcaseItems = listOf(
PhysicsShowcaseItem(
title = "Explosion Physics",
effect = EffectBuilder().withName("Explosion Physics").withDuration(2000.milliseconds)
.withEmissionStrategy(
RadialEmissionStrategy(
radiationMode = RadialEmissionStrategy.RadiationMode.CENTER_OUT
)
).withPhysicsStrategy(
ExplosionPhysicsStrategy(
initialVelocityMin = 3f,
initialVelocityMax = 7f,
velocityDecay = 0.96f,
gravityY = 0.12f,
randomness = 0.3f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(5)
.withContentDisappearanceMode(ContentDisappearanceMode.INSTANT).build(),
description = "Particles move outward with initial velocity, subject to gravity and decay"
), PhysicsShowcaseItem(
title = "Random Fire Physics",
effect = EffectBuilder().withName("Random Fire Physics").withDuration(2000.milliseconds)
.withEmissionStrategy(
RadialEmissionStrategy(
radiationMode = RadialEmissionStrategy.RadiationMode.CENTER_OUT
)
).withPhysicsStrategy(
RandomFirePhysicsStrategy(
velocityMin = 2f,
velocityMax = 6f,
accelerationMin = -0.4f,
accelerationMax = 0.6f,
gravityMin = 0.05f,
gravityMax = 0.15f,
turbulence = 0.7f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleShape(CanvasStarShape())
.withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(5)
.withContentDisappearanceMode(ContentDisappearanceMode.INSTANT).build(),
description = "Chaotic, unpredictable movement with random directional changes"
), PhysicsShowcaseItem(
title = "Vortex Physics",
effect = EffectBuilder().withName("Vortex Physics").withDuration(2500.milliseconds)
.withEmissionStrategy(
PatternEmissionStrategy(
pattern = PatternEmissionStrategy.Pattern.SPIRAL
)
).withPhysicsStrategy(
VortexPhysics(
rotationSpeed = 2.0f,
acceleration = 0.5f,
pullStrength = 0.3f,
initialOutwardForce = 0.2f,
turbulence = 0.2f,
clockwise = true
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(5)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build(),
description = "Swirling movement with rotation and inward/outward forces"
), PhysicsShowcaseItem(
title = "Gravity Well Physics",
effect = EffectBuilder().withName("Gravity Well Physics").withDuration(2500.milliseconds)
.withEmissionStrategy(
RadialEmissionStrategy(
radiationMode = RadialEmissionStrategy.RadiationMode.EDGE_IN
)
).withPhysicsStrategy(
GravityWellPhysics(
wells = listOf(
GravityWellPhysics.GravityWell(
strength = 2.0f,
isRepulsive = false,
falloff = GravityWellPhysics.GravityWell.Falloff.INVERSE_SQUARE
)
), damping = 0.98f, initialVelocity = 0.3f, turbulence = 0.1f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(5)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build(),
description = "Attraction or repulsion forces that pull particles like a black hole"
), PhysicsShowcaseItem(
title = "Drift Physics",
effect = EffectBuilder().withName("Drift Physics").withDuration(2000.milliseconds)
.withEmissionStrategy(
DirectionalEmissionStrategy(
direction = DirectionalEmissionStrategy.Direction.TOP_TO_BOTTOM,
emissionDelay = 50.milliseconds
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.5f,
verticalStrength = 1.0f,
directionAngle = 100f,
directionVariance = 30f,
horizontalBias = 0.2f,
verticalBias = 0.3f,
gravity = 0.15f,
windStrength = 0.3f,
windGustiness = 0.5f,
turbulenceStrength = 0.2f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build(),
description = "Gentle drifting movement with gravity, wind, and turbulence effects"
)
)
// Assembly strategy showcase items
val assemblyShowcaseItems = listOf(
AssemblyShowcaseItem(
title = "Random ",
effect = EffectBuilder().withName("Random Assembly").withDuration(3000.milliseconds)
.withEmissionStrategy(
AssemblyEmissionStrategy(
startPosition = AssemblyEmissionStrategy.StartPosition.RANDOM_OFFSCREEN,
assemblyOrder = AssemblyEmissionStrategy.AssemblyOrder.UNIFORM,
scatterFactor = 2.0f,
staggering = 0.3f
)
).withPhysicsStrategy(
AssemblyPhysicsStrategy(
speed = 1.0f,
jitter = 0.3f,
easingType = AssemblyPhysicsStrategy.EasingType.ELASTIC
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_IN)
).withAppearanceStrategy(
ScaleStrategy(
scaleMode = ScaleStrategy.ScaleMode.GROW, minScale = 0.3f, maxScale = 1.0f
)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(1000).withParticleDensity(4)
.withContentDisappearanceMode(ContentDisappearanceMode.ASSEMBLY).build(),
description = "Particles start from random offscreen positions and assemble uniformly"
), AssemblyShowcaseItem(
title = "From Bottom",
effect = EffectBuilder().withName("From Bottom").withDuration(3000.milliseconds)
.withEmissionStrategy(
AssemblyEmissionStrategy(
startPosition = AssemblyEmissionStrategy.StartPosition.FROM_BOTTOM,
assemblyOrder = AssemblyEmissionStrategy.AssemblyOrder.BOTTOM_TO_TOP,
scatterFactor = 1.5f,
staggering = 0.4f
)
).withPhysicsStrategy(
AssemblyPhysicsStrategy(
speed = 1.2f,
jitter = 0.2f,
easingType = AssemblyPhysicsStrategy.EasingType.SMOOTH
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_IN)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.ASSEMBLY).build(),
description = "Particles rise from the bottom of the screen, assembling from bottom to top"
), AssemblyShowcaseItem(
title = "From Top",
effect = EffectBuilder().withName("From Top").withDuration(3000.milliseconds)
.withEmissionStrategy(
AssemblyEmissionStrategy(
startPosition = AssemblyEmissionStrategy.StartPosition.FROM_TOP,
assemblyOrder = AssemblyEmissionStrategy.AssemblyOrder.TOP_TO_BOTTOM,
scatterFactor = 1.5f,
staggering = 0.4f
)
).withPhysicsStrategy(
AssemblyPhysicsStrategy(
speed = 1.2f,
jitter = 0.2f,
easingType = AssemblyPhysicsStrategy.EasingType.BOUNCE
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_IN)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.ASSEMBLY).build(),
description = "Particles fall from the top of the screen, assembling from top to bottom"
), AssemblyShowcaseItem(
title = "From Sides",
effect = EffectBuilder().withName("From Sides").withDuration(3000.milliseconds)
.withEmissionStrategy(
AssemblyEmissionStrategy(
startPosition = AssemblyEmissionStrategy.StartPosition.FROM_SIDES,
assemblyOrder = AssemblyEmissionStrategy.AssemblyOrder.LEFT_TO_RIGHT,
scatterFactor = 1.5f,
staggering = 0.4f
)
).withPhysicsStrategy(
AssemblyPhysicsStrategy(
speed = 1.2f,
jitter = 0.2f,
easingType = AssemblyPhysicsStrategy.EasingType.ELASTIC
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_IN)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.ASSEMBLY).build(),
description = "Particles come in from left and right sides, assembling from left to right"
), AssemblyShowcaseItem(
title = "Spiral In",
effect = EffectBuilder().withName("Spiral In").withDuration(3000.milliseconds)
.withEmissionStrategy(
AssemblyEmissionStrategy(
startPosition = AssemblyEmissionStrategy.StartPosition.SPIRAL_IN,
assemblyOrder = AssemblyEmissionStrategy.AssemblyOrder.OUTSIDE_IN,
scatterFactor = 2.0f,
staggering = 0.3f
)
).withPhysicsStrategy(
AssemblyPhysicsStrategy(
speed = 1.0f,
jitter = 0.2f,
easingType = AssemblyPhysicsStrategy.EasingType.SMOOTH
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_IN)
).withAppearanceStrategy(
RotationStrategy(
rotationSpeed = 120f, randomDirection = false
)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.ASSEMBLY).build(),
description = "Particles start in a spiral pattern and assemble from outside in"
), AssemblyShowcaseItem(
title = "Inside Out",
effect = EffectBuilder().withName("Inside Out").withDuration(3000.milliseconds)
.withEmissionStrategy(
AssemblyEmissionStrategy(
startPosition = AssemblyEmissionStrategy.StartPosition.RANDOM_OFFSCREEN,
assemblyOrder = AssemblyEmissionStrategy.AssemblyOrder.INSIDE_OUT,
scatterFactor = 2.0f,
staggering = 0.4f
)
).withPhysicsStrategy(
AssemblyPhysicsStrategy(
speed = 1.1f,
jitter = 0.2f,
easingType = AssemblyPhysicsStrategy.EasingType.ELASTIC
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_IN)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.ASSEMBLY).build(),
description = "Particles assemble starting from the center and moving outward"
), AssemblyShowcaseItem(
title = "Outside In",
effect = EffectBuilder().withName("Outside In").withDuration(3000.milliseconds)
.withEmissionStrategy(
AssemblyEmissionStrategy(
startPosition = AssemblyEmissionStrategy.StartPosition.RANDOM_OFFSCREEN,
assemblyOrder = AssemblyEmissionStrategy.AssemblyOrder.OUTSIDE_IN,
scatterFactor = 2.0f,
staggering = 0.4f
)
).withPhysicsStrategy(
AssemblyPhysicsStrategy(
speed = 1.1f,
jitter = 0.2f,
easingType = AssemblyPhysicsStrategy.EasingType.BOUNCE
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_IN)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.ASSEMBLY).build(),
description = "Particles assemble starting from the edges and moving inward"
)
)
// Fade strategy showcase items
val fadeShowcaseItems = listOf(
ShowcaseItem(
title = "Fade In",
effect = EffectBuilder().withName("Fade In").withDuration(2000.milliseconds)
.withEmissionStrategy(
RadialEmissionStrategy(
radiationMode = RadialEmissionStrategy.RadiationMode.CENTER_OUT
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.5f, verticalStrength = 0.5f, directionVariance = 60f
)
).withAppearanceStrategy(
FadeStrategy(
fadeMode = FadeStrategy.FadeMode.FADE_IN
)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
), ShowcaseItem(
title = "Fade Out",
effect = EffectBuilder().withName("Fade Out").withDuration(2000.milliseconds)
.withEmissionStrategy(
RadialEmissionStrategy(
radiationMode = RadialEmissionStrategy.RadiationMode.CENTER_OUT
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.5f, verticalStrength = 0.5f, directionVariance = 60f
)
).withAppearanceStrategy(
FadeStrategy(
fadeMode = FadeStrategy.FadeMode.FADE_OUT
)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
), ShowcaseItem(
title = "Pulse",
effect = EffectBuilder().withName("Pulse").withDuration(2000.milliseconds)
.withEmissionStrategy(
RadialEmissionStrategy(
radiationMode = RadialEmissionStrategy.RadiationMode.CENTER_OUT
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.5f, verticalStrength = 0.5f, directionVariance = 60f
)
).withAppearanceStrategy(
FadeStrategy(
fadeMode = FadeStrategy.FadeMode.PULSE
)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
), ShowcaseItem(
title = "Delayed Fade",
effect = EffectBuilder().withName("Delayed Fade").withDuration(2000.milliseconds)
.withEmissionStrategy(
RadialEmissionStrategy(
radiationMode = RadialEmissionStrategy.RadiationMode.CENTER_OUT
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.5f, verticalStrength = 0.5f, directionVariance = 60f
)
).withAppearanceStrategy(
FadeStrategy(
fadeMode = FadeStrategy.FadeMode.FADE_OUT, fadeStartDelay = 500.milliseconds
)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
)
)
// Scale strategy showcase items
val scaleShowcaseItems = listOf(
ShowcaseItem(
title = "Grow",
effect = EffectBuilder().withName("Grow").withDuration(2000.milliseconds)
.withEmissionStrategy(
RadialEmissionStrategy(
radiationMode = RadialEmissionStrategy.RadiationMode.CENTER_OUT
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.5f, verticalStrength = 0.5f, directionVariance = 60f
)
).withAppearanceStrategy(
ScaleStrategy(
scaleMode = ScaleStrategy.ScaleMode.GROW, minScale = 0.2f, maxScale = 1.5f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
), ShowcaseItem(
title = "Shrink",
effect = EffectBuilder().withName("Shrink").withDuration(2000.milliseconds)
.withEmissionStrategy(
RadialEmissionStrategy(
radiationMode = RadialEmissionStrategy.RadiationMode.CENTER_OUT
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.5f, verticalStrength = 0.5f, directionVariance = 60f
)
).withAppearanceStrategy(
ScaleStrategy(
scaleMode = ScaleStrategy.ScaleMode.SHRINK, minScale = 0.2f, maxScale = 1.0f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
), ShowcaseItem(
title = "Pulse",
effect = EffectBuilder().withName("Scale Pulse").withDuration(2000.milliseconds)
.withEmissionStrategy(
RadialEmissionStrategy(
radiationMode = RadialEmissionStrategy.RadiationMode.CENTER_OUT
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.5f, verticalStrength = 0.5f, directionVariance = 60f
)
).withAppearanceStrategy(
ScaleStrategy(
scaleMode = ScaleStrategy.ScaleMode.PULSE, minScale = 0.5f, maxScale = 1.5f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
)
)
// Rotation strategy showcase items
val rotationShowcaseItems = listOf(
ShowcaseItem(
title = "Clockwise",
effect = EffectBuilder().withName("Clockwise").withDuration(2000.milliseconds)
.withEmissionStrategy(
RadialEmissionStrategy(
radiationMode = RadialEmissionStrategy.RadiationMode.CENTER_OUT
)
).withParticleShape(CanvasRectangleShape()).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.5f, verticalStrength = 0.5f, directionVariance = 60f
)
).withAppearanceStrategy(
RotationStrategy(
rotationSpeed = 180f, randomDirection = false
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
), ShowcaseItem(
title = "Random Direction",
effect = EffectBuilder().withName("Random Direction").withDuration(2000.milliseconds)
.withEmissionStrategy(
RadialEmissionStrategy(
radiationMode = RadialEmissionStrategy.RadiationMode.CENTER_OUT
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.5f, verticalStrength = 0.5f, directionVariance = 60f
)
).withParticleShape(CanvasRectangleShape()).withAppearanceStrategy(
RotationStrategy(
rotationSpeed = 180f, randomDirection = true
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
), ShowcaseItem(
title = "Accelerating",
effect = EffectBuilder().withName("Accelerating").withDuration(2000.milliseconds)
.withEmissionStrategy(
RadialEmissionStrategy(
radiationMode = RadialEmissionStrategy.RadiationMode.CENTER_OUT
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.5f, verticalStrength = 0.5f, directionVariance = 60f
)
).withParticleShape(CanvasRectangleShape()).withAppearanceStrategy(
RotationStrategy(
rotationSpeed = 90f, randomDirection = true, rotationAcceleration = 2f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
)
)
// Color transform strategy showcase items
val colorShowcaseItems = listOf(
ShowcaseItem(
title = "To Red",
effect = EffectBuilder().withName("To Red").withDuration(2000.milliseconds)
.withEmissionStrategy(
RadialEmissionStrategy(
radiationMode = RadialEmissionStrategy.RadiationMode.CENTER_OUT
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.5f, verticalStrength = 0.5f, directionVariance = 60f
)
).withAppearanceStrategy(
ColorTransformStrategy(
targetColor = Color.RED, duration = 1000.milliseconds
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
), ShowcaseItem(
title = "To Gold",
effect = EffectBuilder().withName("To Gold").withDuration(2000.milliseconds)
.withEmissionStrategy(
RadialEmissionStrategy(
radiationMode = RadialEmissionStrategy.RadiationMode.CENTER_OUT
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.5f, verticalStrength = 0.5f, directionVariance = 60f
)
).withAppearanceStrategy(
ColorTransformStrategy(
targetColor = Color.rgb(255, 215, 0), // Gold
duration = 1000.milliseconds
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
), ShowcaseItem(
title = "Delayed Transform",
effect = EffectBuilder().withName("Delayed Transform").withDuration(2000.milliseconds)
.withEmissionStrategy(
RadialEmissionStrategy(
radiationMode = RadialEmissionStrategy.RadiationMode.CENTER_OUT
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.5f, verticalStrength = 0.5f, directionVariance = 60f
)
).withAppearanceStrategy(
ColorTransformStrategy(
targetColor = Color.BLUE,
startDelay = 500.milliseconds,
duration = 500.milliseconds
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
)
)
// Shape showcase items
val shapeShowcaseItems = listOf(
ShowcaseItem(
title = "Circle",
effect = EffectBuilder().withName("Circle").withDuration(2000.milliseconds)
.withEmissionStrategy(
RadialEmissionStrategy(
radiationMode = RadialEmissionStrategy.RadiationMode.CENTER_OUT
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.5f, verticalStrength = 0.5f, directionVariance = 60f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withParticleShape(CanvasCircleShape())
.withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
), ShowcaseItem(
title = "Rectangle",
effect = EffectBuilder().withName("Rectangle").withDuration(2000.milliseconds)
.withEmissionStrategy(
RadialEmissionStrategy(
radiationMode = RadialEmissionStrategy.RadiationMode.CENTER_OUT
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.5f, verticalStrength = 0.5f, directionVariance = 60f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withAppearanceStrategy(
RotationStrategy(
rotationSpeed = 90f, randomDirection = true
)
).withParticleShape(CanvasRectangleShape())
.withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
), ShowcaseItem(
title = "Star",
effect = EffectBuilder().withName("Star").withDuration(2000.milliseconds)
.withEmissionStrategy(
RadialEmissionStrategy(
radiationMode = RadialEmissionStrategy.RadiationMode.CENTER_OUT
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.5f, verticalStrength = 0.5f, directionVariance = 60f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withAppearanceStrategy(
RotationStrategy(
rotationSpeed = 45f, randomDirection = true
)
).withParticleShape(CanvasStarShape())
.withParticleLifetime(4000.milliseconds, 4500.milliseconds)
.withMaxEmissionsPerFrame(500).withParticleDensity(6)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
)
)
val confettiShowcaseItems = listOf(
ShowcaseItem(
title = "Party Confetti",
effect = EffectBuilder().withName("Party Confetti").withDuration(2000.milliseconds)
.withEmissionStrategy(
RadialEmissionStrategy(
radiationMode = RadialEmissionStrategy.RadiationMode.CENTER_OUT
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.5f,
verticalStrength = 1.2f,
directionAngle = 90f, // Down
directionVariance = 45f,
gravity = 0.2f,
turbulenceStrength = 0.3f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withAppearanceStrategy(
RotationStrategy(
rotationSpeed = 180f, randomDirection = true
)
).withParticleShape(CanvasCircleShape())
.withParticleLifetime(1000.milliseconds, 1800.milliseconds).withParticleDensity(4)
.withContentDisappearanceMode(ContentDisappearanceMode.INSTANT).build()
), ShowcaseItem(
title = "Celebration",
effect = EffectBuilder().withName("Celebration").withDuration(2000.milliseconds)
.withEmissionStrategy(
RadialEmissionStrategy(
radiationMode = RadialEmissionStrategy.RadiationMode.CENTER_OUT
)
).withPhysicsStrategy(
ExplosionPhysicsStrategy(
initialVelocityMin = 4f,
initialVelocityMax = 8f,
gravityY = 0.15f,
randomness = 0.5f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.PULSE)
).withAppearanceStrategy(
RotationStrategy(
rotationSpeed = 180f, randomDirection = true
)
).withParticleShape(CanvasStarShape())
.withParticleLifetime(1200.milliseconds, 1800.milliseconds).withParticleDensity(5)
.withContentDisappearanceMode(ContentDisappearanceMode.INSTANT).build()
), ShowcaseItem(
title = "Rain Down",
effect = EffectBuilder().withName("Rain Down").withDuration(2500.milliseconds)
.withEmissionStrategy(
DirectionalEmissionStrategy(
direction = DirectionalEmissionStrategy.Direction.TOP_TO_BOTTOM,
emissionRate = 4,
emissionDelayMs = 50
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.3f,
verticalStrength = 1.5f,
directionAngle = 90f, // Down
directionVariance = 20f,
gravity = 0.25f,
windStrength = 0.2f,
windGustiness = 0.5f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withAppearanceStrategy(
RotationStrategy(
rotationSpeed = 90f, randomDirection = true
)
).withParticleLifetime(1500.milliseconds, 2000.milliseconds).withParticleDensity(5)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
)
)
val otherShowcaseItems = listOf(
ShowcaseItem(
title = "Magic Sparkle",
effect = EffectBuilder().withName("Magic Sparkle").withDuration(2000.milliseconds)
.withEmissionStrategy(
PatternEmissionStrategy(
pattern = PatternEmissionStrategy.Pattern.SPIRAL,
clockwise = true,
randomVariation = 0.2f
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.5f,
verticalStrength = 0.5f,
directionAngle = -30f, // Up and right
gravity = -0.05f, // Slight upward drift
turbulenceStrength = 0.2f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.PULSE)
).withAppearanceStrategy(
ScaleStrategy(
scaleMode = ScaleStrategy.ScaleMode.PULSE, minScale = 0.5f, maxScale = 1.5f
)
).withAppearanceStrategy(
RotationStrategy(
rotationSpeed = 90f, randomDirection = true
)
).withParticleShape(CanvasStarShape())
.withParticleLifetime(1200.milliseconds, 1800.milliseconds).withParticleDensity(5)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
),
ShowcaseItem(
title = "Magic Sparkle2",
effect = EffectBuilder()
.withName("Magic Sparkle 2")
.withDuration(5000.milliseconds)
.withEmissionStrategy(
RandomEmissionStrategy()
).withPhysicsStrategy(
RandomFirePhysicsStrategy()
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withAppearanceStrategy(
ScaleStrategy(
scaleMode = ScaleStrategy.ScaleMode.GROW,
minScale = 0.5f,
maxScale = 1.5f,
scaleRate = 5f
)
)
.withAppearanceStrategy(
RotationStrategy(
randomDirection = true
)
).withParticleShape(CanvasStarShape())
.withParticleLifetime(8000.milliseconds, 10000.milliseconds).withParticleDensity(5)
.withMaxEmissionsPerFrame(10)
.withContentDisappearanceMode(ContentDisappearanceMode.NONE).build()
), ShowcaseItem(
title = "Thanos Effect Telegram Message Deletion",
effect = EffectBuilder().withName("Disintegration").withDuration(2500.milliseconds)
.withEmissionStrategy(
InstantEmissionStrategy(
sortMode = InstantEmissionStrategy.SortMode.LEFT_TO_RIGHT
)
).withPhysicsStrategy(
DriftPhysics(
horizontalStrength = 0.7f,
verticalStrength = 0.7f,
directionAngle = -135f, // Up-right drift
directionVariance = 30f,
gravity = 0.1f,
turbulenceStrength = 0.8f
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withAppearanceStrategy(
ScaleStrategy(
scaleMode = ScaleStrategy.ScaleMode.SHRINK, minScale = 0.1f, maxScale = 1.0f
)
).withParticleLifetime(1200.milliseconds, 1800.milliseconds).withParticleDensity(5)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
), ShowcaseItem(
title = "Black Hole",
effect = EffectBuilder().withName("Black Hole").withDuration(2500.milliseconds)
.withEmissionStrategy(
RadialEmissionStrategy(
radiationMode = RadialEmissionStrategy.RadiationMode.EDGE_IN
)
).withPhysicsStrategy(
VortexPhysics(
rotationSpeed = 2.0f, pullStrength = 0.5f, turbulence = 0.1f, clockwise = true
)
).withAppearanceStrategy(
FadeStrategy(FadeStrategy.FadeMode.FADE_OUT)
).withAppearanceStrategy(
ScaleStrategy(
scaleMode = ScaleStrategy.ScaleMode.SHRINK, minScale = 0.1f, maxScale = 1.0f
)
).withAppearanceStrategy(
RotationStrategy(
rotationSpeed = 90f, randomDirection = false, rotationAcceleration = 2.0f
)
).withParticleLifetime(1500.milliseconds, 2000.milliseconds).withParticleDensity(5)
.withContentDisappearanceMode(ContentDisappearanceMode.PROGRESSIVE).build()
)
)
| 1 | 0.726394 | 1 | 0.726394 | game-dev | MEDIA | 0.711761 | game-dev | 0.963531 | 1 | 0.963531 |
folgerwang/UnrealEngine | 13,406 | Engine/Plugins/Runtime/Steam/SteamController/Source/SteamController/Private/SteamController.cpp | // Copyright 1998-2019 Epic Games, Inc. All Rights Reserved.
#include "CoreMinimal.h"
#include "HAL/PlatformTime.h"
#include "HAL/PlatformProcess.h"
#include "Misc/Paths.h"
#include "GenericPlatform/GenericApplicationMessageHandler.h"
#include "Modules/ModuleManager.h"
#include "GenericPlatform/IInputInterface.h"
#include "IInputDevice.h"
#include "IInputDeviceModule.h"
#include "ISteamControllerPlugin.h"
#include "SteamControllerPrivate.h"
#include "GameFramework/InputSettings.h"
#include "ISteamControllerPlugin.h"
DEFINE_LOG_CATEGORY_STATIC(LogSteamController, Log, All);
#if WITH_STEAM_CONTROLLER
/** @todo - do something about this define */
#ifndef MAX_STEAM_CONTROLLERS
#define MAX_STEAM_CONTROLLERS 8
#endif
// Support function to load the proper version of the Steamworks library
bool LoadSteamModule()
{
#if PLATFORM_WINDOWS
#if PLATFORM_64BITS
void* SteamDLLHandle = nullptr;
FString RootSteamPath = FPaths::EngineDir() / FString::Printf(TEXT("Binaries/ThirdParty/Steamworks/%s/Win64/"), STEAM_SDK_VER_PATH);
FPlatformProcess::PushDllDirectory(*RootSteamPath);
SteamDLLHandle = FPlatformProcess::GetDllHandle(*(RootSteamPath + "steam_api64.dll"));
FPlatformProcess::PopDllDirectory(*RootSteamPath);
#else
FString RootSteamPath = FPaths::EngineDir() / FString::Printf(TEXT("Binaries/ThirdParty/Steamworks/%s/Win32/"), STEAM_SDK_VER_PATH);
FPlatformProcess::PushDllDirectory(*RootSteamPath);
SteamDLLHandle = FPlatformProcess::GetDllHandle(*(RootSteamPath + "steam_api.dll"));
FPlatformProcess::PopDllDirectory(*RootSteamPath);
#endif
#elif PLATFORM_MAC
void* SteamDLLHandle = FPlatformProcess::GetDllHandle(TEXT("libsteam_api.dylib"));
#elif PLATFORM_LINUX
void* SteamDLLHandle = FPlatformProcess::GetDllHandle(TEXT("libsteam_api.so"));
#endif //PLATFORM_WINDOWS
if (!SteamDLLHandle)
{
UE_LOG(LogSteamController, Warning, TEXT("Failed to load Steam library."));
return false;
}
return true;
}
class FSteamController : public IInputDevice
{
public:
FSteamController(const TSharedRef< FGenericApplicationMessageHandler >& InMessageHandler) :
InitialButtonRepeatDelay(0.2),
ButtonRepeatDelay(0.1),
MessageHandler(InMessageHandler),
bSteamAPIInitialized(false),
bSteamControllerInitialized(false),
InputSettings(nullptr)
{
// Attempt to load the Steam Library
if (!LoadSteamModule())
{
return;
}
// Initialize the API, so we can start calling SteamController functions
bSteamAPIInitialized = SteamAPI_Init();
// [RCL] 2015-01-23 FIXME: move to some other code than constructor so we can handle failures more gracefully
if (bSteamAPIInitialized && (SteamController() != nullptr))
{
bSteamControllerInitialized = SteamController()->Init();
InputSettings = GetDefault<UInputSettings>();
if (InputSettings != nullptr)
{
TArray<FName> ActionNames;
InputSettings->GetActionNames(ActionNames);
for (const FName ActionName : ActionNames)
{
ANSICHAR AnsiActionName[NAME_SIZE];
ActionName.GetPlainANSIString(AnsiActionName);
ControllerDigitalActionHandle_t DigitalActionHandle = SteamController()->GetDigitalActionHandle(AnsiActionName);
if (DigitalActionHandle > 0)
{
DigitalActionHandlesMap.Add(ActionName, DigitalActionHandle);
for (FControllerState& ControllerState : ControllerStates)
{
ControllerState.DigitalStatusMap.Add(ActionName, false);
ControllerState.DigitalRepeatTimeMap.Add(ActionName, 0.0);
}
}
}
TArray<FName> AxisNames;
InputSettings->GetAxisNames(AxisNames);
for (const FName AxisName : AxisNames)
{
ANSICHAR AnsiAxisName[NAME_SIZE];
AxisName.GetPlainANSIString(AnsiAxisName);
ControllerAnalogActionHandle_t AnalogActionHandle = SteamController()->GetAnalogActionHandle(AnsiAxisName);
if (AnalogActionHandle > 0)
{
AnalogActionHandlesMap.Add(AxisName, AnalogActionHandle);
for (FControllerState& ControllerState : ControllerStates)
{
ControllerAnalogActionData_t AnalogActionData;
AnalogActionData.x = 0.0f;
AnalogActionData.y = 0.0f;
ControllerState.AnalogStatusMap.Add(AxisName, AnalogActionData);
}
}
}
for (FInputActionKeyMapping ActionMapping : InputSettings->ActionMappings)
{
if (ActionMapping.Key.IsGamepadKey())
{
DigitalNamesToKeysMap.Add(ActionMapping.ActionName, ActionMapping.Key);
}
}
for (FInputAxisKeyMapping AxisMapping : InputSettings->AxisMappings)
{
if (AxisMapping.Key.IsGamepadKey() || AxisMapping.Key == EKeys::MouseX || AxisMapping.Key == EKeys::MouseY)
{
AxisNamesToKeysMap.Add(AxisMapping.AxisName, AxisMapping.Key);
}
}
}
}
else
{
UE_LOG(LogSteamController, Log, TEXT("SteamController is not available"));
}
}
virtual ~FSteamController()
{
if (SteamController() != nullptr)
{
SteamController()->Shutdown();
}
}
virtual void Tick( float DeltaTime ) override
{
}
virtual void SendControllerEvents() override
{
if (!bSteamControllerInitialized)
{
return;
}
double CurrentTime = FPlatformTime::Seconds();
ControllerHandle_t ControllerHandles[STEAM_CONTROLLER_MAX_COUNT];
int32 NumControllers = (int32)SteamController()->GetConnectedControllers(ControllerHandles);
for (int32 i = 0; i < NumControllers; i++)
{
ControllerHandle_t ControllerHandle = ControllerHandles[i];
FControllerState& ControllerState = ControllerStates[i];
for (auto It = DigitalActionHandlesMap.CreateConstIterator(); It; ++It)
{
FName DigitalActionName = It.Key();
ControllerDigitalActionData_t DigitalActionData = SteamController()->GetDigitalActionData(ControllerHandle, It.Value());
if (ControllerState.DigitalStatusMap[DigitalActionName] == false && DigitalActionData.bState)
{
MessageHandler->OnControllerButtonPressed(DigitalNamesToKeysMap[DigitalActionName].GetFName(), i, false);
ControllerState.DigitalRepeatTimeMap[DigitalActionName] = FPlatformTime::Seconds() + ButtonRepeatDelay;
}
else if (ControllerState.DigitalStatusMap[DigitalActionName] == true && !DigitalActionData.bState)
{
MessageHandler->OnControllerButtonReleased(DigitalNamesToKeysMap[DigitalActionName].GetFName(), i, false);
}
else if (ControllerState.DigitalStatusMap[DigitalActionName] == true && DigitalActionData.bState && ControllerState.DigitalRepeatTimeMap[DigitalActionName] <= CurrentTime)
{
ControllerState.DigitalRepeatTimeMap[DigitalActionName] += ButtonRepeatDelay;
MessageHandler->OnControllerButtonPressed(DigitalNamesToKeysMap[DigitalActionName].GetFName(), i, true);
}
ControllerState.DigitalStatusMap[DigitalActionName] = DigitalActionData.bState;
}
for (auto It = AnalogActionHandlesMap.CreateConstIterator(); It; ++It)
{
FName AnalogActionName = It.Key();
ControllerAnalogActionData_t AnalogActionData = SteamController()->GetAnalogActionData(ControllerHandle, It.Value());
if (AxisNamesToKeysMap[AnalogActionName] == EKeys::MouseX || AxisNamesToKeysMap[AnalogActionName] == EKeys::MouseY)
{
ControllerState.MouseX += AnalogActionData.x;
ControllerState.MouseY += AnalogActionData.y;
MessageHandler->OnRawMouseMove(AnalogActionData.x, AnalogActionData.y);
}
else if (AxisNamesToKeysMap[AnalogActionName] == EKeys::Gamepad_LeftX || AxisNamesToKeysMap[AnalogActionName] == EKeys::Gamepad_LeftY)
{
if (ControllerState.AnalogStatusMap[It.Key()].x != AnalogActionData.x)
{
MessageHandler->OnControllerAnalog(EKeys::Gamepad_LeftX.GetFName(), i, AnalogActionData.x);
}
if (ControllerState.AnalogStatusMap[It.Key()].y != AnalogActionData.y)
{
MessageHandler->OnControllerAnalog(EKeys::Gamepad_LeftY.GetFName(), i, AnalogActionData.y);
}
}
else if (AxisNamesToKeysMap[AnalogActionName] == EKeys::Gamepad_RightX || AxisNamesToKeysMap[AnalogActionName] == EKeys::Gamepad_RightY)
{
if (ControllerState.AnalogStatusMap[It.Key()].x != AnalogActionData.x)
{
MessageHandler->OnControllerAnalog(EKeys::Gamepad_RightX.GetFName(), i, AnalogActionData.x);
}
if (ControllerState.AnalogStatusMap[It.Key()].y != AnalogActionData.y)
{
MessageHandler->OnControllerAnalog(EKeys::Gamepad_RightY.GetFName(), i, AnalogActionData.y);
}
}
else if (AxisNamesToKeysMap[AnalogActionName] == EKeys::Gamepad_LeftTriggerAxis)
{
if (ControllerState.AnalogStatusMap[It.Key()].x != AnalogActionData.x)
{
MessageHandler->OnControllerAnalog(EKeys::Gamepad_LeftTriggerAxis.GetFName(), i, AnalogActionData.x);
}
}
else if (AxisNamesToKeysMap[AnalogActionName] == EKeys::Gamepad_RightTriggerAxis)
{
if (ControllerState.AnalogStatusMap[It.Key()].x != AnalogActionData.x)
{
MessageHandler->OnControllerAnalog(EKeys::Gamepad_RightTriggerAxis.GetFName(), i, AnalogActionData.x);
}
}
ControllerState.AnalogStatusMap[AnalogActionName] = AnalogActionData;
}
}
}
void SetChannelValue(int32 ControllerId, FForceFeedbackChannelType ChannelType, float Value) override
{
// Skip unless this is the large channels, which we consider to be the only SteamController feedback channels
if ((ChannelType != FForceFeedbackChannelType::LEFT_LARGE) && (ChannelType != FForceFeedbackChannelType::RIGHT_LARGE))
{
return;
}
if ((ControllerId >= 0) && (ControllerId < MAX_STEAM_CONTROLLERS))
{
FForceFeedbackValues Values;
if (ChannelType == FForceFeedbackChannelType::LEFT_LARGE)
{
Values.LeftLarge = Value;
}
else
{
Values.RightLarge = Value;
}
UpdateVibration(ControllerId, Values);
}
}
void SetChannelValues(int32 ControllerId, const FForceFeedbackValues &Values) override
{
if ((ControllerId >= 0) && (ControllerId < MAX_STEAM_CONTROLLERS))
{
UpdateVibration(ControllerId, Values);
}
}
void UpdateVibration(int32 ControllerId, const FForceFeedbackValues& ForceFeedbackValues)
{
// make sure there is a valid device for this controller
ISteamController* const Controller = SteamController();
if (Controller == nullptr || IsGamepadAttached() == false)
{
return;
}
ControllerHandle_t ControllerHandles[STEAM_CONTROLLER_MAX_COUNT];
int32 NumControllers = (int32)SteamController()->GetConnectedControllers(ControllerHandles);
if (ControllerHandles[ControllerId] == 0)
{
return;
}
// Steam discussion threads indicate that 4ms is the max length of the pulse, so multiply the values that are passed in by that to try and create the sensation
// of a "stronger" vibration
if (ForceFeedbackValues.LeftLarge > 0.f)
{
Controller->TriggerHapticPulse(ControllerHandles[ControllerId], ESteamControllerPad::k_ESteamControllerPad_Left, ForceFeedbackValues.LeftLarge * 4000.0f);
}
if (ForceFeedbackValues.RightLarge > 0.f)
{
Controller->TriggerHapticPulse(ControllerHandles[ControllerId], ESteamControllerPad::k_ESteamControllerPad_Right, ForceFeedbackValues.RightLarge * 4000.0f);
}
}
virtual void SetMessageHandler(const TSharedRef< FGenericApplicationMessageHandler >& InMessageHandler) override
{
MessageHandler = InMessageHandler;
}
virtual bool Exec(UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar) override
{
return false;
}
virtual bool IsGamepadAttached() const override
{
return (bSteamAPIInitialized && bSteamControllerInitialized);
}
private:
struct FControllerState
{
/** Analog status for all actions from previous frame, on a -1.0 to 1.0 range */
TMap<FName, ControllerAnalogActionData_t> AnalogStatusMap;
/** Button status for all actions from previous frame (pressed down or not) */
TMap<FName, bool> DigitalStatusMap;
/** List of times that if a button is still pressed counts as a "repeated press" */
TMap<FName, double> DigitalRepeatTimeMap;
/** Values for force feedback on this controller. We only consider the LEFT_LARGE channel for SteamControllers */
FForceFeedbackValues VibeValues;
int32 MouseX;
int32 MouseY;
FControllerState() : MouseX(0), MouseY(0) {}
};
/** Controller states */
FControllerState ControllerStates[MAX_STEAM_CONTROLLERS];
/** Delay before sending a repeat message after a button was first pressed */
double InitialButtonRepeatDelay;
/** Delay before sending a repeat message after a button has been pressed for a while */
double ButtonRepeatDelay;
/** handler to send all messages to */
TSharedRef<FGenericApplicationMessageHandler> MessageHandler;
/** SteamAPI initialized **/
bool bSteamAPIInitialized;
/** SteamController initialized **/
bool bSteamControllerInitialized;
/** Default input settings */
const UInputSettings* InputSettings;
TMap<FName, ControllerDigitalActionHandle_t> DigitalActionHandlesMap;
TMap<FName, ControllerAnalogActionHandle_t> AnalogActionHandlesMap;
TMap<FName, FKey> DigitalNamesToKeysMap;
TMap<FName, FKey> AxisNamesToKeysMap;
};
#endif // WITH_STEAM_CONTROLLER
class FSteamControllerPlugin : public IInputDeviceModule
{
virtual TSharedPtr< class IInputDevice > CreateInputDevice(const TSharedRef< FGenericApplicationMessageHandler >& InMessageHandler) override
{
#if WITH_STEAM_CONTROLLER
return TSharedPtr< class IInputDevice >(new FSteamController(InMessageHandler));
#else
return nullptr;
#endif
}
};
IMPLEMENT_MODULE( FSteamControllerPlugin, SteamController)
| 1 | 0.963181 | 1 | 0.963181 | game-dev | MEDIA | 0.554381 | game-dev | 0.727273 | 1 | 0.727273 |
blackbeard334/djoom3 | 41,819 | src/main/java/neo/Game/GameSys/Class.java | package neo.Game.GameSys;
import static neo.Game.Entity.EV_Activate;
import neo.CM.CollisionModel;
import neo.CM.CollisionModel.trace_s;
import neo.Game.AI.AI.idAI;
import neo.Game.Entity.idEntity;
import static neo.Game.GameSys.Class.idEventArg.toArg;
import static neo.Game.GameSys.Event.D_EVENT_ENTITY;
import static neo.Game.GameSys.Event.D_EVENT_FLOAT;
import static neo.Game.GameSys.Event.D_EVENT_INTEGER;
import static neo.Game.GameSys.Event.D_EVENT_MAXARGS;
import neo.Game.GameSys.Event.idEvent;
import neo.Game.GameSys.Event.idEventDef;
import neo.Game.GameSys.SaveGame.idRestoreGame;
import neo.Game.GameSys.SaveGame.idSaveGame;
import static neo.Game.GameSys.Event.D_EVENT_STRING;
import static neo.Game.GameSys.Event.D_EVENT_TRACE;
import static neo.Game.GameSys.Event.D_EVENT_VECTOR;
import static neo.Game.GameSys.Event.D_EVENT_VOID;
import static neo.Game.GameSys.SysCvar.g_debugTriggers;
import static neo.Game.Game_local.gameLocal;
import static neo.Game.Game_local.gameState_t.GAMESTATE_STARTUP;
import neo.Game.Projectile.idBFGProjectile;
import neo.Game.Projectile.idProjectile;
import neo.Game.Script.Script_Thread.idThread;
import neo.Game.Target.idTarget_Remove;
import neo.Game.Trigger.idTrigger_Multi;
import neo.TempDump;
import neo.TempDump.Deprecation_Exception;
import static neo.TempDump.NOT;
import neo.TempDump.TODO_Exception;
import static neo.TempDump.sizeof;
import neo.framework.CmdSystem.cmdFunction_t;
import neo.idlib.CmdArgs.idCmdArgs;
import neo.idlib.Text.Str.idStr;
import neo.idlib.containers.Hierarchy.idHierarchy;
import neo.idlib.containers.List.idList;
import static neo.idlib.math.Math_h.SEC2MS;
import neo.idlib.math.Math_h.idMath;
import neo.idlib.math.Vector;
import neo.idlib.math.Vector.idVec3;
import java.util.HashMap;
import java.util.Map;
/**
*
*/
public class Class {
public static final idEventDef EV_Remove = new idEventDef("<immediateremove>", null);
public static final idEventDef EV_SafeRemove = new idEventDef("remove", null);
// this is the head of a singly linked list of all the idTypes
static idTypeInfo typelist = null;
static idHierarchy<idTypeInfo> classHierarchy = new idHierarchy<>();
static int eventCallbackMemory = 0;
@FunctionalInterface
public interface eventCallback_t<T extends idClass> {
void accept(T t, idEventArg...args);
}
@FunctionalInterface
public interface eventCallback_t0<T extends idClass> extends eventCallback_t<T> {
@Override
default void accept(T t, idEventArg... args) {
accept(t);
}
void accept(T e);
}
@FunctionalInterface
public interface eventCallback_t1<T extends idClass> extends eventCallback_t<T> {
@Override
default void accept(T t, idEventArg... args) {
accept(t, args[0]);
}
void accept(T t, idEventArg a);
}
@FunctionalInterface
public interface eventCallback_t2<T extends idClass> extends eventCallback_t<T> {
@Override
default void accept(T t, idEventArg... args) {
accept(t, args[0], args[1]);
}
void accept(T t, idEventArg a, idEventArg b);
}
@FunctionalInterface
public interface eventCallback_t3<T extends idClass> extends eventCallback_t<T> {
@Override
default void accept(T t, idEventArg... args) {
accept(t, args[0], args[1], args[2]);
}
void accept(T t, idEventArg a, idEventArg b, idEventArg c);
}
@FunctionalInterface
public interface eventCallback_t4<T extends idClass> extends eventCallback_t<T> {
@Override
default void accept(T t, idEventArg... args) {
accept(t, args[0], args[1], args[2], args[3]);
}
void accept(T t, idEventArg a, idEventArg b, idEventArg c, idEventArg d);
}
@FunctionalInterface
public interface eventCallback_t5<T extends idClass> extends eventCallback_t<T> {
@Override
default void accept(T t, idEventArg... args) {
accept(t, args[0], args[1], args[2], args[3], args[4]);
}
void accept(T t, idEventArg a, idEventArg b, idEventArg c, idEventArg d, idEventArg e);
}
@FunctionalInterface
public interface eventCallback_t6<T extends idClass> extends eventCallback_t<T> {
@Override
default void accept(T t, idEventArg... args) {
accept(t, args[0], args[1], args[2], args[3], args[4], args[5]);
}
void accept(T t, idEventArg a, idEventArg b, idEventArg c, idEventArg d, idEventArg e, idEventArg f);
}
public static abstract class classSpawnFunc_t<type> {
public abstract type run();
}
public static abstract class idClass_Save {
public abstract void run(idSaveGame savefile);
}
public static abstract class idClass_Restore {
public abstract void run(idRestoreGame savefile);
}
public static class idEventFunc<type> {
idEventDef event;
eventCallback_t function;
};
public static class idEventArg<T> {
public final int type;
public final T value;
//
//
private idEventArg(T data) {
if(data instanceof Integer) type = D_EVENT_INTEGER;
else if(data instanceof Enum) type = D_EVENT_INTEGER;
else if(data instanceof Float) type = D_EVENT_FLOAT;
else if(data instanceof idVec3) type = D_EVENT_VECTOR;
else if(data instanceof idStr) type = D_EVENT_STRING;
else if(data instanceof String) type = D_EVENT_STRING;
else if(data instanceof idEntity) type = D_EVENT_ENTITY;
else if(data instanceof trace_s) type = D_EVENT_TRACE;
else {
// type = D_EVENT_VOID;
throw new TempDump.TypeErasure_Expection();
}
value = data;
}
private idEventArg(int type, T data) {
this.type = type;
value = data;
}
static <T> idEventArg<T> toArg(T data) {
return new idEventArg(data);
}
public static idEventArg<Integer> toArg(int data) {
return new idEventArg(D_EVENT_INTEGER, data);
}
public static idEventArg<Float> toArg(float data) {
return new idEventArg(D_EVENT_FLOAT, data);
}
public static idEventArg<idVec3> toArg(idVec3 data) {
return new idEventArg(D_EVENT_VECTOR, data);
}
public static idEventArg<idStr> toArg(idStr data) {
return new idEventArg(D_EVENT_STRING, data);
}
public static idEventArg<String> toArg(String data) {
return new idEventArg(D_EVENT_STRING, data);
}
public static idEventArg<idEntity> toArg(idEntity data) {
return new idEventArg(D_EVENT_ENTITY, data);
}
public static idEventArg<trace_s> toArg(trace_s data) {
return new idEventArg(D_EVENT_TRACE, data);
}
};
public static class idAllocError extends neo.idlib.Lib.idException {
public idAllocError(final String text /*= ""*/) {
super(text);
}
};
// /*
//================
//ABSTRACT_PROTOTYPE
//
//This macro must be included in the definition of any abstract subclass of idClass.
//It prototypes variables used in class instanciation and type checking.
//Use this on single inheritance abstract classes only.
//================
//*/
//#define ABSTRACT_PROTOTYPE( nameofclass ) \
//public: \
// static idTypeInfo Type; \
// static idClass *CreateInstance( void ); \
// virtual idTypeInfo *GetType( void ) const; \
// static idEventFunc<nameofclass> eventCallbacks[]
//
///*
//================
//ABSTRACT_DECLARATION
//
//This macro must be included in the code to properly initialize variables
//used in type checking. It also defines the list of events that the class
//responds to. Take special care to ensure that the proper superclass is
//indicated or the run-time tyep information will be incorrect. Use this
//on abstract classes only.
//================
//*/
//#define ABSTRACT_DECLARATION( nameofsuperclass, nameofclass ) \
// idTypeInfo nameofclass::Type( #nameofclass, #nameofsuperclass, \
// ( idEventFunc<idClass> * )nameofclass::eventCallbacks, nameofclass::CreateInstance, ( void ( idClass::* )( void ) )&nameofclass::Spawn, \
// ( void ( idClass::* )( idSaveGame * ) const )&nameofclass::Save, ( void ( idClass::* )( idRestoreGame * ) )&nameofclass::Restore ); \
// idClass *nameofclass::CreateInstance( void ) { \
// gameLocal.Error( "Cannot instanciate abstract class %s.", #nameofclass ); \
// return NULL; \
// } \
// idTypeInfo *nameofclass::GetType( void ) const { \
// return &( nameofclass::Type ); \
// } \
// idEventFunc<nameofclass> nameofclass::eventCallbacks[] = {
//
//typedef void ( idClass::*classSpawnFunc_t )( void );
//
//class idSaveGame;
//class idRestoreGame;
public static abstract class idClass/*<nameOfClass>*/ {
// public static final idTypeInfo Type = null;
private static Map<idEventDef, eventCallback_t> eventCallbacks = new HashMap<>();
static {
eventCallbacks.put(EV_Remove, (eventCallback_t0<idClass>) idClass::Event_Remove);
eventCallbacks.put(EV_SafeRemove, (eventCallback_t0<idClass>) idClass::Event_SafeRemove);
}
//
private static boolean initialized = false;
// alphabetical order
private static idList<idTypeInfo> types = new idList<>();
// typenum order
private static idList<idTypeInfo> typenums = new idList<>();
private static int typeNumBits = 0;
private static int memused = 0;
private static int numobjects = 0;
//
//
public abstract idClass CreateInstance();
public abstract java.lang.Class/*idTypeInfo*/ GetType();
public abstract eventCallback_t getEventCallBack(idEventDef event);
public static Map<idEventDef, eventCallback_t> getEventCallBacks() {
return eventCallbacks;
}
// #ifdef ID_REDIRECT_NEWDELETE
// #undef new
// #endif
//public Object operator new( size_t );
//public Object operator new( size_t s, int, int, char *, int );
//public void operator delete( void * );
//public void operator delete( void *, int, int, char *, int );
// #ifdef ID_REDIRECT_NEWDELETE
// #define new ID_DEBUG_NEW
// #endif
// virtual ~idClass();
protected void _deconstructor() {
idEvent.CancelEvents(this);
}
public void Spawn() {
}
public void CallSpawn() {
throw new TODO_Exception();
// java.lang.Class/*idTypeInfo*/ type;
//
// type = GetType();
// CallSpawnFunc(type);
}
/*
================
idClass::IsType
Checks if the object's class is a subclass of the class defined by the
passed in idTypeInfo.
================
*/
public boolean IsType(final java.lang.Class/*idTypeInfo*/ superclass) {
java.lang.Class/*idTypeInfo*/ subclass;
subclass = this.getClass();
return superclass.isAssignableFrom(subclass);
}
/*
================
idClass::GetClassname
Returns the text classname of the object.
================
*/
public String GetClassname() {
return this.getClass().getSimpleName();
}
/*
================
idClass::GetSuperclass
Returns the text classname of the superclass.
================
*/
public String GetSuperclass() {
throw new TODO_Exception();
// java.lang.Class/*idTypeInfo*/ cls;
//
// cls = GetType();
// return cls.superclass;
}
public void FindUninitializedMemory() {
//#ifdef ID_DEBUG_UNINITIALIZED_MEMORY
// unsigned long *ptr = ( ( unsigned long * )this ) - 1;
// int size = *ptr;
// assert( ( size & 3 ) == 0 );
// size >>= 2;
// for ( int i = 0; i < size; i++ ) {
// if ( ptr[i] == 0xcdcdcdcd ) {
// const char *varName = GetTypeVariableName( GetClassname(), i << 2 );
// gameLocal.Warning( "type '%s' has uninitialized variable %s (offset %d)", GetClassname(), varName, i << 2 );
// }
// }
//#endif
}
public void Save(idSaveGame savefile) {
}
public void Restore(idRestoreGame savefile) {
}
public boolean RespondsTo(final idEventDef ev) {
return getEventCallBack(ev) != null;//HACKME::7
// throw new TODO_Exception();
// final idTypeInfo c;
//
// assert (idEvent.initialized);
// c = GetType();
// return c.RespondsTo(ev);
}
public boolean PostEventMS(final idEventDef ev, int time) {
return PostEventArgs(ev, time, 0);
}
public boolean PostEventMS(final idEventDef ev, float time, Object arg1) {
return PostEventArgs(ev, (int) time, 1, toArg(arg1));
}
public boolean PostEventMS(final idEventDef ev, int time, Object arg1, Object arg2) {
return PostEventArgs(ev, time, 2, toArg(arg1), toArg(arg2));
}
public boolean PostEventMS(final idEventDef ev, int time, Object arg1, Object arg2, Object arg3) {
return PostEventArgs(ev, time, 3, toArg(arg1), toArg(arg2), toArg(arg3));
}
public boolean PostEventMS(final idEventDef ev, int time, Object arg1, Object arg2, Object arg3, Object arg4) {
return PostEventArgs(ev, time, 4, toArg(arg1), toArg(arg2), toArg(arg3), toArg(arg4));
}
public boolean PostEventMS(final idEventDef ev, int time, Object arg1, Object arg2, Object arg3, Object arg4, Object arg5) {
return PostEventArgs(ev, time, 5, toArg(arg1), toArg(arg2), toArg(arg3), toArg(arg4), toArg(arg5));
}
public boolean PostEventMS(final idEventDef ev, int time, Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6) {
return PostEventArgs(ev, time, 6, toArg(arg1), toArg(arg2), toArg(arg3), toArg(arg4), toArg(arg5), toArg(arg6));
}
public boolean PostEventMS(final idEventDef ev, int time, Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Object arg7) {
return PostEventArgs(ev, time, 7, toArg(arg1), toArg(arg2), toArg(arg3), toArg(arg4), toArg(arg5), toArg(arg6), toArg(arg7));
}
public boolean PostEventMS(final idEventDef ev, int time, Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Object arg7, Object arg8) {
return PostEventArgs(ev, time, 8, toArg(arg1), toArg(arg2), toArg(arg3), toArg(arg4), toArg(arg5), toArg(arg6), toArg(arg7), toArg(arg8));
}
public boolean PostEventSec(final idEventDef ev, float time) {
return PostEventArgs(ev, (int) SEC2MS(time), 0);
}
public boolean PostEventSec(final idEventDef ev, float time, idEventArg arg1) {
return PostEventArgs(ev, (int) SEC2MS(time), 1, arg1);
}
public boolean PostEventSec(final idEventDef ev, float time, Object arg1) {
return PostEventArgs(ev, (int) SEC2MS(time), 1, toArg(arg1));
}
public boolean PostEventSec(final idEventDef ev, float time, Object arg1, Object arg2) {
return PostEventArgs(ev, (int) SEC2MS(time), 2, toArg(arg1), toArg(arg2));
}
public boolean PostEventSec(final idEventDef ev, float time, Object arg1, Object arg2, Object arg3) {
return PostEventArgs(ev, (int) SEC2MS(time), 3, toArg(arg1), toArg(arg2), toArg(arg3));
}
public boolean PostEventSec(final idEventDef ev, float time, Object arg1, Object arg2, Object arg3, Object arg4) {
return PostEventArgs(ev, (int) SEC2MS(time), 4, toArg(arg1), toArg(arg2), toArg(arg3), toArg(arg4));
}
public boolean PostEventSec(final idEventDef ev, float time, Object arg1, Object arg2, Object arg3, Object arg4, Object arg5) {
return PostEventArgs(ev, (int) SEC2MS(time), 5, toArg(arg1), toArg(arg2), toArg(arg3), toArg(arg4), toArg(arg5));
}
public boolean PostEventSec(final idEventDef ev, float time, Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6) {
return PostEventArgs(ev, (int) SEC2MS(time), 6, toArg(arg1), toArg(arg2), toArg(arg3), toArg(arg4), toArg(arg5), toArg(arg6));
}
public boolean PostEventSec(final idEventDef ev, float time, Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Object arg7) {
return PostEventArgs(ev, (int) SEC2MS(time), 7, toArg(arg1), toArg(arg2), toArg(arg3), toArg(arg4), toArg(arg5), toArg(arg6), toArg(arg7));
}
public boolean PostEventSec(final idEventDef ev, float time, Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Object arg7, Object arg8) {
return PostEventArgs(ev, (int) SEC2MS(time), 8, toArg(arg1), toArg(arg2), toArg(arg3), toArg(arg4), toArg(arg5), toArg(arg6), toArg(arg7), toArg(arg8));
}
public boolean ProcessEvent(final idEventDef ev) {
return ProcessEventArgs(ev, 0);
}
public boolean ProcessEvent(final idEventDef ev, Object arg1) {
return ProcessEventArgs(ev, 1, toArg(arg1));
}
public boolean ProcessEvent(final idEventDef ev, idEntity arg1) {
return ProcessEventArgs(ev, 1, toArg(arg1));
}
public boolean ProcessEvent(final idEventDef ev, Object arg1, Object arg2) {
return ProcessEventArgs(ev, 2, toArg(arg1), toArg(arg2));
}
public boolean ProcessEvent(final idEventDef ev, Object arg1, Object arg2, Object arg3) {
return ProcessEventArgs(ev, 3, toArg(arg1), toArg(arg2), toArg(arg3));
}
public boolean ProcessEvent(final idEventDef ev, Object arg1, Object arg2, Object arg3, Object arg4) {
return ProcessEventArgs(ev, 4, toArg(arg1), toArg(arg2), toArg(arg3), toArg(arg4));
}
public boolean ProcessEvent(final idEventDef ev, Object arg1, Object arg2, Object arg3, Object arg4, Object arg5) {
return ProcessEventArgs(ev, 5, toArg(arg1), toArg(arg2), toArg(arg3), toArg(arg4), toArg(arg5));
}
public boolean ProcessEvent(final idEventDef ev, Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6) {
return ProcessEventArgs(ev, 6, toArg(arg1), toArg(arg2), toArg(arg3), toArg(arg4), toArg(arg5), toArg(arg6));
}
public boolean ProcessEvent(final idEventDef ev, Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Object arg7) {
return ProcessEventArgs(ev, 7, toArg(arg1), toArg(arg2), toArg(arg3), toArg(arg4), toArg(arg5), toArg(arg6), toArg(arg7));
}
public boolean ProcessEvent(final idEventDef ev, Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Object arg7, Object arg8) {
return ProcessEventArgs(ev, 8, toArg(arg1), toArg(arg2), toArg(arg3), toArg(arg4), toArg(arg5), toArg(arg6), toArg(arg7), toArg(arg8));
}
public boolean ProcessEventArgPtr(final idEventDef ev, idEventArg[] data) {
int num;
eventCallback_t callback;
assert (ev != null);
assert (idEvent.initialized);
if (g_debugTriggers.GetBool() && (ev == EV_Activate) && IsType(idEntity.class)) {
final String name;
if (data[0] != null && ((idClass) data[0].value).IsType(idEntity.class))
name = ((idEntity) data[0].value).GetName();
else
name = "NULL";
gameLocal.Printf("%d: '%s' activated by '%s'\n", gameLocal.framenum, ((idEntity) this).GetName(), name);
}
num = ev.GetEventNum();
callback = this.getEventCallBack(ev);//callback = c.eventMap[num];
if (callback == null) {
// we don't respond to this event, so ignore it
return false;
}
////
//// #if !CPU_EASYARGS
//// /*
//// on ppc architecture, floats are passed in a seperate set of registers
//// the function prototypes must have matching float declaration
//// http://developer.apple.com/documentation/DeveloperTools/Conceptual/MachORuntime/2rt_powerpc_abi/chapter_9_section_5.html
//// */
// // switch( ev.GetFormatspecIndex() ) {
// // case 1 << D_EVENT_MAXARGS :
// // ( this.*callback )();
// // break;
//// // generated file - see CREATE_EVENT_CODE
//// #include "Callbacks.cpp"
// // default:
// // gameLocal.Warning( "Invalid formatspec on event '%s'", ev.GetName() );
// // break;
// // }
//// #else
assert (D_EVENT_MAXARGS == 8);
switch (ev.GetNumArgs()) {
case 0:
// callback.run();
// break;
//
case 1:
//// typedef void ( idClass.*eventCallback_1_t )( const int );
//// ( this.*( eventCallback_1_t )callback )( data[ 0 ] );
// callback.run(data[0]);
// break;
//
case 2:
//// typedef void ( idClass.*eventCallback_2_t )( const int, const int );
//// ( this.*( eventCallback_2_t )callback )( data[ 0 ], data[ 1 ] );
// callback.run(data[0], data[1]);
// break;
//
case 3:
//// typedef void ( idClass.*eventCallback_3_t )( const int, const int, const int );
//// ( this.*( eventCallback_3_t )callback )( data[ 0 ], data[ 1 ], data[ 2 ] );
// callback.run(data[0], data[1], data[2]);
// break;
//
case 4:
//// typedef void ( idClass.*eventCallback_4_t )( const int, const int, const int, const int );
//// ( this.*( eventCallback_4_t )callback )( data[ 0 ], data[ 1 ], data[ 2 ], data[ 3 ] );
// callback.run(data[0], data[1], data[2], data[3]);
// break;
//
case 5:
//// typedef void ( idClass.*eventCallback_5_t )( const int, const int, const int, const int, const int );
//// ( this.*( eventCallback_5_t )callback )( data[ 0 ], data[ 1 ], data[ 2 ], data[ 3 ], data[ 4 ] );
// callback.run(data[0], data[1], data[2], data[3], data[4]);
// break;
//
case 6:
//// typedef void ( idClass.*eventCallback_6_t )( const int, const int, const int, const int, const int, const int );
//// ( this.*( eventCallback_6_t )callback )( data[ 0 ], data[ 1 ], data[ 2 ], data[ 3 ], data[ 4 ], data[ 5 ] );
// break;
//
case 7:
//// typedef void ( idClass.*eventCallback_7_t )( const int, const int, const int, const int, const int, const int, const int );
//// ( this.*( eventCallback_7_t )callback )( data[ 0 ], data[ 1 ], data[ 2 ], data[ 3 ], data[ 4 ], data[ 5 ], data[ 6 ] );
// callback.run(data[0], data[1], data[2], data[3], data[4], data[5], data[6]);
// break;
//
case 8:
//// typedef void ( idClass.*eventCallback_8_t )( const int, const int, const int, const int, const int, const int, const int, const int );
//// ( this.*( eventCallback_8_t )callback )( data[ 0 ], data[ 1 ], data[ 2 ], data[ 3 ], data[ 4 ], data[ 5 ], data[ 6 ], data[ 7 ] );
// callback.run(data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]);
callback.accept(this, data);
break;
//
default:
gameLocal.Warning("Invalid formatspec on event '%s'", ev.GetName());
break;
}
// #endif
return true;
}
public void CancelEvents(final idEventDef ev) {
idEvent.CancelEvents(this, ev);
}
public void Event_Remove() {
// delete this;//if only
if (this instanceof idBFGProjectile) idBFGProjectile.delete((idBFGProjectile) this);
else if (this instanceof idProjectile) idProjectile.delete((idProjectile) this);
else if (this instanceof idTrigger_Multi) idTrigger_Multi.delete((idTrigger_Multi) this);
else if (this instanceof idTarget_Remove) idTarget_Remove.delete((idTarget_Remove) this);
else if (this instanceof idAI) idAI.delete((idAI) this);
else if (this instanceof idEntity) idEntity.delete((idEntity) this);
else if (this instanceof idThread) idThread.delete((idThread) this);
else throw new TODO_Exception();
}
// Static functions
/*
================
idClass::Init
Should be called after all idTypeInfos are initialized, so must be called
manually upon game code initialization. Tells all the idTypeInfos to initialize
their event callback table for the associated class. This should only be called
once during the execution of the program or DLL.
================
*/
public void Init() {
INIT();
}
public static void INIT() {
idTypeInfo c;
int num;
gameLocal.Printf("Initializing class hierarchy\n");
if (initialized) {
gameLocal.Printf("...already initialized\n");
return;
}
// init the event callback tables for all the classes
for (c = typelist; c != null; c = c.next) {
c.Init();
}
// number the types according to the class hierarchy so we can quickly determine if a class
// is a subclass of another
num = 0;
for (c = classHierarchy.GetNext(); c != null; c = c.node.GetNext(), num++) {
c.typeNum = num;
c.lastChild += num;
}
// number of bits needed to send types over network
typeNumBits = idMath.BitsForInteger(num);
// create a list of the types so we can do quick lookups
// one list in alphabetical order, one in typenum order
types.SetGranularity(1);
types.SetNum(num);
typenums.SetGranularity(1);
typenums.SetNum(num);
num = 0;
for (c = typelist; c != null; c = c.next, num++) {
types.oSet(num, c);
typenums.oSet(c.typeNum, c);
}
initialized = true;
gameLocal.Printf("...%d classes, %d bytes for event callbacks\n", types.Num(), eventCallbackMemory);
}
public static void Shutdown() {
idTypeInfo c;
for (c = typelist; c != null; c = c.next) {
c.Shutdown();
}
types.Clear();
typenums.Clear();
initialized = false;
}
/*
================
idClass::GetClass
Returns the idTypeInfo for the name of the class passed in. This is a static function
so it must be called as idClass::GetClass( classname )
================
*/@Deprecated
public static idTypeInfo GetClass(final String name) {
switch (name) {
case "idWorldspawn":
}
throw new Deprecation_Exception();
// idTypeInfo c;
// int order;
// int mid;
// int min;
// int max;
//
// if (!initialized) {
// // idClass::Init hasn't been called yet, so do a slow lookup
// for (c = typelist; c != null; c = c.next) {
// if (NOT(idStr.Cmp(c.classname, name))) {
// return c;
// }
// }
// } else {
// // do a binary search through the list of types
// min = 0;
// max = types.Num() - 1;
// while (min <= max) {
// mid = (min + max) / 2;
// c = types.oGet(mid);
// order = idStr.Cmp(c.classname, name);
// if (0 == order) {
// return c;
// } else if (order > 0) {
// max = mid - 1;
// } else {
// min = mid + 1;
// }
// }
// }
//
// return null;
}
public abstract void oSet(idClass oGet);
/*
================
idClass::DisplayInfo_f
================
*/
public static class DisplayInfo_f extends cmdFunction_t {
private static final cmdFunction_t instance = new DisplayInfo_f();
private DisplayInfo_f() {
}
public static cmdFunction_t getInstance() {
return instance;
}
@Override
public void run(idCmdArgs args) {
gameLocal.Printf("Class memory status: %d bytes allocated in %d objects\n", memused, numobjects);
}
};
/*
================
idClass::ListClasses_f
================
*/
public static class ListClasses_f extends cmdFunction_t {
private static final cmdFunction_t instance = new ListClasses_f();
private ListClasses_f() {
}
public static cmdFunction_t getInstance() {
return instance;
}
@Override
public void run(idCmdArgs args) {
int i;
idTypeInfo type;
gameLocal.Printf("%-24s %-24s %-6s %-6s\n", "Classname", "Superclass", "Type", "Subclasses");
gameLocal.Printf("----------------------------------------------------------------------\n");
for (i = 0; i < types.Num(); i++) {
type = types.oGet(i);
gameLocal.Printf("%-24s %-24s %6d %6d\n", type.classname, type.superclass, type.typeNum, type.lastChild - type.typeNum);
}
gameLocal.Printf("...%d classes", types.Num());
}
};
public static idClass CreateInstance(final String name) {
// idTypeInfo type;
// idClass obj;
//
// type = idClass.GetClass(name);
// if (NOT(type)) {
// return null;
// }
//
// obj = type.CreateInstance();
// return obj;
throw new TODO_Exception();
}
public static int GetNumTypes() {
return types.Num();
}
public static int GetTypeNumBits() {
return typeNumBits;
}
public static idTypeInfo GetType(int typeNum) {
idTypeInfo c;
if (!initialized) {
for (c = typelist; c != null; c = c.next) {
if (c.typeNum == typeNum) {
return c;
}
}
} else if ((typeNum >= 0) && (typeNum < types.Num())) {
return typenums.oGet(typeNum);
}
return null;
}
private classSpawnFunc_t CallSpawnFunc(idTypeInfo cls) {
classSpawnFunc_t func;
if (cls.zuper != null) {//TODO:rename super
func = CallSpawnFunc(cls.zuper);
if (func == cls.Spawn) {
// don't call the same function twice in a row.
// this can happen when subclasses don't have their own spawn function.
return func;
}
}
// ( this.*cls.Spawn )();
cls.Spawn.run();
return cls.Spawn;
}
private boolean PostEventArgs(final idEventDef ev, int time, int numargs, idEventArg... args) {
java.lang.Class c;
idEvent event;
// va_list args;
assert (ev != null);
if (!idEvent.initialized) {
return false;
}
//TODO:disabled for medicinal reasons
c = this.getClass();
if (NOT(this.getEventCallBack(ev))) {
// we don't respond to this event, so ignore it
return false;
}
// we service events on the client to avoid any bad code filling up the event pool
// we don't want them processed usually, unless when the map is (re)loading.
// we allow threads to run fine, though.
if (gameLocal.isClient && (gameLocal.GameState() != GAMESTATE_STARTUP) && !IsType(idThread.class)) {
return true;
}
// va_start(args, numargs);
event = idEvent.Alloc(ev, numargs, args);
// va_end(args);
//TODO:same as line #755
event.Schedule(this, c, time);
return true;
}
private boolean ProcessEventArgs(final idEventDef ev, int numargs, idEventArg... args) {
idTypeInfo c;
int num;
idEventArg[] data = new idEventArg[D_EVENT_MAXARGS];
// va_list args;
assert (ev != null);
assert (idEvent.initialized);
//TODO:same as PostEventArgs
// c = GetType();
// num = ev.GetEventNum();
// if (NOT(c.eventMap[num])) {
// // we don't respond to this event, so ignore it
// return false;
// }
// va_start(args, numargs);
idEvent.CopyArgs(ev, numargs, args, data);
// va_end(args);
ProcessEventArgPtr(ev, data);
return true;
}
private void Event_SafeRemove() {
// Forces the remove to be done at a safe time
PostEventMS(EV_Remove, 0);
}
public static void delete(final idClass clazz){
if (clazz != null) clazz._deconstructor();
}
};
/**
* *********************************************************************
*
* idTypeInfo
*
* @deprecated use the native java classes instead.
* *********************************************************************
*/
@Deprecated
public static class idTypeInfo {
public String classname;
public String superclass;
//
public idEventFunc<idClass>[] eventCallbacks;
public eventCallback_t[] eventMap;
public idTypeInfo zuper;
public idTypeInfo next;
public boolean freeEventMap;
public int typeNum;
public int lastChild;
//
public idHierarchy<idTypeInfo> node;
//
public classSpawnFunc_t CreateInstance;
public classSpawnFunc_t Spawn;
public idClass_Save Save;
public idClass_Restore Restore;
//
//
public idTypeInfo(final String classname, final String superclass,
idEventFunc<idClass>[] eventCallbacks, classSpawnFunc_t CreateInstance, classSpawnFunc_t Spawn,
idClass_Save Save, idClass_Restore Restore) {
idTypeInfo type;
idTypeInfo insert;
this.classname = classname;
this.superclass = superclass;
this.eventCallbacks = eventCallbacks;
this.eventMap = null;
this.Spawn = Spawn;
this.Save = Save;
this.Restore = Restore;
this.CreateInstance = CreateInstance;
this.zuper = idClass.GetClass(superclass);
this.freeEventMap = false;
typeNum = 0;
lastChild = 0;
// Check if any subclasses were initialized before their superclass
for (type = typelist; type != null; type = type.next) {
if ((type.zuper == null) && NOT(idStr.Cmp(type.superclass, this.classname))
&& idStr.Cmp(type.classname, "idClass") != 0) {
type.zuper = this;
}
}
// Insert sorted
for (insert = typelist; insert != null; insert = insert.next) {
assert (idStr.Cmp(classname, insert.classname) != 0);
if (idStr.Cmp(classname, insert.classname) < 0) {
next = insert;
insert = this;
break;
}
}
if (null == insert) {
insert = this;
next = null;
}
}
// ~idTypeInfo();
/*
================
idTypeInfo::Init
Initializes the event callback table for the class. Creates a
table for fast lookups of event functions. Should only be called once.
================
*/
public void Init() {
idTypeInfo c;
idEventFunc<idClass>[] def;
int ev;
int i;
boolean[] set;
int num;
if (eventMap != null) {
// we've already been initialized by a subclass
return;
}
// make sure our superclass is initialized first
if (zuper != null && null == zuper.eventMap) {
zuper.Init();
}
// add to our node hierarchy
if (zuper != null) {
node.ParentTo(zuper.node);
} else {
node.ParentTo(classHierarchy);
}
node.SetOwner(this);
// keep track of the number of children below each class
for (c = zuper; c != null; c = c.zuper) {
c.lastChild++;
}
// if we're not adding any new event callbacks, we can just use our superclass's table
if ((null == eventCallbacks || NOT(eventCallbacks[0].event)) && zuper != null) {
eventMap = zuper.eventMap;
return;
}
// set a flag so we know to delete the eventMap table
freeEventMap = true;
// Allocate our new table. It has to have as many entries as there
// are events. NOTE: could save some space by keeping track of the maximum
// event that the class responds to and doing range checking.
num = idEventDef.NumEventCommands();
eventMap = new eventCallback_t[num];
// memset( eventMap, 0, sizeof( eventCallback_t ) * num );
eventCallbackMemory += sizeof(eventCallback_t.class) * num;
// allocate temporary memory for flags so that the subclass's event callbacks
// override the superclass's event callback
set = new boolean[num];
// memset( set, 0, sizeof( bool ) * num );
// go through the inheritence order and copies the event callback function into
// a list indexed by the event number. This allows fast lookups of
// event functions.
for (c = this; c != null; c = c.zuper) {
def = c.eventCallbacks;
if (null == def) {
continue;
}
// go through each entry until we hit the NULL terminator
for (i = 0; def[ i].event != null; i++) {
ev = def[ i].event.GetEventNum();
if (set[ ev]) {
continue;
}
set[ ev] = true;
eventMap[ ev] = def[ i].function;
}
}
// delete[] set;
}
/*
================
idTypeInfo::Shutdown
Should only be called when DLL or EXE is being shutdown.
Although it cleans up any allocated memory, it doesn't bother to remove itself
from the class list since the program is shutting down.
================
*/
public void Shutdown() {
// free up the memory used for event lookups
if (eventMap != null) {
// if ( freeEventMap ) {
// delete[] eventMap;
// }
eventMap = null;
}
typeNum = 0;
lastChild = 0;
}
/*
================
idTypeInfo::IsType
Checks if the object's class is a subclass of the class defined by the
passed in idTypeInfo.
================
*/
public boolean IsType(final idTypeInfo type) {
return ((typeNum >= type.typeNum) && (typeNum <= type.lastChild));
}
public boolean IsType(final java.lang.Class type) {
throw new TODO_Exception();
}
public boolean RespondsTo(final idEventDef ev) {
assert (idEvent.initialized);
if (null == eventMap[ ev.GetEventNum()]) {
// we don't respond to this event
return false;
}
return true;
}
};
}
| 1 | 0.744993 | 1 | 0.744993 | game-dev | MEDIA | 0.923217 | game-dev | 0.841047 | 1 | 0.841047 |
goonstation/goonstation-2016 | 7,360 | code/unused/NPC.dm | /*
/obj/npcmonkeyspawner/New()
var/mob/living/carbon/monkey/M = new /mob/living/carbon/monkey ( loc )
M.AIactive = 1
M.think()
qdel(src)
/obj/npcmonkeyspawner/angry/New()
var/mob/living/carbon/monkey/M = new /mob/living/carbon/monkey ( loc )
M.AIactive = 1
M.aggressiveness = 22
M.think()
qdel(src)
/obj/npcmonkeyspawner/special/New()
var/mob/living/carbon/monkey/special/M = new /mob/living/carbon/monkey/special ( loc )
M.AIactive = 1
M.think()
qdel(src)
/mob/living/carbon/monkey/proc/helpme(mob/M as mob) // GANGBANG
target = M
mainstate = 3
/mob/living/carbon/monkey/proc/think()
var/turf/T = get_turf(src)
var/nolos = 0
var/cantact = 0
//emote("EMOTENAME")
//var/count = 0
//var/friend // His friend . real_name .
//var/mainstate = 0
// 0 = Idle
// 1 = Targeting
// 2 = Angry
// 3 = Attacking
// 4 = Moving out of Danger.
// 5 = Run awayyy
// 6 = Following
//var/substate = 0
//var/target = null // His target .
//var/AIactive = 0 // Is the AI on or off?
if (special) // Just testing
HealDamage("All", 10000, 10000)
weakened = 0
drowsyness = 0
stunned = 0
paralysis = 0
toxloss = 0
oxyloss = 0
if (!AIactive) return
if (transforming) return
if (stat || stunned || weakened || paralysis) cantact = 1
if(target && (mainstate == 2 || mainstate == 3))
var/list/L = new/list()
L = getline(get_turf(src), get_turf(target))
for (var/turf/Trf as turf in L)
if (Trf.density) nolos = 1
for (var/atom/C in Trf)
if (!istype(C,/mob/living) && C.density) // Somethings blocking our way
nolos = 1
switch(mainstate)
if(0)
if(target)
target = null
if((T.sl_gas || T.poison) && !special) // ahaha what a shitty workaround.
mainstate = 4
SaferTurf()
spawn(5) //////////////////////////////////////!!!
think()
return
var/mob/Temp
var/TempHp = 100
for(var/mob/M as mob in oview(world.view-3,src))
if(!M.client || !istype(M,/mob/living/carbon/human)) continue
if(M.health <= TempHp && !M.stat)
Temp = M
TempHp = M.health
if ((Temp && prob( ( (100 - TempHp) * 2) + aggressiveness )) || Temp && health < 90 + (aggressiveness / 2) )
if (!istype(Temp, /mob/living))
spawn(5) //////////////////////////////////////!!!
think()
return
mainstate = 1
target = Temp
else
if(!cantact && canmove)
step_rand(src)
if(1)
if(!target || cantact || target:stat)
mainstate = 0
target = null
spawn(5) //////////////////////////////////////!!!
think()
return
for(var/mob/M as mob in oview(world.view,src))
boutput(M, "<span style=\"color:red\">The [src.name] stares at [target]</span>")
if (prob(10) && !special) emote("gnarl")
mainstate = 2
spawn(15) //////////////////////////////////////!!!
think()
return
if(2)
if(!target)
mainstate = 0
spawn(5) //////////////////////////////////////!!!
think()
return
if( (get_dist(src,target) >= world.view - 2) && !cantact)
for(var/mob/M as mob in oview(world.view,src))
boutput(M, "<span style=\"color:red\">The [src.name] calms down.</span>")
target = null
count = 0
mainstate = 0
spawn(10) //////////////////////////////////////!!!
think()
return
if ((prob(33) || health < 50) && !cantact)
if (prob(10) && !special) emote("paw")
for(var/mob/living/carbon/monkey/M as mob in oview(world.view,src))
if (istype(M,/mob/living/carbon/monkey)) // BYOND SUCKS ARRRGH
if(M.AIactive && !M.stat && M.canmove)
M.helpme(target)
if (!nolos && canmove && !cantact)
for(var/mob/M as mob in oview(world.view,src))
boutput(M, "<span style=\"color:red\">The [src.name] lunges at [target].</span>")
if (prob(10) && !special) emote("roar")
while(get_dist(src,target) > 2)
step_towards(src,target)
sleep(2)
mainstate = 3
if(3)
if( ( (target:stat && prob(50-aggressiveness) ) && !cantact) || count > 300 )
for(var/mob/M as mob in oview(world.view,src))
boutput(M, "<span style=\"color:red\">The [src.name] loses interest in its target.</span>")
target = null
count = 0
mainstate = 0
spawn(10) //////////////////////////////////////!!!
think()
return
if(get_dist(src,target) > world.view + 2 && !cantact)
for(var/mob/M as mob in oview(world.view,src))
boutput(M, "<span style=\"color:red\">The [src.name] calms down.</span>")
target = null
count = 0
mainstate = 0
spawn(10) //////////////////////////////////////!!!
think()
return
if(get_dist(src,target) > 1 && !cantact && canmove)
count++
step_towards(src,target)
if((T.sl_gas > 3000 || T.poison > 3000 ) && !special) // ahaha what a shitty workaround.
mainstate = 4
SaferTurf()
if(get_dist(src,target) == 2 && prob(50) && (!cantact && canmove))
if(!nolos)
for(var/mob/M as mob in oview(world.view,src))
boutput(M, "<span style=\"color:red\">The [src.name] pounces [target].</span>")
target:weakened += 3
step_towards(src,target)
step_towards(src,target)
spawn(10)
think()
return
if(get_dist(src,target) < 2 && (!cantact && !istype(src.wear_mask, /obj/item/clothing/mask/muzzle)) )
for(var/mob/M as mob in oview(world.view,src))
boutput(M, "<span style=\"color:red\">The [src.name] bites [target].</span>")
if(prob(15) && special)
randmutb(target)
for(var/mob/M as mob in oview(world.view,src))
boutput(M, "<span style=\"color:red\">[target] has been infected.</span>")
target:TakeDamage("chest", 5, 0)
spawn(20)
think()
return
if(4)
if (prob(5) && !special) emote("whimper")
if((T.sl_gas || T.poison || t_oxygen) && !special)
SaferTurf()
else
if(target) mainstate = 2
if(!target) mainstate = 0
spawn(5)
think()
return
/mob/living/carbon/monkey/proc/SaferTurf()
var/turf/Current = get_turf(src)
var/turf/Temp = Current
var/turf/Check = Current
var/blocked = 0
var/cantact = 0
if (stat || stunned || weakened || paralysis) cantact = 1
if(Current.sl_gas && canmove && !cantact)
Current = get_turf(src)
Temp = Current
Check = Current
for(var/A in alldirs)
Check = get_step(src, A)
if(!istype(Check,/turf)) continue
if (Check.sl_gas < Current.sl_gas && Check.sl_gas < Temp.sl_gas && !Check.density)
blocked = 0
for (var/atom/B in Check)
if(B.density)
blocked = 1
if(!blocked)
Temp = Check
step_towards(src,Temp)
if(Current.poison && canmove && !cantact)
Current = get_turf(src)
Temp = Current
Check = Current
for(var/A in alldirs)
Check = get_step(src, A)
if(!istype(Check,/turf)) continue
if (Check.poison < Current.poison && Check.poison < Temp.poison && !Check.density)
blocked = 0
for (var/atom/B in Check)
if(B.density)
blocked = 1
if(!blocked)
Temp = Check
step_towards(src,Temp)
if(t_oxygen && canmove && !cantact)
Current = get_turf(src)
Temp = Current
Check = Current
for(var/A in alldirs)
Check = get_step(src, A)
if(!istype(Check,/turf)) continue
if (Check.oxygen > Current.oxygen && Check.oxygen > Temp.oxygen && !Check.density)
blocked = 0
for (var/atom/B in Check)
if(B.density)
blocked = 1
if(!blocked)
Temp = Check
step_towards(src,Temp)
*/
| 1 | 0.937308 | 1 | 0.937308 | game-dev | MEDIA | 0.993323 | game-dev | 0.962863 | 1 | 0.962863 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.