@directivegames/genesys.js 3.1.24

package/dist/games/examples/vehicle/primitive-vehicle.d.ts

@@ -0,0 +1,21 @@
+import * as ENGINE from 'genesys.js';
+import { BaseVehicle } from './base-vehicle.js';
+/**
+ * A simple vehicle with a box geometry
+ *
+ * Key points:
+ * - Movement parameters configured in createVehicleMovementComponent
+ * - No component is persisted (root is transient) in order to support recreating all the components in code (which is desired)
+ * - Rely on the builtin feature to create the wheel mesh (createWheelMeshes = true), no need to create them manually
+ * - All decorative meshes have physics disabled won't mess with the handling
+ * - Find the tail light meshes after the constructor so it works with deserialized actor
+ * - Rely on the base vehicle class to handle the camera and player interaction
+ */
+export declare class PrimitiveVehicle extends BaseVehicle {
+    private tailLightComponents;
+    constructor(options: ENGINE.PawnOptions);
+    tickPrePhysics(deltaTime: number): void;
+    private updateBrakeLights;
+    static createDecorativeMeshes(rootComponent: ENGINE.MeshComponent): void;
+    static createVehicleMovementComponent(): ENGINE.VehicleMovementComponent;
+}

package/dist/games/examples/vehicle/primitive-vehicle.js

