react-three-game 0.0.107 → 0.0.109

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

@@ -1,5 +1,6 @@
 // biome-ignore assist/source/organizeImports: <in order of display in the editor>
 import TransformComponent from "./TransformComponent";
+import PrefabRefComponent from "./PrefabRefComponent";
 import GeometryComponent from "./GeometryComponent";
 import BufferGeometryComponent from "./BufferGeometryComponent";
 import ModelComponent from "./ModelComponent";
@@ -14,6 +15,7 @@ import EnvironmentComponent from "./EnvironmentComponent";
 import CameraComponent from "./CameraComponent";
 import SoundComponent from "./SoundComponent";
 import DataComponent from "./DataComponent";
+import { registerComponent } from "./ComponentRegistry";
 // this controls the order of components in the editor, and also which components are available to add
 export const builtinComponents = [
     TransformComponent,
@@ -35,4 +37,12 @@ export const builtinComponents = [
     CameraComponent,
     SoundComponent,
     DataComponent,
+    PrefabRefComponent,
 ];
+let didRegisterBuiltinComponents = false;
+export function registerBuiltinComponents() {
+    if (didRegisterBuiltinComponents)
+        return;
+    builtinComponents.forEach(registerComponent);
+    didRegisterBuiltinComponents = true;
+}

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

@@ -0,0 +1,4 @@
+import { type Component } from "./ComponentRegistry";
+declare const runtimeComponents: Component[];
+export declare function registerRuntimeComponents(): void;
+export { runtimeComponents };

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

@@ -0,0 +1,372 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Environment } from "@react-three/drei";
+import { useFrame, useThree } from "@react-three/fiber";
+import { lazy, Suspense, useEffect, useMemo, useRef, useState } from "react";
+import { AudioListener, ClampToEdgeWrapping, DoubleSide, LinearFilter, LinearMipmapLinearFilter, Mesh, NoColorSpace, RepeatWrapping, SRGBColorSpace } from "three";
+import { Text } from "three-text/three/react";
+import { assetRef, assetRefs, getComponentDef, registerComponent } from "./ComponentRegistry";
+import { useAssetRuntime, useNode } from "../assetRuntime";
+import { gameEvents } from "../GameEvents";
+import { withBasePath } from "../runtimeUtils";
+const PrefabRoot = lazy(() => import("../PrefabRoot"));
+const RuntimeText = Text;
+function GeometryView({ properties }) {
+    const { geometryType } = properties;
+    const args = Array.isArray(properties.args) ? properties.args : [];
+    const geometryKey = `${geometryType !== null && geometryType !== void 0 ? geometryType : "box"}:${JSON.stringify(args)}`;
+    switch (geometryType) {
+        case "sphere":
+            return _jsx("sphereGeometry", { args: args }, geometryKey);
+        case "plane":
+            return _jsx("planeGeometry", { args: args }, geometryKey);
+        case "cylinder":
+            return _jsx("cylinderGeometry", { args: args }, geometryKey);
+        case "box":
+        default:
+            return _jsx("boxGeometry", { args: (args.length ? args : [1, 1, 1]) }, geometryKey);
+    }
+}
+const DEFAULT_TRIANGLE_POSITIONS = [0, 0, 0, 1, 0, 0, 0, 1, 0];
+const DEFAULT_TRIANGLE_INDICES = [0, 1, 2];
+const DEFAULT_TRIANGLE_UVS = [0, 0, 1, 0, 0, 1];
+function numberArray(value, fallback) {
+    return Array.isArray(value) && value.every(entry => typeof entry === "number" && Number.isFinite(entry))
+        ? value
+        : fallback;
+}
+function indexArray(indices) {
+    if (indices.length === 0)
+        return null;
+    return Math.max(...indices) > 65535 ? new Uint32Array(indices) : new Uint16Array(indices);
+}
+function BufferGeometryView({ properties }) {
+    const positions = numberArray(properties.positions, DEFAULT_TRIANGLE_POSITIONS);
+    const indices = numberArray(properties.indices, DEFAULT_TRIANGLE_INDICES);
+    const normals = numberArray(properties.normals, []);
+    const uvs = numberArray(properties.uvs, DEFAULT_TRIANGLE_UVS);
+    const hasNormals = normals.length === positions.length;
+    const hasUvs = uvs.length >= (positions.length / 3) * 2;
+    const indicesArray = indexArray(indices);
+    return (_jsxs("bufferGeometry", { onUpdate: (geometry) => {
+            if (properties.computeVertexNormals !== false && !hasNormals)
+                geometry.computeVertexNormals();
+            geometry.computeBoundingBox();
+            geometry.computeBoundingSphere();
+        }, children: [_jsx("bufferAttribute", { attach: "attributes-position", args: [new Float32Array(positions), 3] }), indicesArray ? _jsx("bufferAttribute", { attach: "index", args: [indicesArray, 1] }) : null, hasNormals ? _jsx("bufferAttribute", { attach: "attributes-normal", args: [new Float32Array(normals), 3] }) : null, hasUvs ? _jsx("bufferAttribute", { attach: "attributes-uv", args: [new Float32Array(uvs), 2] }) : null] }));
+}
+function ModelView({ properties, children }) {
+    const { getModel } = useAssetRuntime();
+    const sourceModel = properties.filename ? getModel(properties.filename) : null;
+    const clonedModel = useMemo(() => {
+        if (!sourceModel || !properties.filename || properties.instanced)
+            return null;
+        const clone = sourceModel.clone();
+        clone.traverse((object) => {
+            if (object instanceof Mesh) {
+                object.castShadow = true;
+                object.receiveShadow = true;
+            }
+        });
+        return clone;
+    }, [properties.filename, properties.instanced, sourceModel]);
+    return clonedModel ? _jsx("primitive", { object: clonedModel, children: children }) : _jsx(_Fragment, { children: children });
+}
+function configureTexture(texture, properties, colorSpace) {
+    var _a, _b, _c, _d;
+    if (!texture)
+        return;
+    const repeat = Boolean(properties.repeat);
+    const repeatCount = Array.isArray(properties.repeatCount) ? properties.repeatCount : [1, 1];
+    const offset = Array.isArray(properties.offset) ? properties.offset : [0, 0];
+    texture.wrapS = texture.wrapT = repeat ? RepeatWrapping : ClampToEdgeWrapping;
+    texture.repeat.set(Number((_a = repeatCount[0]) !== null && _a !== void 0 ? _a : 1), Number((_b = repeatCount[1]) !== null && _b !== void 0 ? _b : 1));
+    texture.offset.set(Number((_c = offset[0]) !== null && _c !== void 0 ? _c : 0), Number((_d = offset[1]) !== null && _d !== void 0 ? _d : 0));
+    texture.colorSpace = colorSpace;
+    texture.generateMipmaps = properties.generateMipmaps !== false;
+    texture.minFilter = (properties.minFilter === "LinearFilter" ? LinearFilter : LinearMipmapLinearFilter);
+    texture.magFilter = LinearFilter;
+    texture.needsUpdate = true;
+}
+function useConfiguredTexture(path, properties, colorSpace) {
+    const { getTexture } = useAssetRuntime();
+    const sourceTexture = typeof path === "string" ? getTexture(path) : null;
+    const texture = useMemo(() => sourceTexture === null || sourceTexture === void 0 ? void 0 : sourceTexture.clone(), [sourceTexture]);
+    useEffect(() => {
+        configureTexture(texture, properties, colorSpace);
+    }, [properties, texture, colorSpace]);
+    return texture !== null && texture !== void 0 ? texture : null;
+}
+function MaterialView({ properties }) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    const materialType = (_a = properties.materialType) !== null && _a !== void 0 ? _a : "standard";
+    const colorMap = useConfiguredTexture(properties.texture, properties, SRGBColorSpace);
+    const normalMap = useConfiguredTexture(properties.normalMapTexture, properties, NoColorSpace);
+    const offsetSpeed = Array.isArray(properties.offsetSpeed) ? properties.offsetSpeed : [0, 0];
+    const animateOffset = Boolean(properties.animateOffset);
+    useFrame((_state, delta) => {
+        var _a, _b;
+        if (!animateOffset)
+            return;
+        for (const texture of [colorMap, normalMap]) {
+            if (!texture)
+                continue;
+            texture.offset.x += Number((_a = offsetSpeed[0]) !== null && _a !== void 0 ? _a : 0) * delta;
+            texture.offset.y += Number((_b = offsetSpeed[1]) !== null && _b !== void 0 ? _b : 0) * delta;
+        }
+    });
+    const sharedProps = {
+        attach: (_b = properties.attach) !== null && _b !== void 0 ? _b : "material",
+        color: (_c = properties.color) !== null && _c !== void 0 ? _c : "#ffffff",
+        opacity: (_d = properties.opacity) !== null && _d !== void 0 ? _d : 1,
+        transparent: Boolean(properties.transparent),
+        wireframe: Boolean(properties.wireframe),
+        toneMapped: properties.toneMapped !== false,
+        side: DoubleSide,
+        map: colorMap,
+    };
+    if (materialType === "basic")
+        return _jsx("meshBasicMaterial", Object.assign({}, sharedProps));
+    if (materialType === "sprite") {
+        return (_jsx("spriteMaterial", Object.assign({}, sharedProps, { rotation: (_e = properties.rotation) !== null && _e !== void 0 ? _e : 0, sizeAttenuation: properties.sizeAttenuation !== false, depthTest: properties.depthTest !== false, depthWrite: Boolean(properties.depthWrite) })));
+    }
+    const normalScale = Array.isArray(properties.normalScale) ? properties.normalScale : [1, 1];
+    return (_jsx("meshStandardMaterial", Object.assign({}, sharedProps, { metalness: (_f = properties.metalness) !== null && _f !== void 0 ? _f : 0, roughness: (_g = properties.roughness) !== null && _g !== void 0 ? _g : 1, normalMap: normalMap, normalScale: normalMap ? [Number((_h = normalScale[0]) !== null && _h !== void 0 ? _h : 1), Number((_j = normalScale[1]) !== null && _j !== void 0 ? _j : 1)] : undefined })));
+}
+function TextView({ properties, children, basePath = "" }) {
+    const { text = "", font, size, depth, width, align, color } = properties;
+    const textContent = String(text || "");
+    const resolvedFont = typeof font === "string" ? withBasePath(basePath, font) : undefined;
+    const [offset, setOffset] = useState([0, 0, 0]);
+    useEffect(() => {
+        Text.setHarfBuzzPath(withBasePath(basePath, "/fonts/hb.wasm"));
+    }, [basePath]);
+    if (!textContent)
+        return null;
+    const textProps = {
+        size: size,
+        depth: depth,
+        layout: { align: align, width: width },
+        color: color,
+        onLoad: (_geometry, info) => {
+            const bounds = info === null || info === void 0 ? void 0 : info.planeBounds;
+            if (!bounds)
+                return;
+            const x = align === "center" ? -(bounds.min.x + bounds.max.x) / 2 : align === "right" ? -bounds.max.x : -bounds.min.x;
+            setOffset([x, -(bounds.min.y + bounds.max.y) / 2, 0]);
+        },
+    };
+    if (resolvedFont)
+        textProps.font = resolvedFont;
+    return (_jsxs("group", { position: offset, children: [_jsx(RuntimeText, Object.assign({}, textProps, { children: textContent })), children] }));
+}
+function merge(defaults, properties) {
+    return Object.assign(Object.assign({}, defaults), properties);
+}
+function AmbientLightView({ properties, children }) {
+    const props = merge({ color: "#ffffff", intensity: 1 }, properties);
+    return _jsxs(_Fragment, { children: [_jsx("ambientLight", { color: props.color, intensity: props.intensity }), children] });
+}
+function PointLightView({ properties, children }) {
+    const props = merge({ color: "#ffffff", intensity: 1, distance: 0, decay: 2 }, properties);
+    return (_jsx("pointLight", { color: props.color, intensity: props.intensity, distance: props.distance, decay: props.decay, children: children }));
+}
+function DirectionalLightView({ properties, children }) {
+    const props = merge({ color: "#ffffff", intensity: 1, castShadow: false }, properties);
+    return _jsx("directionalLight", { color: props.color, intensity: props.intensity, castShadow: Boolean(props.castShadow), children: children });
+}
+function SpotLightView({ properties, children }) {
+    const props = merge({ color: "#ffffff", intensity: 1, angle: Math.PI / 3, penumbra: 0, distance: 0, decay: 2, castShadow: false }, properties);
+    return (_jsx("spotLight", { color: props.color, intensity: props.intensity, angle: props.angle, penumbra: props.penumbra, distance: props.distance, decay: props.decay, castShadow: Boolean(props.castShadow), children: children }));
+}
+function CameraView({ properties, children }) {
+    var _a, _b, _c;
+    const projection = (_a = properties.projection) !== null && _a !== void 0 ? _a : "perspective";
+    if (projection === "orthographic") {
+        return _jsx("orthographicCamera", { zoom: (_b = properties.zoom) !== null && _b !== void 0 ? _b : 1, children: children });
+    }
+    return _jsx("perspectiveCamera", { fov: (_c = properties.fov) !== null && _c !== void 0 ? _c : 50, children: children });
+}
+function EnvironmentView({ properties, children }) {
+    var _a, _b;
+    const { getAssetRevision } = useAssetRuntime();
+    const intensity = (_a = properties.intensity) !== null && _a !== void 0 ? _a : 1;
+    const resolution = (_b = properties.resolution) !== null && _b !== void 0 ? _b : 256;
+    return (_jsx(Environment, { background: true, environmentIntensity: intensity, resolution: resolution, frames: 1, children: children }, `${getAssetRevision()}::${intensity}::${resolution}`));
+}
+function PrefabRefView({ properties, children, basePath = "" }) {
+    const [loadedPrefab, setLoadedPrefab] = useState(null);
+    const resolvedUrl = properties.url ? withBasePath(basePath, properties.url) : "";
+    useEffect(() => {
+        if (!resolvedUrl)
+            return undefined;
+        let cancelled = false;
+        void fetch(resolvedUrl)
+            .then(response => response.json())
+            .then(data => {
+            if (!cancelled)
+                setLoadedPrefab(data);
+        })
+            .catch(error => console.warn("[PrefabRef] Failed to load:", resolvedUrl, error));
+        return () => {
+            cancelled = true;
+        };
+    }, [resolvedUrl]);
+    return (_jsxs(_Fragment, { children: [loadedPrefab ? (_jsx(Suspense, { fallback: null, children: _jsx(PrefabRoot, { data: loadedPrefab, editMode: false, basePath: basePath }) })) : null, children] }));
+}
+let sharedAudioListener = null;
+function getSharedAudioListener() {
+    if (!sharedAudioListener)
+        sharedAudioListener = new AudioListener();
+    return sharedAudioListener;
+}
+function clampRange(min, max, fallbackMin, fallbackMax) {
+    const safeMin = Number.isFinite(min) ? Number(min) : fallbackMin;
+    const safeMax = Number.isFinite(max) ? Number(max) : fallbackMax;
+    return safeMin <= safeMax ? [safeMin, safeMax] : [safeMax, safeMin];
+}
+function sampleRange(min, max) {
+    return min + Math.random() * (max - min);
+}
+function getPitchValue(properties) {
+    if (properties.randomizePitch) {
+        const [pitchFloor, pitchCeiling] = clampRange(properties.minPitch, properties.maxPitch, 0.96, 1.04);
+        return sampleRange(pitchFloor, pitchCeiling);
+    }
+    return Number.isFinite(properties.pitch) ? Number(properties.pitch) : 1;
+}
+function getVolumeValue(properties) {
+    if (properties.randomizeVolume) {
+        const [volumeFloor, volumeCeiling] = clampRange(properties.minVolume, properties.maxVolume, 0.9, 1);
+        return sampleRange(volumeFloor, volumeCeiling);
+    }
+    return Number.isFinite(properties.volume) ? Number(properties.volume) : 1;
+}
+function resolveClipPaths({ clips, clipMode }) {
+    const paths = (clips !== null && clips !== void 0 ? clips : []).map(clip => clip.trim()).filter(Boolean);
+    return { paths, mode: paths.length > 0 ? clipMode !== null && clipMode !== void 0 ? clipMode : "random" : "single" };
+}
+function pickClip(paths, mode, sequenceIndexRef) {
+    if (paths.length <= 1 || mode === "single")
+        return paths[0];
+    if (mode === "sequence") {
+        const clip = paths[sequenceIndexRef.current % paths.length];
+        sequenceIndexRef.current += 1;
+        return clip;
+    }
+    return paths[Math.floor(Math.random() * paths.length)];
+}
+function payloadMatchesNode(nodeId, payload) {
+    if (!nodeId || !payload || typeof payload !== "object")
+        return true;
+    const eventPayload = payload;
+    const relatedNodeIds = [
+        eventPayload.nodeId,
+        eventPayload.sourceEntityId,
+        eventPayload.sourceNodeId,
+        eventPayload.targetEntityId,
+        eventPayload.targetNodeId,
+        eventPayload.instanceEntityId,
+    ].filter((value) => typeof value === "string");
+    return relatedNodeIds.length > 0 ? relatedNodeIds.includes(nodeId) : true;
+}
+function playBufferedAudio(audio, buffer, properties) {
+    void audio.listener.context.resume();
+    if (audio.isPlaying)
+        audio.stop();
+    audio.setBuffer(buffer);
+    audio.setLoop(Boolean(properties.loop));
+    audio.setPlaybackRate(getPitchValue(properties));
+    audio.setVolume(getVolumeValue(properties));
+    audio.play();
+}
+function SoundView({ properties, children }) {
+    const { getSound } = useAssetRuntime();
+    const { editMode, nodeId } = useNode();
+    const { camera } = useThree();
+    const { eventName, autoplay = false, positional = false, refDistance = 1, maxDistance = 24, rolloffFactor = 1, distanceModel = "inverse" } = properties;
+    const sequenceIndexRef = useRef(0);
+    const listenerRef = useRef(null);
+    const positionalAudioRef = useRef(null);
+    const { paths, mode } = resolveClipPaths(properties);
+    if (!listenerRef.current)
+        listenerRef.current = getSharedAudioListener();
+    useEffect(() => {
+        var _a;
+        const listener = listenerRef.current;
+        if (!listener)
+            return;
+        if (listener.parent !== camera) {
+            (_a = listener.parent) === null || _a === void 0 ? void 0 : _a.remove(listener);
+            camera.add(listener);
+        }
+        return () => {
+            if (listener.parent === camera)
+                camera.remove(listener);
+        };
+    }, [camera]);
+    useEffect(() => {
+        const audio = positionalAudioRef.current;
+        if (!audio)
+            return;
+        audio.setRefDistance(positional ? refDistance : Math.max(refDistance, 1));
+        audio.setMaxDistance(positional ? maxDistance : 1000000);
+        audio.setRolloffFactor(positional ? rolloffFactor : 0);
+        audio.setDistanceModel(positional ? distanceModel : "inverse");
+    }, [distanceModel, maxDistance, positional, refDistance, rolloffFactor]);
+    useEffect(() => {
+        if (editMode || paths.length === 0 || !eventName)
+            return;
+        return gameEvents.on(eventName, (payload) => {
+            if (!payloadMatchesNode(nodeId, payload))
+                return;
+            const clip = pickClip(paths, mode, sequenceIndexRef);
+            const audio = positionalAudioRef.current;
+            const buffer = clip ? getSound(clip) : null;
+            if (audio && buffer)
+                playBufferedAudio(audio, buffer, properties);
+        });
+    }, [editMode, eventName, getSound, mode, nodeId, paths, properties]);
+    useEffect(() => {
+        if (editMode || !autoplay || paths.length === 0)
+            return;
+        const clip = pickClip(paths, mode, sequenceIndexRef);
+        const audio = positionalAudioRef.current;
+        const buffer = clip ? getSound(clip) : null;
+        if (audio && buffer)
+            playBufferedAudio(audio, buffer, properties);
+        return () => {
+            if (audio === null || audio === void 0 ? void 0 : audio.isPlaying)
+                audio.stop();
+        };
+    }, [autoplay, editMode, getSound, mode, paths, properties]);
+    return (_jsxs(_Fragment, { children: [listenerRef.current ? _jsx("positionalAudio", { ref: positionalAudioRef, args: [listenerRef.current] }) : null, children] }));
+}
+const runtimeComponents = [
+    { name: "Transform", disableSiblingComposition: true, defaultProperties: {} },
+    { name: "Geometry", disableSiblingComposition: "geometry", View: GeometryView, defaultProperties: { geometryType: "box", args: [1, 1, 1], emitClickEvent: false, clickEventName: "" } },
+    { name: "BufferGeometry", disableSiblingComposition: "geometry", View: BufferGeometryView, defaultProperties: { positions: DEFAULT_TRIANGLE_POSITIONS, indices: DEFAULT_TRIANGLE_INDICES, normals: [], uvs: DEFAULT_TRIANGLE_UVS, groups: [], computeVertexNormals: true, emitClickEvent: false, clickEventName: "" } },
+    { name: "Model", View: ModelView, defaultProperties: {}, getAssetRefs: properties => assetRefs(assetRef("model", properties.filename)) },
+    { name: "Sprite", disableSiblingComposition: true, defaultProperties: { center: [0.5, 0.5], emitClickEvent: false, clickEventName: "node:click" } },
+    { name: "Text", View: TextView, defaultProperties: { text: "Hello World", color: "#ffffff", size: 1, depth: 0.05, align: "center" } },
+    { name: "Material", View: MaterialView, defaultProperties: { attach: "material", materialType: "standard", color: "#ffffff", toneMapped: true, wireframe: false, transparent: false, opacity: 1, sizeAttenuation: true, offset: [0, 0], animateOffset: false, offsetSpeed: [0, 0], metalness: 0, roughness: 1 }, getAssetRefs: properties => assetRefs(assetRef("texture", properties.texture), assetRef("texture", properties.normalMapTexture)) },
+    { name: "SpotLight", View: SpotLightView, defaultProperties: {}, getAssetRefs: properties => assetRefs(assetRef("texture", properties.map)) },
+    { name: "PointLight", View: PointLightView, defaultProperties: {} },
+    { name: "DirectionalLight", View: DirectionalLightView, defaultProperties: {} },
+    { name: "AmbientLight", View: AmbientLightView, defaultProperties: {} },
+    { name: "Environment", disableSiblingComposition: true, View: EnvironmentView, defaultProperties: {} },
+    { name: "Camera", disableSiblingComposition: true, View: CameraView, defaultProperties: { projection: "perspective", fov: 50, near: 0.1, zoom: 1, far: 1000 } },
+    { name: "Sound", View: SoundView, defaultProperties: { eventName: "", autoplay: false, loop: false, clips: [], clipMode: "single", positional: false, refDistance: 1, maxDistance: 24, rolloffFactor: 1, distanceModel: "inverse", pitch: 1, randomizePitch: false, minPitch: 0.96, maxPitch: 1.04, volume: 1, randomizeVolume: false, minVolume: 0.9, maxVolume: 1 }, getAssetRefs: (properties) => Array.isArray(properties.clips) ? properties.clips.filter((clip) => typeof clip === "string").map(path => ({ type: "sound", path })) : [] },
+    { name: "Data", defaultProperties: { values: {} } },
+    { name: "PrefabRef", View: PrefabRefView, defaultProperties: { url: "" } },
+];
+let didRegisterRuntimeComponents = false;
+export function registerRuntimeComponents() {
+    if (didRegisterRuntimeComponents)
+        return;
+    runtimeComponents.forEach(component => {
+        if (!getComponentDef(component.name))
+            registerComponent(component);
+    });
+    didRegisterRuntimeComponents = true;
+}
+export { runtimeComponents };

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

