react-three-game 0.0.49 → 0.0.51

package/README.md

@@ -163,9 +163,13 @@ Keys: **T**ranslate / **R**otate / **S**cale. Drag tree nodes to reparent. Impor
 ## Tree Utilities
 
 ```typescript
-import { findNode, updateNode, deleteNode, cloneNode } from 'react-three-game';
+import { findNode, updateNode, updateNodeById, deleteNode, cloneNode, exportGLBData } from 'react-three-game';
 
-const updated = updateNode(root, nodeId, n => ({ ...n, disabled: true }));
+const node = findNode(root, nodeId);
+const updated = updateNode(root, nodeId, n => ({ ...n, disabled: true }));  // or updateNodeById
+const afterDelete = deleteNode(root, nodeId);
+const cloned = cloneNode(node);
+const glbData = await exportGLBData(sceneRoot);  // export scene to GLB ArrayBuffer
 ```
 
 ## Development

package/dist/index.d.ts

@@ -12,5 +12,9 @@ export type { PrefabRootRef } from './tools/prefabeditor/PrefabRoot';
 export type { Component } from './tools/prefabeditor/components/ComponentRegistry';
 export type { FieldDefinition, FieldType } from './tools/prefabeditor/components/Input';
 export type { Prefab, GameObject, ComponentData } from './tools/prefabeditor/types';
+export { gameEvents, useGameEvent, getEntityIdFromRigidBody } from './tools/prefabeditor/GameEvents';
+export type { GameEventType, GameEventMap, GameEventPayload, PhysicsEventType, PhysicsEventPayload } from './tools/prefabeditor/GameEvents';
+export { entityEvents, useEntityEvent } from './tools/prefabeditor/GameEvents';
+export type { EntityEventType, EntityEventPayload } from './tools/prefabeditor/GameEvents';
 export { DragDropLoader } from './tools/dragdrop/DragDropLoader';
 export { TextureListViewer, ModelListViewer, SoundListViewer, SharedCanvas, } from './tools/assetviewer/page';

package/dist/index.js

@@ -12,6 +12,10 @@ export { registerComponent } from './tools/prefabeditor/components/ComponentRegi
 export { FieldRenderer, Input, Label, Vector3Input, ColorInput, StringInput, BooleanInput, SelectInput, } from './tools/prefabeditor/components/Input';
 // Prefab Editor - Styles & Utils
 export * from './tools/prefabeditor/utils';
+// Game Events (physics + custom events)
+export { gameEvents, useGameEvent, getEntityIdFromRigidBody } from './tools/prefabeditor/GameEvents';
+// Backward compatibility aliases
+export { entityEvents, useEntityEvent } from './tools/prefabeditor/GameEvents';
 // Asset Tools
 export { DragDropLoader } from './tools/dragdrop/DragDropLoader';
 export { TextureListViewer, ModelListViewer, SoundListViewer, SharedCanvas, } from './tools/assetviewer/page';

package/dist/tools/prefabeditor/EntityEvents.d.ts

@@ -0,0 +1,54 @@
+import type { RapierRigidBody } from '@react-three/rapier';
+export type EntityEventType = 'sensor:enter' | 'sensor:exit' | 'collision:enter' | 'collision:exit';
+export interface EntityEventPayload {
+    sourceEntityId: string;
+    targetEntityId: string | null;
+    targetRigidBody: RapierRigidBody | null | undefined;
+}
+type EventHandler = (payload: EntityEventPayload) => void;
+/**
+ * Entity event system for physics interactions.
+ *
+ * Events:
+ * - sensor:enter - Fired when something enters a sensor collider
+ * - sensor:exit - Fired when something exits a sensor collider
+ * - collision:enter - Fired when a collision starts
+ * - collision:exit - Fired when a collision ends
+ */
+export declare const entityEvents: {
+    /**
+     * Emit an event to all subscribers
+     */
+    emit(type: EntityEventType, payload: EntityEventPayload): void;
+    /**
+     * Subscribe to an event type
+     * @returns Unsubscribe function
+     */
+    on(type: EntityEventType, handler: EventHandler): () => void;
+    /**
+     * Unsubscribe from an event type
+     */
+    off(type: EntityEventType, handler: EventHandler): void;
+    /**
+     * Remove all subscribers (useful for cleanup)
+     */
+    clear(): void;
+};
+/**
+ * React hook to subscribe to entity events.
+ * Automatically cleans up on unmount.
+ *
+ * @example
+ * useEntityEvent('sensor:enter', (payload) => {
+ *   if (payload.sourceEntityId === 'trigger-zone') {
+ *     console.log('Player entered trigger zone!');
+ *   }
+ * });
+ */
+export declare function useEntityEvent(type: EntityEventType, handler: EventHandler, deps?: any[]): void;
+/**
+ * Helper to extract entity ID from Rapier collision data.
+ * Entity IDs are stored in RigidBody userData.
+ */
+export declare function getEntityIdFromRigidBody(rigidBody: RapierRigidBody | null | undefined): string | null;
+export {};

