react-three-game 0.0.85 → 0.0.86

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-three-game",
-  "version": "0.0.85",
+  "version": "0.0.86",
   "description": "high performance 3D game engine built in React",
   "main": "dist/index.js",
   "module": "dist/index.js",

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

@@ -1,128 +0,0 @@
-import type { RapierRigidBody } from '@react-three/rapier';
-/** Physics event types (built-in) */
-export type PhysicsEventType = 'sensor:enter' | 'sensor:exit' | 'collision:enter' | 'collision:exit';
-export type InteractionEventType = 'click';
-/** Payload for physics events */
-export interface PhysicsEventPayload {
-    sourceEntityId: string;
-    targetEntityId: string | null;
-    targetRigidBody: RapierRigidBody | null | undefined;
-}
-export interface ClickEventPayload {
-    sourceEntityId: string;
-    instanceEntityId?: string;
-    point: [number, number, number];
-    button: number;
-    altKey: boolean;
-    ctrlKey: boolean;
-    metaKey: boolean;
-    shiftKey: boolean;
-}
-/**
- * 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;
-    'click': ClickEventPayload;
-}
-/** 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;
-type UnknownEventPayload = Record<string, unknown>;
-declare function emitGameEvent<TType extends keyof GameEventMap>(type: TType, payload: GameEventMap[TType]): void;
-declare function emitGameEvent(type: string, payload: UnknownEventPayload): void;
-declare function onGameEvent<TType extends keyof GameEventMap>(type: TType, handler: EventHandler<GameEventMap[TType]>): () => void;
-declare function onGameEvent(type: string, handler: EventHandler<UnknownEventPayload>): () => void;
-declare function offGameEvent<TType extends keyof GameEventMap>(type: TType, handler: EventHandler<GameEventMap[TType]>): void;
-declare function offGameEvent(type: string, handler: EventHandler<UnknownEventPayload>): void;
-/**
- * Game event system for all game interactions.
- *
- * Built-in 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
- * - click - A prefab entity with a Click component was clicked in play mode
- *
- * 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: typeof emitGameEvent;
-    /**
-     * Subscribe to an event type
-     * @returns Unsubscribe function
-     */
-    on: typeof onGameEvent;
-    /**
-     * Unsubscribe from an event type
-     */
-    off: typeof offGameEvent;
-    /**
-     * 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) => {
- *   const cause = typeof payload.cause === 'string' ? payload.cause : 'unknown';
- *   showGameOver(cause);
- * }, []);
- */
-export declare function useGameEvent<TType extends keyof GameEventMap>(type: TType, handler: EventHandler<GameEventMap[TType]>, deps?: unknown[]): void;
-export declare function useGameEvent(type: string, handler: EventHandler<UnknownEventPayload>, deps?: unknown[]): void;
-/**
- * React hook to subscribe to any physics event payload.
- * Use this when the event name is dynamic but the payload comes from PhysicsComponent.
- */
-export declare function usePhysicsEvent(type: string, handler: EventHandler<PhysicsEventPayload>, deps?: unknown[]): void;
-/**
- * React hook to subscribe to click event payloads.
- * Use this when the event name is dynamic but the payload comes from ClickComponent.
- */
-export declare function useClickEvent(type: string, handler: EventHandler<ClickEventPayload>, 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;
-export {};

package/dist/tools/prefabeditor/GameEvents.js

@@ -1,118 +0,0 @@
-import { useEffect, useCallback } from 'react';
-// Internal subscriber storage
-const subscribers = new Map();
-function emitGameEvent(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);
-            }
-        });
-    }
-}
-function onGameEvent(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);
-    };
-}
-function offGameEvent(type, handler) {
-    var _a;
-    (_a = subscribers.get(type)) === null || _a === void 0 ? void 0 : _a.delete(handler);
-}
-function useTypedGameEvent(type, handler, deps = []) {
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    const stableHandler = useCallback(handler, deps);
-    useEffect(() => {
-        return onGameEvent(type, stableHandler);
-    }, [type, stableHandler]);
-}
-/**
- * Game event system for all game interactions.
- *
- * Built-in 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
- * - click - A prefab entity with a Click component was clicked in play mode
- *
- * 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: emitGameEvent,
-    /**
-     * Subscribe to an event type
-     * @returns Unsubscribe function
-     */
-    on: onGameEvent,
-    /**
-     * Unsubscribe from an event type
-     */
-    off: offGameEvent,
-    /**
-     * 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;
-    }
-};
-export function useGameEvent(type, handler, deps = []) {
-    useTypedGameEvent(type, handler, deps);
-}
-/**
- * React hook to subscribe to any physics event payload.
- * Use this when the event name is dynamic but the payload comes from PhysicsComponent.
- */
-export function usePhysicsEvent(type, handler, deps = []) {
-    useTypedGameEvent(type, handler, deps);
-}
-/**
- * React hook to subscribe to click event payloads.
- * Use this when the event name is dynamic but the payload comes from ClickComponent.
- */
-export function useClickEvent(type, handler, deps = []) {
-    useTypedGameEvent(type, handler, deps);
-}
-// ============================================================================
-// 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;
-}

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

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

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