@@ -6,9 +6,12 @@ export interface DecomposeModelOptions {
     idPrefix?: string;
     /** Include invisible Three objects in the generated prefab tree. */
     includeInvisible?: boolean;
+    /** Create CrashcatPhysics components from Blender-style mesh name suffixes. */
+    inferCollisionMeshes?: boolean;
     /** Return a serializable texture ref for embedded or externally loaded textures. */
     getTexturePath?: (texture: Texture, usage: 'map' | 'normalMap') => string | null | undefined;
 }
+export declare function hasCollisionMeshConventions(object: Object3D, enabled?: boolean): boolean;
 /**
  * Converts a live Three object hierarchy into prefab JSON nodes made from
  * Transform, BufferGeometry, and Material components.

package/dist/tools/prefabeditor/modelPrefab.js

@@ -52,6 +52,27 @@ function serializeGeometry(geometry) {
         computeVertexNormals: normals.length === 0,
     };
 }
+function getCollisionMeshConvention(name, enabled) {
+    if (!enabled)
+        return null;
+    const match = name.match(/^(.*)_(colonly|col)(?:\.\d+)?$/i);
+    if (!match)
+        return null;
+    const [, baseName, suffix] = match;
+    return {
+        displayName: baseName || name,
+        renderMesh: suffix.toLowerCase() === 'col',
+    };
+}
+export function hasCollisionMeshConventions(object, enabled = true) {
+    let hasConvention = false;
+    object.traverse(child => {
+        if (hasConvention)
+            return;
+        hasConvention = child instanceof Mesh && getCollisionMeshConvention(child.name, enabled) != null;
+    });
+    return hasConvention;
+}
 function getSideName(side) {
     if (side === BackSide)
         return 'BackSide';
@@ -138,17 +159,19 @@ function createTransformComponent(object) {
         },
     };
 }
-function createNode(object, idPrefix, children = [], components = {}) {
+function createNode(object, idPrefix, children = [], components = {}, options = {}) {
+    var _a, _b;
     return {
         id: createId(idPrefix),
-        name: object.name || object.type,
-        hidden: object.visible === false ? true : undefined,
+        name: ((_a = options.name) !== null && _a !== void 0 ? _a : object.name) || object.type,
+        hidden: (_b = options.hidden) !== null && _b !== void 0 ? _b : (object.visible === false ? true : undefined),
         components: Object.assign({ transform: createTransformComponent(object) }, components),
         children,
     };
 }
 function decomposeObject(object, options) {
-    if (!options.includeInvisible && !object.visible)
+    const collisionMesh = getCollisionMeshConvention(object.name, options.inferCollisionMeshes);
+    if (!options.includeInvisible && !object.visible && !collisionMesh)
         return null;
     const childNodes = object.children
         .map(child => decomposeObject(child, options))
@@ -161,20 +184,30 @@ function decomposeObject(object, options) {
         result[part.key] = serializeMaterial(part.material, part.attach, options);
         return result;
     }, {});
-    return createNode(object, options.idPrefix, childNodes, Object.assign({ geometry: {
+    return createNode(object, options.idPrefix, childNodes, Object.assign(Object.assign({ geometry: {
             type: 'BufferGeometry',
-            properties: Object.assign(Object.assign({}, serializeGeometry(object.geometry)), { visible: object.visible, castShadow: object.castShadow, receiveShadow: object.receiveShadow }),
-        } }, materialComponents));
+            properties: Object.assign(Object.assign({}, serializeGeometry(object.geometry)), { visible: collisionMesh ? collisionMesh.renderMesh : object.visible, castShadow: object.castShadow, receiveShadow: object.receiveShadow }),
+        } }, materialComponents), (collisionMesh ? {
+        crashcatPhysics: {
+            type: 'CrashcatPhysics',
+            properties: {
+                type: 'fixed',
+                colliders: 'trimesh',
+                sensor: false,
+            },
+        },
+    } : null)), collisionMesh ? { name: collisionMesh.displayName, hidden: false } : undefined);
 }
 /**
  * Converts a live Three object hierarchy into prefab JSON nodes made from
  * Transform, BufferGeometry, and Material components.
  */
 export function decomposeModelToPrefabNodes(object, options = {}) {
-    var _a, _b, _c, _d, _e;
-    return (_d = decomposeObject(object, {
+    var _a, _b, _c, _d, _e, _f;
+    return (_e = decomposeObject(object, {
         idPrefix: (_a = options.idPrefix) !== null && _a !== void 0 ? _a : 'model',
         includeInvisible: (_b = options.includeInvisible) !== null && _b !== void 0 ? _b : false,
-        getTexturePath: (_c = options.getTexturePath) !== null && _c !== void 0 ? _c : (() => undefined),
-    })) !== null && _d !== void 0 ? _d : createNode(object, (_e = options.idPrefix) !== null && _e !== void 0 ? _e : 'model');
+        inferCollisionMeshes: (_c = options.inferCollisionMeshes) !== null && _c !== void 0 ? _c : true,
+        getTexturePath: (_d = options.getTexturePath) !== null && _d !== void 0 ? _d : (() => undefined),
+    })) !== null && _e !== void 0 ? _e : createNode(object, (_f = options.idPrefix) !== null && _f !== void 0 ? _f : 'model');
 }

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

