-hit triggers

frontend/src/GameModel.ts

@@ -5,6 +5,9 @@ import {Vector2, Vector3} from "math.gl";
 import Main from "./Main";
 import GoInside from "./transitions/GoInside";
 import mapRange = gsap.utils.mapRange;
+import Trigger from "./trigers/Trigger";
+import HitTrigger from "./trigers/HitTrigger";
+import UI from "./lib/UI/UI";
 
 
 
@@ -26,6 +29,7 @@ class GameModel {
 
 
     public currentScene:Scenes =Scenes.ROOM
+
     public yMouseCenter: number = 1;
     public yMouseScale: number = 1;
     public sceneHeight =3;
@@ -36,11 +40,26 @@ class GameModel {
     public characterPos: Vector3 = new Vector3(0, 0, 0);
     dayNight: number = 0;
     lockView: boolean =false;
-    constructor() {
-    }
 
 
+    private triggers:Array<Trigger>=[]
 
+    private _hitObjectLabel: string ="";
+   public hitStateChange: boolean =false;
+    public hitObjectLabelPrev: string ="";
+    constructor() {
+
+        this.makeTriggers();
+    }
+    private makeTriggers() {
+        this.triggers.push(new HitTrigger(Scenes.ROOM, "door_HO"))
+    }
+    update(){
+        for(let t of this.triggers){
+            t.check();
+        }
+        this.hitStateChange =false;
+    }
 
 
     public setScene(scenes:Scenes){
@@ -53,6 +72,21 @@ class GameModel {
     transitionComplete(){
        // console.log("complete")
     }
+    get hitObjectLabel(): string {
+        return this._hitObjectLabel;
+    }
+
+    set hitObjectLabel(value: string) {
+        if(value == this._hitObjectLabel){
+            return;
+        }
+      UI.logEvent("HIT",value)
+
+        this.hitStateChange =true;
+        this.hitObjectLabelPrev =   this._hitObjectLabel;
+        this._hitObjectLabel = value;
+    }
+
 
 }
 

frontend/src/Main.ts

@@ -309,10 +309,11 @@ export default class Main {
             this.shadowPassCube.setLightPos(this.room.mainLight.getWorldPos());
         } else {
             this.outside.update()
+
             this.shadowPassCube.setLightPos(this.outside.lightGrave.getWorldPos());
         }
 
-
+        GameModel.update()
 
 
 

frontend/src/Outside.ts

@@ -58,4 +58,6 @@ export default class Outside {
 
         }
     }
+
+
 }

frontend/src/Room.ts

@@ -9,6 +9,7 @@ import {FpsScreen} from "./extras/FpsScreen";
 import ModelRenderer from "./lib/model/ModelRenderer";
 import Mill from "./extras/Mill";
 import Ray from "./lib/Ray";
+import GameModel from "./GameModel";
 
 export default class Room {
     leftHolder: Object3D;
@@ -86,7 +87,11 @@ export default class Room {
 
     checkMouseHit(mouseRay: Ray) {
         for (let m of this.glFTLoader.modelsHit) {
-            m.checkHit(mouseRay);
+           if( m.checkHit(mouseRay)){
+
+               return;
+           }
         }
+        GameModel.hitObjectLabel =""
     }
 }

frontend/src/lib/Camera.ts

@@ -14,7 +14,7 @@ export default class Camera extends UniformGroup {
     public far = 100;
     public ratio = 1
     public lensShift = new Vector2(0, 0)
-    public viewProjectionInv!: Matrix4;
+    public viewProjectionInv= new Matrix4();
     public viewInv!: Matrix4;
     public projectionInv!: Matrix4;
     public perspective: boolean = true;

frontend/src/lib/Ray.ts

@@ -1,52 +1,81 @@
-import {Vector2, Vector3, Vector4} from "math.gl";
+import {Matrix4, Vector2, Vector3, Vector4} from "math.gl";
 import Camera from "./Camera";
 import Renderer from "./Renderer";
 
-export default class Ray{
+export default class Ray {
+    public hit: boolean = false;
+    public hitPos: Vector3 = new Vector3();
     private renderer: Renderer;
-    private rayStart: Vector3 =new Vector3();
-    private rayDir: Vector3 =new Vector3();
-    public hit:boolean=false;
-    public hitPos:Vector3 =new Vector3();
-    constructor(renderer:Renderer) {
-        this.renderer =renderer;
+    private rayStart: Vector3 = new Vector3();
+    private rayDir: Vector3 = new Vector3();
 
+    constructor(renderer: Renderer) {
+        this.renderer = renderer;
+
+    }
+
+    clone() {
+        let r = new Ray(this.renderer)
+        r.rayStart = this.rayStart;
+        r.rayDir = this.rayDir;
+        return r;
     }
-    setFromCamera(camera:Camera,mousePosIn:Vector2)
-    {
+
+    setFromCamera(camera: Camera, mousePosIn: Vector2) {
         let mousePos = mousePosIn.clone().scale(new Vector2(2 / (this.renderer.width / this.renderer.pixelRatio), 2 / (this.renderer.height / this.renderer.pixelRatio)))
         let pos = new Vector4(mousePos.x - 1, (mousePos.y - 1) * -1, 1, 1);
-        if (camera.viewProjectionInv) {
-            pos.transform(camera.viewProjectionInv);
-            this.rayStart = camera.cameraWorld.clone()
-            this.rayDir = new Vector3(pos.x - this.rayStart.x, pos.y - this.rayStart.y, pos.z - this.rayStart.z).normalize()
-        }
+
+        pos.transform(camera.viewProjectionInv);
+        this.rayStart = camera.cameraWorld.clone()
+        this.rayDir = new Vector3(pos.x - this.rayStart.x, pos.y - this.rayStart.y, pos.z - this.rayStart.z).normalize()
+
     }
 
-intersectPlane(position:Vector3,normal:Vector3){
+    intersectPlane(position: Vector3, normal: Vector3) {
 
         let denom = normal.dot(this.rayDir);
         if (Math.abs(denom) > 0.0001) // your favorite epsilon
         {
 
-        let t = (position.clone().subtract(this.rayStart)).dot(normal) / denom;
-        if (t < 0) {
-            this.hit = false;
-            return;
+            let t = (position.clone().subtract(this.rayStart)).dot(normal) / denom;
+            if (t < 0) {
+                this.hit = false;
+                return;
+            } else {
+                this.hit = true;
+                this.rayDir.clone().scale(t);
+                this.hitPos = this.rayStart.clone().add(this.rayDir.clone().scale(t)).subtract(position);
+            }
+
         } else {
-            this.hit =true;
-            this.rayDir.clone().scale(t);
-            this.hitPos =  this.rayStart.clone().add(  this.rayDir.clone().scale(t)).subtract(position);
+            this.hit = false;
+        }
+
+    }
 
+    intersectsBox(min: Vector3, max: Vector3) {
 
-        }
+        const t1 = (min.x - this.rayStart.x) / this.rayDir.x;
+        const t2 = (max.x - this.rayStart.x) / this.rayDir.x;
+        const t3 = (min.y - this.rayStart.y) / this.rayDir.y;
+        const t4 = (max.y - this.rayStart.y) / this.rayDir.y;
+        const t5 = (min.z - this.rayStart.z) / this.rayDir.z;
+        const t6 = (max.z - this.rayStart.z) / this.rayDir.z;
 
+        const tmin = Math.max(Math.max(Math.min(t1, t2), Math.min(t3, t4)), Math.min(t5, t6));
+        const tmax = Math.min(Math.min(Math.max(t1, t2), Math.max(t3, t4)), Math.max(t5, t6));
 
-    } else {
-        this.hit = false;
+        if (tmax < 0) return false;
+        if (tmin > tmax) return false;
+        return true;
     }
 
+    transform(invModel: Matrix4) {
 
-}
+        this.rayDir.add(this.rayStart);
+        this.rayDir.transform(invModel);
+        this.rayStart.transform(invModel);
+        this.rayDir.subtract(this.rayStart);
 
+    }
 }

frontend/src/lib/core/Object3D.ts

@@ -11,7 +11,7 @@ export default class Object3D extends ObjectGPU {
     private _scale = new Vector3(1, 1, 1);
     private _rotation = new Quaternion(0, 0, 0, 1);
     public castShadow :boolean=true;
-    public worldMatrixInv: Matrix4;
+    public worldMatrixInv: Matrix4=new Matrix4();
     constructor(renderer: Renderer, label: string = "") {
         super(renderer, label);
     }

frontend/src/lib/meshes/HitTestObject.ts

@@ -10,18 +10,17 @@ export default class HitTestObject{
 
     }
     checkHit(ray:Ray,invModel:Matrix4){
-/*
-        const t2 = (this.max.x - this.ro.x) / this.rd.x;
-        const t3 = (min.y - this.ro.y) / this.rd.y;
-        const t4 = (max.y - this.ro.y) / this.rd.y;
-        const t5 = (min.z - this.ro.z) / this.rd.z;
-        const t6 = (max.z - this.ro.z) / this.rd.z;
-
-        const tmin = Math.max(Math.max(Math.min(t1, t2), Math.min(t3, t4)), Math.min(t5, t6));
-        const tmax = Math.min(Math.min(Math.max(t1, t2), Math.max(t3, t4)), Math.max(t5, t6));
-
-        if (tmax < 0) return false;
-        if (tmin > tmax) return false;*/
+
+        let rayT = ray.clone();
+        rayT.transform(invModel);
+        if(rayT.intersectsBox(this.min,this.max))
+        {
+
+            return true;
+
+        }
+
+        return false;
 
     }
 }

frontend/src/lib/model/Model.ts

@@ -1,45 +1,51 @@
-
 import Renderer from "../Renderer";
 import Material from "../core/Material";
 import Mesh from "../core/Mesh";
 import Object3D from "../core/Object3D";
 import ModelTransform from "./ModelTransform";
 import HitTestObject from "../meshes/HitTestObject";
 import Ray from "../Ray";
+import GameModel from "../../GameModel";
 
 
-export default class Model extends Object3D
-{
+export default class Model extends Object3D {
     material!: Material;
-    mesh!:Mesh
+    mesh!: Mesh
 
     public modelTransform: ModelTransform;
-    public visible: boolean =true;
+    public visible: boolean = true;
     public hitTestObject: HitTestObject;
-    public canHitTest: boolean =false;
+    public canHitTest: boolean = false;
 
-    constructor(renderer:Renderer,label:string) {
-        super(renderer,label);
-        this.modelTransform =new ModelTransform(renderer,label+"_transform")
+    constructor(renderer: Renderer, label: string) {
+        super(renderer, label);
+        this.modelTransform = new ModelTransform(renderer, label + "_transform")
 
         this.renderer.addModel(this);
     }
-    public update()
-    {
-        if(!this._dirty)return;
-            this.updateMatrices()
 
-    }
-    protected updateMatrices(){
-        super.updateMatrices();
+    public update() {
+        if (!this._dirty) return;
+        this.updateMatrices()
 
-        this.modelTransform.setWorldMatrix(this.worldMatrix);
     }
-    public checkHit(ray:Ray)
-    {
-        this.hitTestObject.checkHit(ray,this.worldMatrixInv)
+
+    public checkHit(ray: Ray) {
+        if(!this.visible) return false;
+        if(this.hitTestObject.checkHit(ray, this.worldMatrixInv)){
+            GameModel.hitObjectLabel =this.label;
+            return true;
+        }
+        return false;
     }
+
     destroy() {
-        if(this.parent)this.parent.removeChild(this);
+        if (this.parent) this.parent.removeChild(this);
+    }
+
+    protected updateMatrices() {
+        super.updateMatrices();
+
+        this.modelTransform.setWorldMatrix(this.worldMatrix);
     }
 }

frontend/src/renderPasses/LightOutsideRenderPass.ts

@@ -34,7 +34,7 @@ export default class LightOutsideRenderPass extends RenderPass  {
     private globalLightMaterial: Material;
     private blitGlobalLight: Blit;
 
-    private sunLightColor: ColorV = new ColorV(1.00,0.71,0.39,1.00);
+    private sunLightColor: ColorV = new ColorV(1.00,0.83,0.63,1.00);
     private sunLightStrength: number =5.6;
 
     private topColorDay: ColorV = new ColorV(   0.73,0.99,0.95,0.40);

frontend/src/shaders/GlobalLightOutsideShader.ts

@@ -159,7 +159,7 @@ fn mainFragment(@location(0)  uv0: vec2f) -> @location(0) vec4f
   for (var y = -1; y <= 1; y++) {
     for (var x = -1; x <= 1; x++) {
       let offset = vec2<f32>(vec2i(x, y)) * oneOverShadowDepthTextureSize;
-    shadowVal += textureSampleCompare(shadow, mySamplerComp, shadowUV+offset, shadowProjN.z-0.003);
+    shadowVal += textureSampleCompare(shadow, mySamplerComp, shadowUV+offset, shadowProjN.z-0.007);
   }
   }
   shadowVal/=9.0;

frontend/src/trigers/HitTrigger.ts

@@ -0,0 +1,36 @@
+import Trigger from "./Trigger";
+import GameModel, {Scenes} from "../GameModel";
+import UI from "../lib/UI/UI";
+
+export default class HitTrigger extends Trigger{
+    private objectLabel: string;
+    constructor(scene:Scenes,objectLabel:string) {
+        super(scene);
+        this.objectLabel =objectLabel;
+
+    }
+    check() {
+        if(!super.check())return false;
+        if(!GameModel.hitStateChange)return
+        if(GameModel.hitObjectLabel ==this.objectLabel) {
+           this.over()
+            return true;
+        }
+        if(GameModel.hitObjectLabelPrev ==this.objectLabel) {
+            this.out()
+            return true;
+        }
+
+
+
+
+    }
+
+    private over() {
+        //UI.logEvent("Over", this.objectLabel);
+    }
+
+    private out() {
+      //  UI.logEvent("Out", this.objectLabel);
+    }
+}