@@ -1,52 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { useRef } from 'react';
-import { gameEvents } from '../GameEvents';
-import { useEntityRuntime } from '../runtime';
-import { EventField, FieldGroup } from './Input';
-function ClickComponentEditor({ component, onUpdate }) {
-    return (_jsxs(FieldGroup, { children: [_jsx("div", { style: { fontSize: 12, opacity: 0.8 }, children: "Emits a game event in play mode when this entity is clicked." }), _jsx(EventField, { name: "eventName", label: "Emit Event", values: component.properties, onChange: onUpdate, placeholder: "click" })] }));
-}
-function ClickComponentView({ children, properties }) {
-    const clickValid = useRef(false);
-    const { editMode, nodeId } = useEntityRuntime();
-    const eventName = (properties === null || properties === void 0 ? void 0 : properties.eventName) || 'click';
-    const emitClick = (event) => {
-        if (!nodeId)
-            return;
-        gameEvents.emit(eventName, {
-            sourceEntityId: nodeId,
-            point: [event.point.x, event.point.y, event.point.z],
-            button: event.button,
-            altKey: event.nativeEvent.altKey,
-            ctrlKey: event.nativeEvent.ctrlKey,
-            metaKey: event.nativeEvent.metaKey,
-            shiftKey: event.nativeEvent.shiftKey,
-        });
-    };
-    if (editMode) {
-        return _jsx(_Fragment, { children: children });
-    }
-    return (_jsx("group", { onPointerDown: (event) => {
-            event.stopPropagation();
-            clickValid.current = true;
-        }, onClick: (event) => {
-            event.stopPropagation();
-        }, onPointerMove: () => {
-            clickValid.current = false;
-        }, onPointerUp: (event) => {
-            if (!clickValid.current)
-                return;
-            event.stopPropagation();
-            emitClick(event);
-            clickValid.current = false;
-        }, children: children }));
-}
-const ClickComponent = {
-    name: 'Click',
-    Editor: ClickComponentEditor,
-    View: ClickComponentView,
-    defaultProperties: {
-        eventName: 'click',
-    },
-};
-export default ClickComponent;

package/dist/tools/prefabeditor/runtime.js

