react-three-game 0.0.86 → 0.0.87

package/dist/index.d.ts

@@ -11,13 +11,15 @@ export type { EditorContextType } from './tools/prefabeditor/PrefabEditor';
 export { createPrefabStore, prefabStoreToPrefab, usePrefabStoreApi } from './tools/prefabeditor/prefabStore';
 export type { PrefabStoreApi, PrefabStoreState } from './tools/prefabeditor/prefabStore';
 export { denormalizePrefab } from './tools/prefabeditor/prefab';
+export { gameEvents, getEntityIdFromRigidBody, useClickEvent, useGameEvent, usePhysicsEvent } from './tools/prefabeditor/GameEvents';
+export type { ClickEventPayload, GameEventHandler, GameEventMap, PhysicsEventPayload } from './tools/prefabeditor/GameEvents';
 export { registerComponent } from './tools/prefabeditor/components/ComponentRegistry';
 export { FieldRenderer, FieldGroup, ListEditor, Label, Vector3Input, Vector3Field, NumberField, ColorInput, ColorField, StringInput, StringField, BooleanInput, BooleanField, SelectInput, SelectField, } from './tools/prefabeditor/components/Input';
 export { loadJson, saveJson, exportGLB, exportGLBData, regenerateIds, computeParentWorldMatrix, } from './tools/prefabeditor/utils';
 export type { ExportGLBOptions } from './tools/prefabeditor/utils';
 export { createModelNode, createImageNode, } from './tools/prefabeditor/prefab';
 export type { PrefabEditorProps, PrefabEditorRef, } from './tools/prefabeditor/PrefabEditor';
-export type { SpawnOptions, } from './tools/prefabeditor/scene';
+export type { Entity, EntityComponent, EntityData, EntityUpdate, PropertyPath, Scene, SceneUpdates, SpawnOptions, } from './tools/prefabeditor/scene';
 export type { PrefabRootProps } from './tools/prefabeditor/PrefabRoot';
 export type { AssetRuntime, EntityRuntime, LiveObjectRef, LiveRigidBodyRef } from './tools/prefabeditor/assetRuntime';
 export { useAssetRuntime, useEntityRuntime, useEntityObjectRef, useEntityRigidBodyRef } from './tools/prefabeditor/assetRuntime';

package/dist/index.js

@@ -11,6 +11,7 @@ export { useEditorContext } from './tools/prefabeditor/PrefabEditor';
 // Prefab Editor - Store & Scene API
 export { createPrefabStore, prefabStoreToPrefab, usePrefabStoreApi } from './tools/prefabeditor/prefabStore';
 export { denormalizePrefab } from './tools/prefabeditor/prefab';
+export { gameEvents, getEntityIdFromRigidBody, useClickEvent, useGameEvent, usePhysicsEvent } from './tools/prefabeditor/GameEvents';
 // Prefab Editor - Component Registry
 export { registerComponent } from './tools/prefabeditor/components/ComponentRegistry';
 // Prefab Editor - Input Components

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

@@ -0,0 +1,47 @@
+export type GameEventHandler<TPayload = unknown> = (payload: TPayload) => void;
+export type PhysicsEventPayload = {
+    sourceEntityId?: string;
+    sourceNodeId?: string;
+    sourceObject?: unknown;
+    sourceRigidBody?: unknown;
+    targetEntityId?: string | null;
+    targetNodeId?: string | null;
+    targetObject?: unknown;
+    targetRigidBody?: unknown;
+    rapierEvent?: unknown;
+};
+export type ClickEventPayload = {
+    sourceEntityId?: string;
+    sourceNodeId?: string;
+    instanceEntityId?: string;
+    nodeId?: string;
+    node?: unknown;
+    object?: unknown;
+    point?: [number, number, number];
+    button?: number;
+    altKey?: boolean;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    shiftKey?: boolean;
+    r3fEvent?: unknown;
+};
+export interface GameEventMap {
+    'sensor:enter': PhysicsEventPayload;
+    'sensor:exit': PhysicsEventPayload;
+    'collision:enter': PhysicsEventPayload;
+    'collision:exit': PhysicsEventPayload;
+    click: ClickEventPayload;
+    [eventType: string]: unknown;
+}
+export declare const gameEvents: {
+    emit<TType extends string>(type: TType, payload: TType extends keyof GameEventMap ? GameEventMap[TType] : unknown): void;
+    on<TType extends string>(type: TType, handler: GameEventHandler<TType extends keyof GameEventMap ? GameEventMap[TType] : unknown>): () => void;
+    clear(): void;
+    hasListeners(type: string): boolean;
+};
+export declare function useGameEvent<TType extends string>(type: TType, handler: GameEventHandler<TType extends keyof GameEventMap ? GameEventMap[TType] : unknown>, deps?: React.DependencyList): void;
+export declare function usePhysicsEvent<TType extends string>(type: TType, handler: GameEventHandler<TType extends keyof GameEventMap ? GameEventMap[TType] : unknown>, deps?: React.DependencyList): void;
+export declare function useClickEvent<TType extends string>(type: TType, handler: GameEventHandler<TType extends keyof GameEventMap ? GameEventMap[TType] : unknown>, deps?: React.DependencyList): void;
+export declare function getEntityIdFromRigidBody(rigidBody: {
+    userData?: unknown;
+} | null | undefined): string | null;