package/dist/tools/prefabeditor/EntityEvents.js

@@ -0,0 +1,85 @@
+import { useEffect, useCallback } from 'react';
+// Internal subscriber storage
+const subscribers = new Map();
+/**
+ * Entity event system for physics interactions.
+ *
+ * Events:
+ * - sensor:enter - Fired when something enters a sensor collider
+ * - sensor:exit - Fired when something exits a sensor collider
+ * - collision:enter - Fired when a collision starts
+ * - collision:exit - Fired when a collision ends
+ */
+export const entityEvents = {
+    /**
+     * Emit an event to all subscribers
+     */
+    emit(type, payload) {
+        const handlers = subscribers.get(type);
+        if (handlers) {
+            handlers.forEach(handler => {
+                try {
+                    handler(payload);
+                }
+                catch (e) {
+                    console.error(`Error in entityEvents handler for ${type}:`, e);
+                }
+            });
+        }
+    },
+    /**
+     * Subscribe to an event type
+     * @returns Unsubscribe function
+     */
+    on(type, handler) {
+        if (!subscribers.has(type)) {
+            subscribers.set(type, new Set());
+        }
+        subscribers.get(type).add(handler);
+        return () => {
+            var _a;
+            (_a = subscribers.get(type)) === null || _a === void 0 ? void 0 : _a.delete(handler);
+        };
+    },
+    /**
+     * Unsubscribe from an event type
+     */
+    off(type, handler) {
+        var _a;
+        (_a = subscribers.get(type)) === null || _a === void 0 ? void 0 : _a.delete(handler);
+    },
+    /**
+     * Remove all subscribers (useful for cleanup)
+     */
+    clear() {
+        subscribers.clear();
+    }
+};
+/**
+ * React hook to subscribe to entity events.
+ * Automatically cleans up on unmount.
+ *
+ * @example
+ * useEntityEvent('sensor:enter', (payload) => {
+ *   if (payload.sourceEntityId === 'trigger-zone') {
+ *     console.log('Player entered trigger zone!');
+ *   }
+ * });
+ */
+export function useEntityEvent(type, handler, deps = []) {
+    const stableHandler = useCallback(handler, deps);
+    useEffect(() => {
+        return entityEvents.on(type, stableHandler);
+    }, [type, stableHandler]);
+}
+/**
+ * Helper to extract entity ID from Rapier collision data.
+ * Entity IDs are stored in RigidBody userData.
+ */
+export function getEntityIdFromRigidBody(rigidBody) {
+    var _a;
+    if (!rigidBody)
+        return null;
+    const userData = rigidBody.userData;
+    return (_a = userData === null || userData === void 0 ? void 0 : userData.entityId) !== null && _a !== void 0 ? _a : null;
+}

package/dist/tools/prefabeditor/GameEvents.d.ts

