pixi-fusion 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,115 @@
+[![Release Train](https://github.com/laverve/fusion/actions/workflows/main.yaml/badge.svg?branch=main)](https://github.com/laverve/fusion/actions/workflows/main.yaml)
+
+# pixi-fusion - The lightweight Game Engine
+
+This project aims to provide a frwmework for games built on top of [PixiJS](https://pixijs.com/) and [matter-js](https://brm.io/matter-js/).
+
+It is designed to be used with [React](https://react.dev/) framework v18.2.0 or above.
+
+# Installation
+
+```
+npm i --save pixi-fusion
+```
+
+# Basic Usage Example
+
+1. Create a component with `GameContextProvider` and `World`.
+
+```
+<GameContextProvider timeout={10}>
+    <World size={{width: 300, height: 300}} eventMode="dynamic">
+        <layer>
+            <MyAwesomeStage />
+        </Layer>
+    </World>
+</GameContextProvider>
+```
+
+2. Create a component `MyAwesomeStage`.
+
+```
+export const MyAwesomeStage: React.FC<MazeHeroProps> = () => {
+    const { status } = useGame();
+    const displayObjectConfig = useMemo(
+        () => ({
+            type: DisplayObjectType.SPRITE,
+            url: "https://image_url",
+            anchor: { x: 0.5, y: 0.5 },
+        }),
+        []
+    );
+
+    const [position, setPosition] = useState({x: 0, y: 0});
+
+    useDisplayObject({
+        ...displayObjectConfig,
+        position: position
+    });
+
+    const onKeyDown = useCallback(
+        (e: KeyboardEvent) => {
+            switch (e.key) {
+                case "ArrowUp":
+                    setPosition({x: position.x, y: position.y - 1})
+                    break;
+                case "ArrowDown":
+                    setPosition({x: position.x, y: position.y + 1})
+                    break;
+                case "ArrowRight":
+                    setPosition({x: position.x + 1, y: position.y})
+                    setDirection(90);
+                    break;
+                case "ArrowLeft":
+                    setPosition({x: position.x - 1, y: position.y})
+                    break;
+                default:
+                    break;
+            }
+        },
+        [position]
+    );
+
+    useGlobalEventHandler({ event: "keydown", callback: onKeyDown, isEnabled: status === GameStatus.IN_PROGRESS });
+
+    return null;
+};
+```
+
+# Demos
+
+-   [Maze](https://laverve.github.io/fusion/?path=/story/games-maze-gameplay--maze-story)
+-   [WordSearch](https://laverve.github.io/fusion/?path=/story/games-wordsearch-gameplay--word-search-story)
+-   [Spelling spree](https://laverve.github.io/fusion/?path=/story/games-spelling-spree-gameplay--spelling-spree)
+
+# Contribution guidelines
+
+You are encouraged to contribute to this project as soon as you see any defects or issues.
+
+## Code Editor Configuration
+
+This monorepo contains configuration for VSCode editor. It doesn't mean that you cannot use a different tool. Feel free to push configurations for your favourite code editor.
+
+## Commands
+
+1. To run tests use: `npm run test`
+2. To build monorepo use: `npm run build`
+3. To lint monorepo use: `npm run lint`
+4. To initialize pre-commit hooks use: `npm run prepare`
+5. To run storybook `npm run storybook`
+
+## Workflow
+
+Before you get started make sure that there is noone working on an issue you are going to address.
+
+As a first step, clone the repository and run `npm i && npm run prepare` command to install all dependencies and initialize pre-commit hooks.
+
+Create a branch to work on your code changes.
+
+Once you are done with coding, create pull request and get an approval.
+
+Lastly, enjoy your changes.
+
+# License
+
+This content is released under the ([http://opensource.org/licenses/MIT](http://opensource.org/licenses/MIT)) MIT License.

package/dist/src/assets-manager/AssetsManager.context.d.ts

@@ -0,0 +1,15 @@
+import { Texture } from "pixi.js";
+export type Asset = {
+    src: string;
+    alias: string;
+};
+export type AssetsManagerContextValue = {
+    isFetching: boolean;
+    isFetched: boolean;
+    isError: boolean;
+    error?: unknown;
+    load: (groupId: string, asset: Asset[]) => Promise<void>;
+    unload: (groupIdOrAlias: string) => void;
+    getAsset: (alias: string) => Texture | undefined;
+};
+export declare const AssetsManagerContext: import("react").Context<AssetsManagerContextValue>;

package/dist/src/assets-manager/AssetsManager.context.js

@@ -0,0 +1,6 @@
+import { createContext } from "react";
+export const AssetsManagerContext = createContext({
+    isFetching: false,
+    isFetched: false,
+    isError: false
+});

package/dist/src/assets-manager/AssetsManager.d.ts

@@ -0,0 +1,2 @@
+import React, { PropsWithChildren } from "react";
+export declare const AssetsManager: React.FC<PropsWithChildren>;

package/dist/src/assets-manager/AssetsManager.js

@@ -0,0 +1,43 @@
+import React, { useCallback, useEffect, useMemo, useState } from "react";
+import { AssetsManagerContext } from "./AssetsManager.context";
+import { Assets } from "pixi.js";
+export const AssetsManager = ({ children }) => {
+    const [isFetching, setIsFetching] = useState(false);
+    const [isFetched, setIsFetched] = useState(false);
+    const [isError, setIsError] = useState(false);
+    const [error, setError] = useState();
+    useEffect(() => {
+        Assets.cache.reset();
+    }, []);
+    const load = useCallback(async (groupId, localAsset) => {
+        try {
+            Assets.addBundle(groupId, localAsset);
+            await Assets.loadBundle(groupId);
+            setIsFetched(true);
+        }
+        catch (e) {
+            setIsError(true);
+            setIsFetched(false);
+            setError(e);
+        }
+        finally {
+            setIsFetching(false);
+        }
+    }, [isFetching, isError, isFetched, error]);
+    const unload = useCallback((groupId) => {
+        Assets.unloadBundle(groupId);
+    }, []);
+    const getAsset = useCallback((alias) => {
+        return Assets.get(alias);
+    }, []);
+    const conextValue = useMemo(() => ({
+        load,
+        unload,
+        getAsset,
+        isFetching,
+        isFetched,
+        isError,
+        error
+    }), [load, unload, getAsset, isFetching, isFetched, isError, error]);
+    return React.createElement(AssetsManagerContext.Provider, { value: conextValue }, children);
+};

package/dist/src/assets-manager/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./AssetsManager";
+export * from "./AssetsManager.context";
+export * from "./useAssetManager";

package/dist/src/assets-manager/index.js

@@ -0,0 +1,3 @@
+export * from "./AssetsManager";
+export * from "./AssetsManager.context";
+export * from "./useAssetManager";

package/dist/src/assets-manager/useAssetManager.d.ts

@@ -0,0 +1 @@
+export declare const useAssetManager: () => import("./AssetsManager.context").AssetsManagerContextValue;

package/dist/src/assets-manager/useAssetManager.js

@@ -0,0 +1,5 @@
+import { useContext } from "react";
+import { AssetsManagerContext } from "./AssetsManager.context";
+export const useAssetManager = () => {
+    return useContext(AssetsManagerContext);
+};

package/dist/src/camera/Camera.context.d.ts

@@ -0,0 +1,13 @@
+import { Container } from "pixi.js";
+export type EnsureVisibleOptions = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    resizeToFit?: boolean;
+};
+export type CameraContextValue = {
+    follow: (object: Container) => void;
+    ensureVisible: (options: EnsureVisibleOptions) => void;
+};
+export declare const CameraContext: import("react").Context<CameraContextValue>;

package/dist/src/camera/Camera.context.js

@@ -0,0 +1,2 @@
+import { createContext } from "react";
+export const CameraContext = createContext({});

package/dist/src/camera/Camera.d.ts

@@ -0,0 +1,7 @@
+import React, { PropsWithChildren } from "react";
+import { Viewport as ViewportContainer } from "pixi-viewport";
+type CameraProps = {
+    clampZoom?: Parameters<ViewportContainer["clampZoom"]>[0];
+};
+export declare const Camera: React.FC<CameraProps & PropsWithChildren>;
+export {};

package/dist/src/camera/Camera.js

@@ -0,0 +1,99 @@
+import React, { useCallback, useEffect, useMemo, useState } from "react";
+import { Viewport as ViewportContainer } from "pixi-viewport";
+import { Layer } from "../layer";
+import { useStage, useWorld } from "../hooks";
+import { LayerContext } from "../layer/Layer.context";
+import { CameraContext } from "./Camera.context";
+export const Camera = ({ children, clampZoom }) => {
+    const [isReady, setIsReady] = useState(false);
+    const [followContainer, setFollowContainer] = useState(null);
+    const [ensureVisibleOptions, setEnsureVisibleOptions] = useState(null);
+    const { application, isInitialized, size } = useWorld();
+    const { addObject: addObjectToStage, removeObject: removeObjectFromStage } = useStage();
+    const [things, setThings] = useState([]);
+    const viewport = useMemo(() => isInitialized
+        ? new ViewportContainer({
+            worldHeight: size.height,
+            worldWidth: size.width,
+            screenHeight: application.canvas.height,
+            screenWidth: application.canvas.width,
+            events: application?.renderer?.events
+        })
+        : null, [size, application, isInitialized]);
+    const addObject = useCallback((thing) => {
+        setThings((oldThings) => [...oldThings, thing]);
+    }, [things]);
+    const removeObject = useCallback((thing) => {
+        setThings((oldThings) => oldThings.filter(({ uid }) => uid === thing.uid));
+    }, [application]);
+    const conextValue = useMemo(() => ({
+        addObject,
+        removeObject
+    }), [addObject, removeObject]);
+    useEffect(() => {
+        if (viewport && clampZoom) {
+            viewport.clampZoom(clampZoom);
+        }
+    }, [clampZoom, isInitialized]);
+    useEffect(() => {
+        if (viewport) {
+            if (size.width) {
+                viewport.width = size.width;
+            }
+            if (size.height) {
+                viewport.height = size.height;
+            }
+        }
+    }, [size, viewport?.uid, isInitialized]);
+    useEffect(() => {
+        if (!isInitialized || !viewport) {
+            return;
+        }
+        viewport?.moveCenter(0, 0);
+    }, [viewport, size, isInitialized]);
+    useEffect(() => {
+        if (!viewport) {
+            return;
+        }
+        addObjectToStage(viewport);
+        setIsReady(true);
+        return () => {
+            removeObjectFromStage(viewport);
+            setIsReady(false);
+        };
+    }, [application, isInitialized]);
+    useEffect(() => {
+        if (!viewport || !isReady) {
+            return;
+        }
+        viewport.addChild(...things);
+        return () => {
+            viewport.removeChild(...things);
+        };
+    }, [things, viewport, isReady]);
+    useEffect(() => {
+        if (isReady && viewport && followContainer) {
+            viewport.follow(followContainer, { radius: 300 });
+        }
+    }, [isReady, viewport, followContainer]);
+    useEffect(() => {
+        if (isReady && viewport && ensureVisibleOptions) {
+            viewport.ensureVisible(ensureVisibleOptions.x, ensureVisibleOptions.y, ensureVisibleOptions.width, ensureVisibleOptions.height, ensureVisibleOptions.resizeToFit);
+        }
+    }, [isReady, viewport, ensureVisibleOptions]);
+    const followCallback = useCallback((container) => {
+        setFollowContainer(container);
+    }, [followContainer]);
+    const ensureVisibleCallback = useCallback((options) => {
+        setEnsureVisibleOptions(options);
+    }, [followContainer]);
+    const value = useMemo(() => {
+        return {
+            follow: followCallback,
+            ensureVisible: ensureVisibleCallback
+        };
+    }, [followCallback]);
+    return (React.createElement(CameraContext.Provider, { value: value },
+        React.createElement(LayerContext.Provider, { value: conextValue },
+            React.createElement(Layer, null, children))));
+};

package/dist/src/camera/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Camera";
+export * from "./Camera.context";

package/dist/src/camera/index.js

@@ -0,0 +1,2 @@
+export * from "./Camera";
+export * from "./Camera.context";

package/dist/src/game-context/Game.context.d.ts

@@ -0,0 +1,39 @@
+import React, { PropsWithChildren } from "react";
+import { GameStatus } from "../types";
+export type GameContextValue = {
+    readonly reset: () => void;
+    readonly start: () => void;
+    readonly stop: () => void;
+    readonly timeout: number;
+    readonly status: GameStatus;
+    readonly startTime: number | null;
+    readonly endTime: number | null;
+};
+export type GameContextProviderEvents = {
+    onStart?: (event: {
+        startTime: number | null;
+        status: GameStatus;
+        endTime: number | null;
+    }) => unknown;
+    onStop?: (event: {
+        startTime: number | null;
+        status: GameStatus;
+        endTime: number | null;
+    }) => unknown;
+    onTimedOut?: (event: {
+        startTime: number | null;
+        status: GameStatus;
+        endTime: number | null;
+    }) => unknown;
+    onReset?: (event: {
+        startTime: number | null;
+        status: GameStatus;
+        endTime: number | null;
+    }) => unknown;
+};
+export declare const GameContext: React.Context<GameContextValue>;
+export type GameContextProviderProps = PropsWithChildren & {
+    timeout?: number;
+    events?: GameContextProviderEvents;
+};
+export declare const GameContextProvider: React.FC<GameContextProviderProps>;

package/dist/src/game-context/Game.context.js

@@ -0,0 +1,85 @@
+import React, { createContext, useMemo, useRef, useState } from "react";
+import { GameStatus } from "../types";
+export const GameContext = createContext({
+    reset: () => { },
+    start: () => { },
+    stop: () => { },
+    timeout: 0,
+    status: GameStatus.READY,
+    startTime: null,
+    endTime: null
+});
+export const GameContextProvider = ({ children, timeout: inputTimeout = 0, events }) => {
+    const timerRef = useRef();
+    const timeout = Math.max(0, inputTimeout);
+    const [status, setStatus] = useState(GameStatus.READY);
+    const [startTime, setStartTime] = useState(null);
+    const [endTime, setEndTime] = useState(null);
+    const onTimedOut = () => {
+        const newEndTime = +new Date();
+        const newStatus = GameStatus.TIMEDOUT;
+        setEndTime(newEndTime);
+        setStatus(GameStatus.TIMEDOUT);
+        events?.onTimedOut?.({
+            startTime,
+            endTime: newEndTime,
+            status: newStatus
+        });
+    };
+    const start = () => {
+        const newStartTime = +new Date();
+        const newStatus = GameStatus.IN_PROGRESS;
+        const newEndTime = null;
+        setStatus(newStatus);
+        setStartTime(newStartTime);
+        setEndTime(newEndTime);
+        if (timeout !== 0) {
+            timerRef.current = setTimeout(() => {
+                onTimedOut();
+            }, timeout * 1000);
+        }
+        events?.onStart?.({
+            startTime: newStartTime,
+            endTime: newEndTime,
+            status: newStatus
+        });
+    };
+    const reset = () => {
+        const newStartTime = null;
+        const newStatus = GameStatus.READY;
+        const newEndTime = null;
+        setStatus(newStatus);
+        setStartTime(newStartTime);
+        setEndTime(newEndTime);
+        if (timerRef.current) {
+            clearTimeout(timerRef.current);
+        }
+        events?.onReset?.({
+            startTime: newStartTime,
+            endTime: newEndTime,
+            status: newStatus
+        });
+    };
+    const stop = () => {
+        const newStatus = GameStatus.COMPLETED;
+        const newEndTime = +new Date();
+        clearTimeout(timerRef.current);
+        setEndTime(+new Date());
+        setStatus(GameStatus.COMPLETED);
+        events?.onStop?.({
+            startTime,
+            endTime: newEndTime,
+            status: newStatus
+        });
+    };
+    const contextValue = useMemo(() => ({
+        status,
+        startTime,
+        endTime,
+        timeout,
+        stop,
+        start,
+        reset
+    }), [timeout, status, startTime, endTime]);
+    return React.createElement(GameContext.Provider, { value: contextValue }, children);
+};

package/dist/src/game-context/index.d.ts

@@ -0,0 +1 @@
+export * from "./Game.context";

package/dist/src/game-context/index.js

@@ -0,0 +1 @@
+export * from "./Game.context";

package/dist/src/game-objects/GameObjectPhysicalObjectConfig.d.ts

@@ -0,0 +1,4 @@
+import { IBodyDefinition } from "matter-js";
+type PhysicalObjectConfig = Pick<IBodyDefinition, "vertices" | "label" | "inertia" | "position" | "friction" | "frictionAir" | "frictionStatic" | "parts" | "isStatic" | "isSensor" | "collisionFilter">;
+export type GameObjectPhysicalObjectConfig = PhysicalObjectConfig;
+export {};

package/dist/src/game-objects/GameObjectPhysicalObjectConfig.js

@@ -0,0 +1 @@
+export {};

package/dist/src/game-objects/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./usePhysicalObject";
+export * from "./useWalls";

package/dist/src/game-objects/index.js

@@ -0,0 +1,2 @@
+export * from "./usePhysicalObject";
+export * from "./useWalls";

package/dist/src/game-objects/usePhysicalObject.d.ts

@@ -0,0 +1,7 @@
+import { Body, Composite } from "matter-js";
+import { Nullable } from "../types";
+export declare const usePhysicalObject: ({ physicalObject }: {
+    physicalObject: Nullable<Body | Composite>;
+}) => {
+    physicalObject: Nullable<Body | Composite>;
+};

package/dist/src/game-objects/usePhysicalObject.js

@@ -0,0 +1,17 @@
+import { useContext, useEffect } from "react";
+import { MatterPhysicsContext } from "../physics";
+export const usePhysicalObject = ({ physicalObject }) => {
+    const { addBody, removeBody } = useContext(MatterPhysicsContext);
+    useEffect(() => {
+        if (!physicalObject) {
+            return () => { };
+        }
+        addBody(physicalObject);
+        return () => {
+            removeBody(physicalObject);
+        };
+    }, [physicalObject?.id]);
+    return {
+        physicalObject
+    };
+};

package/dist/src/game-objects/usePhysicalObjectFromConfig.d.ts

@@ -0,0 +1,6 @@
+import { Body } from "matter-js";
+import { GameObjectPhysicalObjectConfig } from "./GameObjectPhysicalObjectConfig";
+import { Nullable } from "../types";
+export declare const usePhysicalObjectFromConfig: <PhysicalObjectType extends Nullable<Body> = Body>({ position, ...physicalObjectConfig }: GameObjectPhysicalObjectConfig) => {
+    physicalObject: PhysicalObjectType;
+};

package/dist/src/game-objects/usePhysicalObjectFromConfig.js

@@ -0,0 +1,13 @@
+import { Body } from "matter-js";
+import { useMemo } from "react";
+import { usePhysicalObject } from "./usePhysicalObject";
+export const usePhysicalObjectFromConfig = ({ position = { x: 0, y: 0 }, ...physicalObjectConfig }) => {
+    const physicalObject = useMemo(() => {
+        if (physicalObjectConfig) {
+            return Body.create({ position, ...physicalObjectConfig });
+        }
+        return null;
+    }, []);
+    usePhysicalObject({ physicalObject });
+    return { physicalObject };
+};

package/dist/src/game-objects/useWalls.d.ts

@@ -0,0 +1,11 @@
+type WallOptions = {
+    thikness: number;
+};
+type UseWallsOptions = {
+    left?: Partial<WallOptions> | boolean;
+    right?: Partial<WallOptions> | boolean;
+    top?: Partial<WallOptions> | boolean;
+    bottom?: Partial<WallOptions> | boolean;
+};
+export declare const useWalls: ({ left, right, top, bottom }?: UseWallsOptions) => void;
+export {};

package/dist/src/game-objects/useWalls.js

@@ -0,0 +1,59 @@
+import { useContext, useEffect, useMemo } from "react";
+import { Bodies, Composite } from "matter-js";
+import { MatterPhysicsContext } from "../physics/MatterPhysics.context";
+const DEFAULT_WALL_CONFIG = {
+    thikness: 10
+};
+export const useWalls = ({ left = true, right = true, top = true, bottom = true } = {}) => {
+    const { config } = useContext(MatterPhysicsContext);
+    const { height, width } = config.world;
+    const center = {
+        x: width / 2,
+        y: height / 2
+    };
+    const { addBody, removeBody } = useContext(MatterPhysicsContext);
+    const body = useMemo(() => {
+        const walls = Composite.create();
+        const parts = [];
+        if (left) {
+            const leftWallConfig = Object.assign(DEFAULT_WALL_CONFIG, typeof left === "boolean" ? {} : { ...left });
+            const leftWallPosition = { x: 0, y: center.y };
+            parts.push(Bodies.rectangle(leftWallPosition.x, leftWallPosition.y, leftWallConfig.thikness, height, {
+                isStatic: true,
+                label: "left-wall"
+            }));
+        }
+        if (right) {
+            const rightWallConfig = Object.assign(DEFAULT_WALL_CONFIG, typeof right === "boolean" ? {} : { ...right });
+            const rightWallPosition = { x: width, y: center.y };
+            parts.push(Bodies.rectangle(rightWallPosition.x, rightWallPosition.y, rightWallConfig.thikness, height, {
+                isStatic: true,
+                label: "right-wall"
+            }));
+        }
+        if (top) {
+            const topWallConfig = Object.assign(DEFAULT_WALL_CONFIG, typeof top === "boolean" ? {} : { ...top });
+            const topWallPosition = { x: center.x, y: 0 };
+            parts.push(Bodies.rectangle(topWallPosition.x, topWallPosition.y, width, topWallConfig.thikness, {
+                isStatic: true,
+                label: "top-wall"
+            }));
+        }
+        if (bottom) {
+            const bottomWallConfig = Object.assign(DEFAULT_WALL_CONFIG, typeof bottom === "boolean" ? {} : { ...bottom });
+            const bottomWallPosition = { x: center.x, y: height };
+            parts.push(Bodies.rectangle(bottomWallPosition.x, bottomWallPosition.y, width, bottomWallConfig.thikness, {
+                isStatic: true,
+                label: "bottom-wall"
+            }));
+        }
+        Composite.add(walls, parts);
+        return walls;
+    }, [width, height]);
+    useEffect(() => {
+        addBody(body);
+        return () => {
+            removeBody(body);
+        };
+    }, [body.id]);
+};

package/dist/src/hooks/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./useGlobalEventHandler";
+export * from "./useStage";
+export * from "./useTickerCallback";
+export * from "./useWorld";
+export * from "./useLayerContext";
+export * from "./useSprite";
+export * from "./useAnimatedSprite";
+export * from "./useTexture";
+export * from "./useGame";
+export * from "./useTilingSprite";
+export * from "./useCamera";
+export * from "./useCollisionDetection";

package/dist/src/hooks/index.js

@@ -0,0 +1,12 @@
+export * from "./useGlobalEventHandler";
+export * from "./useStage";
+export * from "./useTickerCallback";
+export * from "./useWorld";
+export * from "./useLayerContext";
+export * from "./useSprite";
+export * from "./useAnimatedSprite";
+export * from "./useTexture";
+export * from "./useGame";
+export * from "./useTilingSprite";
+export * from "./useCamera";
+export * from "./useCollisionDetection";