react-three-game 0.0.56 → 0.0.57

package/dist/tools/prefabeditor/PrefabEditor.js

@@ -21,12 +21,14 @@ const DEFAULT_PREFAB = {
         }
     }
 };
-const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, onPrefabChange, children }, ref) => {
+const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, onPrefabChange, uiPlugins, children }, ref) => {
     const [editMode, setEditMode] = useState(true);
     const [loadedPrefab, setLoadedPrefab] = useState(initialPrefab !== null && initialPrefab !== void 0 ? initialPrefab : DEFAULT_PREFAB);
     const [selectedId, setSelectedId] = useState(null);
     const [transformMode, setTransformMode] = useState("translate");
     const [snapResolution, setSnapResolution] = useState(0);
+    const [positionSnap, setPositionSnap] = useState(0.5);
+    const [rotationSnap, setRotationSnap] = useState(Math.PI / 4);
     const [history, setHistory] = useState([loadedPrefab]);
     const [historyIndex, setHistoryIndex] = useState(0);
     const throttleRef = useRef(null);
@@ -107,6 +109,10 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, onPr
             filename: `${loadedPrefab.name || 'scene'}.glb`
         });
     };
+    const handleFocusNode = (nodeId) => {
+        var _a;
+        (_a = prefabRootRef.current) === null || _a === void 0 ? void 0 : _a.focusNode(nodeId);
+    };
     useEffect(() => {
         const canvas = document.querySelector('canvas');
         if (canvas)
@@ -180,9 +186,14 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, onPr
             setTransformMode,
             snapResolution,
             setSnapResolution,
+            positionSnap,
+            setPositionSnap,
+            rotationSnap,
+            setRotationSnap,
+            onFocusNode: handleFocusNode,
             onScreenshot: handleScreenshot,
             onExportGLB: handleExportGLB
-        }, children: [_jsx(GameCanvas, { children: physics ? (_jsx(Physics, { debug: editMode, paused: editMode, children: content })) : content }), _jsx("div", { style: toolbar.panel, children: _jsx("button", { style: base.btn, onClick: () => setEditMode(!editMode), children: editMode ? "▶" : "⏸" }) }), editMode && _jsx(EditorUI, { prefabData: loadedPrefab, setPrefabData: updatePrefab, selectedId: selectedId, setSelectedId: setSelectedId, basePath: basePath, onUndo: undo, onRedo: redo, canUndo: historyIndex > 0, canRedo: historyIndex < history.length - 1 })] });
+        }, children: [_jsx(GameCanvas, { camera: { position: [0, 5, 15] }, children: physics ? (_jsx(Physics, { debug: editMode, paused: editMode, children: content })) : content }), _jsxs("div", { style: toolbar.panel, children: [_jsx("button", { style: base.btn, onClick: () => setEditMode(!editMode), children: editMode ? "▶" : "⏸" }), uiPlugins] }), _jsx(EditorUI, { prefabData: loadedPrefab, setPrefabData: updatePrefab, selectedId: selectedId, setSelectedId: setSelectedId, basePath: basePath, onUndo: undo, onRedo: redo, canUndo: historyIndex > 0, canRedo: historyIndex < history.length - 1 })] });
 });
 PrefabEditor.displayName = "PrefabEditor";
 export default PrefabEditor;

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