@@ -0,0 +1,126 @@
+import type { RapierRigidBody } from '@react-three/rapier';
+/** Physics event types (built-in) */
+export type PhysicsEventType = 'sensor:enter' | 'sensor:exit' | 'collision:enter' | 'collision:exit';
+/** Payload for physics events */
+export interface PhysicsEventPayload {
+    sourceEntityId: string;
+    targetEntityId: string | null;
+    targetRigidBody: RapierRigidBody | null | undefined;
+}
+/**
+ * Register your custom event types here by extending this interface:
+ *
+ * declare module 'react-three-game' {
+ *   interface GameEventMap {
+ *     'player:death': { playerId: string; cause: string };
+ *     'score:change': { delta: number; total: number };
+ *   }
+ * }
+ */
+export interface GameEventMap {
+    'sensor:enter': PhysicsEventPayload;
+    'sensor:exit': PhysicsEventPayload;
+    'collision:enter': PhysicsEventPayload;
+    'collision:exit': PhysicsEventPayload;
+}
+/** All registered event types */
+export type GameEventType = keyof GameEventMap | (string & {});
+/** Get payload type for an event, or fallback to generic */
+export type GameEventPayload<T extends string> = T extends keyof GameEventMap ? GameEventMap[T] : Record<string, unknown>;
+type EventHandler<T = unknown> = (payload: T) => void;
+/**
+ * Game event system for all game interactions.
+ *
+ * Built-in physics events:
+ * - sensor:enter - Something entered a sensor collider
+ * - sensor:exit - Something exited a sensor collider
+ * - collision:enter - A collision started
+ * - collision:exit - A collision ended
+ *
+ * Custom events:
+ * - Emit any event type with any payload
+ * - Extend GameEventMap interface for type safety
+ *
+ * @example
+ * // Physics events (typed)
+ * gameEvents.emit('sensor:enter', { sourceEntityId: 'zone', targetEntityId: 'player', targetRigidBody: rb });
+ *
+ * // Custom events
+ * gameEvents.emit('player:death', { playerId: 'p1', cause: 'lava' });
+ * gameEvents.emit('level:complete', { levelId: 3, time: 45.2 });
+ */
+export declare const gameEvents: {
+    /**
+     * Emit an event to all subscribers
+     */
+    emit<T extends string>(type: T, payload: GameEventPayload<T>): void;
+    /**
+     * Subscribe to an event type
+     * @returns Unsubscribe function
+     */
+    on<T extends string>(type: T, handler: EventHandler<GameEventPayload<T>>): () => void;
+    /**
+     * Unsubscribe from an event type
+     */
+    off<T extends string>(type: T, handler: EventHandler<GameEventPayload<T>>): void;
+    /**
+     * Remove all subscribers (useful for cleanup/reset)
+     */
+    clear(): void;
+    /**
+     * Check if an event type has any subscribers
+     */
+    hasListeners(type: string): boolean;
+};
+/**
+ * React hook to subscribe to game events.
+ * Automatically cleans up on unmount.
+ *
+ * @example
+ * // Physics event
+ * useGameEvent('sensor:enter', (payload) => {
+ *   if (payload.sourceEntityId === 'coin') collectCoin();
+ * }, []);
+ *
+ * // Custom event
+ * useGameEvent('player:death', (payload) => {
+ *   showGameOver(payload.cause);
+ * }, []);
+ */
+export declare function useGameEvent<T extends string>(type: T, handler: EventHandler<GameEventPayload<T>>, deps?: unknown[]): void;
+/**
+ * Helper to extract entity ID from Rapier collision data.
+ * Entity IDs are stored in RigidBody userData.
+ */
+export declare function getEntityIdFromRigidBody(rigidBody: RapierRigidBody | null | undefined): string | null;
+/** @deprecated Use gameEvents instead */
+export declare const entityEvents: {
+    /**
+     * Emit an event to all subscribers
+     */
+    emit<T extends string>(type: T, payload: GameEventPayload<T>): void;
+    /**
+     * Subscribe to an event type
+     * @returns Unsubscribe function
+     */
+    on<T extends string>(type: T, handler: EventHandler<GameEventPayload<T>>): () => void;
+    /**
+     * Unsubscribe from an event type
+     */
+    off<T extends string>(type: T, handler: EventHandler<GameEventPayload<T>>): void;
+    /**
+     * Remove all subscribers (useful for cleanup/reset)
+     */
+    clear(): void;
+    /**
+     * Check if an event type has any subscribers
+     */
+    hasListeners(type: string): boolean;
+};
+/** @deprecated Use useGameEvent instead */
+export declare const useEntityEvent: typeof useGameEvent;
+/** @deprecated Use GameEventType instead */
+export type EntityEventType = PhysicsEventType;
+/** @deprecated Use PhysicsEventPayload instead */
+export type EntityEventPayload = PhysicsEventPayload;
+export {};

package/dist/tools/prefabeditor/GameEvents.js