@@ -0,0 +1,269 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var PrimitiveVehicle_1;
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+import { BaseVehicle } from './base-vehicle.js';
+/**
+ * A simple vehicle with a box geometry
+ *
+ * Key points:
+ * - Movement parameters configured in createVehicleMovementComponent
+ * - No component is persisted (root is transient) in order to support recreating all the components in code (which is desired)
+ * - Rely on the builtin feature to create the wheel mesh (createWheelMeshes = true), no need to create them manually
+ * - All decorative meshes have physics disabled won't mess with the handling
+ * - Find the tail light meshes after the constructor so it works with deserialized actor
+ * - Rely on the base vehicle class to handle the camera and player interaction
+ */
+let PrimitiveVehicle = PrimitiveVehicle_1 = class PrimitiveVehicle extends BaseVehicle {
+    constructor(options) {
+        // Create chassis mesh
+        const rootComponent = new ENGINE.MeshComponent({
+            geometry: new THREE.BoxGeometry(2, 1, 4),
+            material: new THREE.MeshStandardMaterial({
+                color: 0x4444FF,
+                roughness: 0.7,
+                metalness: 0.3,
+            }),
+            physicsOptions: {
+                enabled: true,
+                motionType: ENGINE.PhysicsMotionType.Dynamic,
+                generateCollisionEvents: true,
+            },
+        });
+        rootComponent.castShadow = true;
+        rootComponent.name = 'chassis';
+        // mark the component as transient, this prevents all the components from being saved since we're recreating them in code
+        rootComponent.setTransient(true);
+        options.rootComponent = rootComponent;
+        // create decorative meshes
+        PrimitiveVehicle_1.createDecorativeMeshes(rootComponent);
+        options.movementComponent = PrimitiveVehicle_1.createVehicleMovementComponent();
+        super(options);
+        Object.defineProperty(this, "tailLightComponents", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        this.tailLightComponents = this.getComponents(ENGINE.MeshComponent)
+            .filter((component) => component.name.includes('_taillight'));
+    }
+    tickPrePhysics(deltaTime) {
+        super.tickPrePhysics(deltaTime);
+        this.updateBrakeLights();
+    }
+    updateBrakeLights() {
+        if (!this.movementComponent || this.tailLightComponents.length === 0)
+            return;
+        const inputState = this.movementComponent.getInputState();
+        const isBraking = inputState.brakeInput > 0;
+        for (const tailLightComponent of this.tailLightComponents) {
+            const mesh = tailLightComponent.getMesh();
+            if (mesh && mesh.material) {
+                const material = mesh.material;
+                if (isBraking) {
+                    material.color.setHex(0xFF0000);
+                }
+                else {
+                    material.color.setHex(0xFFFFFF);
+                }
+            }
+        }
+    }
+    static createDecorativeMeshes(rootComponent) {
+        // Add windshield
+        const windshieldComponent = new ENGINE.MeshComponent({
+            geometry: new THREE.BoxGeometry(1.8, 1.8, 0.1),
+            material: new THREE.MeshStandardMaterial({
+                color: 0x87CEEB,
+                transparent: true,
+                opacity: 0.5,
+                roughness: 0.1,
+                metalness: 0.1,
+            }),
+            physicsOptions: {
+                enabled: false,
+            }
+        });
+        windshieldComponent.position.set(0, 0.4, -1.5);
+        windshieldComponent.rotation.x = Math.PI / 8; // Slight tilt
+        windshieldComponent.name = 'windshield';
+        rootComponent.add(windshieldComponent);
+        // Add left headlight
+        const leftHeadlightComponent = new ENGINE.MeshComponent({
+            geometry: new THREE.CylinderGeometry(0.15, 0.15, 0.1, 8),
+            material: new THREE.MeshStandardMaterial({
+                color: 0xFFFFFF,
+                emissive: 0xFFFFAA,
+                emissiveIntensity: 0.3,
+            }),
+            physicsOptions: {
+                enabled: false,
+            }
+        });
+        leftHeadlightComponent.position.set(-0.7, 0.1, -2.05);
+        leftHeadlightComponent.rotation.z = Math.PI / 2;
+        leftHeadlightComponent.name = 'left_headlight';
+        rootComponent.add(leftHeadlightComponent);
+        // Add right headlight
+        const rightHeadlightComponent = new ENGINE.MeshComponent({
+            geometry: new THREE.CylinderGeometry(0.15, 0.15, 0.1, 8),
+            material: new THREE.MeshStandardMaterial({
+                color: 0xFFFFFF,
+                emissive: 0xFFFFAA,
+                emissiveIntensity: 0.3,
+            }),
+            physicsOptions: {
+                enabled: false,
+            }
+        });
+        rightHeadlightComponent.position.set(0.7, 0.1, -2.05);
+        rightHeadlightComponent.rotation.z = Math.PI / 2;
+        rightHeadlightComponent.name = 'right_headlight';
+        rootComponent.add(rightHeadlightComponent);
+        // Add left tail light
+        const leftTaillightMaterial = new THREE.MeshStandardMaterial({
+            color: 0xFF0000,
+            emissive: 0x440000,
+            emissiveIntensity: 0.2,
+        });
+        const leftTaillightComponent = new ENGINE.MeshComponent({
+            geometry: new THREE.CylinderGeometry(0.1, 0.1, 0.1, 8),
+            material: leftTaillightMaterial,
+            physicsOptions: {
+                enabled: false,
+            }
+        });
+        leftTaillightComponent.position.set(-0.7, 0.1, 2.05);
+        leftTaillightComponent.rotation.z = Math.PI / 2;
+        leftTaillightComponent.name = 'left_taillight';
+        rootComponent.add(leftTaillightComponent);
+        // Add right tail light
+        const rightTaillightMaterial = new THREE.MeshStandardMaterial({
+            color: 0xFF0000,
+            emissive: 0x440000,
+            emissiveIntensity: 0.2,
+        });
+        const rightTaillightComponent = new ENGINE.MeshComponent({
+            geometry: new THREE.CylinderGeometry(0.1, 0.1, 0.1, 8),
+            material: rightTaillightMaterial,
+            physicsOptions: {
+                enabled: false,
+            }
+        });
+        rightTaillightComponent.position.set(0.7, 0.1, 2.05);
+        rightTaillightComponent.rotation.z = Math.PI / 2;
+        rightTaillightComponent.name = 'right_taillight';
+        rootComponent.add(rightTaillightComponent);
+    }
+    static createVehicleMovementComponent() {
+        const wheelBaseWidth = 2.6;
+        const wheelBaseLength = 3.0;
+        const wheelBaseHeight = 0;
+        const suspensionRestLength = 0.6;
+        const wheelRadius = 0.5;
+        const wheelWidth = 0.4;
+        const suspensionStiffness = 20;
+        const suspensionCompression = 0.83;
+        const suspensionRelaxation = 0.88;
+        const maxSuspensionForce = 6000.0;
+        const maxSuspensionTravel = 5.0;
+        const sideFrictionStiffness = 2;
+        const frictionSlip = 8;
+        const options = {
+            ...ENGINE.BasePawnMovementComponent.DEFAULT_OPTIONS,
+            maxEnginePower: 35,
+            maxSteeringAngle: Math.PI / 6, // 30 degrees
+            maxBrakeForce: 1,
+            engineResponseRate: 8.0,
+            steeringResponseRate: 12.0,
+            brakeResponseRate: 15.0,
+            createWheelMeshes: true,
+            wheelMaterialColor: 0x333333,
+            autoBreakWhenNotPossessed: 1,
+            autoStopBreak: 0.5,
+            wheels: [
+                // Default 4-wheel configuration
+                {
+                    position: new THREE.Vector3(-wheelBaseWidth / 2, wheelBaseHeight, -wheelBaseLength / 2), // Front left
+                    radius: wheelRadius,
+                    width: wheelWidth,
+                    canSteer: true,
+                    isPowered: false,
+                    canBrake: true,
+                    suspensionRestLength,
+                    suspensionStiffness,
+                    suspensionCompression,
+                    suspensionRelaxation,
+                    maxSuspensionForce,
+                    maxSuspensionTravel,
+                    sideFrictionStiffness,
+                    frictionSlip,
+                },
+                {
+                    position: new THREE.Vector3(wheelBaseWidth / 2, wheelBaseHeight, -wheelBaseLength / 2), // Front right
+                    radius: wheelRadius,
+                    width: wheelWidth,
+                    canSteer: true,
+                    isPowered: false,
+                    canBrake: true,
+                    suspensionRestLength,
+                    suspensionStiffness,
+                    suspensionCompression,
+                    suspensionRelaxation,
+                    maxSuspensionForce,
+                    maxSuspensionTravel,
+                    sideFrictionStiffness,
+                    frictionSlip,
+                },
+                {
+                    position: new THREE.Vector3(-wheelBaseWidth / 2, wheelBaseHeight, wheelBaseLength / 2), // Rear left
+                    radius: wheelRadius,
+                    width: wheelWidth,
+                    canSteer: false,
+                    isPowered: true,
+                    canBrake: true,
+                    suspensionRestLength,
+                    suspensionStiffness,
+                    suspensionCompression,
+                    suspensionRelaxation,
+                    maxSuspensionForce,
+                    maxSuspensionTravel,
+                    sideFrictionStiffness,
+                    frictionSlip,
+                },
+                {
+                    position: new THREE.Vector3(wheelBaseWidth / 2, wheelBaseHeight, wheelBaseLength / 2), // Rear right
+                    radius: wheelRadius,
+                    width: wheelWidth,
+                    canSteer: false,
+                    isPowered: true,
+                    canBrake: true,
+                    suspensionRestLength,
+                    suspensionStiffness,
+                    suspensionCompression,
+                    suspensionRelaxation,
+                    maxSuspensionForce,
+                    maxSuspensionTravel,
+                    sideFrictionStiffness,
+                    frictionSlip,
+                },
+            ],
+        };
+        return new ENGINE.VehicleMovementComponent(options);
+    }
+};
+PrimitiveVehicle = PrimitiveVehicle_1 = __decorate([
+    ENGINE.GameClass(),
+    __metadata("design:paramtypes", [Object])
+], PrimitiveVehicle);
+export { PrimitiveVehicle };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"primitive-vehicle.js","sourceRoot":"","sources":["../../../../games/examples/vehicle/primitive-vehicle.ts"],"names":[],"mappings":"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"}