@@ -1,5 +1,5 @@
-import type { ComponentData, GameObject, Prefab } from './types';
-export type PrefabNodeRecord = Omit<GameObject, 'children'>;
+import type { ComponentData, GameObject, Prefab } from "./types";
+export type PrefabNodeRecord = Omit<GameObject, "children">;
 export type PrefabAssetRefCounts = Record<string, number>;
 export interface PrefabState {
     prefabId?: string;
@@ -24,12 +24,13 @@ export declare function createEmptyNode(name?: string): GameObject;
 export declare function createEmptyPrefab(): Prefab;
 export declare function createModelNode(filename: string, name?: string): GameObject;
 export declare function createImageNode(texturePath: string, name?: string): GameObject;
+export declare function createPackedPrefabNode(url: string): GameObject;
 export declare function normalizePrefab(prefab: Prefab): PrefabState;
 export declare function createPrefabPatch(state: PrefabState, patch: Partial<PrefabState>, nextAssetRefCounts?: PrefabAssetRefCounts): Partial<PrefabState>;
-export declare function denormalizePrefab(state: Pick<PrefabState, 'prefabId' | 'prefabName' | 'rootId' | 'nodesById' | 'childIdsById'>): Prefab;
+export declare function denormalizePrefab(state: Pick<PrefabState, "prefabId" | "prefabName" | "rootId" | "nodesById" | "childIdsById">): Prefab;
 export declare function collectSubtreeIds(id: string, childIdsById: Record<string, string[]>): string[];
 export declare function insertSubtree(node: GameObject, parentId: string | null, nodesById: Record<string, PrefabNodeRecord>, childIdsById: Record<string, string[]>, parentIdById: Record<string, string | null>): void;
-export declare function cloneSubtree(id: string, parentId: string | null, source: Pick<PrefabState, 'nodesById' | 'childIdsById'>, nodesById: Record<string, PrefabNodeRecord>, childIdsById: Record<string, string[]>, parentIdById: Record<string, string | null>): string | null;
+export declare function cloneSubtree(id: string, parentId: string | null, source: Pick<PrefabState, "nodesById" | "childIdsById">, nodesById: Record<string, PrefabNodeRecord>, childIdsById: Record<string, string[]>, parentIdById: Record<string, string | null>): string | null;
 export declare function isDescendant(id: string, potentialAncestorId: string, parentIdById: Record<string, string | null>): boolean;
 export declare function updateAssetRefsForNodeChange(assetRefCounts: PrefabAssetRefCounts, currentNode: PrefabNodeRecord, nextNode: PrefabNodeRecord): PrefabAssetRefCounts;
 export declare function collectSubtreeAssetRefs(node: GameObject): string[];