@@ -0,0 +1,119 @@
+import { useEffect, useCallback } from 'react';
+// Internal subscriber storage
+const subscribers = new Map();
+/**
+ * Game event system for all game interactions.
+ *
+ * Built-in physics events:
+ * - sensor:enter - Something entered a sensor collider
+ * - sensor:exit - Something exited a sensor collider
+ * - collision:enter - A collision started
+ * - collision:exit - A collision ended
+ *
+ * Custom events:
+ * - Emit any event type with any payload
+ * - Extend GameEventMap interface for type safety
+ *
+ * @example
+ * // Physics events (typed)
+ * gameEvents.emit('sensor:enter', { sourceEntityId: 'zone', targetEntityId: 'player', targetRigidBody: rb });
+ *
+ * // Custom events
+ * gameEvents.emit('player:death', { playerId: 'p1', cause: 'lava' });
+ * gameEvents.emit('level:complete', { levelId: 3, time: 45.2 });
+ */
+export const gameEvents = {
+    /**
+     * Emit an event to all subscribers
+     */
+    emit(type, payload) {
+        const handlers = subscribers.get(type);
+        if (handlers) {
+            handlers.forEach(handler => {
+                try {
+                    handler(payload);
+                }
+                catch (e) {
+                    console.error(`Error in gameEvents handler for ${type}:`, e);
+                }
+            });
+        }
+    },
+    /**
+     * Subscribe to an event type
+     * @returns Unsubscribe function
+     */
+    on(type, handler) {
+        if (!subscribers.has(type)) {
+            subscribers.set(type, new Set());
+        }
+        subscribers.get(type).add(handler);
+        return () => {
+            var _a;
+            (_a = subscribers.get(type)) === null || _a === void 0 ? void 0 : _a.delete(handler);
+        };
+    },
+    /**
+     * Unsubscribe from an event type
+     */
+    off(type, handler) {
+        var _a;
+        (_a = subscribers.get(type)) === null || _a === void 0 ? void 0 : _a.delete(handler);
+    },
+    /**
+     * Remove all subscribers (useful for cleanup/reset)
+     */
+    clear() {
+        subscribers.clear();
+    },
+    /**
+     * Check if an event type has any subscribers
+     */
+    hasListeners(type) {
+        var _a, _b;
+        return ((_b = (_a = subscribers.get(type)) === null || _a === void 0 ? void 0 : _a.size) !== null && _b !== void 0 ? _b : 0) > 0;
+    }
+};
+/**
+ * React hook to subscribe to game events.
+ * Automatically cleans up on unmount.
+ *
+ * @example
+ * // Physics event
+ * useGameEvent('sensor:enter', (payload) => {
+ *   if (payload.sourceEntityId === 'coin') collectCoin();
+ * }, []);
+ *
+ * // Custom event
+ * useGameEvent('player:death', (payload) => {
+ *   showGameOver(payload.cause);
+ * }, []);
+ */
+export function useGameEvent(type, handler, deps = []) {
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    const stableHandler = useCallback(handler, deps);
+    useEffect(() => {
+        return gameEvents.on(type, stableHandler);
+    }, [type, stableHandler]);
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+/**
+ * Helper to extract entity ID from Rapier collision data.
+ * Entity IDs are stored in RigidBody userData.
+ */
+export function getEntityIdFromRigidBody(rigidBody) {
+    var _a;
+    if (!rigidBody)
+        return null;
+    const userData = rigidBody.userData;
+    return (_a = userData === null || userData === void 0 ? void 0 : userData.entityId) !== null && _a !== void 0 ? _a : null;
+}
+// ============================================================================
+// Backward Compatibility Aliases
+// ============================================================================
+/** @deprecated Use gameEvents instead */
+export const entityEvents = gameEvents;
+/** @deprecated Use useGameEvent instead */
+export const useEntityEvent = useGameEvent;

package/dist/tools/prefabeditor/PrefabRoot.d.ts

@@ -1,8 +1,10 @@
 import { Group, Matrix4, Object3D, Texture } from "three";
 import { ThreeEvent } from "@react-three/fiber";
 import { Prefab, GameObject as GameObjectType } from "./types";
+import type { RapierRigidBody } from "@react-three/rapier";
 export interface PrefabRootRef {
     root: Group | null;
+    rigidBodyRefs: Map<string, RapierRigidBody | null>;
 }
 export declare const PrefabRoot: import("react").ForwardRefExoticComponent<{
     editMode?: boolean;
@@ -20,6 +22,7 @@ interface RendererProps {
     onSelect?: (id: string) => void;
     onClick?: (event: ThreeEvent<PointerEvent>, entity: GameObjectType) => void;
     registerRef: (id: string, obj: Object3D | null) => void;
+    registerRigidBodyRef: (id: string, rb: RapierRigidBody | null) => void;
     loadedModels: Record<string, Object3D>;
     loadedTextures: Record<string, Texture>;
     editMode?: boolean;

package/dist/tools/prefabeditor/PrefabRoot.js

@@ -30,16 +30,21 @@ export const PrefabRoot = forwardRef(({ editMode, data, onPrefabChange, selected
     const [textures, setTextures] = useState({});
     const loading = useRef(new Set());
     const objectRefs = useRef({});
+    const rigidBodyRefs = useRef(new Map());
     const [selectedObject, setSelectedObject] = useState(null);
     const rootRef = useRef(null);
     useImperativeHandle(ref, () => ({
-        root: rootRef.current
+        root: rootRef.current,
+        rigidBodyRefs: rigidBodyRefs.current
     }), []);
     const registerRef = useCallback((id, obj) => {
         objectRefs.current[id] = obj;
         if (id === selectedId)
             setSelectedObject(obj);
     }, [selectedId]);
+    const registerRigidBodyRef = useCallback((id, rb) => {
+        rigidBodyRefs.current.set(id, rb);
+    }, []);
     useEffect(() => {
         const originalError = console.error;
         console.error = (...args) => {
@@ -103,7 +108,7 @@ export const PrefabRoot = forwardRef(({ editMode, data, onPrefabChange, selected
             });
         });
     }, [data, models, textures]);
-    return (_jsxs("group", { ref: rootRef, children: [_jsx(GameInstanceProvider, { models: models, selectedId: selectedId, editMode: editMode, onSelect: editMode ? onSelect : undefined, registerRef: registerRef, children: _jsx(GameObjectRenderer, { gameObject: data.root, selectedId: selectedId, onSelect: editMode ? onSelect : undefined, onClick: onClick, registerRef: registerRef, loadedModels: models, loadedTextures: textures, editMode: editMode, parentMatrix: IDENTITY }) }), editMode && (_jsxs(_Fragment, { children: [_jsx(MapControls, { makeDefault: true }), selectedObject && (_jsx(TransformControls, { object: selectedObject, mode: transformMode, space: "local", onObjectChange: onTransformChange, translationSnap: snapResolution > 0 ? snapResolution : undefined, rotationSnap: snapResolution > 0 ? snapResolution : undefined, scaleSnap: snapResolution > 0 ? snapResolution : undefined }, `transform-${snapResolution}`))] }))] }));
+    return (_jsxs("group", { ref: rootRef, children: [_jsx(GameInstanceProvider, { models: models, selectedId: selectedId, editMode: editMode, onSelect: editMode ? onSelect : undefined, registerRef: registerRef, children: _jsx(GameObjectRenderer, { gameObject: data.root, selectedId: selectedId, onSelect: editMode ? onSelect : undefined, onClick: onClick, registerRef: registerRef, registerRigidBodyRef: registerRigidBodyRef, loadedModels: models, loadedTextures: textures, editMode: editMode, parentMatrix: IDENTITY }) }), editMode && (_jsxs(_Fragment, { children: [_jsx(MapControls, { makeDefault: true }), selectedObject && (_jsx(TransformControls, { object: selectedObject, mode: transformMode, space: "local", onObjectChange: onTransformChange, translationSnap: snapResolution > 0 ? snapResolution : undefined, rotationSnap: snapResolution > 0 ? snapResolution : undefined, scaleSnap: snapResolution > 0 ? snapResolution : undefined }, `transform-${snapResolution}`))] }))] }));
 });
 export function GameObjectRenderer(props) {
     var _a, _b, _c;
@@ -160,7 +165,7 @@ function InstancedNode({ gameObject, parentMatrix = IDENTITY, editMode, register
     }
     return (_jsx(GameInstance, { id: gameObject.id, modelUrl: (_k = (_j = (_h = gameObject.components) === null || _h === void 0 ? void 0 : _h.model) === null || _j === void 0 ? void 0 : _j.properties) === null || _k === void 0 ? void 0 : _k.filename, position: worldPosition, rotation: worldRotation, scale: worldScale, physics: physicsProps }));
 }
-function StandardNode({ gameObject, selectedId, onSelect, onClick, registerRef, loadedModels, loadedTextures, editMode, parentMatrix = IDENTITY, }) {
+function StandardNode({ gameObject, selectedId, onSelect, onClick, registerRef, registerRigidBodyRef, loadedModels, loadedTextures, editMode, parentMatrix = IDENTITY, }) {
     var _a, _b, _c, _d, _e, _f;
     const groupRef = useRef(null);
     const helperRef = useRef(null);
@@ -193,12 +198,12 @@ function StandardNode({ gameObject, selectedId, onSelect, onClick, registerRef,
     const physicsDef = hasPhysics ? getComponent("Physics") : null;
     const isInstanced = (_e = (_d = (_c = gameObject.components) === null || _c === void 0 ? void 0 : _c.model) === null || _d === void 0 ? void 0 : _d.properties) === null || _e === void 0 ? void 0 : _e.instanced;
     const physicsKey = `physics_${gameObject.id}_${isInstanced ? 'instanced' : 'standard'}`;
-    const inner = (_jsxs("group", { onPointerDown: editMode ? onDown : undefined, onPointerMove: editMode ? () => (clickValid.current = false) : undefined, onPointerUp: editMode ? onUp : undefined, children: [renderCoreNode(gameObject, { loadedModels, loadedTextures, editMode, registerRef }, parentMatrix), (_f = gameObject.children) === null || _f === void 0 ? void 0 : _f.map(child => (_jsx(GameObjectRenderer, { gameObject: child, selectedId: selectedId, onSelect: onSelect, onClick: onClick, registerRef: registerRef, loadedModels: loadedModels, loadedTextures: loadedTextures, editMode: editMode, parentMatrix: world }, child.id)))] }));
+    const inner = (_jsxs("group", { onPointerDown: editMode ? onDown : undefined, onPointerMove: editMode ? () => (clickValid.current = false) : undefined, onPointerUp: editMode ? onUp : undefined, children: [renderCoreNode(gameObject, { loadedModels, loadedTextures, editMode, registerRef }, parentMatrix), (_f = gameObject.children) === null || _f === void 0 ? void 0 : _f.map(child => (_jsx(GameObjectRenderer, { gameObject: child, selectedId: selectedId, onSelect: onSelect, onClick: onClick, registerRef: registerRef, registerRigidBodyRef: registerRigidBodyRef, loadedModels: loadedModels, loadedTextures: loadedTextures, editMode: editMode, parentMatrix: world }, child.id)))] }));
     if (editMode) {
-        return (_jsxs(_Fragment, { children: [_jsx("group", { ref: groupRef, position: transform.position, rotation: transform.rotation, scale: transform.scale, children: _jsx("mesh", { visible: false, children: _jsx("boxGeometry", { args: [0.01, 0.01, 0.01] }) }) }), _jsx("group", { ref: helperRef, position: transform.position, rotation: transform.rotation, scale: transform.scale, children: inner }), hasPhysics && (physicsDef === null || physicsDef === void 0 ? void 0 : physicsDef.View) ? (_jsx(physicsDef.View, { properties: physics.properties, position: transform.position, rotation: transform.rotation, scale: transform.scale, editMode: editMode, children: inner }, physicsKey)) : null] }));
+        return (_jsxs(_Fragment, { children: [_jsx("group", { ref: groupRef, position: transform.position, rotation: transform.rotation, scale: transform.scale, children: _jsx("mesh", { visible: false, children: _jsx("boxGeometry", { args: [0.01, 0.01, 0.01] }) }) }), _jsx("group", { ref: helperRef, position: transform.position, rotation: transform.rotation, scale: transform.scale, children: inner }), hasPhysics && (physicsDef === null || physicsDef === void 0 ? void 0 : physicsDef.View) ? (_jsx(physicsDef.View, { properties: physics.properties, position: transform.position, rotation: transform.rotation, scale: transform.scale, editMode: editMode, nodeId: gameObject.id, registerRigidBodyRef: registerRigidBodyRef, children: inner }, physicsKey)) : null] }));
     }
     if (hasPhysics && (physicsDef === null || physicsDef === void 0 ? void 0 : physicsDef.View)) {
-        return (_jsx(physicsDef.View, { properties: physics.properties, position: transform.position, rotation: transform.rotation, scale: transform.scale, editMode: editMode, children: inner }, physicsKey));
+        return (_jsx(physicsDef.View, { properties: physics.properties, position: transform.position, rotation: transform.rotation, scale: transform.scale, editMode: editMode, nodeId: gameObject.id, registerRigidBodyRef: registerRigidBodyRef, children: inner }, physicsKey));
     }
     return (_jsx("group", { ref: groupRef, position: transform.position, rotation: transform.rotation, scale: transform.scale, onPointerDown: onDown, onPointerMove: () => (clickValid.current = false), onPointerUp: onUp, children: inner }));
 }

package/dist/tools/prefabeditor/components/MaterialComponent.d.ts

@@ -1,3 +1,12 @@
 import { Component } from './ComponentRegistry';
+import { MeshStandardMaterialProperties } from 'three';
+export interface MaterialProps extends Omit<MeshStandardMaterialProperties, 'args'> {
+    texture?: string;
+    repeat?: boolean;
+    repeatCount?: [number, number];
+    generateMipmaps?: boolean;
+    minFilter?: string;
+    magFilter?: string;
+}
 declare const MaterialComponent: Component;
 export default MaterialComponent;

package/dist/tools/prefabeditor/components/MaterialComponent.js

@@ -1,3 +1,14 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { SingleTextureViewer, TextureListViewer } from '../../assetviewer/page';
 import { useEffect, useState } from 'react';
@@ -25,6 +36,13 @@ function MaterialComponentEditor({ component, onUpdate, basePath = "" }) {
     const fields = [
         { name: 'color', type: 'color', label: 'Color' },
         { name: 'wireframe', type: 'boolean', label: 'Wireframe' },
+        { name: 'transparent', type: 'boolean', label: 'Transparent' },
+        { name: 'opacity', type: 'number', label: 'Opacity', min: 0, max: 1, step: 0.01 },
+        { name: 'metalness', type: 'number', label: 'Metalness', min: 0, max: 1, step: 0.01 },
+        { name: 'roughness', type: 'number', label: 'Roughness', min: 0, max: 1, step: 0.01 },
+        { name: 'transmission', type: 'number', label: 'Transmission', min: 0, max: 1, step: 0.01 },
+        { name: 'thickness', type: 'number', label: 'Thickness', min: 0, step: 0.1 },
+        { name: 'ior', type: 'number', label: 'IOR (Index of Refraction)', min: 1, max: 2.333, step: 0.01 },
         {
             name: 'texture',
             type: 'custom',
@@ -80,6 +98,9 @@ function MaterialComponentView({ properties, loadedTextures }) {
     const minFilter = (properties === null || properties === void 0 ? void 0 : properties.minFilter) || 'LinearMipmapLinearFilter';
     const magFilter = (properties === null || properties === void 0 ? void 0 : properties.magFilter) || 'LinearFilter';
     const texture = textureName && loadedTextures ? loadedTextures[textureName] : undefined;
+    // Destructure all material props and separate custom texture handling props
+    const _b = properties || {}, { texture: _texture, repeat: _repeat, repeatCount: _repeatCount, generateMipmaps: _generateMipmaps, minFilter: _minFilter, magFilter: _magFilter, map: _map } = _b, // Filter out map since we set it explicitly
+    materialProps = __rest(_b, ["texture", "repeat", "repeatCount", "generateMipmaps", "minFilter", "magFilter", "map"]);
     const minFilterMap = {
         NearestFilter,
         LinearFilter,
@@ -116,8 +137,7 @@ function MaterialComponentView({ properties, loadedTextures }) {
     if (!properties) {
         return _jsx("meshStandardMaterial", { color: "red", wireframe: true });
     }
-    const { color, wireframe = false } = properties;
-    return (_jsx("meshStandardMaterial", { color: color, wireframe: wireframe, map: finalTexture, transparent: !!finalTexture }, (_a = finalTexture === null || finalTexture === void 0 ? void 0 : finalTexture.uuid) !== null && _a !== void 0 ? _a : 'no-texture'));
+    return (_jsx("meshStandardMaterial", Object.assign({ map: finalTexture }, materialProps), (_a = finalTexture === null || finalTexture === void 0 ? void 0 : finalTexture.uuid) !== null && _a !== void 0 ? _a : 'no-texture'));
 }
 const MaterialComponent = {
     name: 'Material',
@@ -126,7 +146,11 @@ const MaterialComponent = {
     nonComposable: true,
     defaultProperties: {
         color: '#ffffff',
-        wireframe: false
+        wireframe: false,
+        transparent: false,
+        opacity: 1,
+        metalness: 0,
+        roughness: 1
     }
 };
 export default MaterialComponent;