@@ -6,6 +6,7 @@ export interface PrefabRootRef {
     rigidBodyRefs: Map<string, any>;
     injectModel: (filename: string, model: Object3D) => void;
     injectTexture: (filename: string, file: File) => void;
+    focusNode: (nodeId: string) => void;
 }
 export declare const PrefabRoot: import("react").ForwardRefExoticComponent<{
     editMode?: boolean;

package/dist/tools/prefabeditor/PrefabRoot.js

@@ -15,24 +15,28 @@ import { getComponent, registerComponent, getNonComposableKeys } from "./compone
 import components from "./components";
 import { loadModel } from "../dragdrop/modelLoader";
 import { GameInstance, GameInstanceProvider, useInstanceCheck } from "./InstanceProvider";
-import { updateNode } from "./utils";
+import { focusCameraOnObject, updateNode } from "./utils";
 import { EditorContext } from "./EditorContext";
 components.forEach(registerComponent);
 const IDENTITY = new Matrix4();
 export const PrefabRoot = forwardRef(({ editMode, data, onPrefabChange, selectedId, onSelect, onClick, basePath = "" }, ref) => {
-    var _a, _b;
+    var _a, _b, _c, _d;
     // optional editor context
     const editorContext = useContext(EditorContext);
     const transformMode = (_a = editorContext === null || editorContext === void 0 ? void 0 : editorContext.transformMode) !== null && _a !== void 0 ? _a : "translate";
     const snapResolution = (_b = editorContext === null || editorContext === void 0 ? void 0 : editorContext.snapResolution) !== null && _b !== void 0 ? _b : 0;
+    const positionSnap = (_c = editorContext === null || editorContext === void 0 ? void 0 : editorContext.positionSnap) !== null && _c !== void 0 ? _c : 0.5;
+    const rotationSnap = (_d = editorContext === null || editorContext === void 0 ? void 0 : editorContext.rotationSnap) !== null && _d !== void 0 ? _d : Math.PI / 4;
     // prefab root state
     const [models, setModels] = useState({});
     const [textures, setTextures] = useState({});
     const loading = useRef(new Set());
+    const failedTextures = useRef(new Set());
     const objectRefs = useRef({});
     const rigidBodyRefs = useRef(new Map());
     const [selectedObject, setSelectedObject] = useState(null);
     const rootRef = useRef(null);
+    const controlsRef = useRef(null);
     const injectModel = useCallback((filename, model) => {
         setModels(m => (Object.assign(Object.assign({}, m), { [filename]: model })));
     }, []);
@@ -50,7 +54,15 @@ export const PrefabRoot = forwardRef(({ editMode, data, onPrefabChange, selected
         root: rootRef.current,
         rigidBodyRefs: rigidBodyRefs.current,
         injectModel,
-        injectTexture
+        injectTexture,
+        focusNode: (nodeId) => {
+            const object = objectRefs.current[nodeId];
+            const controls = controlsRef.current;
+            const camera = controls === null || controls === void 0 ? void 0 : controls.object;
+            if (!object || !controls || !camera)
+                return;
+            focusCameraOnObject(object, camera, controls.target, () => { var _a; return (_a = controls.update) === null || _a === void 0 ? void 0 : _a.call(controls); });
+        }
     }), [injectModel, injectTexture]);
     const registerRef = useCallback((id, obj) => {
         objectRefs.current[id] = obj;
@@ -92,11 +104,13 @@ export const PrefabRoot = forwardRef(({ editMode, data, onPrefabChange, selected
         const modelsToLoad = new Set();
         const texturesToLoad = new Set();
         walk(data.root, node => {
-            var _a, _b, _c, _d, _e, _f;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
             ((_c = (_b = (_a = node.components) === null || _a === void 0 ? void 0 : _a.model) === null || _b === void 0 ? void 0 : _b.properties) === null || _c === void 0 ? void 0 : _c.filename) &&
                 modelsToLoad.add(node.components.model.properties.filename);
             ((_f = (_e = (_d = node.components) === null || _d === void 0 ? void 0 : _d.material) === null || _e === void 0 ? void 0 : _e.properties) === null || _f === void 0 ? void 0 : _f.texture) &&
                 texturesToLoad.add(node.components.material.properties.texture);
+            ((_j = (_h = (_g = node.components) === null || _g === void 0 ? void 0 : _g.material) === null || _h === void 0 ? void 0 : _h.properties) === null || _j === void 0 ? void 0 : _j.normalMapTexture) &&
+                texturesToLoad.add(node.components.material.properties.normalMapTexture);
         });
         modelsToLoad.forEach((file) => __awaiter(void 0, void 0, void 0, function* () {
             if (models[file] || loading.current.has(file))
@@ -111,7 +125,7 @@ export const PrefabRoot = forwardRef(({ editMode, data, onPrefabChange, selected
         }));
         const loader = new TextureLoader();
         texturesToLoad.forEach(file => {
-            if (textures[file] || loading.current.has(file))
+            if (textures[file] || loading.current.has(file) || failedTextures.current.has(file))
                 return;
             loading.current.add(file);
             // Handle full URLs (http/https) or regular paths
@@ -124,12 +138,13 @@ export const PrefabRoot = forwardRef(({ editMode, data, onPrefabChange, selected
                 tex.colorSpace = SRGBColorSpace;
                 setTextures(t => (Object.assign(Object.assign({}, t), { [file]: tex })));
             }, undefined, (err) => {
-                console.error(`Failed to load texture: ${path}`, err);
+                console.warn(`Failed to load texture: ${path}`, err);
                 loading.current.delete(file);
+                failedTextures.current.add(file);
             });
         });
     }, [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, 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}`))] }))] }));
+    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, { ref: controlsRef, makeDefault: true }), selectedObject && (_jsx(TransformControls, { object: selectedObject, mode: transformMode, space: "local", onObjectChange: onTransformChange, translationSnap: positionSnap > 0 ? positionSnap : undefined, rotationSnap: rotationSnap > 0 ? rotationSnap : undefined, scaleSnap: snapResolution > 0 ? snapResolution : undefined }, `transform-${transformMode}-${positionSnap}-${rotationSnap}-${snapResolution}`))] }))] }));
 });
 export function GameObjectRenderer(props) {
     var _a, _b, _c;
@@ -187,7 +202,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, registerRigidBodyRef, loadedModels, loadedTextures, editMode, parentMatrix = IDENTITY, }) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e;
     const groupRef = useRef(null);
     const helperRef = useRef(null);
     const clickValid = useRef(false);
@@ -219,7 +234,20 @@ 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, registerRigidBodyRef: registerRigidBodyRef, loadedModels: loadedModels, loadedTextures: loadedTextures, editMode: editMode, parentMatrix: world }, child.id)))] }));
+    const renderCtx = createRenderContext(loadedModels, loadedTextures, editMode, selectedId, registerRef);
+    const childNodes = getChildHostComponents(gameObject).length > 0
+        ? renderHostedChildren(gameObject, renderCtx, world)
+        : renderSceneChildren(gameObject, world, {
+            selectedId,
+            onSelect,
+            onClick,
+            registerRef,
+            registerRigidBodyRef,
+            loadedModels,
+            loadedTextures,
+            editMode,
+        });
+    const inner = (_jsx("group", { onPointerDown: editMode ? onDown : undefined, onPointerMove: editMode ? () => (clickValid.current = false) : undefined, onPointerUp: editMode ? onUp : undefined, children: renderCompositionNode(gameObject, renderCtx, parentMatrix, childNodes) }));
     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, nodeId: gameObject.id, registerRigidBodyRef: registerRigidBodyRef, children: inner }, physicsKey)) : null] }));
     }
@@ -228,6 +256,28 @@ function StandardNode({ gameObject, selectedId, onSelect, onClick, registerRef,
     }
     return (_jsx("group", { ref: groupRef, position: transform.position, rotation: transform.rotation, scale: transform.scale, onPointerDown: onDown, onPointerMove: () => (clickValid.current = false), onPointerUp: onUp, children: inner }));
 }
+const CHILD_HOST_COMPONENT_TYPES = new Set(["Environment"]);
+function isChildHostType(type) {
+    return CHILD_HOST_COMPONENT_TYPES.has(type);
+}
+function getChildHostComponents(gameObject) {
+    var _a;
+    return Object.entries((_a = gameObject.components) !== null && _a !== void 0 ? _a : {}).flatMap(([key, comp]) => {
+        if (!(comp === null || comp === void 0 ? void 0 : comp.type) || !isChildHostType(comp.type))
+            return [];
+        const def = getComponent(comp.type);
+        if (!(def === null || def === void 0 ? void 0 : def.View))
+            return [];
+        return { key, View: def.View, properties: comp.properties };
+    });
+}
+function createRenderContext(loadedModels, loadedTextures, editMode, selectedId, registerRef) {
+    return { loadedModels, loadedTextures, editMode, selectedId, registerRef };
+}
+function renderSceneChildren(gameObject, parentMatrix, props) {
+    var _a;
+    return (_a = gameObject.children) === null || _a === void 0 ? void 0 : _a.map(child => _jsx(GameObjectRenderer, { gameObject: child, selectedId: props.selectedId, onSelect: props.onSelect, onClick: props.onClick, registerRef: props.registerRef, registerRigidBodyRef: props.registerRigidBodyRef, loadedModels: props.loadedModels, loadedTextures: props.loadedTextures, editMode: props.editMode, parentMatrix: parentMatrix }, child.id));
+}
 function walk(node, fn) {
     var _a;
     fn(node);
@@ -270,7 +320,25 @@ function computeParentWorldMatrix(root, targetId) {
     visit(root, IDENTITY);
     return result !== null && result !== void 0 ? result : IDENTITY;
 }
-function renderCoreNode(gameObject, ctx, parentMatrix) {
+function renderCompositionSubtree(gameObject, ctx, parentMatrix = IDENTITY) {
+    if (!gameObject || gameObject.disabled)
+        return null;
+    const transform = getNodeTransformProps(gameObject);
+    const world = parentMatrix.clone().multiply(compose(gameObject));
+    const childNodes = renderHostedChildren(gameObject, ctx, world);
+    return (_jsx("group", { position: transform.position, rotation: transform.rotation, scale: transform.scale, children: renderCompositionNode(gameObject, ctx, parentMatrix, childNodes) }, gameObject.id));
+}
+function renderHostedChildren(gameObject, ctx, parentMatrix) {
+    var _a;
+    return (_a = gameObject.children) === null || _a === void 0 ? void 0 : _a.map(child => renderCompositionSubtree(child, ctx, parentMatrix));
+}
+function renderCompositionNode(gameObject, ctx, parentMatrix, childNodes) {
+    const ownContent = renderNodeOwnContent(gameObject, ctx, parentMatrix);
+    const siblingContent = renderNodeSiblingComponents(gameObject, ctx, parentMatrix);
+    const subtree = _jsxs(_Fragment, { children: [ownContent, siblingContent, childNodes] });
+    return wrapWithChildHosts(gameObject, ctx, parentMatrix, subtree);
+}
+function renderNodeOwnContent(gameObject, ctx, parentMatrix) {
     var _a, _b, _c, _d;
     const geometry = (_a = gameObject.components) === null || _a === void 0 ? void 0 : _a.geometry;
     const material = (_b = gameObject.components) === null || _b === void 0 ? void 0 : _b.material;
@@ -284,41 +352,59 @@ function renderCoreNode(gameObject, ctx, parentMatrix) {
         loadedModels: ctx.loadedModels,
         loadedTextures: ctx.loadedTextures,
         editMode: ctx.editMode,
+        isSelected: ctx.selectedId === gameObject.id,
+        nodeId: gameObject.id,
         parentMatrix,
         registerRef: ctx.registerRef,
     };
-    const wrappers = [];
-    const leaves = [];
-    if (gameObject.components) {
-        Object.entries(gameObject.components)
-            .filter(([k]) => !getNonComposableKeys().includes(k))
-            .forEach(([key, comp]) => {
-            if (!(comp === null || comp === void 0 ? void 0 : comp.type))
-                return;
-            const def = getComponent(comp.type);
-            if (!(def === null || def === void 0 ? void 0 : def.View))
-                return;
-            if (def.View.toString().includes("children")) {
-                wrappers.push({ key, View: def.View, properties: comp.properties });
-            }
-            else {
-                leaves.push(_jsx(def.View, Object.assign({ properties: comp.properties }, contextProps), key));
-            }
-        });
-    }
     let core;
     if (model && (modelDef === null || modelDef === void 0 ? void 0 : modelDef.View)) {
-        core = (_jsxs(modelDef.View, Object.assign({ properties: model.properties }, contextProps, { children: [material && (materialDef === null || materialDef === void 0 ? void 0 : materialDef.View) && (_jsx(materialDef.View, Object.assign({ properties: material.properties }, contextProps), "material")), leaves] })));
+        core = (_jsx(modelDef.View, Object.assign({ properties: model.properties }, contextProps, { children: material && (materialDef === null || materialDef === void 0 ? void 0 : materialDef.View) && (_jsx(materialDef.View, Object.assign({ properties: material.properties }, contextProps), "material")) })));
     }
     else if (geometry && (geometryDef === null || geometryDef === void 0 ? void 0 : geometryDef.View)) {
-        core = (_jsxs("mesh", { castShadow: true, receiveShadow: true, children: [_jsx(geometryDef.View, Object.assign({ properties: geometry.properties }, contextProps)), material && (materialDef === null || materialDef === void 0 ? void 0 : materialDef.View) && (_jsx(materialDef.View, Object.assign({ properties: material.properties }, contextProps), "material")), leaves] }));
+        core = (_jsxs("mesh", { castShadow: true, receiveShadow: true, children: [_jsx(geometryDef.View, Object.assign({ properties: geometry.properties }, contextProps)), material && (materialDef === null || materialDef === void 0 ? void 0 : materialDef.View) && (_jsx(materialDef.View, Object.assign({ properties: material.properties }, contextProps), "material"))] }));
     }
     else if (text && (textDef === null || textDef === void 0 ? void 0 : textDef.View)) {
-        core = (_jsxs(_Fragment, { children: [_jsx(textDef.View, Object.assign({ properties: text.properties }, contextProps)), leaves] }));
+        core = (_jsx(_Fragment, { children: _jsx(textDef.View, Object.assign({ properties: text.properties }, contextProps)) }));
     }
     else {
-        core = _jsx(_Fragment, { children: leaves });
+        core = null;
     }
-    return wrappers.reduce((acc, { key, View, properties }) => (_jsx(View, Object.assign({ properties: properties }, contextProps, { children: acc }), key)), core);
+    return core;
+}
+function renderNodeSiblingComponents(gameObject, ctx, parentMatrix) {
+    var _a;
+    const contextProps = {
+        loadedModels: ctx.loadedModels,
+        loadedTextures: ctx.loadedTextures,
+        editMode: ctx.editMode,
+        isSelected: ctx.selectedId === gameObject.id,
+        nodeId: gameObject.id,
+        parentMatrix,
+        registerRef: ctx.registerRef,
+    };
+    return Object.entries((_a = gameObject.components) !== null && _a !== void 0 ? _a : {})
+        .filter(([key]) => !getNonComposableKeys().includes(key))
+        .flatMap(([key, comp]) => {
+        if (!(comp === null || comp === void 0 ? void 0 : comp.type) || isChildHostType(comp.type))
+            return [];
+        const def = getComponent(comp.type);
+        if (!(def === null || def === void 0 ? void 0 : def.View))
+            return [];
+        return _jsx(def.View, Object.assign({ properties: comp.properties }, contextProps), key);
+    });
+}
+function wrapWithChildHosts(gameObject, ctx, parentMatrix, subtree) {
+    const contextProps = {
+        loadedModels: ctx.loadedModels,
+        loadedTextures: ctx.loadedTextures,
+        editMode: ctx.editMode,
+        isSelected: ctx.selectedId === gameObject.id,
+        nodeId: gameObject.id,
+        parentMatrix,
+        registerRef: ctx.registerRef,
+    };
+    const childHosts = getChildHostComponents(gameObject);
+    return childHosts.reduce((acc, { key, View, properties }) => (_jsx(View, Object.assign({ properties: properties }, contextProps, { children: acc }), key)), subtree);
 }
 export default PrefabRoot;

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

@@ -1,11 +1,7 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { FieldRenderer } from "./Input";
-const ambientLightFields = [
-    { name: 'color', type: 'color', label: 'Color' },
-    { name: 'intensity', type: 'number', label: 'Intensity', step: 0.1, min: 0 },
-];
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ColorField, FieldGroup, NumberField } from "./Input";
 function AmbientLightComponentEditor({ component, onUpdate, }) {
-    return (_jsx(FieldRenderer, { fields: ambientLightFields, values: component.properties, onChange: onUpdate }));
+    return (_jsxs(FieldGroup, { children: [_jsx(ColorField, { name: "color", label: "Color", values: component.properties, onChange: onUpdate }), _jsx(NumberField, { name: "intensity", label: "Intensity", values: component.properties, onChange: onUpdate, min: 0, step: 0.1, fallback: 1 })] }));
 }
 function AmbientLightComponentView({ properties }) {
     const { color = '#ffffff', intensity = 1 } = properties;

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

@@ -0,0 +1,3 @@
+import { Component } from './ComponentRegistry';
+declare const CameraComponent: Component;
+export default CameraComponent;

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

@@ -0,0 +1,25 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { PerspectiveCamera, useHelper } from '@react-three/drei';
+import { useRef } from 'react';
+import { CameraHelper } from 'three';
+import { FieldGroup, NumberField } from './Input';
+function CameraComponentEditor({ component, onUpdate }) {
+    return (_jsxs(FieldGroup, { children: [_jsx(NumberField, { name: "fov", label: "FOV", values: component.properties, onChange: onUpdate, fallback: 50, min: 1, max: 179, step: 1 }), _jsx(NumberField, { name: "near", label: "Near", values: component.properties, onChange: onUpdate, fallback: 0.1, min: 0.001, step: 0.1 }), _jsx(NumberField, { name: "zoom", label: "Zoom", values: component.properties, onChange: onUpdate, fallback: 1, min: 0.01, step: 0.1 }), _jsx(NumberField, { name: "far", label: "Far", values: component.properties, onChange: onUpdate, fallback: 1000, min: 0.1, step: 1 })] }));
+}
+function CameraComponentView({ properties, editMode, isSelected }) {
+    var _a, _b, _c, _d;
+    const fov = (_a = properties === null || properties === void 0 ? void 0 : properties.fov) !== null && _a !== void 0 ? _a : 50;
+    const near = (_b = properties === null || properties === void 0 ? void 0 : properties.near) !== null && _b !== void 0 ? _b : 0.1;
+    const zoom = (_c = properties === null || properties === void 0 ? void 0 : properties.zoom) !== null && _c !== void 0 ? _c : 1;
+    const far = (_d = properties === null || properties === void 0 ? void 0 : properties.far) !== null && _d !== void 0 ? _d : 1000;
+    const cameraRef = useRef(null);
+    useHelper(editMode && isSelected ? cameraRef : null, CameraHelper);
+    return (_jsxs(_Fragment, { children: [_jsx(PerspectiveCamera, { ref: cameraRef, makeDefault: !editMode, fov: fov, near: near, zoom: zoom, far: far }), editMode && !isSelected ? (_jsxs("mesh", { children: [_jsx("boxGeometry", { args: [0.34, 0.22, 0.18] }), _jsx("meshBasicMaterial", { color: "#22d3ee", wireframe: true })] })) : null] }));
+}
+const CameraComponent = {
+    name: 'Camera',
+    Editor: CameraComponentEditor,
+    View: CameraComponentView,
+    defaultProperties: {},
+};
+export default CameraComponent;

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

@@ -31,7 +31,7 @@ const directionalLightFields = [
 function DirectionalLightComponentEditor({ component, onUpdate }) {
     return (_jsx(FieldRenderer, { fields: directionalLightFields, values: component.properties, onChange: onUpdate }));
 }
-function DirectionalLightView({ properties, editMode }) {
+function DirectionalLightView({ properties, editMode, isSelected }) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
     const color = (_a = properties.color) !== null && _a !== void 0 ? _a : '#ffffff';
     const intensity = (_b = properties.intensity) !== null && _b !== void 0 ? _b : 1.0;
@@ -61,7 +61,7 @@ function DirectionalLightView({ properties, editMode }) {
         // Target is positioned relative to light's world position
         targetRef.current.position.set(lightWorldPos.x + targetOffset[0], lightWorldPos.y + targetOffset[1], lightWorldPos.z + targetOffset[2]);
     });
-    return (_jsxs(_Fragment, { children: [_jsx("directionalLight", { ref: directionalLightRef, color: color, intensity: intensity, castShadow: castShadow, "shadow-mapSize-width": shadowMapSize, "shadow-mapSize-height": shadowMapSize, "shadow-camera-near": shadowCameraNear, "shadow-camera-far": shadowCameraFar, "shadow-camera-top": shadowCameraTop, "shadow-camera-bottom": shadowCameraBottom, "shadow-camera-left": shadowCameraLeft, "shadow-camera-right": shadowCameraRight, "shadow-bias": -0.001, "shadow-normalBias": 0.02 }), _jsx("object3D", { ref: targetRef }), editMode && (_jsxs(_Fragment, { children: [_jsxs("mesh", { children: [_jsx("sphereGeometry", { args: [0.3, 8, 6] }), _jsx("meshBasicMaterial", { color: color, wireframe: true })] }), _jsxs("mesh", { position: targetOffset, children: [_jsx("sphereGeometry", { args: [0.2, 8, 6] }), _jsx("meshBasicMaterial", { color: color, wireframe: true, opacity: 0.5, transparent: true })] }), _jsxs("line", { children: [_jsx("bufferGeometry", { onUpdate: (geo) => {
+    return (_jsxs(_Fragment, { children: [_jsx("directionalLight", { ref: directionalLightRef, color: color, intensity: intensity, castShadow: castShadow, "shadow-mapSize-width": shadowMapSize, "shadow-mapSize-height": shadowMapSize, "shadow-camera-near": shadowCameraNear, "shadow-camera-far": shadowCameraFar, "shadow-camera-top": shadowCameraTop, "shadow-camera-bottom": shadowCameraBottom, "shadow-camera-left": shadowCameraLeft, "shadow-camera-right": shadowCameraRight, "shadow-bias": -0.001, "shadow-normalBias": 0.02 }), _jsx("object3D", { ref: targetRef }), editMode && isSelected && (_jsxs(_Fragment, { children: [_jsxs("mesh", { children: [_jsx("sphereGeometry", { args: [0.3, 8, 6] }), _jsx("meshBasicMaterial", { color: color, wireframe: true })] }), _jsxs("mesh", { position: targetOffset, children: [_jsx("sphereGeometry", { args: [0.2, 8, 6] }), _jsx("meshBasicMaterial", { color: color, wireframe: true, opacity: 0.5, transparent: true })] }), _jsxs("line", { children: [_jsx("bufferGeometry", { onUpdate: (geo) => {
                                     const points = [
                                         new Vector3(0, 0, 0),
                                         new Vector3(targetOffset[0], targetOffset[1], targetOffset[2])

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

@@ -0,0 +1,3 @@
+import { Component } from './ComponentRegistry';
+declare const EnvironmentComponent: Component;
+export default EnvironmentComponent;

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

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Environment } from '@react-three/drei';
+import { FieldGroup, NumberField } from './Input';
+function EnvironmentView({ properties, children, editMode, loadedTextures, loadedModels, }) {
+    const { intensity = 1, resolution = 256 } = properties;
+    const assetRevision = `${Object.keys(loadedTextures !== null && loadedTextures !== void 0 ? loadedTextures : {}).sort().join('|')}::${Object.keys(loadedModels !== null && loadedModels !== void 0 ? loadedModels : {}).sort().join('|')}`;
+    return (_jsx(Environment, { background: true, environmentIntensity: intensity, resolution: resolution, frames: editMode ? undefined : 1, children: children }, assetRevision));
+}
+const EnvironmentComponent = {
+    name: 'Environment',
+    Editor: ({ component, onUpdate }) => (_jsxs(FieldGroup, { children: [_jsx(NumberField, { name: "intensity", label: "Intensity", values: component.properties, onChange: onUpdate, min: 0, step: 0.1, fallback: 1 }), _jsx(NumberField, { name: "resolution", label: "Resolution", values: component.properties, onChange: onUpdate, min: 64, step: 64, fallback: 256 })] })),
+    View: EnvironmentView,
+    defaultProperties: {},
+};
+export default EnvironmentComponent;

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

@@ -1,67 +1,67 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { FieldRenderer, Input } from "./Input";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { FieldGroup, NumberField, SelectField } from "./Input";
 const GEOMETRY_ARGS = {
     box: {
-        labels: ["Width", "Height", "Depth"],
-        defaults: [1, 1, 1],
+        fields: [
+            { name: 'width', label: 'Width', defaultValue: 1, min: 0.01, step: 0.1 },
+            { name: 'height', label: 'Height', defaultValue: 1, min: 0.01, step: 0.1 },
+            { name: 'depth', label: 'Depth', defaultValue: 1, min: 0.01, step: 0.1 },
+        ],
     },
     sphere: {
-        labels: ["Radius", "Width Segments", "Height Segments"],
-        defaults: [1, 32, 16],
+        fields: [
+            { name: 'radius', label: 'Radius', defaultValue: 1, min: 0.01, step: 0.1 },
+            { name: 'widthSegments', label: 'Width Segments', defaultValue: 32, min: 3, step: 1 },
+            { name: 'heightSegments', label: 'Height Segments', defaultValue: 16, min: 2, step: 1 },
+        ],
     },
     plane: {
-        labels: ["Width", "Height"],
-        defaults: [1, 1],
+        fields: [
+            { name: 'width', label: 'Width', defaultValue: 1, min: 0.01, step: 0.1 },
+            { name: 'height', label: 'Height', defaultValue: 1, min: 0.01, step: 0.1 },
+        ],
     },
     cylinder: {
-        labels: ["Radius Top", "Radius Bottom", "Height", "Radial Segments"],
-        defaults: [1, 1, 1, 32],
+        fields: [
+            { name: 'radiusTop', label: 'Radius Top', defaultValue: 1, min: 0.01, step: 0.1 },
+            { name: 'radiusBottom', label: 'Radius Bottom', defaultValue: 1, min: 0.01, step: 0.1 },
+            { name: 'height', label: 'Height', defaultValue: 1, min: 0.01, step: 0.1 },
+            { name: 'radialSegments', label: 'Radial Segments', defaultValue: 32, min: 3, step: 1 },
+        ],
     },
 };
+function getDefaultArgs(geometryType) {
+    var _a, _b;
+    return ((_b = (_a = GEOMETRY_ARGS[geometryType]) === null || _a === void 0 ? void 0 : _a.fields) !== null && _b !== void 0 ? _b : []).map(field => field.defaultValue);
+}
 function GeometryComponentEditor({ component, onUpdate, }) {
-    const { geometryType, args = [] } = component.properties;
-    const schema = GEOMETRY_ARGS[geometryType];
-    const fields = [
-        {
-            name: 'geometryType',
-            type: 'select',
-            label: 'Type',
-            options: [
-                { value: 'box', label: 'Box' },
-                { value: 'sphere', label: 'Sphere' },
-                { value: 'plane', label: 'Plane' },
-                { value: 'cylinder', label: 'Cylinder' },
-            ],
-        },
-        {
-            name: 'args',
-            type: 'custom',
-            label: '',
-            render: ({ values, onChangeMultiple }) => {
-                const currentType = values.geometryType;
-                const currentSchema = GEOMETRY_ARGS[currentType];
-                const currentArgs = values.args || currentSchema.defaults;
-                return (_jsx("div", { style: { display: 'flex', flexDirection: 'column', gap: 4 }, children: currentSchema.labels.map((label, i) => {
-                        var _a;
-                        return (_jsx(Input, { label: label, value: (_a = currentArgs[i]) !== null && _a !== void 0 ? _a : currentSchema.defaults[i], step: 0.1, min: 0.01, onChange: value => {
-                                const next = [...currentArgs];
-                                next[i] = value;
-                                onChangeMultiple({ args: next });
-                            } }, label));
-                    }) }));
-            },
-        },
-    ];
+    var _a, _b, _c;
+    const geometryType = (_a = component.properties.geometryType) !== null && _a !== void 0 ? _a : 'box';
+    const schema = (_b = GEOMETRY_ARGS[geometryType]) !== null && _b !== void 0 ? _b : GEOMETRY_ARGS.box;
+    const args = (_c = component.properties.args) !== null && _c !== void 0 ? _c : getDefaultArgs(geometryType);
     // Handle geometry type change to reset args
     const handleChange = (newValues) => {
         if ('geometryType' in newValues && newValues.geometryType !== geometryType) {
-            onUpdate({ geometryType: newValues.geometryType, args: GEOMETRY_ARGS[newValues.geometryType].defaults });
+            onUpdate({ geometryType: newValues.geometryType, args: getDefaultArgs(newValues.geometryType) });
         }
         else {
             onUpdate(newValues);
         }
     };
-    return (_jsx(FieldRenderer, { fields: fields, values: component.properties, onChange: handleChange }));
+    const updateArg = (index, value) => {
+        const next = [...args];
+        next[index] = value;
+        onUpdate({ args: next });
+    };
+    return (_jsxs(FieldGroup, { children: [_jsx(SelectField, { name: "geometryType", label: "Type", values: component.properties, onChange: handleChange, options: [
+                    { value: 'box', label: 'Box' },
+                    { value: 'sphere', label: 'Sphere' },
+                    { value: 'plane', label: 'Plane' },
+                    { value: 'cylinder', label: 'Cylinder' },
+                ] }), schema.fields.map((field, index) => {
+                var _a;
+                return (_jsx(NumberField, { name: field.name, label: field.label, values: { [field.name]: (_a = args[index]) !== null && _a !== void 0 ? _a : field.defaultValue }, onChange: (next) => updateArg(index, next[field.name]), fallback: field.defaultValue, min: field.min, step: field.step }, field.name));
+            })] }));
 }
 // View for Geometry component
 function GeometryComponentView({ properties, children }) {
@@ -87,7 +87,7 @@ const GeometryComponent = {
     nonComposable: true,
     defaultProperties: {
         geometryType: 'box',
-        args: GEOMETRY_ARGS.box.defaults,
+        args: getDefaultArgs('box'),
     }
 };
 export default GeometryComponent;

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

@@ -58,11 +58,12 @@ export declare function Input({ value, onChange, step, min, max, style, label }:
 export declare function Label({ children }: {
     children: React.ReactNode;
 }): import("react/jsx-runtime").JSX.Element;
-export declare function Vector3Input({ label, value, onChange, snap }: {
+export declare function Vector3Input({ label, value, onChange, snap, labelExtra }: {
     label: string;
     value: [number, number, number];
     onChange: (v: [number, number, number]) => void;
     snap?: number;
+    labelExtra?: React.ReactNode;
 }): import("react/jsx-runtime").JSX.Element;
 export declare function ColorInput({ label, value, onChange }: {
     label?: string;
@@ -89,6 +90,55 @@ export declare function SelectInput({ label, value, onChange, options }: {
         label: string;
     }[];
 }): import("react/jsx-runtime").JSX.Element;
+interface BoundFieldProps {
+    name: string;
+    values: Record<string, any>;
+    onChange: (values: Record<string, any>) => void;
+}
+interface BoundNumberFieldProps extends BoundFieldProps {
+    label: string;
+    fallback?: number;
+    step?: string | number;
+    min?: number;
+    max?: number;
+    style?: React.CSSProperties;
+}
+interface BoundStringFieldProps extends BoundFieldProps {
+    label: string;
+    fallback?: string;
+    placeholder?: string;
+}
+interface BoundColorFieldProps extends BoundFieldProps {
+    label: string;
+    fallback?: string;
+}
+interface BoundBooleanFieldProps extends BoundFieldProps {
+    label: string;
+    fallback?: boolean;
+}
+interface BoundSelectFieldProps extends BoundFieldProps {
+    label: string;
+    fallback?: string;
+    options: {
+        value: string;
+        label: string;
+    }[];
+}
+interface BoundVector3FieldProps extends BoundFieldProps {
+    label: string;
+    fallback?: [number, number, number];
+    snap?: number;
+    labelExtra?: React.ReactNode;
+}
+export declare function FieldGroup({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function NumberField({ name, label, values, onChange, fallback, step, min, max, style, }: BoundNumberFieldProps): import("react/jsx-runtime").JSX.Element;
+export declare function StringField({ name, label, values, onChange, fallback, placeholder, }: BoundStringFieldProps): import("react/jsx-runtime").JSX.Element;
+export declare function ColorField({ name, label, values, onChange, fallback, }: BoundColorFieldProps): import("react/jsx-runtime").JSX.Element;
+export declare function BooleanField({ name, label, values, onChange, fallback, }: BoundBooleanFieldProps): import("react/jsx-runtime").JSX.Element;
+export declare function SelectField({ name, label, values, onChange, fallback, options, }: BoundSelectFieldProps): import("react/jsx-runtime").JSX.Element;
+export declare function Vector3Field({ name, label, values, onChange, fallback, snap, labelExtra, }: BoundVector3FieldProps): import("react/jsx-runtime").JSX.Element;
 interface FieldRendererProps {
     fields: FieldDefinition[];
     values: Record<string, any>;