@needle-tools/engine 2.65.1-pre → 2.66.1-pre

package/src/engine/engine_gizmos.ts

@@ -145,10 +145,9 @@ class Internal {
     }
 
     static getSphere(radius: number, duration: number, wireframe: boolean): Mesh {
-
         let sphere = this.spheresCache.pop();
         if (!sphere) {
-            sphere = new Mesh(new SphereGeometry(.5, 8, 8));
+            sphere = new Mesh(new SphereGeometry(1, 8, 8));
         }
         sphere.scale.set(radius, radius, radius);
         sphere.material["wireframe"] = wireframe;
@@ -176,6 +175,8 @@ class Internal {
             this.contextPostRenderCallbacks.set(context, cb);
             context.post_render_callbacks.push(cb);
         }
+        object.layers.disableAll();
+        object.layers.enable(2);
         object[$cacheSymbol] = cache;
         this.timedObjectsBuffer.push(object);
         this.timesBuffer.push(Context.Current.time.time + duration);

package/src/engine/engine_networking.ts

@@ -147,7 +147,7 @@ export class OwnershipModel {
         // console.log(res);
         if (res.guid === this.guid) {
             if (this._isWaitingForOwnershipResponseCallback) {
-                this.connection.stopListening(OwnershipEvent.ResponseHasOwner, this._isWaitingForOwnershipResponseCallback);
+                this.connection.stopListen(OwnershipEvent.ResponseHasOwner, this._isWaitingForOwnershipResponseCallback);
                 this._isWaitingForOwnershipResponseCallback = null;
             }
             this._isOwned = res.value;
@@ -185,18 +185,18 @@ export class OwnershipModel {
         // TODO: abort "requestOwnershipIfNotOwned"
         this.connection.send(OwnershipEvent.RemoveOwnership, { guid: this.guid });
         if (this._isWaitingForOwnershipResponseCallback) {
-            this.connection.stopListening(OwnershipEvent.ResponseHasOwner, this._isWaitingForOwnershipResponseCallback);
+            this.connection.stopListen(OwnershipEvent.ResponseHasOwner, this._isWaitingForOwnershipResponseCallback);
             this._isWaitingForOwnershipResponseCallback = null;
         }
         return this;
     }
 
     public destroy() {
-        this.connection.stopListening(OwnershipEvent.GainedOwnership, this._gainSubscription);
-        this.connection.stopListening(OwnershipEvent.LostOwnership, this._lostSubscription);
-        this.connection.stopListening(OwnershipEvent.ResponseHasOwner, this._hasOwnerResponse);
+        this.connection.stopListen(OwnershipEvent.GainedOwnership, this._gainSubscription);
+        this.connection.stopListen(OwnershipEvent.LostOwnership, this._lostSubscription);
+        this.connection.stopListen(OwnershipEvent.ResponseHasOwner, this._hasOwnerResponse);
         if (this._isWaitingForOwnershipResponseCallback) {
-            this.connection.stopListening(OwnershipEvent.ResponseHasOwner, this._isWaitingForOwnershipResponseCallback);
+            this.connection.stopListen(OwnershipEvent.ResponseHasOwner, this._isWaitingForOwnershipResponseCallback);
             this._isWaitingForOwnershipResponseCallback = null;
         }
     }
@@ -368,7 +368,9 @@ export class NetworkConnection implements INetworkConnection {
         return callback;
     }
 
-    public stopListening(key: string | OwnershipEvent, callback: Function | null) {
+    /**@deprecated please use stopListen instead (2.65.2-pre) */
+    public stopListening(key: string | OwnershipEvent, callback: Function | null) { return this.stopListen(key, callback); }
+    public stopListen(key: string | OwnershipEvent, callback: Function | null) {
         if (!callback) return;
         if (!this._listeners[key]) return;
         const index = this._listeners[key].indexOf(callback);
@@ -377,7 +379,7 @@ export class NetworkConnection implements INetworkConnection {
         }
     }
 
-    public beginListenBinrary(identifier: string, callback: BinaryCallback): BinaryCallback {
+    public beginListenBinary(identifier: string, callback: BinaryCallback): BinaryCallback {
         if (!this._listenersBinary[identifier])
             this._listenersBinary[identifier] = [];
         this._listenersBinary[identifier].push(callback);

package/src/engine/engine_physics.ts

@@ -15,7 +15,7 @@ import {
 import { InstancingUtil } from './engine_instancing';
 import { foreachComponent } from './engine_gameobject';
 
-import RAPIER, { ActiveEvents, CoefficientCombineRule, Collider, ColliderDesc, EventQueue, JointData, RigidBody, RigidBodyType, World } from '@dimforge/rapier3d-compat';
+import RAPIER, { ActiveEvents, CoefficientCombineRule, Collider, ColliderDesc, EventQueue, JointData, QueryFilterFlags, RigidBody, RigidBodyType, ShapeColliderTOI, World } from '@dimforge/rapier3d-compat';
 import { CollisionDetectionMode, PhysicsMaterialCombine } from '../engine/engine_physics.types';
 import { Gizmos } from './engine_gizmos';
 import { Mathf } from './engine_math';
@@ -83,12 +83,22 @@ export class SphereIntersection implements Intersection {
     }
 }
 
+export class SphereOverlapResult {
+    object: Object3D;
+    collider: ICollider;
+    constructor(object: Object3D, collider: ICollider) {
+        this.object = object;
+        this.collider = collider;
+    }
+}
+
 declare type PhysicsRaycastResult = {
     point: Vector3,
     normal?: Vector3,
     collider?: ICollider
 }
 
+
 export class Physics {
 
     // raycasting
@@ -107,6 +117,12 @@ export class Physics {
 
     private sphereResults: Array<Intersection> = new Array<Intersection>();
     private sphereMask: Layers = new Layers();
+    /** Test overlapping of a sphere with the threejs geometry. This does not use colliders. This does not return an exact intersection point (intersections returned contain the object and the world position of the object that is being hit)
+     * For a more accurate test use the physics engine's collider overlap test (see sphereOverlapPhysics)
+     * @param spherePos the center of the sphere in world space
+     * @param radius the radius of the sphere
+     * @param traverseChildsAfterHit if false it will stop after the first hit. If true it will continue to traverse and add all hits to the result array
+     */
     public sphereOverlap(spherePos: Vector3, radius: number, traverseChildsAfterHit: boolean = true): Array<Intersection> {
         this.sphereResults.length = 0;
         if (!this.context.scene) return this.sphereResults;
@@ -130,10 +146,9 @@ export class Physics {
                 if (mesh.matrixWorldNeedsUpdate) mesh.updateMatrixWorld();
                 const test = this.tempBoundingBox.copy(geo.boundingBox).applyMatrix4(mesh.matrixWorld);
                 if (sp.intersectsBox(test)) {
-                    // console.log(obj, obj.layers.test(mask), obj.layers.mask, mask.mask);
                     const wp = getWorldPosition(obj);
                     const dist = wp.distanceTo(sp.center);
-                    const int = new SphereIntersection(obj, dist, sp.center.clone());
+                    const int = new SphereIntersection(obj, dist, wp);
                     results.push(int);
                     if (!traverseChildsAfterHit) return;
                 }
@@ -157,6 +172,8 @@ export class Physics {
     /** raycast against rendered three objects. This might be very slow depending on your scene complexity.
      * We recommend setting objects to IgnoreRaycast layer (2) when you don't need them to be raycasted.
      * Raycasting SkinnedMeshes is specially expensive.
+     * Use raycastPhysics for raycasting against physic colliders only. Depending on your scenario this might be faster.
+     * @param options raycast options. If null, default options will be used.
      */
     public raycast(options: RaycastOptions | null = null): Array<Intersection> {
         if (!options) options = this.defaultRaycastOptions;
@@ -222,8 +239,12 @@ export class Physics {
 
     private rapierRay = new RAPIER.Ray({ x: 0, y: 0, z: 0 }, { x: 0, y: 0, z: 1 });
     private raycastVectorsBuffer = new CircularBuffer(() => new Vector3(), 10);
-
-    /** raycast against colliders */
+    /** Fast raycast against physics colliders
+     * @param origin ray origin in screen or worldspace
+     * @param direction ray direction in worldspace
+     * @param maxDistance max distance to raycast
+     * @param solid if true it will also hit the collider if origin is already inside it
+     */
     public raycastPhysicsFast(origin: Vec2 | Vec3, direction: Vec3 | undefined = undefined, maxDistance: number = Infinity, solid: boolean = true)
         : null | { point: Vector3, collider: ICollider } {
 
@@ -285,6 +306,72 @@ export class Physics {
         return ray;
     }
 
+
+    private rapierSphere: RAPIER.Ball | null = null;
+    private rapierColliderArray: Array<SphereOverlapResult> = [];
+    private readonly rapierIdentityRotation = { x: 0, y: 0, z: 0, w: 1 };
+    private readonly rapierForwardVector = { x: 0, y: 0, z: 1 };
+    /** Precice sphere overlap detection using rapier against colliders
+     * @param point center of the sphere in worldspace
+     * @param radius radius of the sphere
+     * @returns array of colliders that overlap with the sphere. Note: they currently only contain the collider and the gameobject
+     */
+    public sphereOverlapPhysics(point: Vector3, radius: number): Array<SphereOverlapResult> {
+        this.rapierColliderArray.length = 0;
+        if (!this.world) return this.rapierColliderArray;
+        if (!this.rapierSphere)
+            this.rapierSphere = new RAPIER.Ball(radius);
+        this.rapierSphere.radius = radius;
+
+        this.world.intersectionsWithShape(point, this.rapierIdentityRotation, this.rapierSphere, col => {
+            const collider = col[$componentKey] as ICollider
+            // if (collider.gameObject.layers.isEnabled(2)) return true;
+            const intersection = new SphereOverlapResult(collider.gameObject, collider);
+            this.rapierColliderArray.push(intersection);
+            return true; // Return `false` instead if we want to stop searching for other colliders that contain this point.
+        }, QueryFilterFlags.EXCLUDE_SENSORS, undefined, undefined, undefined,
+            col => {
+                const collider = col[$componentKey] as ICollider
+                return collider.gameObject.layers.isEnabled(2) == false
+            }
+        );
+        return this.rapierColliderArray;
+
+
+        // TODO: this only returns one hit
+        // let filterGroups = 0xffffffff;
+        // filterGroups &= ~(1 << 2);
+        // const hit: ShapeColliderTOI | null = this.world.castShape(point,
+        //     this.rapierIdentityRotation,
+        //     this.rapierForwardVector,
+        //     this.rapierSphere,
+        //     0,
+        //     QueryFilterFlags.EXCLUDE_SENSORS,
+        //     // filterGroups,
+        // );
+        // // console.log(hit);
+        // if (hit) {
+        //     const collider = hit.collider[$componentKey] as ICollider
+        //     const intersection = new SphereOverlapResult(collider.gameObject);
+        //     this.rapierColliderArray.push(intersection);
+        //     // const localpt = hit.witness2;
+        //     // // const normal = hit.normal2;
+        //     // const hitPoint = new Vector3(localpt.x, localpt.y, localpt.z);
+        //     // // collider.gameObject.localToWorld(hitPoint);
+        //     // // const normalPt = new Vector3(normal.x, normal.y, normal.z);
+        //     // // const mat = new Matrix4().setPosition(point).scale(new Vector3(radius, radius, radius));
+        //     // // hitPoint.applyMatrix4(mat);
+        //     // console.log(hit.witness2)
+        //     // // hitPoint.add(point);
+        //     // const dist = hitPoint.distanceTo(point);
+        // }
+
+        // return this.rapierColliderArray;
+    }
+
+
+
+
     // physics simulation
 
     enabled: boolean = true;
@@ -352,42 +439,58 @@ export class Physics {
 
     addBoxCollider(collider: ICollider, center: Vector3, size: Vector3) {
         if (!this.enabled) {
-            if(debugPhysics) console.warn("Physics is disabled");
+            if (debugPhysics) console.warn("Physics are disabled");
             return;
         }
         const obj = collider.gameObject;
         const scale = getWorldScale(obj, this._tempPosition).multiply(size);
         scale.multiplyScalar(0.5);
+
+        // prevent negative scale
+        if (scale.x < 0)
+            scale.x = Math.abs(scale.x);
+        if (scale.y < 0)
+            scale.y = Math.abs(scale.y);
+        if (scale.z < 0)
+            scale.z = Math.abs(scale.z);
+
         const desc = ColliderDesc.cuboid(scale.x, scale.y, scale.z);
+        // const objectLayerMask = collider.gameObject.layers.mask;
+        // const mask = objectLayerMask & ~2;
+        // desc.setCollisionGroups(objectLayerMask);
         this.createCollider(collider, desc, center);
     }
 
     addSphereCollider(collider: ICollider, center: Vector3, radius: number) {
         if (!this.enabled) {
-            if(debugPhysics) console.warn("Physics is disabled");
+            if (debugPhysics) console.warn("Physics are disabled");
             return;
         }
         const obj = collider.gameObject;
         const scale = getWorldScale(obj, this._tempPosition).multiplyScalar(radius);
+        // Prevent negative scales
+        scale.x = Math.abs(scale.x);
         const desc = ColliderDesc.ball(scale.x);
         this.createCollider(collider, desc, center);
     }
 
     addCapsuleCollider(collider: ICollider, center: Vector3, height: number, radius: number) {
         if (!this.enabled) {
-            if(debugPhysics) console.warn("Physics is disabled");
+            if (debugPhysics) console.warn("Physics are disabled");
             return;
         }
         const obj = collider.gameObject;
         const scale = getWorldScale(obj, this._tempPosition);
-        if (debugPhysics) console.log("capsule scale", scale, height, radius);
+        // Prevent negative scales
+        scale.x = Math.abs(scale.x);
+        scale.y = Math.abs(scale.y);
         const desc = ColliderDesc.capsule(height * .5 * scale.y - radius, radius * scale.x);
         this.createCollider(collider, desc, center);
     }
 
     addMeshCollider(collider: ICollider, mesh: Mesh, convex: boolean, scale: Vector3) {
         if (!this.enabled) {
-            if(debugPhysics) console.warn("Physics is disabled");
+            if (debugPhysics) console.warn("Physics are disabled");
             return;
         }
         const geo = mesh.geometry;

package/src/engine/engine_setup.ts

@@ -744,6 +744,10 @@ export class Context implements IContext {
 		this.connection.sendBufferedMessagesNow();
 
 		this._stats?.end();
+
+		if (this.time.frame === 1) {
+			this.domElement.dispatchEvent(new CustomEvent("ready"));
+		}
 	}
 
 	renderNow(camera?: Camera) {

package/src/engine/extensions/NEEDLE_render_objects.ts

@@ -23,7 +23,10 @@ import {
     DecrementWrapStencilOp,
     InvertStencilOp,
 } from "three";
-import { getParam } from "../engine_utils";
+import { getParam, isDebugMode } from "../engine_utils";
+import { showBalloonWarning } from "../debug";
+import { isUsingInstancing } from "../engine_gameobject";
+import { isLocalNetwork } from "../engine_networking_utils";
 
 const debug = getParam("debugstencil");
 
@@ -62,6 +65,12 @@ export class NEEDLE_render_objects implements GLTFLoaderPlugin {
             const stencil: StencilSettingsModel = settings[i];
             if (matchesLayer(stencil.layer, obj)) {
                 if (debug) console.log(stencil);
+                setTimeout(() => {
+                    if (isLocalNetwork() && isUsingInstancing(obj.gameObject)) {
+                        showBalloonWarning("Stencil not supported on instanced objects");
+                        console.warn("Stencil not supported on instanced objects", obj);
+                    }
+                }, 500)
                 for (let i = 0; i < obj.sharedMaterials.length; i++) {
                     let mat = obj.sharedMaterials[i];
                     if (mat) {

package/src/engine/extensions/NEEDLE_techniques_webgl.ts

@@ -9,7 +9,7 @@ import { SourceIdentifier } from "../engine_types";
 import { ILight } from "../engine_types";
 import { getWorldPosition } from "../engine_three_utils";
 
-const debug = getParam("debugshaders");
+const debug = getParam("debugcustomshader");
 
 export const NEEDLE_TECHNIQUES_WEBGL_NAME = "NEEDLE_techniques_webgl";
 
@@ -524,8 +524,11 @@ export class NEEDLE_techniques_webgl implements GLTFLoaderPlugin {
                             console.warn("Missing/unassigned texture, fallback to white: " + uniformName)
                             break;
                         default:
+                            if (uniformName === "unity_OrthoParams") {
 
-                            console.warn("TODO: EXPECTED UNIFORM / fallback NOT SET: " + uniformName, techniqueUniforms[u]);
+                            }
+                            else
+                                console.warn("TODO: EXPECTED UNIFORM / fallback NOT SET: " + uniformName, techniqueUniforms[u]);
                             break;
                     }
                 }

package/src/engine-components/Animator.ts

@@ -50,55 +50,81 @@ export class Animator extends Behaviour {
         return this._animatorController;
     }
 
-    Play(name: string | number, layer: number = -1, normalizedTime: number = Number.NEGATIVE_INFINITY, transitionDurationInSec: number = 0) {
-        this.runtimeAnimatorController?.Play(name, layer, normalizedTime, transitionDurationInSec);
-    }
+    // NOTE: the uppercase events have been deprecated because UnityEvent methods are all exported with lowercase first letter
 
-    Reset() {
-        this._animatorController?.Reset();
+    /**@deprecated use play */
+    Play(name: string | number, layer: number = -1, normalizedTime: number = Number.NEGATIVE_INFINITY, transitionDurationInSec: number = 0) { this.play(name, layer, normalizedTime, transitionDurationInSec); }
+    play(name: string | number, layer: number = -1, normalizedTime: number = Number.NEGATIVE_INFINITY, transitionDurationInSec: number = 0) {
+        this.runtimeAnimatorController?.play(name, layer, normalizedTime, transitionDurationInSec);
     }
 
-    SetBool(name: string | number, value: boolean) {
-        this.runtimeAnimatorController?.SetBool(name, value);
+    /**@deprecated use reset */
+    Reset() { this.reset(); }
+    reset() {
+        this._animatorController?.reset();
     }
 
-    GetBool(name: string | number): boolean {
-        return this.runtimeAnimatorController?.GetBool(name) ?? false;
+    /**@deprecated use setBool */
+    SetBool(name: string | number, val: boolean) { this.setBool(name, val); }
+    setBool(name: string | number, value: boolean) {
+        this.runtimeAnimatorController?.setBool(name, value);
     }
 
-    SetFloat(name: string | number, val: number) {
-        this.runtimeAnimatorController?.SetFloat(name, val);
+    /**@deprecated use getBool */
+    GetBool(name: string | number) { return this.getBool(name); }
+    getBool(name: string | number): boolean {
+        return this.runtimeAnimatorController?.getBool(name) ?? false;
     }
 
-    GetFloat(name: string | number): number {
-        return this.runtimeAnimatorController?.GetFloat(name) ?? -1;
+    /**@deprecated use setFloat */
+    SetFloat(name: string | number, val: number) { this.setFloat(name, val); }
+    setFloat(name: string | number, val: number) {
+        this.runtimeAnimatorController?.setFloat(name, val);
     }
 
-    SetInteger(name: string | number, val: number) {
-        this.runtimeAnimatorController?.SetInteger(name, val);
+    /**@deprecated use getFloat */
+    GetFloat(name: string | number) { return this.getFloat(name); }
+    getFloat(name: string | number): number {
+        return this.runtimeAnimatorController?.getFloat(name) ?? -1;
     }
 
-    GetInteger(name: string | number): number {
-        return this.runtimeAnimatorController?.GetInteger(name) ?? -1;
+    /**@deprecated use setInteger */
+    SetInteger(name: string | number, val: number) { this.setInteger(name, val); }
+    setInteger(name: string | number, val: number) {
+        this.runtimeAnimatorController?.setInteger(name, val);
     }
 
-    SetTrigger(name: string | number) {
-        this.runtimeAnimatorController?.SetTrigger(name);
+    /**@deprecated use getInteger */
+    GetInteger(name: string | number) { return this.getInteger(name); }
+    getInteger(name: string | number): number {
+        return this.runtimeAnimatorController?.getInteger(name) ?? -1;
     }
 
-    ResetTrigger(name: string | number) {
-        this.runtimeAnimatorController?.ResetTrigger(name);
+    /**@deprecated use setTrigger */
+    SetTrigger(name: string | number) { this.setTrigger(name); }
+    setTrigger(name: string | number) {
+        console.log("name", name);
+        this.runtimeAnimatorController?.setTrigger(name);
     }
 
-    IsInTransition(): boolean {
-        return this.runtimeAnimatorController?.IsInTransition() ?? false;
+    /**@deprecated use resetTrigger */
+    ResetTrigger(name: string | number) { this.resetTrigger(name); }
+    resetTrigger(name: string | number) {
+        this.runtimeAnimatorController?.resetTrigger(name);
     }
 
+    /**@deprecated use isInTransition */
+    IsInTransition() { return this.isInTransition(); }
+    isInTransition(): boolean {
+        return this.runtimeAnimatorController?.isInTransition() ?? false;
+    }
 
-    SetSpeed(speed: number) {
+    /**@deprecated use setSpeed */
+    SetSpeed(speed: number) { return this.setSpeed(speed); }
+    setSpeed(speed: number) {
         if (speed === this.speed) return;
         this.speed = speed;
-        this._animatorController?.SetSpeed(speed);
+        this._animatorController?.setSpeed(speed);
     }
 
     set minMaxSpeed(minMax: { x: number, y: number }) {
@@ -130,7 +156,7 @@ export class Animator extends Behaviour {
                 this.runtimeAnimatorController = clone;
                 console.assert(this.runtimeAnimatorController === clone);
                 this.runtimeAnimatorController.bind(this);
-                this.runtimeAnimatorController.SetSpeed(this.speed);
+                this.runtimeAnimatorController.setSpeed(this.speed);
                 this.runtimeAnimatorController.normalizedStartOffset = this.normalizedStartOffset;
             }
             else console.warn("Could not clone animator controller", this.runtimeAnimatorController);
@@ -139,7 +165,7 @@ export class Animator extends Behaviour {
 
     onDisable() {
         if (!this.keepAnimatorControllerStateOnDisable)
-            this._animatorController?.Reset();
+            this._animatorController?.reset();
     }
 
     onBeforeRender() {

package/src/engine-components/AnimatorController.ts

@@ -14,7 +14,7 @@ const debugRootMotion = getParam("debugrootmotion");
 
 export class AnimatorController {
 
-    Play(name: string | number, layerIndex: number = -1, normalizedTime: number = Number.NEGATIVE_INFINITY, durationInSec: number = 0) {
+    play(name: string | number, layerIndex: number = -1, normalizedTime: number = Number.NEGATIVE_INFINITY, durationInSec: number = 0) {
         if (layerIndex < 0) layerIndex = 0;
         else if (layerIndex >= this.model.layers.length) {
             console.warn("invalid layer");
@@ -33,61 +33,63 @@ export class AnimatorController {
         console.warn("Could not find " + name + " to play");
     }
 
-    Reset() {
+    reset() {
         this.setStartTransition();
     }
 
-    SetBool(name: string | number, value: boolean) {
+    setBool(name: string | number, value: boolean) {
         const key = typeof name === "string" ? "name" : "hash";
         return this.model?.parameters?.filter(p => p[key] === name).forEach(p => p.value = value);
     }
 
-    GetBool(name: string | number): boolean {
+    getBool(name: string | number): boolean {
         const key = typeof name === "string" ? "name" : "hash";
         return this.model?.parameters?.find(p => p[key] === name)?.value as boolean ?? false;
     }
 
-    SetFloat(name: string | number, val: number) {
+    setFloat(name: string | number, val: number) {
         const key = typeof name === "string" ? "name" : "hash";
         return this.model?.parameters?.filter(p => p[key] === name).forEach(p => p.value = val);
     }
 
-    GetFloat(name: string | number): number {
+    getFloat(name: string | number): number {
         const key = typeof name === "string" ? "name" : "hash";
         return this.model?.parameters?.find(p => p[key] === name)?.value as number ?? 0;
     }
 
-    SetInteger(name: string | number, val: number) {
+    setInteger(name: string | number, val: number) {
         const key = typeof name === "string" ? "name" : "hash";
         return this.model?.parameters?.filter(p => p[key] === name).forEach(p => p.value = val);
     }
 
-    GetInteger(name: string | number): number {
+    getInteger(name: string | number): number {
         const key = typeof name === "string" ? "name" : "hash";
         return this.model?.parameters?.find(p => p[key] === name)?.value as number ?? 0;
     }
 
-    SetTrigger(name: string | number) {
+    setTrigger(name: string | number) {
         if (debug)
             console.log("SET TRIGGER", name);
         const key = typeof name === "string" ? "name" : "hash";
         return this.model?.parameters?.filter(p => p[key] === name).forEach(p => p.value = true);
     }
 
-    ResetTrigger(name: string | number) {
+    resetTrigger(name: string | number) {
         const key = typeof name === "string" ? "name" : "hash";
         return this.model?.parameters?.filter(p => p[key] === name).forEach(p => p.value = false);
     }
 
-    IsInTransition(): boolean {
+    isInTransition(): boolean {
         return this._activeStates.length > 1;
     }
 
-    SetSpeed(speed: number) {
+    setSpeed(speed: number) {
         this._speed = speed;
     }
 
-    FindState(name: string | undefined | null): State | null {
+    /**@deprecated use findState */
+    FindState(name: string | undefined | null): State | null { return this.findState(name); }
+    findState(name: string | undefined | null): State | null {
         if (!name) return null;
         if (Array.isArray(this.model.layers)) {
             for (const layer of this.model.layers) {

package/src/engine-components/CharacterController.ts

@@ -86,6 +86,9 @@ export class CharacterControllerInput extends Behaviour {
     @serializable()
     jumpForce: number = 1;
 
+    @serializable()
+    doubleJumpForce: number = 2;
+
     @serializable(Animator)
     animator?: Animator;
 
@@ -106,7 +109,7 @@ export class CharacterControllerInput extends Behaviour {
 
         if (this.controller?.isGrounded) {
             this._jumpCount = 0;
-            this.animator?.SetBool("doubleJump", false);
+            if (this.doubleJumpForce > 0) this.animator?.setBool("doubleJump", false);
         }
 
         const forward = this.context.input.isKeyPressed("w");
@@ -121,8 +124,8 @@ export class CharacterControllerInput extends Behaviour {
         this._currentSpeed.z += step * this.movementSpeed * this.context.time.deltaTime;
 
         // if (!this.controller || this.controller.isGrounded)
-        this.animator?.SetBool("running", step != 0);
-        this.animator?.SetBool("jumping", this.controller?.isGrounded === true && jump);
+        this.animator?.setBool("running", step != 0);
+        this.animator?.setBool("jumping", this.controller?.isGrounded === true && jump);
 
         this._temp.copy(this._currentSpeed);
         this._temp.applyQuaternion(this.gameObject.quaternion);
@@ -146,9 +149,9 @@ export class CharacterControllerInput extends Behaviour {
 
         if (this.controller && jump && this.jumpForce > 0) {
             let canJump = this.controller?.isGrounded;
-            if (!this.controller?.isGrounded && this._jumpCount === 1) {
+            if (this.doubleJumpForce > 0 && !this.controller?.isGrounded && this._jumpCount === 1) {
                 canJump = true;
-                this.animator?.SetBool("doubleJump", true);
+                this.animator?.setBool("doubleJump", true);
             }
 
             if (canJump) {
@@ -156,8 +159,8 @@ export class CharacterControllerInput extends Behaviour {
                 // TODO: factor in mass
                 const rb = this.controller.rigidbody;
                 // const fullJumpHoldLength = .1;
-                const factor = this._jumpCount === 2 ? 2 : 1;// Mathf.clamp((this.context.time.time - this._jumpDownTime), 0, fullJumpHoldLength) / fullJumpHoldLength;
-                rb.applyImpulse(new Vector3(0, 1, 0).multiplyScalar(this.jumpForce * factor));
+                const factor = this._jumpCount === 2 ? this.doubleJumpForce : this.jumpForce;// Mathf.clamp((this.context.time.time - this._jumpDownTime), 0, fullJumpHoldLength) / fullJumpHoldLength;
+                rb.applyImpulse(new Vector3(0, 1, 0).multiplyScalar(factor));
             }
         }
 
@@ -174,10 +177,10 @@ export class CharacterControllerInput extends Behaviour {
                 const hits = this.context.physics.raycast(this._raycastOptions);
                 this.gameObject.layers.set(currentLayer);
                 if ((hits.length && hits[0].distance > 2 || verticalSpeed < -10)) {
-                    this.animator?.SetBool("falling", true);
+                    this.animator?.setBool("falling", true);
                 }
             }
-            else this.animator?.SetBool("falling", false);
+            else this.animator?.setBool("falling", false);
         }
     }