@series-inc/rundot-3d-engine 0.3.0

package/dist/index.js

@@ -0,0 +1,1390 @@
+import {
+  AssetManager,
+  Component,
+  ComponentUpdater,
+  GameObject,
+  InstancedMeshManager,
+  PrefabComponent,
+  PrefabInstance,
+  RigidBodyComponentThree,
+  SkeletonCache,
+  StowKitSystem,
+  VenusGame,
+  __decorateClass
+} from "./chunk-ZNDJR3RD.js";
+
+// src/engine/interaction/InteractionZone.ts
+import * as THREE from "three";
+var InteractionZone = class extends Component {
+  id;
+  active = true;
+  onEnterCallback;
+  onExitCallback;
+  entitiesInZone = /* @__PURE__ */ new Set();
+  rigidBody = null;
+  visualMesh = null;
+  options;
+  constructor(onEnter, onExit, options = {}) {
+    super();
+    this.id = `interaction_${Math.random().toString(36).substr(2, 9)}`;
+    this.onEnterCallback = onEnter;
+    this.onExitCallback = onExit;
+    this.options = {
+      width: 2,
+      depth: 2,
+      active: true,
+      show: true,
+      ...options
+    };
+    this.active = this.options.active ?? true;
+  }
+  /**
+   * Set interaction callbacks
+   */
+  setCallbacks(callbacks) {
+    this.onEnterCallback = callbacks.onEnter;
+    this.onExitCallback = callbacks.onExit;
+  }
+  /**
+   * Called when component is attached to GameObject
+   */
+  onCreate() {
+    if (this.options.show) {
+      this.createVisualMesh();
+    }
+    this.createTriggerCollider();
+    this.setActive(this.active);
+  }
+  onEnabled() {
+  }
+  /**
+   * Create the visual mesh for the interaction zone
+   */
+  createVisualMesh() {
+    const width = this.options.width;
+    const height = 0.1;
+    const depth = this.options.depth;
+    const geometry = new THREE.BoxGeometry(width, height, depth);
+    const material = new THREE.MeshBasicMaterial({
+      color: 0,
+      // Black like the original
+      transparent: true,
+      opacity: 0.15,
+      // Original opacity
+      side: THREE.DoubleSide
+    });
+    this.visualMesh = new THREE.Mesh(geometry, material);
+    this.gameObject.add(this.visualMesh);
+    this.visualMesh.position.y += 0.1;
+  }
+  /**
+   * Create the physics trigger collider
+   */
+  createTriggerCollider() {
+    this.rigidBody = new RigidBodyComponentThree({
+      type: "static" /* STATIC */,
+      shape: "box" /* BOX */,
+      size: new THREE.Vector3(this.options.width, 0.1, this.options.depth),
+      // Fixed height of 0.1
+      isSensor: true
+      // This makes it a trigger collider
+      // No collision groups = default behavior (can detect anything that wants to hit it)
+    });
+    if (this.options.centerOffset) {
+      this.gameObject.position.x += this.options.centerOffset.x;
+      this.gameObject.position.z += this.options.centerOffset.y;
+    }
+    this.gameObject.addComponent(this.rigidBody);
+    this.rigidBody.registerOnTriggerEnter(this.onTriggerEnter.bind(this));
+    this.rigidBody.registerOnTriggerExit(this.onTriggerExit.bind(this));
+  }
+  /**
+   * Handle trigger enter event (to be called by physics system)
+   */
+  onTriggerEnter(other) {
+    if (!this.active) {
+      console.warn(`\u{1F3AF} InteractionZone ${this.id}: Ignoring enter event - zone is inactive`);
+      return;
+    }
+    if (!this.gameObject.isEnabled()) {
+      return;
+    }
+    if (!this.entitiesInZone.has(other)) {
+      this.entitiesInZone.add(other);
+      if (this.onEnterCallback) {
+        this.onEnterCallback(other);
+      }
+    }
+  }
+  /**
+   * Handle trigger exit event (to be called by physics system)
+   */
+  onTriggerExit(other) {
+    if (!this.active) {
+      return;
+    }
+    if (!this.gameObject.isEnabled()) {
+      return;
+    }
+    if (this.entitiesInZone.has(other)) {
+      this.entitiesInZone.delete(other);
+      if (this.onExitCallback) {
+        this.onExitCallback(other);
+      }
+    }
+  }
+  /**
+   * Get all entities currently in the zone
+   */
+  getEntitiesInZone() {
+    return Array.from(this.entitiesInZone);
+  }
+  /**
+   * Check if a specific entity is in the zone
+   */
+  hasEntity(entity) {
+    return this.entitiesInZone.has(entity);
+  }
+  /**
+   * Set active state
+   */
+  setActive(active) {
+    this.active = active;
+    if (this.visualMesh) {
+      this.visualMesh.visible = active;
+    }
+    if (this.rigidBody) {
+    }
+    if (!active) {
+      this.entitiesInZone.clear();
+    }
+  }
+  /**
+   * Check if the interaction zone is active
+   */
+  isActive() {
+    return this.active;
+  }
+  /**
+   * Get the visual mesh
+   */
+  getVisualMesh() {
+    return this.visualMesh;
+  }
+  /**
+   * Get the collider component
+   */
+  getCollider() {
+    return this.rigidBody;
+  }
+  /**
+   * Get the GameObject this zone is attached to
+   */
+  getGameObject() {
+    return this.gameObject;
+  }
+  /**
+   * Component cleanup
+   */
+  onCleanup() {
+    this.entitiesInZone.clear();
+    if (this.visualMesh) {
+      this.visualMesh.geometry.dispose();
+      if (this.visualMesh.material instanceof THREE.Material) {
+        this.visualMesh.material.dispose();
+      }
+      this.gameObject.remove(this.visualMesh);
+      this.visualMesh = null;
+    }
+  }
+};
+
+// src/engine/mobile/VirtualJoystickThree.ts
+import * as THREE2 from "three";
+var VirtualJoystickThree = class _VirtualJoystickThree extends Component {
+  // Configuration
+  options;
+  // Mobile detection
+  static isMobileDevice() {
+    return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent) || "ontouchstart" in window || navigator.maxTouchPoints > 0;
+  }
+  // UI Elements
+  joystickContainer = null;
+  joystickBase = null;
+  joystickKnob = null;
+  mobileHint = null;
+  // State
+  isActive = false;
+  startPosition = new THREE2.Vector2();
+  currentPosition = new THREE2.Vector2();
+  direction = new THREE2.Vector2();
+  magnitude = 0;
+  // Input tracking
+  joystickPointerId = null;
+  isDragging = false;
+  joystickRadius = 0;
+  // Event handlers (need to bind them for proper cleanup)
+  boundPointerDown = this.onPointerDown.bind(this);
+  boundPointerMove = this.onPointerMove.bind(this);
+  boundPointerUp = this.onPointerUp.bind(this);
+  boundTouchStart = this.onTouchStart.bind(this);
+  boundTouchMove = this.onTouchMove.bind(this);
+  boundTouchEnd = this.onTouchEnd.bind(this);
+  constructor(options = {}) {
+    super();
+    this.options = {
+      size: options.size ?? 120,
+      knobSize: options.knobSize ?? 40,
+      deadZone: options.deadZone ?? 0.15,
+      maxDistance: options.maxDistance ?? 50,
+      color: options.color ?? "white",
+      visible: options.visible ?? true,
+      opacity: options.opacity ?? 0.2
+    };
+    this.joystickRadius = this.options.maxDistance;
+  }
+  onCreate() {
+    this.createJoystickUI();
+    this.createMobileHint();
+    this.setupInputHandlers();
+  }
+  onCleanup() {
+    this.cleanupUI();
+    this.removeInputHandlers();
+  }
+  /**
+   * Create the joystick UI elements using HTML/CSS
+   */
+  createJoystickUI() {
+    this.joystickContainer = document.createElement("div");
+    this.joystickContainer.id = "virtual-joystick-container";
+    this.joystickContainer.style.cssText = `
+            position: fixed;
+            width: ${this.options.size + this.options.knobSize}px;
+            height: ${this.options.size + this.options.knobSize}px;
+            display: none;
+            pointer-events: none;
+            z-index: 1000;
+            user-select: none;
+            touch-action: none;
+        `;
+    this.joystickBase = document.createElement("div");
+    this.joystickBase.style.cssText = `
+            position: absolute;
+            width: ${this.options.size}px;
+            height: ${this.options.size}px;
+            border: 4px solid ${this.options.color};
+            border-radius: 50%;
+            background: rgba(255, 255, 255, 0.2);
+            left: 50%;
+            top: 50%;
+            transform: translate(-50%, -50%);
+            box-sizing: border-box;
+            opacity: ${this.options.opacity};
+        `;
+    this.joystickKnob = document.createElement("div");
+    this.joystickKnob.style.cssText = `
+            position: absolute;
+            width: ${this.options.knobSize}px;
+            height: ${this.options.knobSize}px;
+            border: 2px solid ${this.options.color};
+            border-radius: 50%;
+            background: rgba(255, 255, 255, 0.8);
+            left: 50%;
+            top: 50%;
+            transform: translate(-50%, -50%);
+            transition: none;
+            box-sizing: border-box;
+            opacity: ${this.options.opacity};
+        `;
+    this.joystickContainer.appendChild(this.joystickBase);
+    this.joystickContainer.appendChild(this.joystickKnob);
+    document.body.appendChild(this.joystickContainer);
+  }
+  /**
+   * Create mobile hint for touch controls (only shows on mobile devices)
+   */
+  createMobileHint() {
+    if (!_VirtualJoystickThree.isMobileDevice()) {
+      return;
+    }
+    this.mobileHint = document.createElement("div");
+    this.mobileHint.id = "mobile-joystick-hint";
+    this.mobileHint.textContent = "Touch & drag to move";
+    this.mobileHint.style.cssText = `
+            position: fixed;
+            bottom: 20px;
+            left: 50%;
+            transform: translateX(-50%);
+            background: rgba(0, 0, 0, 0.8);
+            color: white;
+            padding: 10px 20px;
+            border-radius: 20px;
+            font-family: Arial, sans-serif;
+            font-size: 14px;
+            z-index: 999;
+            pointer-events: none;
+            user-select: none;
+            border: 2px solid rgba(255, 255, 255, 0.3);
+            animation: fadeInOut 4s ease-in-out;
+        `;
+    if (!document.querySelector("#mobile-hint-styles")) {
+      const style = document.createElement("style");
+      style.id = "mobile-hint-styles";
+      style.textContent = `
+                @keyframes fadeInOut {
+                    0% { opacity: 0; transform: translateX(-50%) translateY(20px); }
+                    20% { opacity: 1; transform: translateX(-50%) translateY(0px); }
+                    80% { opacity: 1; transform: translateX(-50%) translateY(0px); }
+                    100% { opacity: 0; transform: translateX(-50%) translateY(-20px); }
+                }
+            `;
+      document.head.appendChild(style);
+    }
+    document.body.appendChild(this.mobileHint);
+    setTimeout(() => {
+      if (this.mobileHint && this.mobileHint.parentNode) {
+        this.mobileHint.parentNode.removeChild(this.mobileHint);
+        this.mobileHint = null;
+      }
+    }, 4e3);
+  }
+  /**
+   * Setup input handlers for pointer and touch events
+   */
+  setupInputHandlers() {
+    document.addEventListener("pointerdown", this.boundPointerDown, {
+      passive: false
+    });
+    document.addEventListener("pointermove", this.boundPointerMove, {
+      passive: false
+    });
+    document.addEventListener("pointerup", this.boundPointerUp, {
+      passive: false
+    });
+    document.addEventListener("touchstart", this.boundTouchStart, {
+      passive: false
+    });
+    document.addEventListener("touchmove", this.boundTouchMove, {
+      passive: false
+    });
+    document.addEventListener("touchend", this.boundTouchEnd, {
+      passive: false
+    });
+  }
+  /**
+   * Remove input handlers
+   */
+  removeInputHandlers() {
+    document.removeEventListener("pointerdown", this.boundPointerDown);
+    document.removeEventListener("pointermove", this.boundPointerMove);
+    document.removeEventListener("pointerup", this.boundPointerUp);
+    document.removeEventListener("touchstart", this.boundTouchStart);
+    document.removeEventListener("touchmove", this.boundTouchMove);
+    document.removeEventListener("touchend", this.boundTouchEnd);
+  }
+  /**
+   * Handle pointer down event
+   */
+  onPointerDown(event) {
+    if (this.isActive || !event.isPrimary) return;
+    this.startJoystick(event.clientX, event.clientY, event.pointerId);
+    event.preventDefault();
+  }
+  /**
+   * Handle touch start event (fallback)
+   */
+  onTouchStart(event) {
+    if (this.isActive || event.touches.length === 0) return;
+    const touch = event.touches[0];
+    this.startJoystick(touch.clientX, touch.clientY, touch.identifier);
+    event.preventDefault();
+  }
+  /**
+   * Start the joystick at the given position
+   */
+  startJoystick(x, y, pointerId) {
+    this.isActive = true;
+    this.isDragging = true;
+    this.joystickPointerId = pointerId;
+    if (this.mobileHint && this.mobileHint.parentNode) {
+      this.mobileHint.parentNode.removeChild(this.mobileHint);
+      this.mobileHint = null;
+    }
+    this.startPosition.set(x, y);
+    this.currentPosition.set(x, y);
+    if (this.joystickContainer) {
+      this.joystickContainer.style.display = this.options.visible ? "block" : "none";
+      this.joystickContainer.style.left = `${x - (this.options.size + this.options.knobSize) / 2}px`;
+      this.joystickContainer.style.top = `${y - (this.options.size + this.options.knobSize) / 2}px`;
+    }
+    if (this.joystickKnob) {
+      this.joystickKnob.style.transform = "translate(-50%, -50%)";
+    }
+    this.updateDirection();
+  }
+  /**
+   * Handle pointer move event
+   */
+  onPointerMove(event) {
+    if (!this.isActive || !this.isDragging || event.pointerId !== this.joystickPointerId) {
+      return;
+    }
+    this.updateJoystick(event.clientX, event.clientY);
+    event.preventDefault();
+  }
+  /**
+   * Handle touch move event (fallback)
+   */
+  onTouchMove(event) {
+    if (!this.isActive || !this.isDragging) return;
+    for (let i = 0; i < event.touches.length; i++) {
+      const touch = event.touches[i];
+      if (touch.identifier === this.joystickPointerId) {
+        this.updateJoystick(touch.clientX, touch.clientY);
+        event.preventDefault();
+        break;
+      }
+    }
+  }
+  /**
+   * Update joystick position and direction
+   */
+  updateJoystick(x, y) {
+    this.currentPosition.set(x, y);
+    this.updateKnobPosition();
+    this.updateDirection();
+  }
+  /**
+   * Handle pointer up event
+   */
+  onPointerUp(event) {
+    if (!this.isActive || event.pointerId !== this.joystickPointerId) {
+      return;
+    }
+    this.endJoystick();
+    event.preventDefault();
+  }
+  /**
+   * Handle touch end event (fallback)
+   */
+  onTouchEnd(event) {
+    if (!this.isActive) return;
+    let touchEnded = true;
+    for (let i = 0; i < event.touches.length; i++) {
+      if (event.touches[i].identifier === this.joystickPointerId) {
+        touchEnded = false;
+        break;
+      }
+    }
+    if (touchEnded) {
+      this.endJoystick();
+      event.preventDefault();
+    }
+  }
+  /**
+   * End the joystick interaction
+   */
+  endJoystick() {
+    this.isActive = false;
+    this.isDragging = false;
+    this.joystickPointerId = null;
+    if (this.joystickContainer) {
+      this.joystickContainer.style.display = "none";
+    }
+    this.direction.set(0, 0);
+    this.magnitude = 0;
+  }
+  /**
+   * Update knob position based on current pointer position
+   */
+  updateKnobPosition() {
+    if (!this.joystickKnob) return;
+    const offset = this.currentPosition.clone().sub(this.startPosition);
+    const distance = offset.length();
+    if (distance > this.joystickRadius) {
+      offset.normalize().multiplyScalar(this.joystickRadius);
+    }
+    this.joystickKnob.style.transform = `translate(calc(-50% + ${offset.x}px), calc(-50% + ${offset.y}px))`;
+  }
+  /**
+   * Update direction vector based on knob position
+   */
+  updateDirection() {
+    const offset = this.currentPosition.clone().sub(this.startPosition);
+    const distance = offset.length();
+    if (distance < this.options.deadZone * this.joystickRadius) {
+      this.direction.set(0, 0);
+      this.magnitude = 0;
+      return;
+    }
+    const normalizedDistance = Math.min(distance / this.joystickRadius, 1);
+    this.direction = offset.normalize();
+    this.magnitude = normalizedDistance;
+  }
+  /**
+   * Get the current input direction as a Vector3 (Y=0 for movement)
+   */
+  getDirection() {
+    if (!this.isActive || this.magnitude === 0) {
+      return null;
+    }
+    return new THREE2.Vector3(
+      this.direction.x * this.magnitude,
+      0,
+      -this.direction.y * this.magnitude
+    );
+  }
+  /**
+   * Get the current input magnitude (0-1)
+   */
+  getMagnitude() {
+    return this.magnitude;
+  }
+  /**
+   * Check if the joystick is currently active
+   */
+  isActiveJoystick() {
+    return this.isActive;
+  }
+  /**
+   * Toggle joystick visual visibility (joystick remains functional)
+   */
+  setVisible(visible) {
+    this.options.visible = visible;
+    if (this.joystickContainer && this.isActive) {
+      this.joystickContainer.style.display = visible ? "block" : "none";
+    }
+  }
+  /**
+   * Get current visibility state
+   */
+  isVisible() {
+    return this.options.visible;
+  }
+  /**
+   * Set joystick opacity (0-1)
+   */
+  setOpacity(opacity) {
+    this.options.opacity = Math.max(0, Math.min(1, opacity));
+    if (this.joystickBase) {
+      this.joystickBase.style.opacity = `${this.options.opacity}`;
+    }
+    if (this.joystickKnob) {
+      this.joystickKnob.style.opacity = `${this.options.opacity}`;
+    }
+  }
+  /**
+   * Get current opacity
+   */
+  getOpacity() {
+    return this.options.opacity;
+  }
+  /**
+   * Clean up UI resources
+   */
+  cleanupUI() {
+    if (this.joystickContainer && this.joystickContainer.parentNode) {
+      this.joystickContainer.parentNode.removeChild(this.joystickContainer);
+    }
+    if (this.mobileHint && this.mobileHint.parentNode) {
+      this.mobileHint.parentNode.removeChild(this.mobileHint);
+    }
+    this.joystickContainer = null;
+    this.joystickBase = null;
+    this.joystickKnob = null;
+    this.mobileHint = null;
+  }
+};
+
+// src/engine/movement/MovementController.ts
+import * as THREE3 from "three";
+var MovementController = class extends Component {
+  // Public configuration properties
+  maxMoveSpeed = 8;
+  acceleration = 40;
+  turnSpeed = 12;
+  // How fast to rotate (radians per second)
+  rigidBodyComponent = null;
+  targetRotationY = 0;
+  currentRotationY = 0;
+  // Pre-allocated vector for velocity queries to avoid GC pressure
+  _currentVelocity = new THREE3.Vector3();
+  /**
+   * Called when the component is created and attached to a GameObject
+   */
+  onCreate() {
+    this.findRigidBodyComponentThree();
+    this.currentRotationY = this.gameObject.rotation.y;
+    this.targetRotationY = this.currentRotationY;
+  }
+  /**
+   * Find the rigid body component on this GameObject
+   */
+  findRigidBodyComponentThree() {
+    this.rigidBodyComponent = this.gameObject.getComponent(RigidBodyComponentThree) || null;
+    if (!this.rigidBodyComponent) {
+      console.warn("MovementController: No RigidBodyComponentThree found on GameObject");
+    }
+  }
+  /**
+   * Set the rigid body component this controller should manage
+   */
+  setRigidBodyComponentThree(rigidBodyComponent) {
+    this.rigidBodyComponent = rigidBodyComponent;
+  }
+  /**
+   * Move the entity based on input direction
+   * @param inputDirection Normalized direction vector (or null for no movement)
+   * @param deltaTime Time since last frame in seconds
+   */
+  move(inputDirection, deltaTime) {
+    if (!this.rigidBodyComponent) return;
+    const targetVelocity = this.calculateTargetVelocity(inputDirection);
+    const smoothedVelocity = this.smoothVelocity(targetVelocity, deltaTime);
+    this.rigidBodyComponent.setVelocity(smoothedVelocity);
+    this.updateRotation(inputDirection, deltaTime);
+  }
+  /**
+   * Calculate target velocity based on input direction
+   */
+  calculateTargetVelocity(inputDirection) {
+    const targetVelocity = new THREE3.Vector3(0, 0, 0);
+    if (inputDirection && inputDirection.length() > 0.01) {
+      targetVelocity.x = inputDirection.x * this.maxMoveSpeed;
+      targetVelocity.z = inputDirection.z * this.maxMoveSpeed;
+    }
+    targetVelocity.y = 0;
+    return targetVelocity;
+  }
+  /**
+   * Smooth velocity towards target using acceleration
+   */
+  smoothVelocity(targetVelocity, deltaTime) {
+    if (!this.rigidBodyComponent) return targetVelocity;
+    this.rigidBodyComponent.getVelocity(this._currentVelocity);
+    const maxDelta = this.acceleration * deltaTime;
+    const smoothedVelocity = new THREE3.Vector3();
+    smoothedVelocity.x = this.moveTowards(this._currentVelocity.x, targetVelocity.x, maxDelta);
+    smoothedVelocity.z = this.moveTowards(this._currentVelocity.z, targetVelocity.z, maxDelta);
+    smoothedVelocity.y = 0;
+    return smoothedVelocity;
+  }
+  /**
+   * Update rotation smoothly towards movement direction using quaternion slerp
+   */
+  updateRotation(inputDirection, deltaTime) {
+    if (this.rigidBodyComponent) {
+      const rigidBody = this.rigidBodyComponent.getRigidBody();
+      if (rigidBody) {
+        this.rigidBodyComponent.setAngularVelocity(new THREE3.Vector3(0, 0, 0));
+      }
+    }
+    if (!inputDirection || inputDirection.length() < 0.01) {
+      return;
+    }
+    const targetRotationY = Math.atan2(inputDirection.x, inputDirection.z);
+    const targetQuaternion = new THREE3.Quaternion();
+    targetQuaternion.setFromAxisAngle(new THREE3.Vector3(0, 1, 0), targetRotationY);
+    const currentQuaternion = new THREE3.Quaternion();
+    currentQuaternion.setFromAxisAngle(new THREE3.Vector3(0, 1, 0), this.currentRotationY);
+    const slerpFactor = Math.min(1, this.turnSpeed * deltaTime);
+    const resultQuaternion = new THREE3.Quaternion();
+    resultQuaternion.slerpQuaternions(currentQuaternion, targetQuaternion, slerpFactor);
+    const euler = new THREE3.Euler();
+    euler.setFromQuaternion(resultQuaternion, "YXZ");
+    this.currentRotationY = euler.y;
+    if (this.rigidBodyComponent) {
+      const rigidBody = this.rigidBodyComponent.getRigidBody();
+      if (rigidBody) {
+        const rapierQuat = {
+          x: resultQuaternion.x,
+          y: resultQuaternion.y,
+          z: resultQuaternion.z,
+          w: resultQuaternion.w
+        };
+        rigidBody.setRotation(rapierQuat, true);
+      } else {
+        this.gameObject.rotation.y = this.currentRotationY;
+      }
+    } else {
+      this.gameObject.rotation.y = this.currentRotationY;
+    }
+  }
+  /**
+   * Utility function to move a value towards a target at a given rate
+   */
+  moveTowards(current, target, maxDelta) {
+    const delta = target - current;
+    if (Math.abs(delta) <= maxDelta) {
+      return target;
+    }
+    return current + Math.sign(delta) * maxDelta;
+  }
+  /**
+   * Get current movement state for debugging
+   */
+  getMovementState() {
+    return {
+      maxMoveSpeed: this.maxMoveSpeed,
+      acceleration: this.acceleration,
+      turnSpeed: this.turnSpeed,
+      currentRotationY: this.currentRotationY,
+      targetRotationY: this.targetRotationY,
+      hasRigidBody: !!this.rigidBodyComponent
+    };
+  }
+  /**
+   * Clean up resources when the component is removed
+   */
+  onCleanup() {
+    this.rigidBodyComponent = null;
+  }
+};
+
+// src/engine/player/PlayerControllerThree.ts
+import * as THREE4 from "three";
+var PlayerControllerThree = class extends Component {
+  // Movement parameters
+  moveSpeed = 5;
+  runSpeed = 8;
+  rotationSpeed = 2;
+  // Controls configuration
+  controls = {
+    forward: "KeyW",
+    backward: "KeyS",
+    left: "KeyA",
+    right: "KeyD",
+    run: "ShiftLeft",
+    interact: "KeyE"
+  };
+  // Input state
+  keys = /* @__PURE__ */ new Set();
+  mouseX = 0;
+  mouseY = 0;
+  mouseSensitivity = 2e-3;
+  isPointerLocked = false;
+  // Camera reference
+  camera;
+  cameraHeight = 1.7;
+  // Eye level height
+  // Movement state
+  velocity = new THREE4.Vector3();
+  direction = new THREE4.Vector3();
+  constructor(camera) {
+    super();
+    this.camera = camera;
+  }
+  onCreate() {
+    this.setupEventListeners();
+    this.setupPointerLock();
+    this.updateCameraPosition();
+    console.log("\u{1F3AE} Player controller initialized");
+    console.log("\u{1F4CB} Controls: WASD to move, Shift to run, E to interact, Click to look around");
+  }
+  /**
+   * Set up keyboard and mouse event listeners
+   */
+  setupEventListeners() {
+    document.addEventListener("keydown", this.onKeyDown.bind(this));
+    document.addEventListener("keyup", this.onKeyUp.bind(this));
+    document.addEventListener("mousemove", this.onMouseMove.bind(this));
+    document.addEventListener("click", this.onClick.bind(this));
+    document.addEventListener("pointerlockchange", this.onPointerLockChange.bind(this));
+  }
+  /**
+   * Set up pointer lock for mouse look
+   */
+  setupPointerLock() {
+    const canvas = document.getElementById("renderCanvas");
+    if (canvas) {
+      canvas.addEventListener("click", () => {
+        if (!this.isPointerLocked) {
+          canvas.requestPointerLock();
+        }
+      });
+    }
+  }
+  /**
+   * Handle key down events
+   */
+  onKeyDown(event) {
+    this.keys.add(event.code);
+    if (event.code === this.controls.interact) {
+      this.onInteract();
+    }
+  }
+  /**
+   * Handle key up events
+   */
+  onKeyUp(event) {
+    this.keys.delete(event.code);
+  }
+  /**
+   * Handle mouse movement for looking around
+   */
+  onMouseMove(event) {
+    if (!this.isPointerLocked) return;
+    this.mouseX += event.movementX * this.mouseSensitivity;
+    this.mouseY += event.movementY * this.mouseSensitivity;
+    this.mouseY = Math.max(-Math.PI / 2, Math.min(Math.PI / 2, this.mouseY));
+    this.camera.rotation.order = "YXZ";
+    this.camera.rotation.y = -this.mouseX;
+    this.camera.rotation.x = -this.mouseY;
+  }
+  /**
+   * Handle canvas clicks for pointer lock
+   */
+  onClick(event) {
+    const canvas = document.getElementById("renderCanvas");
+    if (event.target === canvas && !this.isPointerLocked) {
+      canvas.requestPointerLock();
+    }
+  }
+  /**
+   * Handle pointer lock state changes
+   */
+  onPointerLockChange() {
+    this.isPointerLocked = document.pointerLockElement !== null;
+    if (this.isPointerLocked) {
+      console.log("\u{1F5B1}\uFE0F Mouse locked - look around!");
+    } else {
+      console.log("\u{1F5B1}\uFE0F Mouse unlocked - click canvas to lock again");
+    }
+  }
+  /**
+   * Handle interaction key press
+   */
+  onInteract() {
+    console.log("\u{1F91D} Player trying to interact...");
+  }
+  /**
+   * Update method - called every frame
+   */
+  update(deltaTime) {
+    this.updateMovement(deltaTime);
+    this.updateCameraPosition();
+  }
+  /**
+   * Update player movement based on input
+   */
+  updateMovement(deltaTime) {
+    this.direction.set(0, 0, 0);
+    const isRunning = this.keys.has(this.controls.run);
+    const currentSpeed = isRunning ? this.runSpeed : this.moveSpeed;
+    const forward = new THREE4.Vector3();
+    const right = new THREE4.Vector3();
+    this.camera.getWorldDirection(forward);
+    forward.y = 0;
+    forward.normalize();
+    right.crossVectors(forward, this.camera.up).normalize();
+    if (this.keys.has(this.controls.forward)) {
+      this.direction.add(forward);
+    }
+    if (this.keys.has(this.controls.backward)) {
+      this.direction.sub(forward);
+    }
+    if (this.keys.has(this.controls.right)) {
+      this.direction.add(right);
+    }
+    if (this.keys.has(this.controls.left)) {
+      this.direction.sub(right);
+    }
+    if (this.direction.length() > 0) {
+      this.direction.normalize();
+      this.velocity.copy(this.direction).multiplyScalar(currentSpeed * deltaTime);
+      this.gameObject.position.add(this.velocity);
+    }
+    this.gameObject.position.y = 0;
+  }
+  /**
+   * Update camera position to follow player
+   */
+  updateCameraPosition() {
+    this.camera.position.copy(this.gameObject.position);
+    this.camera.position.y += this.cameraHeight;
+  }
+  /**
+   * Get current movement state for debugging
+   */
+  getMovementState() {
+    const lookDirection = new THREE4.Vector3();
+    this.camera.getWorldDirection(lookDirection);
+    return {
+      position: this.gameObject.position.clone(),
+      isMoving: this.direction.length() > 0,
+      isRunning: this.keys.has(this.controls.run),
+      lookDirection
+    };
+  }
+  /**
+   * Set player position
+   */
+  setPosition(position) {
+    this.gameObject.position.copy(position);
+    this.updateCameraPosition();
+  }
+  /**
+   * Clean up event listeners
+   */
+  onCleanup() {
+    document.removeEventListener("keydown", this.onKeyDown.bind(this));
+    document.removeEventListener("keyup", this.onKeyUp.bind(this));
+    document.removeEventListener("mousemove", this.onMouseMove.bind(this));
+    document.removeEventListener("click", this.onClick.bind(this));
+    document.removeEventListener("pointerlockchange", this.onPointerLockChange.bind(this));
+    if (this.isPointerLocked) {
+      document.exitPointerLock();
+    }
+    console.log("\u{1F3AE} Player controller cleaned up");
+  }
+};
+
+// src/engine/render/SkeletalRenderer.ts
+import * as THREE5 from "three";
+var SkeletalRenderer = class extends Component {
+  _group = null;
+  _assetPath;
+  _material;
+  _skeletalModel = null;
+  constructor(assetPath, material) {
+    super();
+    this._assetPath = assetPath;
+    this._material = material || null;
+  }
+  onCreate() {
+    this.createSkeletalMesh();
+  }
+  createSkeletalMesh() {
+    if (!this._assetPath) {
+      throw new Error("SkeletalRenderer: No asset path specified");
+    }
+    this._group = new THREE5.Group();
+    this._group.name = `skeletal_${this._assetPath.split("/").pop()}`;
+    this.gameObject.add(this._group);
+    this._skeletalModel = AssetManager.getSkeletalClone(this._assetPath);
+    if (!this._skeletalModel) {
+      throw new Error(
+        `No skeletal model found for '${this._assetPath}'. Make sure to preload with AssetManager.preloadSkeletalModel() first.`
+      );
+    }
+    if (this._material) {
+      this._skeletalModel.traverse((child) => {
+        if (child instanceof THREE5.Mesh) {
+          child.material = this._material;
+          child.frustumCulled = false;
+        }
+      });
+    } else {
+      this._skeletalModel.traverse((child) => {
+        if (child instanceof THREE5.Mesh) {
+          child.frustumCulled = false;
+        }
+      });
+    }
+    this._group.add(this._skeletalModel);
+    this.applyShadowsToGroup(this._group);
+  }
+  applyShadowsToGroup(group) {
+    group.traverse((child) => {
+      if (child instanceof THREE5.Mesh) {
+        child.castShadow = true;
+        child.receiveShadow = true;
+      }
+    });
+  }
+  // ========== Public API ==========
+  /**
+   * Get the wrapper group (attached to GameObject)
+   */
+  getGroup() {
+    return this._group;
+  }
+  /**
+   * Get the skeletal model (for animation setup)
+   */
+  getSkeletalModel() {
+    return this._skeletalModel;
+  }
+  /**
+   * Get the asset path being rendered
+   */
+  getAssetPath() {
+    return this._assetPath;
+  }
+  /**
+   * Enable or disable visibility
+   */
+  setVisible(visible) {
+    if (this._group) {
+      this._group.visible = visible;
+    }
+  }
+  /**
+   * Get visibility state
+   */
+  isVisible() {
+    return this._group?.visible ?? false;
+  }
+  // ========== Component Lifecycle ==========
+  onCleanup() {
+    if (this._group) {
+      this.gameObject.remove(this._group);
+    }
+  }
+  onEnabled() {
+    this.setVisible(true);
+  }
+  onDisabled() {
+    this.setVisible(false);
+  }
+};
+
+// src/engine/render/InstancedRenderer.ts
+var InstancedRenderer = class extends Component {
+  batchKey;
+  options;
+  instanceId = null;
+  /**
+   * Create an InstancedRenderer
+   * @param batchKey The batch key to register with. If no batch exists, one is auto-created.
+   * @param options Configuration options (or just pass `true`/`false` for isDynamic)
+   */
+  constructor(batchKey, options = {}) {
+    super();
+    this.batchKey = batchKey;
+    this.options = typeof options === "boolean" ? { isDynamic: options } : options;
+  }
+  /**
+   * Register with the batch when the component is created.
+   * If no batch exists, one will be created automatically from this GameObject's mesh.
+   */
+  onCreate() {
+    const manager = InstancedMeshManager.getInstance();
+    if (!manager.isReady()) {
+      console.error(
+        `InstancedRenderer: Manager not initialized. Call InstancedMeshManager.getInstance().initialize(scene) first.`
+      );
+      return;
+    }
+    this.instanceId = manager.addInstance(this.batchKey, this.gameObject, {
+      isDynamic: this.options.isDynamic ?? true,
+      castShadow: this.options.castShadow ?? false,
+      receiveShadow: this.options.receiveShadow ?? false,
+      initialCapacity: this.options.initialCapacity
+    });
+    if (!this.instanceId) {
+      console.error(`InstancedRenderer: Failed to add instance to batch '${this.batchKey}'`);
+    }
+  }
+  /**
+   * Set the visibility of this instance
+   */
+  setVisible(visible) {
+    if (this.instanceId) {
+      InstancedMeshManager.getInstance().setInstanceVisible(this.batchKey, this.instanceId, visible);
+    }
+  }
+  /**
+   * Get the visibility of this instance
+   */
+  getVisible() {
+    if (this.instanceId) {
+      return InstancedMeshManager.getInstance().getInstanceVisible(this.batchKey, this.instanceId);
+    }
+    return false;
+  }
+  /**
+   * Show the instance (convenience method)
+   */
+  show() {
+    this.setVisible(true);
+  }
+  /**
+   * Hide the instance (convenience method)
+   */
+  hide() {
+    this.setVisible(false);
+  }
+  /**
+   * Get the batch key this renderer is registered with
+   */
+  getBatchKey() {
+    return this.batchKey;
+  }
+  /**
+   * Check if this renderer is successfully registered with a batch
+   */
+  isRegistered() {
+    return this.instanceId !== null;
+  }
+  /**
+   * Get the instance ID (for debugging)
+   */
+  getInstanceId() {
+    return this.instanceId;
+  }
+  /**
+   * Mark this instance as needing a matrix update.
+   * Only relevant for static instances - dynamic instances update every frame anyway.
+   * Call this when the transform of a static instance changes.
+   */
+  markDirty() {
+    if (this.instanceId) {
+      InstancedMeshManager.getInstance().markInstanceDirty(this.batchKey, this.instanceId);
+    }
+  }
+  /**
+   * Set whether this instance is dynamic (updates every frame) or static (only when marked dirty).
+   * Use this to optimize performance when items transition between moving and stationary states.
+   * @param isDynamic If true, updates every frame. If false, only updates when markDirty() is called.
+   */
+  setDynamic(isDynamic) {
+    if (this.instanceId) {
+      InstancedMeshManager.getInstance().setInstanceDynamic(
+        this.batchKey,
+        this.instanceId,
+        isDynamic
+      );
+    }
+  }
+  /**
+   * Called when the GameObject becomes enabled
+   */
+  onEnabled() {
+    this.setVisible(true);
+  }
+  /**
+   * Called when the GameObject becomes disabled
+   */
+  onDisabled() {
+    this.setVisible(false);
+  }
+  /**
+   * Unregister from the batch when the component is cleaned up
+   */
+  onCleanup() {
+    if (this.instanceId) {
+      InstancedMeshManager.getInstance().removeInstance(this.batchKey, this.instanceId);
+      this.instanceId = null;
+    }
+  }
+};
+
+// src/engine/render/MeshRenderer.ts
+import * as THREE6 from "three";
+var MeshRenderer = class extends Component {
+  static fromPrefabJSON(json, _node) {
+    if (!json.mesh?.assetId) {
+      console.error(`[MeshRenderer] stow_mesh component missing mesh.assetId:`, json);
+      return new MeshRenderer("unknown");
+    }
+    const options = PrefabInstance.currentOptions;
+    const castShadow = json.castShadow ?? options?.castShadow ?? true;
+    const receiveShadow = json.receiveShadow ?? options?.receiveShadow ?? true;
+    return new MeshRenderer(json.mesh.assetId, castShadow, receiveShadow);
+  }
+  mesh = null;
+  meshName;
+  castShadow;
+  receiveShadow;
+  _isStatic;
+  isMeshLoaded = false;
+  materialOverride = null;
+  /**
+   * @param meshName The name of the mesh in the StowKit pack
+   * @param castShadow Whether meshes should cast shadows (default: true)
+   * @param receiveShadow Whether meshes should receive shadows (default: true)
+   * @param isStatic Whether this mesh is static (default: false). Static meshes have matrixAutoUpdate disabled for better performance.
+   * @param materialOverride Optional material to use instead of the default StowKit material
+   */
+  constructor(meshName, castShadow = true, receiveShadow = true, isStatic = false, materialOverride = null) {
+    super();
+    this.meshName = meshName;
+    this.castShadow = castShadow;
+    this.receiveShadow = receiveShadow;
+    this._isStatic = isStatic;
+    this.materialOverride = materialOverride;
+  }
+  onCreate() {
+    const stowkit = StowKitSystem.getInstance();
+    const cachedMesh = stowkit.getMeshSync(this.meshName);
+    if (cachedMesh) {
+      this.addMesh(cachedMesh);
+    } else {
+      stowkit.getMesh(this.meshName);
+    }
+  }
+  update(_deltaTime) {
+    if (this.isMeshLoaded) return;
+    const stowkit = StowKitSystem.getInstance();
+    const cachedMesh = stowkit.getMeshSync(this.meshName);
+    if (cachedMesh) {
+      this.addMesh(cachedMesh);
+    }
+  }
+  addMesh(original) {
+    this.isMeshLoaded = true;
+    this.mesh = StowKitSystem.getInstance().cloneMeshSync(
+      original,
+      this.castShadow,
+      this.receiveShadow
+    );
+    if (this.materialOverride) {
+      this.applyMaterialOverride();
+    }
+    this.gameObject.add(this.mesh);
+    if (this._isStatic) {
+      this.setStatic(true);
+    }
+  }
+  /**
+   * Apply the material override to all meshes
+   */
+  applyMaterialOverride() {
+    if (!this.mesh || !this.materialOverride) return;
+    this.mesh.traverse((child) => {
+      if (child instanceof THREE6.Mesh) {
+        child.material = this.materialOverride;
+      }
+    });
+  }
+  /**
+   * Set a material override for all meshes in this renderer.
+   * Call this after the mesh is loaded, or pass it in the constructor.
+   */
+  setMaterial(material) {
+    this.materialOverride = material;
+    if (this.mesh) {
+      this.applyMaterialOverride();
+    }
+  }
+  /**
+   * Check if this mesh is currently static (no automatic matrix updates)
+   */
+  get isStatic() {
+    return this._isStatic;
+  }
+  /**
+   * Set whether this mesh is static (no automatic matrix updates).
+   * Static meshes save CPU by not recalculating transforms every frame.
+   * Call forceMatrixUpdate() after moving a static mesh.
+   */
+  setStatic(isStatic) {
+    this._isStatic = isStatic;
+    if (!this.mesh) return;
+    if (isStatic) {
+      this.forceMatrixUpdate();
+      this.mesh.matrixAutoUpdate = false;
+      this.mesh.traverse((child) => {
+        child.matrixAutoUpdate = false;
+      });
+      this.gameObject.matrixAutoUpdate = false;
+    } else {
+      this.mesh.matrixAutoUpdate = true;
+      this.mesh.traverse((child) => {
+        child.matrixAutoUpdate = true;
+      });
+      this.gameObject.matrixAutoUpdate = true;
+    }
+  }
+  /**
+   * Force a one-time matrix update. Call this after moving a static mesh.
+   * Does not change the static/dynamic state.
+   */
+  forceMatrixUpdate() {
+    if (this.mesh) {
+      this.mesh.updateMatrix();
+      this.mesh.updateMatrixWorld(true);
+    }
+    this.gameObject.updateMatrix();
+    this.gameObject.updateMatrixWorld(true);
+  }
+  /**
+   * Get the mesh group (null if not yet loaded)
+   */
+  getMesh() {
+    return this.mesh;
+  }
+  /**
+   * Get the name of the mesh this component is managing
+   */
+  getMeshName() {
+    return this.meshName;
+  }
+  /**
+   * Check if the mesh was successfully loaded
+   */
+  isLoaded() {
+    return this.mesh !== null;
+  }
+  /**
+   * Set the visibility of the mesh
+   */
+  setVisible(visible) {
+    if (this.mesh) {
+      this.mesh.visible = visible;
+    }
+  }
+  /**
+   * Get bounds of the mesh (useful for physics)
+   */
+  getBounds() {
+    if (!this.mesh) {
+      return null;
+    }
+    return StowKitSystem.getInstance().getBounds(this.mesh);
+  }
+  /**
+   * Cleanup - remove mesh from scene and dispose of resources
+   */
+  onCleanup() {
+    if (this.mesh) {
+      this.gameObject.remove(this.mesh);
+      this.mesh.traverse((child) => {
+        if (child instanceof THREE6.Mesh) {
+          if (child.geometry) {
+            child.geometry.dispose();
+          }
+          if (child.material) {
+            if (Array.isArray(child.material)) {
+              child.material.forEach((m) => {
+                if (m.map) m.map.dispose();
+                m.dispose();
+              });
+            } else {
+              if (child.material.map) child.material.map.dispose();
+              child.material.dispose();
+            }
+          }
+        }
+      });
+      this.mesh = null;
+    }
+  }
+};
+MeshRenderer = __decorateClass([
+  PrefabComponent("stow_mesh")
+], MeshRenderer);
+
+// src/index.ts
+export * from "@series-inc/rundot-game-sdk";
+import { default as default2 } from "@series-inc/rundot-game-sdk/api";
+export {
+  AssetManager,
+  Component,
+  ComponentUpdater,
+  GameObject,
+  InstancedMeshManager,
+  InstancedRenderer,
+  InteractionZone,
+  MeshRenderer,
+  MovementController,
+  PlayerControllerThree,
+  default2 as RundotGameAPI,
+  SkeletalRenderer,
+  SkeletonCache,
+  VenusGame,
+  VirtualJoystickThree
+};
+//# sourceMappingURL=index.js.map