@needle-tools/engine 2.36.0-pre → 2.38.0-pre

package/src/engine-components/Camera.ts

@@ -7,6 +7,7 @@ import { RGBAColor } from "./js-extensions/RGBAColor";
 import { PerspectiveCamera } from "three";
 import { XRSessionMode } from "../engine/engine_setup";
 import { ICamera } from "../engine/engine_types"
+import { showBalloonMessage } from "../engine/debug/debug";
 
 export enum ClearFlags {
     Skybox = 1,
@@ -127,6 +128,10 @@ export class Camera extends Behaviour implements ICamera {
         this.applyClearFlagsIfIsActiveCamera();
     }
 
+    onDisable() {
+        this.context.removeCamera(this);
+    }
+
     buildCamera() {
         if (this._cam) return;
 
@@ -168,6 +173,8 @@ export class Camera extends Behaviour implements ICamera {
     }
 
     applyClearFlagsIfIsActiveCamera() {
+        if (debug)
+            showBalloonMessage("apply Camera clear flags");
         if (this._cam && this.context.mainCameraComponent === this) {
             switch (this._clearFlags) {
                 case ClearFlags.Skybox:
@@ -203,12 +210,22 @@ export class Camera extends Behaviour implements ICamera {
         const session = this.context.renderer.xr?.getSession();
         if (!session) return false;
         const environmentBlendMode = session.environmentBlendMode;
+        if (debug)
+            showBalloonMessage("Environment blend mode: " + environmentBlendMode + " on " + navigator.userAgent);
         const transparent = environmentBlendMode === 'additive' || environmentBlendMode === 'alpha-blend';
-        // workaround for Quest 2 returning opaque when it should be alpha-blend
-        // check user agent if this is the Quest browser and return true if so
 
-        if (environmentBlendMode === "opaque" && navigator.userAgent?.includes("OculusBrowser")) {
-            if (this.context.xrSessionMode === XRSessionMode.ImmersiveAR) return true;
+        if (this.context.xrSessionMode === XRSessionMode.ImmersiveAR) {
+            if (environmentBlendMode === "opaque") {
+                // workaround for Quest 2 returning opaque when it should be alpha-blend
+                // check user agent if this is the Quest browser and return true if so
+                if (navigator.userAgent?.includes("OculusBrowser")) {
+                    return true;
+                }
+                // Mozilla WebXR Viewer
+                else if (navigator.userAgent?.includes("Mozilla") && navigator.userAgent?.includes("Mobile WebXRViewer/v2")) {
+                    return true;
+                }
+            }
         }
         return transparent;
     }

package/src/engine-components/CharacterController.ts

@@ -0,0 +1,171 @@
+import { Ray, Vector3 } from "three";
+import { Mathf } from "../engine/engine_math";
+import { serializeable } from "../engine/engine_serialization";
+import { Collision } from "../engine/engine_types";
+import { CapsuleCollider } from "./Collider";
+import { Behaviour, GameObject } from "./Component";
+import { Rigidbody } from "./RigidBody";
+import { Animator } from "./Animator"
+import { RaycastOptions } from "../engine/engine_physics";
+import { getWorldPosition } from "../engine/engine_three_utils";
+
+export class CharacterController extends Behaviour {
+
+    @serializeable(Vector3)
+    center: Vector3 = new Vector3(0, 0, 0);
+    @serializeable()
+    radius: number = .5;
+    @serializeable()
+    height: number = 2;
+
+    private _rigidbody: Rigidbody | null = null;
+    get rigidbody(): Rigidbody {
+        if (this._rigidbody) return this._rigidbody;
+        this._rigidbody = this.gameObject.getComponent(Rigidbody);
+        if (!this._rigidbody)
+            this._rigidbody = this.gameObject.addNewComponent(Rigidbody) as Rigidbody;
+        return this.rigidbody;
+    }
+
+    onEnable() {
+        let rb = this.rigidbody;
+        let collider = this.gameObject.getComponent(CapsuleCollider);
+        if (!collider)
+            collider = this.gameObject.addNewComponent(CapsuleCollider) as CapsuleCollider;
+        // rb.isKinematic = true;
+        collider.center.copy(this.center);
+        collider.radius = this.radius;
+        collider.height = this.height;
+        this.gameObject.rotation.x = 0;
+        this.gameObject.rotation.z = 0;
+        rb.lockRotationX = true;
+        rb.lockRotationY = true;
+        rb.lockRotationZ = true;
+
+        // TODO: this doesnt work yet
+        // setInterval(()=>{
+        //     this.rigidbody.isKinematic = !this.rigidbody.isKinematic;
+        //     console.log(this.rigidbody.isKinematic);
+        // }, 1000)
+    }
+
+    move(vec: Vector3) {
+        this.gameObject.position.add(vec);
+    }
+
+    private _activeGroundCollisions: Set<Collision> = new Set();
+
+    onCollisionEnter(col: Collision) {
+        for (const contact of col.contacts) {
+            // console.log(contact.normal);
+            if (contact.normal.y > .1) {
+                this._activeGroundCollisions.add(col);
+                break;
+            }
+        }
+    }
+
+    onCollisionExit(col: Collision) {
+        this._activeGroundCollisions.delete(col);
+    }
+
+    get isGrounded(): boolean { return this._activeGroundCollisions.size > 0; }
+}
+
+export class CharacterControllerInput extends Behaviour {
+
+    @serializeable(CharacterController)
+    controller?: CharacterController;
+
+    @serializeable()
+    movementSpeed: number = 2;
+
+    @serializeable()
+    rotationSpeed: number = 2;
+
+    @serializeable()
+    jumpForce: number = 1;
+
+    @serializeable(Animator)
+    animator?: Animator;
+
+    private _currentSpeed: Vector3 = new Vector3(0, 0, 0);
+    private _currentAngularSpeed: Vector3 = new Vector3(0, 0, 0);
+
+    private _temp: Vector3 = new Vector3(0, 0, 0);
+    private _jumpCount: number = 0;
+
+    update() {
+
+        if (this.controller?.isGrounded) {
+            this._jumpCount = 0;
+            this.animator?.SetBool("doubleJump", false);
+        }
+
+        const forward = this.context.input.isKeyPressed("w");
+        const backward = this.context.input.isKeyPressed("s");
+        const rotateLeft = this.context.input.isKeyPressed("a");
+        const rotateRight = this.context.input.isKeyPressed("d");
+        const jump = this.context.input.isKeyDown(" ");
+        // if (jumpDown) this._jumpDownTime = this.context.time.time;
+        // const jumpUp = this.context.input.isKeyUp(" ");
+
+        const step = forward ? 1 : 0 + backward ? -1 : 0;
+        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._temp.copy(this._currentSpeed);
+        this._temp.applyQuaternion(this.gameObject.quaternion);
+        if (this.controller) this.controller.move(this._temp);
+        else this.gameObject.position.add(this._temp);
+
+        const rotation = rotateLeft ? 1 : 0 + rotateRight ? -1 : 0;
+        this._currentAngularSpeed.y += Mathf.toRadians(rotation * this.rotationSpeed) * this.context.time.deltaTime;
+        this.gameObject.rotateY(this._currentAngularSpeed.y);
+
+
+        this._currentSpeed.multiplyScalar(1 - this.context.time.deltaTime * 10);
+        this._currentAngularSpeed.y *= 1 - this.context.time.deltaTime * 10;
+
+        if (this.controller && jump && this.jumpForce > 0) {
+            let canJump = this.controller?.isGrounded;
+            if (!this.controller?.isGrounded && this._jumpCount === 1) {
+                canJump = true;
+                this.animator?.SetBool("doubleJump", true);
+            }
+
+            if (canJump) {
+                this._jumpCount += 1;
+                // 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));
+            }
+        }
+
+        if (this.controller) {
+            // TODO: should probably raycast to the ground or check if we're still in the jump animation
+            const verticalSpeed = this.controller?.rigidbody.getVelocity().y;
+            if (verticalSpeed < -1) {
+                if (!this._raycastOptions.ray) this._raycastOptions.ray = new Ray();
+                this._raycastOptions.ray.origin.copy(getWorldPosition(this.gameObject));
+                this._raycastOptions.ray.direction.set(0, -1, 0);
+                const currentLayer = this.layer;
+                this.gameObject.layers.disableAll();
+                this.gameObject.layers.set(2);
+                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);
+                }
+            }
+            else this.animator?.SetBool("falling", false);
+        }
+    }
+
+    private _raycastOptions = new RaycastOptions();
+}

package/src/engine-components/Collider.ts

@@ -1,18 +1,10 @@
 import { Behaviour } from "./Component";
 import { Rigidbody } from "./RigidBody";
 import { serializeable } from "../engine/engine_serialization_decorator";
-import { Event, Object3D, Vector3 } from "three"
-import { Shape } from "cannon-es";
-import { IColliderProvider, registerColliderProvider } from "../engine/engine_physics";
+import { Event, Mesh, Object3D, Vector3 } from "three"
+// import { IColliderProvider, registerColliderProvider } from "../engine/engine_physics";
 import { ICollider } from "../engine/engine_types";
-import { getComponentInChildren } from "../engine/engine_components";
 
-class ColliderProvider implements IColliderProvider {
-    getCollider(obj: Object3D): ICollider {
-        return getComponentInChildren<Collider>(obj, Collider);
-    }
-}
-registerColliderProvider(new ColliderProvider());
 
 export class Collider extends Behaviour implements ICollider {
 
@@ -25,14 +17,14 @@ export class Collider extends Behaviour implements ICollider {
     @serializeable()
     isTrigger: boolean = false;
 
-    protected _shape: Shape | null = null;
 
     awake() {
         super.awake();
-        this._shape = null;
+        if (!this.attachedRigidbody)
+            this.attachedRigidbody = this.gameObject.getComponentInParent(Rigidbody);
     }
 
-    start(){
+    start() {
         if (!this.attachedRigidbody)
             this.attachedRigidbody = this.gameObject.getComponentInParent(Rigidbody);
     }
@@ -44,9 +36,7 @@ export class Collider extends Behaviour implements ICollider {
     }
 
     onDisable() {
-        if (this._shape) {
-
-        }
+        this.context.physics.removeBody(this);
     }
 
 }
@@ -57,45 +47,65 @@ export class SphereCollider extends Collider {
     @serializeable()
     radius: number = .5;
     @serializeable(Vector3)
-    center: THREE.Vector3 = new Vector3(0, 0, 0);
+    center: Vector3 = new Vector3(0, 0, 0);
 
     onEnable() {
         super.onEnable();
-        if (!this._shape)
-            this._shape = this.context.physics.addSphereCollider(this.gameObject, this.center, this.radius, this.attachedRigidbody);
+        this.context.physics.addSphereCollider(this, this.center, this.radius);
     }
-
-    // onDisable() {
-    //     // if (this._shape)
-    //     //     this.context.physics.removeShape(this.gameObject, this._shape);
-    // }
 }
 
 export class BoxCollider extends Collider {
 
     @serializeable(Vector3)
-    size: THREE.Vector3 = new Vector3(1, 1, 1);
+    size: Vector3 = new Vector3(1, 1, 1);
     @serializeable(Vector3)
-    center: THREE.Vector3 = new Vector3(0, 0, 0);
+    center: Vector3 = new Vector3(0, 0, 0);
 
     onEnable() {
         super.onEnable();
-        if (!this._shape)
-            this._shape = this.context.physics.addBoxCollider(this.gameObject, this.isTrigger, this.center, this.size, this.attachedRigidbody);
+        this.context.physics.addBoxCollider(this, this.center, this.size);
     }
+}
 
-    // onDisable() {
-    //     // if (this._shape) {
-    //     //     this.context.physics.removeShape(this.gameObject, this._shape);
-    //     // }
-    // }
+
+export class MeshCollider extends Collider {
+
+
+    sharedMesh?: Mesh;
+    @serializeable()
+    convex: boolean = false;
+
+    awake() {
+        console.log(this);
+    }
+
+    onEnable() {
+        super.onEnable();
+        if (!this.sharedMesh?.isMesh) {
+            // HACK using the renderer mesh
+            if (this.gameObject instanceof Mesh) {
+                this.sharedMesh = this.gameObject;
+            }
+        }
+        if (this.sharedMesh?.isMesh)
+            this.context.physics.addMeshCollider(this, this.sharedMesh, this.convex);
+    }
 }
 
 
-// export class MeshCollider extends Collider {
+export class CapsuleCollider extends Collider {
+    @serializeable(Vector3)
+    center: Vector3 = new Vector3(0, 0, 0);
+
+    @serializeable()
+    radius: number = .5;
+    @serializeable()
+    height: number = 2;
+
+    onEnable() {
+        super.onEnable();
+        this.context.physics.addCapsuleCollider(this, this.center, this.height, this.radius);
+    }
 
-//     onEnable() {
-//         if (this.enabled)
-//             this.context.physics.addMeshCollider(this.gameObject);
-//     }
-// }
+}

package/src/engine-components/Component.ts

@@ -6,7 +6,7 @@ import { Context, FrameEvent } from "../engine/engine_setup";
 import * as main from "../engine/engine_mainloop_utils";
 import { Object3D } from "three";
 import { syncDestroy, syncInstantiate } from "../engine/engine_networking_instantiate";
-import { ConstructorConcrete, SourceIdentifier, IComponent, IGameObject, Constructor, GuidsMap, UIDProvider, Collision } from "../engine/engine_types";
+import { ConstructorConcrete, SourceIdentifier, IComponent, IGameObject, Constructor, GuidsMap, UIDProvider, Collision, ICollider } from "../engine/engine_types";
 import { addNewComponentInstance, destroyComponentInstance, findObjectOfType, findObjectsOfType, getComponent, getComponentInChildren, getComponentInParent, getComponents, getComponentsInChildren, getComponentsInParent, getOrAddComponent, moveComponentInstance, removeComponent } from "../engine/engine_components";
 import { findByGuid, destroy, InstantiateOptions, instantiate, HideFlags, foreachComponent, markAsInstancedRendered, isActiveInHierarchy, isActiveSelf, isUsingInstancing, setActive } from "../engine/engine_gameobject";
 
@@ -317,9 +317,8 @@ class Component implements IComponent, EventTarget {
     onDestroy() {
         this.__destroyed = true;
     }
+    onValidate?(prop?: string): void;
     start?(): void;
-    // available update loop events:
-    // earlyUpdate, update, lateUpdate, onBeforeRender, onAfterRender
     earlyUpdate?(): void;
     update?(): void;
     lateUpdate?(): void;
@@ -328,12 +327,11 @@ class Component implements IComponent, EventTarget {
 
     onCollisionEnter?(col: Collision);
     onCollisionExit?(col: Collision);
-    onCollisionExitRaw?(col: Collision);
     onCollisionStay?(col: Collision);
-
-    onTriggerEnter?(col: Collision);
-    onTriggerStay?(col: Collision);
-    onTriggerExit?(col: Collision);
+    
+    onTriggerEnter?(col: ICollider);
+    onTriggerStay?(col: ICollider);
+    onTriggerExit?(col: ICollider);
 
     startCoroutine(routine: Generator, evt: FrameEvent = FrameEvent.Update): Generator {
         return this.context.registerCoroutineUpdate(this, routine, evt);
@@ -360,13 +358,19 @@ class Component implements IComponent, EventTarget {
 
     get __internalDidAwakeAndStart() { return this.__didAwake && this.__didStart; }
 
+
+    constructor() {
+        // super();
+        this.__internalNewInstanceCreated();
+    }
+
     __internalNewInstanceCreated() {
         this.__didAwake = false;
         this.__didStart = false;
         this.__didEnable = false;
         this.__isEnabled = undefined;
         this.__destroyed = false;
-        this.__internalResetsCachedPhysicsData();
+        // this.__internalResetsCachedPhysicsData();
     }
 
     __internalAwake() {
@@ -397,9 +401,9 @@ class Component implements IComponent, EventTarget {
     __internalDisable() {
         if (!this.__didEnable) return;
         this.__didEnable = false;
-        this._collisionExitRoutine = undefined;
+        // this._collisionExitRoutine = undefined;
         this.onDisable();
-        this._collisions?.clear();
+        // this._collisions?.clear();
         // if we do this after processing the callback
         this.__isEnabled = false;
     }
@@ -437,126 +441,7 @@ class Component implements IComponent, EventTarget {
         }
     }
 
-    constructor() {
-        // super();
-        this.__internalNewInstanceCreated();
-    }
-
-    private _collisionExitRoutine: any;
-    private _collisions: Map<Object3D, { col: Collision, frame: number, exitFrame?: number }> | null = null;
-
-    private _triggerExitRoutine: any;
-    private _triggerCollisions: Map<Object3D, { col: Collision, frame: number, exitFrame?: number }> | null = null;
-
-    get collisionsCount() { return this._collisions?.size ?? 0; }
-
-    private __internalResetsCachedPhysicsData() {
-        this._collisionExitRoutine = null;
-        this._collisions = null;
-        this._triggerExitRoutine = null;
-        this._triggerCollisions = null;
-    }
-
-    __internalHandleCollision(col: Collision, isTriggerCollision: boolean) {
-        if (isTriggerCollision) {
-            if (!this.onTriggerEnter && !this.onTriggerStay && !this.onTriggerExit) return;
-        }
-        else {
-            if (!this.onCollisionEnter && !this.onCollisionStay && !this.onCollisionExit) return;
-        }
-
-        const otherObject = col.gameObject;
-
-        // lazily create the maps
-        if (isTriggerCollision && !this._triggerCollisions) this._triggerCollisions = new Map();
-        else if (!this._collisions) this._collisions = new Map();
-
-        // select the correct map
-        const collection = isTriggerCollision ? this._triggerCollisions! : this._collisions!;
-
-        if (collection.has(otherObject)) {
-            const cur = collection.get(otherObject)!;
-            // console.log("STAY", this.name, this.context.time.frameCount)
-            // cur.exitFrame = undefined;
-            cur.frame = this.context.time.frameCount;
-            cur.col = col;
-            if (isTriggerCollision)
-                this.onTriggerStay?.(col);
-            else
-                this.onCollisionStay?.call(this, col);
-        }
-        else {
-            // console.log("START", this.name);
-            const entry = { col, frame: this.context.time.frameCount };
-            collection.set(otherObject, entry);
-            if (isTriggerCollision)
-                this.onTriggerEnter?.(col);
-            else
-                this.onCollisionEnter?.call(this, col);
-        }
-    }
-
-    __internalHandleExitCollisionEvent(obj: Object3D, isTriggerCollision: boolean) {
-        if (isTriggerCollision) {
-            if (!this._triggerCollisions) return;
-        }
-        else {
-            if (!this._collisions) return;
-        }
-
-        const collection = isTriggerCollision ? this._triggerCollisions! : this._collisions!;
-
-        const collision = collection.get(obj);
-        if (!collision) return;
-        collision.exitFrame = this.context.time.frameCount;
-        // console.log("EXIT col", this.name, this.context.time.frameCount);
-        // if (this.onCollisionExit !== undefined)
-        this.__waitForCollisionExit(isTriggerCollision);
-        if (!isTriggerCollision)
-            this.onCollisionExitRaw?.call(this, collision.col);
-        // this._collisions.delete(obj);
-    }
-
-    private __waitForCollisionExit(isTriggerCollision: boolean) {
-        const routine = isTriggerCollision ? this._triggerExitRoutine : this._collisionExitRoutine;
-        if (routine) return;
-
-        const collection = isTriggerCollision ? this._triggerCollisions! : this._collisions!;
-        const self = this;
-        const frames = 10;
-        function* delayedExitRoutine() {
-            while (collection && collection.size > 0) {
-                for (let other of collection.keys()) {
-                    const entry = collection!.get(other)!;
-                    if (entry.frame !== undefined && self.context.time.frameCount - entry.frame >= frames) {
-                        // console.log("EXIT real", self.name, entry.col.gameObject.name, collection);
-                        collection!.delete(other);
-                        if (isTriggerCollision)
-                            self.onTriggerExit?.(entry.col);
-                        else
-                            self.onCollisionExit?.call(self, entry.col);
-                    }
-                }
-                for (let i = 0; i < frames; i++)
-                    yield;
-            }
-            if (isTriggerCollision)
-                self._triggerExitRoutine = undefined;
-            else
-                self._collisionExitRoutine = null;
-            // console.log("DONE", self.name);
-        }
-
-        const newRoutine = this.startCoroutine(delayedExitRoutine(), FrameEvent.OnAfterRender);
-        if (isTriggerCollision)
-            this._triggerExitRoutine = newRoutine;
-        else
-            this._collisionExitRoutine = newRoutine
-    }
-
-
     // TODO move this to threeutils
-
     // we need a copy for modifying the values to local space
     private static _worldPositionBuffer: THREE.Vector3 = new THREE.Vector3();
     private static _worldQuaternionBuffer: THREE.Quaternion = new THREE.Quaternion();

package/src/engine-components/DragControls.ts

@@ -230,7 +230,7 @@ export class DragControls extends Interactable implements IPointerDownHandler, I
         this._dragHelper.onUpdate(this.context);
         for (const rb of this._draggingRigidbodies) {
             rb.wakeUp();
-            rb.setBodyFromGameObject();
+            rb.resetVelocities();
         }
     }
 
@@ -238,6 +238,9 @@ export class DragControls extends Interactable implements IPointerDownHandler, I
         if (!this || !this._isDragging) return;
         this._isDragging = false;
         if (!this._dragHelper) return;
+        for(const rb of this._draggingRigidbodies){
+            rb.setVelocity(rb.smoothedVelocity);
+        }
         this._draggingRigidbodies.length = 0;
         const selected = this._dragHelper.selected;
         if (debug)
@@ -323,8 +326,8 @@ class DragHelper {
         if (this._selected && context) {
             for (const rb of this._rbs) {
                 rb.wakeUp();
-                if (!rb.smoothedVelocity) continue;
-                rb.setVelocity(rb.smoothedVelocity.x, rb.smoothedVelocity.y, rb.smoothedVelocity.z);
+                // if (!rb.smoothedVelocity) continue;
+                rb.setVelocity(0,0,0);
             }
         }
 
@@ -358,7 +361,7 @@ class DragHelper {
             this._groundOffset.set(0, 0, 0);
             this._requireUpdateGroundPlane = true;
 
-            this._rbs = GameObject.getComponentsInChildren(this._selected, Rigidbody);
+            // this._rbs = GameObject.getComponentsInChildren(this._selected, Rigidbody);
             this.onUpdateScreenSpacePlane();
         }
     }
@@ -518,7 +521,8 @@ class DragHelper {
 
         for (const rb of this._rbs) {
             rb.wakeUp();
-            rb.setBodyFromGameObject({ x: 0, y: 0, z: 0 });
+            rb.resetForcesAndTorques();
+            // rb.setBodyFromGameObject({ x: 0, y: 0, z: 0 });
             rb.setAngularVelocity(0, 0, 0);
         }
     }

package/src/engine-components/Light.ts

@@ -130,6 +130,9 @@ export class Light extends Behaviour implements ILight {
     get shadowNormalBias(): number { return this._shadowNormalBias; }
     private _shadowNormalBias: number = 1;
 
+    /** when enabled this will remove the multiplication when setting the shadow bias settings initially */
+    private _overrideShadowBiasSettings: boolean = false;
+
     @serializeable()
     set shadows(val: LightShadows) {
         this._shadows = val;
@@ -338,7 +341,7 @@ export class Light extends Behaviour implements ILight {
 
         if (this.light !== undefined) {
             this._intensity = this.light.intensity;
-            
+
             if (this.shadows !== LightShadows.None) {
                 this.light.castShadow = true;
             }
@@ -353,8 +356,19 @@ export class Light extends Behaviour implements ILight {
                 this.light.shadow.mapSize.width = 2048;
                 this.light.shadow.mapSize.height = 2048;
             }
-            this.light.shadow.bias = this.shadowBias * 0.00001;
-            this.light.shadow.normalBias = this.shadowNormalBias * .0001;
+
+            if (debug)
+                console.log("Override shadow bias?", this._overrideShadowBiasSettings, this.shadowBias, this.shadowNormalBias);
+
+            // shadow bias settings
+            if (this._overrideShadowBiasSettings === true) {
+                this.light.shadow.bias = this.shadowBias;
+                this.light.shadow.normalBias = this.shadowNormalBias;
+            }
+            else {
+                this.light.shadow.bias = this.shadowBias * 0.00001;
+                this.light.shadow.normalBias = this.shadowNormalBias * .0001;
+            }
 
             // console.log(this.light.shadow, this);
             const cam = this.light.shadow.camera as THREE.OrthographicCamera;