package/dist/tools/prefabeditor/GameEvents.js

@@ -0,0 +1,66 @@
+import { useCallback, useEffect } from 'react';
+const subscribers = new Map();
+export const gameEvents = {
+    emit(type, payload) {
+        const trimmedType = type.trim();
+        if (!trimmedType)
+            return;
+        const handlers = subscribers.get(trimmedType);
+        if (!handlers)
+            return;
+        handlers.forEach(handler => {
+            try {
+                handler(payload);
+            }
+            catch (error) {
+                console.error(`Error in gameEvents handler for ${trimmedType}:`, error);
+            }
+        });
+    },
+    on(type, handler) {
+        const trimmedType = type.trim();
+        if (!trimmedType) {
+            return () => { };
+        }
+        let handlers = subscribers.get(trimmedType);
+        if (!handlers) {
+            handlers = new Set();
+            subscribers.set(trimmedType, handlers);
+        }
+        handlers.add(handler);
+        return () => {
+            const currentHandlers = subscribers.get(trimmedType);
+            if (!currentHandlers)
+                return;
+            currentHandlers.delete(handler);
+            if (currentHandlers.size === 0) {
+                subscribers.delete(trimmedType);
+            }
+        };
+    },
+    clear() {
+        subscribers.clear();
+    },
+    hasListeners(type) {
+        var _a, _b;
+        return ((_b = (_a = subscribers.get(type.trim())) === null || _a === void 0 ? void 0 : _a.size) !== null && _b !== void 0 ? _b : 0) > 0;
+    },
+};
+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]);
+}
+export function usePhysicsEvent(type, handler, deps = []) {
+    useGameEvent(type, handler, deps);
+}
+export function useClickEvent(type, handler, deps = []) {
+    useGameEvent(type, handler, deps);
+}
+export function getEntityIdFromRigidBody(rigidBody) {
+    var _a;
+    const entityId = (_a = rigidBody === null || rigidBody === void 0 ? void 0 : rigidBody.userData) === null || _a === void 0 ? void 0 : _a.entityId;
+    return typeof entityId === 'string' ? entityId : null;
+}

package/dist/tools/prefabeditor/PrefabRoot.js

@@ -24,6 +24,7 @@ import { composeTransform, decompose } from "./utils";
 import { isPhysicsProps } from "./components/PhysicsComponent";
 import { createPrefabStore, PrefabStoreProvider, useOptionalPrefabStoreApi, usePrefabChildIds, usePrefabNode, usePrefabRootId } from "./prefabStore";
 import { AssetRuntimeContext, EntityRuntimeScope } from "./assetRuntime";
+import { gameEvents } from "./GameEvents";
 import { sound as soundManager } from "../../helpers/SoundManager";
 builtinComponents.forEach(registerComponent);
 const IDENTITY = new Matrix4();
@@ -44,12 +45,6 @@ function isNodeReady(node, loadedModels) {
         return true;
     return Boolean(loadedModels[model.properties.filename]);
 }
-function emitNativeEvent(type, detail) {
-    const trimmedType = type === null || type === void 0 ? void 0 : type.trim();
-    if (!trimmedType || typeof window === 'undefined')
-        return;
-    window.dispatchEvent(new CustomEvent(trimmedType, { detail }));
-}
 function getNodeClickEventName(node) {
     var _a;
     const clickComponents = [
@@ -214,12 +209,16 @@ function StoreRootNode(props) {
 }
 function emitNodePointerEvent(eventName, event, nodeId, node, fallbackObject) {
     var _a;
-    if (!eventName)
+    const trimmedEventName = eventName === null || eventName === void 0 ? void 0 : eventName.trim();
+    if (!trimmedEventName)
         return;
-    emitNativeEvent(eventName, {
+    gameEvents.emit(trimmedEventName, {
+        sourceEntityId: nodeId,
+        sourceNodeId: nodeId,
         nodeId,
         node,
         object: (_a = event.object) !== null && _a !== void 0 ? _a : fallbackObject,
+        point: [event.point.x, event.point.y, event.point.z],
         button: event.button,
         altKey: event.nativeEvent.altKey,
         ctrlKey: event.nativeEvent.ctrlKey,

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

@@ -13,6 +13,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { CapsuleCollider, RigidBody, useRapier } from "@react-three/rapier";
 import { useCallback, useEffect, useRef } from 'react';
 import { useAssetRuntime, useEntityRuntime } from "../assetRuntime";
+import { gameEvents, getEntityIdFromRigidBody } from "../GameEvents";
 import { usePrefabNode } from "../prefabStore";
 import { BooleanField, FieldGroup, NumberField, SelectField, StringField, Vector3Field } from "./Input";
 import { getNodeUserData } from "../types";
@@ -80,16 +81,6 @@ function PhysicsComponentEditor({ component, onUpdate }) {
                     { value: 'all', label: 'All (includes kinematic & fixed)' },
                 ] })] }));
 }