package/dist/games/examples/vr-game/VRAttachableCube.d.ts

@@ -0,0 +1,8 @@
+import * as ENGINE from 'genesys.js';
+/**
+ * Simple VR Attachable Cube - demonstrates minimal implementation with physics
+ */
+export declare class VRAttachableCube extends ENGINE.Actor {
+    private meshComponent;
+    constructor(color?: number);
+}

package/dist/games/examples/vr-game/VRAttachableCube.js

@@ -0,0 +1,41 @@
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+/**
+ * Simple VR Attachable Cube - demonstrates minimal implementation with physics
+ */
+export class VRAttachableCube extends ENGINE.Actor {
+    constructor(color = 0xff0000) {
+        super({
+            rootComponent: new ENGINE.MeshComponent({
+                geometry: new THREE.BoxGeometry(0.5, 0.5, 0.5),
+                material: new THREE.MeshStandardMaterial({
+                    color: color,
+                    roughness: 0.4,
+                    metalness: 0.6
+                }),
+                // Add physics properties
+                physicsOptions: {
+                    motionType: ENGINE.PhysicsMotionType.Dynamic,
+                    density: 1.0,
+                    generateCollisionEvents: false
+                }
+            })
+        });
+        Object.defineProperty(this, "meshComponent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.meshComponent = this.rootComponent;
+        const grabbable = new ENGINE.VRGrabbableComponent({
+            vrAttachmentInputType: 'select',
+            attachmentMode: 'beam',
+            useBeamPickupDistance: true,
+            beamPickupDistance: 2,
+            hideController: false
+        });
+        this.addComponent(grabbable);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVlJBdHRhY2hhYmxlQ3ViZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2dhbWVzL2V4YW1wbGVzL3ZyLWdhbWUvVlJBdHRhY2hhYmxlQ3ViZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssTUFBTSxNQUFNLFlBQVksQ0FBQztBQUNyQyxPQUFPLEtBQUssS0FBSyxNQUFNLE9BQU8sQ0FBQztBQUUvQjs7R0FFRztBQUNILE1BQU0sT0FBTyxnQkFBaUIsU0FBUSxNQUFNLENBQUMsS0FBSztJQUdoRCxZQUFZLFFBQWdCLFFBQVE7UUFDbEMsS0FBSyxDQUFDO1lBQ0osYUFBYSxFQUFFLElBQUksTUFBTSxDQUFDLGFBQWEsQ0FBQztnQkFDdEMsUUFBUSxFQUFFLElBQUksS0FBSyxDQUFDLFdBQVcsQ0FBQyxHQUFHLEVBQUUsR0FBRyxFQUFFLEdBQUcsQ0FBQztnQkFDOUMsUUFBUSxFQUFFLElBQUksS0FBSyxDQUFDLG9CQUFvQixDQUFDO29CQUN2QyxLQUFLLEVBQUUsS0FBSztvQkFDWixTQUFTLEVBQUUsR0FBRztvQkFDZCxTQUFTLEVBQUUsR0FBRztpQkFDZixDQUFDO2dCQUNGLHlCQUF5QjtnQkFDekIsY0FBYyxFQUFFO29CQUNkLFVBQVUsRUFBRSxNQUFNLENBQUMsaUJBQWlCLENBQUMsT0FBTztvQkFDNUMsT0FBTyxFQUFFLEdBQUc7b0JBQ1osdUJBQXVCLEVBQUUsS0FBSztpQkFDL0I7YUFDRixDQUFDO1NBQ0gsQ0FBQyxDQUFDO1FBbEJHOzs7OztXQUFvQztRQW9CMUMsSUFBSSxDQUFDLGFBQWEsR0FBRyxJQUFJLENBQUMsYUFBcUMsQ0FBQztRQUVoRSxNQUFNLFNBQVMsR0FBRyxJQUFJLE1BQU0sQ0FBQyxvQkFBb0IsQ0FBQztZQUNoRCxxQkFBcUIsRUFBRSxRQUFRO1lBQy9CLGNBQWMsRUFBRSxNQUFNO1lBQ3RCLHFCQUFxQixFQUFFLElBQUk7WUFDM0Isa0JBQWtCLEVBQUUsQ0FBQztZQUNyQixjQUFjLEVBQUUsS0FBSztTQUN0QixDQUFDLENBQUM7UUFDSCxJQUFJLENBQUMsWUFBWSxDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQy9CLENBQUM7Q0FDRiJ9

package/dist/games/examples/vr-game/VRInteractableCylinder.d.ts

@@ -0,0 +1,10 @@
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+/**
+ * Interactable cylinder that shoots a ball upward when selected
+ */
+export declare class VRInteractableCylinder extends ENGINE.Actor<{}> {
+    private meshComponent;
+    constructor(position?: THREE.Vector3);
+    onVRInteract(hand: 'left' | 'right'): boolean;
+}

package/dist/games/examples/vr-game/VRInteractableCylinder.js

@@ -0,0 +1,76 @@
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+/**
+ * Interactable cylinder that shoots a ball upward when selected
+ */
+export class VRInteractableCylinder extends ENGINE.Actor {
+    constructor(position = new THREE.Vector3(0, 1, -2)) {
+        super({
+            rootComponent: new ENGINE.MeshComponent({
+                geometry: new THREE.CylinderGeometry(0.25, 0.25, 0.5, 24),
+                material: new THREE.MeshStandardMaterial({
+                    color: 0x33aaee,
+                    roughness: 0.4,
+                    metalness: 0.2
+                }),
+                physicsOptions: {
+                    motionType: ENGINE.PhysicsMotionType.Static,
+                    generateCollisionEvents: false
+                }
+            })
+        });
+        Object.defineProperty(this, "meshComponent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.setWorldPosition(position);
+        this.meshComponent = this.rootComponent;
+        const interactable = new ENGINE.VRInteractableComponent({
+            vrInteractionRange: 6
+        });
+        this.addComponent(interactable);
+        interactable.onInteract.add(this.onVRInteract.bind(this));
+    }
+    onVRInteract(hand) {
+        // Spawn a small sphere and launch it upward
+        const world = this.getWorld();
+        if (!world)
+            return false;
+        const spawnPos = this.rootComponent.getWorldPosition(new THREE.Vector3());
+        spawnPos.y += 0.4;
+        const ball = new ENGINE.Actor({
+            rootComponent: new ENGINE.MeshComponent({
+                geometry: new THREE.SphereGeometry(0.1, 16, 16),
+                material: new THREE.MeshStandardMaterial({ color: 0xffaa00 }),
+                physicsOptions: {
+                    motionType: ENGINE.PhysicsMotionType.Dynamic,
+                    density: 0.5,
+                    generateCollisionEvents: false,
+                    gravityScale: 1
+                }
+            })
+        });
+        world.addActor(ball);
+        ball.rootComponent.setWorldPosition(spawnPos);
+        // Apply upward velocity
+        const physics = world.getPhysicsEngine();
+        const root = ball.rootComponent;
+        if (physics && root instanceof ENGINE.PrimitiveComponent) {
+            const up = new THREE.Vector3(0, 1, 0);
+            const velocity = up.multiplyScalar(6); // m/s
+            root.setPhysicsVectorParam(ENGINE.PhysicsVectorParam.LinearVelocity, [velocity.x, velocity.y, velocity.z]);
+        }
+        // Brief emissive flash as feedback
+        const mesh = this.meshComponent.getMesh();
+        if (mesh && mesh.material?.emissive) {
+            const std = mesh.material;
+            const original = std.emissive.clone();
+            std.emissive.setHex(0x2244ff);
+            setTimeout(() => std.emissive.copy(original), 150);
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/games/examples/vr-game/VRPressableButton.d.ts

@@ -0,0 +1,24 @@
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+export interface VRPressableButtonOptions {
+    baseSize?: THREE.Vector3;
+    plungerSize?: THREE.Vector3;
+    surfaceY?: number;
+    restingY?: number;
+    fullPressDistance?: number;
+    recoverySpeed?: number;
+    onPressed?: () => void;
+}
+export declare class VRPressableButtonActor extends ENGINE.Actor<{}> {
+    private base;
+    private plunger;
+    private contactZone;
+    private surfaceY;
+    private restingY;
+    private fullPressDistance;
+    private recoverySpeed;
+    private pressedFired;
+    private onPressed?;
+    constructor(options?: VRPressableButtonOptions);
+    private updateButton;
+}

package/dist/games/examples/vr-game/VRPressableButton.js

@@ -0,0 +1,135 @@
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+export class VRPressableButtonActor extends ENGINE.Actor {
+    constructor(options = {}) {
+        super({
+            rootComponent: new ENGINE.SceneComponent({})
+        });
+        Object.defineProperty(this, "base", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "plunger", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "contactZone", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "surfaceY", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "restingY", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "fullPressDistance", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "recoverySpeed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pressedFired", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "onPressed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const baseSize = options.baseSize ?? new THREE.Vector3(0.5, 0.12, 0.15);
+        const plungerSize = options.plungerSize ?? new THREE.Vector3(0.08, 0.1, 0.08);
+        this.surfaceY = options.surfaceY ?? 0.05;
+        this.restingY = options.restingY ?? 0.04;
+        this.fullPressDistance = options.fullPressDistance ?? 0.02;
+        this.recoverySpeed = options.recoverySpeed ?? 0.4;
+        this.onPressed = options.onPressed;
+        // Base
+        this.base = new ENGINE.MeshComponent({
+            geometry: new THREE.BoxGeometry(baseSize.x, baseSize.y, baseSize.z),
+            material: new THREE.MeshStandardMaterial({ color: 0x595959 }),
+            physicsOptions: {
+                motionType: ENGINE.PhysicsMotionType.Static,
+                generateCollisionEvents: false
+            }
+        });
+        this.rootComponent.add(this.base);
+        // Plunger (kinematic in local Y; no physics)
+        this.plunger = new ENGINE.MeshComponent({
+            geometry: new THREE.BoxGeometry(plungerSize.x, plungerSize.y, plungerSize.z),
+            material: new THREE.MeshStandardMaterial({ color: 0x355c7d }),
+            physicsOptions: { enabled: false }
+        });
+        this.plunger.position.set(0, this.restingY, 0);
+        this.base.add(this.plunger);
+        // Contact zone above the plunger cap (trigger only)
+        this.contactZone = new ENGINE.TriggerZoneComponent({
+            size: new THREE.Vector3(plungerSize.x * 1.2, plungerSize.y * 1.2, plungerSize.z * 1.2),
+            enableStayEvents: true,
+            offset: new THREE.Vector3(0, this.restingY + (plungerSize.y * 0.5), 0),
+            enableDebugVisualization: false
+        });
+        this.base.add(this.contactZone);
+        // Tick each frame to update motion/state
+        this.rootComponent.onTickPrePhysics.add((_comp, dt) => this.updateButton(dt));
+    }
+    updateButton(deltaTime) {
+        // Gather overlapping actors; find any with a fingertip pointer component name
+        const overlapping = this.contactZone.getActorsInZone();
+        let pressingDistance = 0;
+        if (overlapping.length > 0) {
+            for (const actor of overlapping) {
+                // Use actor world position (assumes fingertip collider actor root at tip)
+                const tipWorld = actor.rootComponent.getWorldPosition(new THREE.Vector3());
+                // Convert to plunger parent local
+                const local = this.base.worldToLocal(tipWorld.clone());
+                const depth = this.surfaceY - local.y;
+                if (depth > pressingDistance)
+                    pressingDistance = depth;
+            }
+        }
+        if (pressingDistance > 0) {
+            const targetY = THREE.MathUtils.clamp(this.restingY - pressingDistance, this.restingY - this.fullPressDistance, this.restingY);
+            this.plunger.position.y = targetY;
+            const fraction = (this.restingY - targetY) / this.fullPressDistance;
+            if (fraction >= 0.99 && !this.pressedFired) {
+                this.pressedFired = true;
+                if (this.onPressed)
+                    this.onPressed();
+            }
+        }
+        else {
+            // Recover toward resting
+            if (this.plunger.position.y < this.restingY) {
+                this.plunger.position.y = Math.min(this.restingY, this.plunger.position.y + this.recoverySpeed * deltaTime);
+            }
+            else {
+                this.plunger.position.y = this.restingY;
+                this.pressedFired = false;
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/games/examples/vr-game/VRProjectileActor.d.ts

@@ -0,0 +1,19 @@
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+/**
+ * Simple projectile actor for rifle shots
+ */
+export declare class VRProjectileActor extends ENGINE.Actor {
+    private direction;
+    private speed;
+    private lifetime;
+    private startTime;
+    constructor(options: {
+        startPosition: THREE.Vector3;
+        direction: THREE.Vector3;
+        speed: number;
+        lifetime: number;
+    });
+    protected doBeginPlay(): void;
+    private updateProjectile;
+}