@@ -1,184 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext, useMemo } from "react";
-import { getComponentDef } from "./components/ComponentRegistry";
-import { createScene } from "./scene";
-export const AssetRuntimeContext = createContext(null);
-const EntityRuntimeContext = createContext(null);
-export function useAssetRuntime() {
-    const ctx = useContext(AssetRuntimeContext);
-    if (!ctx)
-        throw new Error("useAssetRuntime must be used inside <PrefabRoot>");
-    return ctx;
-}
-export function useEntityRuntime() {
-    const ctx = useContext(EntityRuntimeContext);
-    if (!ctx)
-        throw new Error("useEntityRuntime must be used inside a component View rendered by <PrefabRoot>");
-    return ctx;
-}
-export function useEntityObjectRef() {
-    const { getObject } = useEntityRuntime();
-    return useMemo(() => ({ get current() { return getObject(); } }), [getObject]);
-}
-export function useEntityRigidBodyRef() {
-    const { getRigidBody } = useEntityRuntime();
-    return useMemo(() => ({ get current() { return getRigidBody(); } }), [getRigidBody]);
-}
-export function EntityRuntimeScope({ nodeId, editMode, isSelected, children, }) {
-    const asset = useContext(AssetRuntimeContext);
-    if (!asset)
-        throw new Error("EntityRuntimeScope must be used inside <PrefabRoot>");
-    const value = useMemo(() => ({
-        nodeId,
-        editMode,
-        isSelected,
-        getObject: () => asset.getObject(nodeId),
-        getRigidBody: () => asset.getRigidBody(nodeId),
-    }), [asset, editMode, isSelected, nodeId]);
-    return _jsx(EntityRuntimeContext.Provider, { value: value, children: children });
-}
-export function createRuntimeEngine({ store, getObject, getRigidBody, }) {
-    const scene = createScene({
-        getRootId: () => store.getState().rootId,
-        getNode: (id) => { var _a; return (_a = store.getState().nodesById[id]) !== null && _a !== void 0 ? _a : null; },
-        getChildIds: (id) => { var _a; return (_a = store.getState().childIdsById[id]) !== null && _a !== void 0 ? _a : []; },
-        getParentId: (id) => { var _a; return (_a = store.getState().parentIdById[id]) !== null && _a !== void 0 ? _a : null; },
-        updateNode: (id, update) => store.getState().updateNode(id, update),
-        updateNodes: (updates) => {
-            store.getState().updateNodes(Object.entries(updates).map(([id, update]) => ({ id, update })));
-        },
-        addNode: (node, options) => {
-            var _a;
-            const parentId = (_a = options === null || options === void 0 ? void 0 : options.parentId) !== null && _a !== void 0 ? _a : store.getState().rootId;
-            store.getState().addChild(parentId, node);
-            return node.id;
-        },
-        removeNode: (id) => store.getState().deleteNode(id),
-        getObject,
-        getRigidBody,
-    });
-    // key = `${nodeId}:${componentKey}:${componentType}`
-    const instances = new Map();
-    let active = false;
-    let dirty = true;
-    let lastRevision = store.getState().revision;
-    const unsubscribe = store.subscribe((state) => {
-        if (state.revision === lastRevision)
-            return;
-        lastRevision = state.revision;
-        dirty = true;
-    });
-    function destroy(key) {
-        var _a, _b;
-        const record = instances.get(key);
-        if (!record)
-            return;
-        try {
-            (_b = (_a = record.instance).destroy) === null || _b === void 0 ? void 0 : _b.call(_a);
-        }
-        catch (error) {
-            console.error(`[runtime] destroy ${key}`, error);
-        }
-        instances.delete(key);
-    }
-    function sync() {
-        const state = store.getState();
-        const live = new Set();
-        let hasPendingMount = false;
-        const visit = (nodeId) => {
-            var _a, _b, _c;
-            const node = state.nodesById[nodeId];
-            if (!node)
-                return;
-            if (!node.disabled && node.components) {
-                for (const componentKey in node.components) {
-                    const data = node.components[componentKey];
-                    if (!(data === null || data === void 0 ? void 0 : data.type))
-                        continue;
-                    const def = getComponentDef(data.type);
-                    if (!(def === null || def === void 0 ? void 0 : def.create))
-                        continue;
-                    const key = `${nodeId}:${componentKey}:${data.type}`;
-                    live.add(key);
-                    const object = getObject(nodeId);
-                    if (!object) {
-                        hasPendingMount = true;
-                        continue;
-                    }
-                    const rigidBody = getRigidBody(nodeId);
-                    const existing = instances.get(key);
-                    if (existing && existing.object === object && existing.rigidBody === rigidBody) {
-                        continue;
-                    }
-                    if (existing) {
-                        destroy(key);
-                    }
-                    const entity = scene.find(nodeId);
-                    const component = entity === null || entity === void 0 ? void 0 : entity.getComponent(componentKey);
-                    if (!entity || !component)
-                        continue;
-                    let instance;
-                    try {
-                        instance = (_a = def.create({ scene, component, object, rigidBody })) !== null && _a !== void 0 ? _a : {};
-                    }
-                    catch (error) {
-                        console.error(`[runtime] create ${key}`, error);
-                        continue;
-                    }
-                    instances.set(key, { instance, object, rigidBody });
-                    try {
-                        (_b = instance.start) === null || _b === void 0 ? void 0 : _b.call(instance);
-                    }
-                    catch (error) {
-                        console.error(`[runtime] start ${key}`, error);
-                    }
-                }
-            }
-            for (const childId of (_c = state.childIdsById[nodeId]) !== null && _c !== void 0 ? _c : [])
-                visit(childId);
-        };
-        visit(state.rootId);
-        for (const key of Array.from(instances.keys())) {
-            if (!live.has(key))
-                destroy(key);
-        }
-        dirty = hasPendingMount;
-    }
-    return {
-        tick(dt) {
-            if (!active)
-                return;
-            if (dirty)
-                sync();
-            for (const [key, record] of instances) {
-                if (!record.instance.update)
-                    continue;
-                try {
-                    record.instance.update(dt);
-                }
-                catch (error) {
-                    console.error(`[runtime] update ${key}`, error);
-                }
-            }
-        },
-        setActive(nextActive) {
-            if (active === nextActive)
-                return;
-            active = nextActive;
-            dirty = true;
-            if (!active) {
-                for (const key of Array.from(instances.keys()))
-                    destroy(key);
-            }
-        },
-        invalidate() {
-            dirty = true;
-        },
-        dispose() {
-            active = false;
-            for (const key of Array.from(instances.keys()))
-                destroy(key);
-            unsubscribe();
-        },
-    };
-}