-function emitNativeEvent(type, detail) {
-    const trimmedType = type === null || type === void 0 ? void 0 : type.trim();
-    if (!trimmedType || typeof window === 'undefined')
-        return;
-    window.dispatchEvent(new CustomEvent(trimmedType, { detail }));
-}
-function getEntityIdFromRigidBody(rigidBody) {
-    const userData = rigidBody === null || rigidBody === void 0 ? void 0 : rigidBody.userData;
-    return typeof (userData === null || userData === void 0 ? void 0 : userData.entityId) === 'string' ? userData.entityId : null;
-}
 function PhysicsComponentView({ properties, children, position, rotation, scale }) {
     var _a, _b, _c;
     const { registerRigidBodyRef } = useAssetRuntime();
@@ -157,11 +148,17 @@ function PhysicsComponentView({ properties, children, position, rotation, scale
         var _a, _b, _c;
         if (!nodeId)
             return;
-        emitNativeEvent(eventType, {
+        const trimmedEventType = eventType === null || eventType === void 0 ? void 0 : eventType.trim();
+        if (!trimmedEventType)
+            return;
+        const targetEntityId = getEntityIdFromRigidBody(payload.other.rigidBody);
+        gameEvents.emit(trimmedEventType, {
+            sourceEntityId: nodeId,
             sourceNodeId: nodeId,
             sourceObject: getObject(),
             sourceRigidBody: rigidBodyRef.current,
-            targetNodeId: getEntityIdFromRigidBody(payload.other.rigidBody),
+            targetEntityId,
+            targetNodeId: targetEntityId,
             targetObject: (_b = (_a = payload.other.rigidBodyObject) !== null && _a !== void 0 ? _a : payload.other.colliderObject) !== null && _b !== void 0 ? _b : null,
             targetRigidBody: (_c = payload.other.rigidBody) !== null && _c !== void 0 ? _c : null,
             rapierEvent: payload,

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

@@ -4,6 +4,7 @@ import { useThree } from '@react-three/fiber';
 import { SoundPicker } from '../../assetviewer/page';
 import { sound as soundManager } from '../../../helpers/SoundManager';
 import { useAssetRuntime, useEntityRuntime } from '../assetRuntime';
+import { gameEvents } from '../GameEvents';
 import { BooleanField, FieldGroup, FieldRenderer, ListEditor, NumberField, SelectField, StringField } from './Input';
 import { colors } from '../styles';
 import { AudioListener } from 'three';
@@ -62,6 +63,21 @@ function pickClip(paths, mode, sequenceIndexRef) {
     }
     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 SoundComponentEditor({ component, onUpdate, basePath = '' }) {
     const clips = Array.isArray(component.properties.clips)
         ? component.properties.clips.map((clip) => typeof clip === 'string' ? clip : '')
@@ -156,17 +172,12 @@ function SoundComponentView({ properties, children }) {
         audio.setDistanceModel(distanceModel);
     }, [distanceModel, maxDistance, refDistance, rolloffFactor]);
     useEffect(() => {
-        if (editMode || paths.length === 0 || !eventName || typeof window === 'undefined') {
+        if (editMode || paths.length === 0 || !eventName) {
             return;
         }
-        const handleEvent = (event) => {
-            const customEvent = event;
-            const detail = customEvent.detail;
-            if (nodeId && detail && typeof detail === 'object') {
-                const relatedNodeIds = [detail.nodeId, detail.sourceNodeId, detail.targetNodeId].filter((value) => typeof value === 'string');
-                if (relatedNodeIds.length > 0 && !relatedNodeIds.includes(nodeId)) {
-                    return;
-                }
+        return gameEvents.on(eventName, (payload) => {
+            if (!payloadMatchesNode(nodeId, payload)) {
+                return;
             }
             const clip = pickClip(paths, mode, sequenceIndexRef);
             if (!clip)
@@ -200,11 +211,7 @@ function SoundComponentView({ properties, children }) {
             audio.setPlaybackRate(pitch);
             audio.setVolume(volume);
             audio.play();
-        };
-        window.addEventListener(eventName, handleEvent);
-        return () => {
-            window.removeEventListener(eventName, handleEvent);
-        };
+        });
     }, [editMode, eventName, getSound, mode, nodeId, paths, positional, properties]);
     return (_jsxs(_Fragment, { children: [positional && listenerRef.current ? _jsx("positionalAudio", { ref: positionalAudioRef, args: [listenerRef.current] }) : null, children] }));
 }

package/package.json

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