@almadar/ui 5.79.1 → 5.79.2

package/dist/components/game/shared/game.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Game Types — Generalized
+ *
+ * Core type definitions for tactical game state.
+ * Extracted from Trait Wars and generalized for any game project.
+ */
+export interface Position {
+    x: number;
+    y: number;
+}
+export interface GameUnit {
+    id: string;
+    name: string;
+    characterType: string;
+    team: 'player' | 'enemy' | 'neutral';
+    position: Position;
+    health: number;
+    maxHealth: number;
+    movement: number;
+    attack: number;
+    defense: number;
+    traits: UnitTrait[];
+}
+export interface UnitTrait {
+    name: string;
+    currentState: string;
+    states: string[];
+    cooldown: number;
+}
+export interface BoardTile {
+    terrain: string;
+    unitId?: string;
+    isBlocked?: boolean;
+}
+export type GamePhase = 'observation' | 'planning' | 'execution' | 'tick';
+export interface GameState {
+    board: BoardTile[][];
+    units: Record<string, GameUnit>;
+    currentPhase: GamePhase;
+    currentTurn: number;
+    activeTeam: 'player' | 'enemy' | 'neutral';
+    selectedUnitId?: string;
+    validMoves: Position[];
+    attackTargets: Position[];
+}
+export type GameAction = {
+    type: 'SELECT_UNIT';
+    unitId: string;
+} | {
+    type: 'MOVE_UNIT';
+    from: Position;
+    to: Position;
+} | {
+    type: 'ATTACK';
+    attackerId: string;
+    targetId: string;
+} | {
+    type: 'END_TURN';
+} | {
+    type: 'EXECUTE_TRAITS';
+};
+/**
+ * Create the initial game state with board and units.
+ *
+ * @param {number} width - Board width in tiles
+ * @param {number} height - Board height in tiles
+ * @param {GameUnit[]} units - Initial units to place on the board
+ * @param {string} [defaultTerrain] - Default terrain type for empty tiles
+ * @returns {GameState} The initialized game state
+ */
+export declare function createInitialGameState(width: number, height: number, units: GameUnit[], defaultTerrain?: string): GameState;
+/**
+ * Calculate valid movement positions for a unit.
+ *
+ * Returns all tiles within the unit's movement range that are
+ * not blocked and don't contain other units.
+ *
+ * @param {GameState} state - Current game state
+ * @param {string} unitId - ID of the unit to calculate moves for
+ * @returns {Position[]} Array of valid move positions
+ */
+export declare function calculateValidMoves(state: GameState, unitId: string): Position[];
+/**
+ * Calculate valid attack targets for a unit.
+ *
+ * Returns adjacent positions containing enemy units that can be attacked.
+ *
+ * @param {GameState} state - Current game state
+ * @param {string} unitId - ID of the unit to calculate targets for
+ * @returns {Position[]} Array of valid attack target positions
+ */
+export declare function calculateAttackTargets(state: GameState, unitId: string): Position[];

package/dist/components/game/shared/hooks/useAssetLoader.d.ts

@@ -0,0 +1,58 @@
+import * as THREE from 'three';
+import { AssetLoader, LoadedModel } from '../lib/AssetLoader';
+export interface UseAssetLoaderOptions {
+    /** URLs to preload on mount */
+    preloadUrls?: string[];
+    /** Asset loader instance (uses singleton if not provided) */
+    loader?: AssetLoader;
+}
+export interface AssetLoadingState {
+    /** Whether assets are currently loading */
+    isLoading: boolean;
+    /** Loading progress (0-100) */
+    progress: number;
+    /** Number of loaded assets */
+    loaded: number;
+    /** Total assets to load */
+    total: number;
+    /** Any loading errors */
+    errors: string[];
+}
+export interface UseAssetLoaderReturn extends AssetLoadingState {
+    /** Load a single model */
+    loadModel: (url: string) => Promise<LoadedModel>;
+    /** Load a single OBJ model */
+    loadOBJ: (url: string) => Promise<THREE.Group>;
+    /** Load a single texture */
+    loadTexture: (url: string) => Promise<THREE.Texture>;
+    /** Preload multiple assets */
+    preload: (urls: string[]) => Promise<void>;
+    /** Check if model is cached */
+    hasModel: (url: string) => boolean;
+    /** Check if texture is cached */
+    hasTexture: (url: string) => boolean;
+    /** Get cached model */
+    getModel: (url: string) => LoadedModel | undefined;
+    /** Get cached texture */
+    getTexture: (url: string) => THREE.Texture | undefined;
+    /** Clear all caches */
+    clearCache: () => void;
+}
+/**
+ * Hook for managing 3D asset loading in React components
+ *
+ * @example
+ * ```tsx
+ * const { loadModel, isLoading, progress } = useAssetLoader({
+ *     preloadUrls: ['/assets/model.glb']
+ * });
+ *
+ * useEffect(() => {
+ *     loadModel('/assets/character.glb').then((model) => {
+ *         scene.add(model.scene);
+ *     });
+ * }, []);
+ * ```
+ */
+export declare function useAssetLoader(options?: UseAssetLoaderOptions): UseAssetLoaderReturn;
+export default useAssetLoader;

package/dist/components/game/shared/hooks/useBattleState.d.ts

@@ -0,0 +1,47 @@
+import type { EventEmit, EntityRow } from '@almadar/core';
+import type { BattlePhase } from '../../2d/organisms/BattleBoard';
+export interface BattleStateEventConfig {
+    tileClickEvent?: EventEmit<{
+        x: number;
+        y: number;
+    }>;
+    unitClickEvent?: EventEmit<{
+        unitId: string;
+    }>;
+    endTurnEvent?: EventEmit<Record<string, never>>;
+    cancelEvent?: EventEmit<Record<string, never>>;
+    gameEndEvent?: EventEmit<{
+        result: 'victory' | 'defeat';
+    }>;
+    playAgainEvent?: EventEmit<Record<string, never>>;
+    attackEvent?: EventEmit<{
+        attackerId: string;
+        targetId: string;
+        damage: number;
+    }>;
+}
+export interface BattleStateCallbacks {
+    /** Called when a unit attacks another */
+    onAttack?: (attacker: EntityRow, target: EntityRow, damage: number) => void;
+    /** Called when battle ends */
+    onGameEnd?: (result: 'victory' | 'defeat') => void;
+    /** Called after a unit moves */
+    onUnitMove?: (unit: EntityRow, to: {
+        x: number;
+        y: number;
+    }) => void;
+    /** Custom combat damage calculator */
+    calculateDamage?: (attacker: EntityRow, target: EntityRow) => number;
+}
+export interface BattleStateResult {
+    units: EntityRow[];
+    selectedUnitId: string | null;
+    phase: BattlePhase;
+    turn: number;
+    gameResult: 'victory' | 'defeat' | null;
+    handleTileClick: (x: number, y: number) => void;
+    handleUnitClick: (unitId: string) => void;
+    handleEndTurn: () => void;
+    handleRestart: () => void;
+}
+export declare function useBattleState(initialUnits: EntityRow[], eventConfig?: BattleStateEventConfig, callbacks?: BattleStateCallbacks): BattleStateResult;

package/dist/components/game/shared/hooks/useCamera.d.ts

@@ -0,0 +1,57 @@
+import type { CameraState } from '../isometricTypes';
+interface CameraResult {
+    /** Mutable camera state ref (x, y, zoom) */
+    cameraRef: React.MutableRefObject<CameraState>;
+    /** Target camera position for smooth lerp centering. Set to null when reached. */
+    targetCameraRef: React.MutableRefObject<{
+        x: number;
+        y: number;
+    } | null>;
+    /** Whether the user is currently dragging */
+    isDragging: () => boolean;
+    /** Total drag distance — used to distinguish click from pan (threshold: 5px) */
+    dragDistance: () => number;
+    /** Mouse down handler — starts panning */
+    handleMouseDown: (e: React.MouseEvent) => void;
+    /** Mouse up handler — stops panning */
+    handleMouseUp: () => void;
+    /** Mouse move handler — pans camera if dragging, returns true if panning */
+    handleMouseMove: (e: React.MouseEvent, drawFn?: () => void) => boolean;
+    /** Mouse leave handler — cancels drag */
+    handleMouseLeave: () => void;
+    /** Wheel handler — zoom in/out */
+    handleWheel: (e: React.WheelEvent, drawFn?: () => void) => void;
+    /** Pointer down — starts panning (mouse/touch/pen via Pointer Events). */
+    handlePointerDown: (e: React.PointerEvent) => void;
+    /** Pointer up — stops panning. */
+    handlePointerUp: () => void;
+    /** Pointer move — pans camera if dragging, returns true if panning. */
+    handlePointerMove: (e: React.PointerEvent, drawFn?: () => void) => boolean;
+    /** Apply a two-finger pan delta (screen px) directly to the camera. */
+    panBy: (dx: number, dy: number, drawFn?: () => void) => void;
+    /**
+     * Multiplicative zoom by `factor` keeping the world point under (centerX,centerY)
+     * — screen px relative to the canvas — fixed. Used by wheel + pinch.
+     */
+    zoomAtPoint: (factor: number, centerX: number, centerY: number, viewportSize: {
+        width: number;
+        height: number;
+    }, drawFn?: () => void) => void;
+    /** Convert screen coordinates to world coordinates (inverse camera transform) */
+    screenToWorld: (clientX: number, clientY: number, canvas: HTMLCanvasElement, viewportSize: {
+        width: number;
+        height: number;
+    }) => {
+        x: number;
+        y: number;
+    };
+    /** Lerp camera toward target. Call in animation loop. Returns true if still animating. */
+    lerpToTarget: (t?: number) => boolean;
+}
+/**
+ * Camera hook for pan/zoom canvas rendering.
+ *
+ * @returns Camera state, event handlers, and coordinate conversion
+ */
+export declare function useCamera(): CameraResult;
+export {};

package/dist/components/game/shared/hooks/useCanvasEffects.d.ts

@@ -0,0 +1,27 @@
+import type { AssetUrl } from '@almadar/core';
+import type { CombatActionType, EffectAssetManifest } from '../effects';
+export interface UseCanvasEffectsOptions {
+    /** Effect asset manifest (baseUrl + particles + animations) */
+    manifest: EffectAssetManifest;
+}
+export interface UseCanvasEffectsResult {
+    /** All effect sprite URLs for preloading via useImageCache */
+    effectSpriteUrls: AssetUrl[];
+    /** Spawn a combat effect at the given screen position */
+    spawnEffect: (type: CombatActionType, screenX: number, screenY: number) => void;
+    /** Draw all active effects — call inside draw() after units, before ctx.restore() */
+    drawEffects: (ctx: CanvasRenderingContext2D, animTime: number, getImage: (url: string) => HTMLImageElement | undefined) => void;
+    /** Whether there are active effects (keeps RAF alive) */
+    hasActiveEffects: boolean;
+    /** Screen shake offset to apply to container transform */
+    screenShake: {
+        x: number;
+        y: number;
+    };
+    /** Screen flash overlay (null = no flash) */
+    screenFlash: {
+        color: string;
+        alpha: number;
+    } | null;
+}
+export declare function useCanvasEffects({ manifest, }: UseCanvasEffectsOptions): UseCanvasEffectsResult;

package/dist/components/game/shared/hooks/useGameAudio.d.ts

@@ -0,0 +1,47 @@
+export interface SoundEntry {
+    /** Single path or array of paths — array picks randomly on each play */
+    path: string | string[];
+    /** Volume 0–1 (multiplied by masterVolume; default 1) */
+    volume?: number;
+    /** Whether this sound loops (background music) */
+    loop?: boolean;
+    /** Number of concurrent Audio instances in the pool (default 1) */
+    poolSize?: number;
+    /** Start automatically on first user interaction */
+    autostart?: boolean;
+    /** Use crossfade transitions when played via playMusic() */
+    crossfade?: boolean;
+    /** Crossfade duration in ms (default 1500) */
+    crossfadeDurationMs?: number;
+}
+export type AudioManifest = Record<string, SoundEntry>;
+export interface GameAudioControls {
+    /** Play a sound effect (instant, pooled) */
+    play: (key: string) => void;
+    /** Stop all instances of a sound effect */
+    stop: (key: string) => void;
+    /** Stop all sounds including music */
+    stopAll: () => void;
+    /** Crossfade to a new music track */
+    playMusic: (key: string) => void;
+    /** Fade out and stop the current music */
+    stopMusic: (fadeDurationMs?: number) => void;
+    muted: boolean;
+    setMuted: (muted: boolean) => void;
+    masterVolume: number;
+    setMasterVolume: (volume: number) => void;
+}
+export interface UseGameAudioOptions {
+    /** Sound definitions keyed by logical name */
+    manifest: AudioManifest;
+    /** Prefix prepended to all `path` values (default '') */
+    baseUrl?: string;
+    /** Start muted (default false) */
+    initialMuted?: boolean;
+    /** Master volume 0–1 (default 1) */
+    initialVolume?: number;
+}
+export declare function useGameAudio({ manifest, baseUrl, initialMuted, initialVolume, }: UseGameAudioOptions): GameAudioControls;
+export declare namespace useGameAudio {
+    var displayName: string;
+}

package/dist/components/game/shared/hooks/useGameCanvas3DEvents.d.ts

@@ -0,0 +1,123 @@
+import type { EventEmit } from '@almadar/core';
+import type { IsometricTile, IsometricUnit, IsometricFeature } from '../isometricTypes';
+export interface GameCanvas3DEventConfig {
+    /** Event name for tile clicks */
+    tileClickEvent?: EventEmit<{
+        tileId: string;
+        x: number;
+        z: number;
+        type?: string;
+        terrain?: string;
+        elevation?: number;
+    }>;
+    /** Event name for unit clicks */
+    unitClickEvent?: EventEmit<{
+        unitId: string;
+        x: number;
+        z: number;
+        unitType?: string;
+        name?: string;
+        team?: string;
+        faction?: string;
+        health?: number;
+        maxHealth?: number;
+    }>;
+    /** Event name for feature clicks */
+    featureClickEvent?: EventEmit<{
+        featureId: string;
+        x: number;
+        z: number;
+        type?: string;
+        elevation?: number;
+    }>;
+    /** Event name for canvas clicks */
+    canvasClickEvent?: EventEmit<{
+        clientX: number;
+        clientY: number;
+        button: number;
+    }>;
+    /** Event name for tile hover */
+    tileHoverEvent?: EventEmit<{
+        tileId: string;
+        x: number;
+        z: number;
+        type?: string;
+    }>;
+    /** Event name for tile leave */
+    tileLeaveEvent?: EventEmit<Record<string, never>>;
+    /** Event name for unit animation changes */
+    unitAnimationEvent?: EventEmit<{
+        unitId: string;
+        state: string;
+        timestamp: number;
+    }>;
+    /** Event name for camera changes */
+    cameraChangeEvent?: EventEmit<{
+        position: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        timestamp: number;
+    }>;
+}
+/** Minimal mouse event interface — satisfied by both React.MouseEvent and ThreeEvent<MouseEvent> */
+export interface MinimalMouseEvent {
+    clientX: number;
+    clientY: number;
+    button: number;
+}
+export interface UseGameCanvas3DEventsOptions extends GameCanvas3DEventConfig {
+    /** Callback for tile clicks (direct) */
+    onTileClick?: (tile: IsometricTile, event: MinimalMouseEvent) => void;
+    /** Callback for unit clicks (direct) */
+    onUnitClick?: (unit: IsometricUnit, event: MinimalMouseEvent) => void;
+    /** Callback for feature clicks (direct) */
+    onFeatureClick?: (feature: IsometricFeature, event: MinimalMouseEvent) => void;
+    /** Callback for canvas clicks (direct) */
+    onCanvasClick?: (event: MinimalMouseEvent) => void;
+    /** Callback for tile hover (direct) */
+    onTileHover?: (tile: IsometricTile | null, event: MinimalMouseEvent) => void;
+    /** Callback for unit animation changes (direct) */
+    onUnitAnimation?: (unitId: string, state: string) => void;
+}
+export interface UseGameCanvas3DEventsReturn {
+    /** Handle tile click - emits event and calls callback */
+    handleTileClick: (tile: IsometricTile, event: MinimalMouseEvent) => void;
+    /** Handle unit click - emits event and calls callback */
+    handleUnitClick: (unit: IsometricUnit, event: MinimalMouseEvent) => void;
+    /** Handle feature click - emits event and calls callback */
+    handleFeatureClick: (feature: IsometricFeature, event: MinimalMouseEvent) => void;
+    /** Handle canvas click - emits event and calls callback */
+    handleCanvasClick: (event: MinimalMouseEvent) => void;
+    /** Handle tile hover - emits event and calls callback */
+    handleTileHover: (tile: IsometricTile | null, event: MinimalMouseEvent) => void;
+    /** Handle unit animation - emits event and calls callback */
+    handleUnitAnimation: (unitId: string, state: string) => void;
+    /** Handle camera change - emits event */
+    handleCameraChange: (position: {
+        x: number;
+        y: number;
+        z: number;
+    }) => void;
+}
+/**
+ * Hook for integrating GameCanvas3D with the event bus
+ *
+ * Supports both declarative event props (tileClickEvent) and
+ * direct callback props (onTileClick).
+ *
+ * @example
+ * ```tsx
+ * const events = useGameCanvas3DEvents({
+ *     tileClickEvent: 'TILE_SELECTED',
+ *     unitClickEvent: 'UNIT_SELECTED',
+ *     onTileClick: (tile) => console.log('Tile:', tile)
+ * });
+ *
+ * // In component:
+ * <TileRenderer onTileClick={events.handleTileClick} />
+ * ```
+ */
+export declare function useGameCanvas3DEvents(options: UseGameCanvas3DEventsOptions): UseGameCanvas3DEventsReturn;
+export default useGameCanvas3DEvents;

package/dist/components/game/shared/hooks/useRaycaster.d.ts

@@ -0,0 +1,86 @@
+import * as THREE from 'three';
+export interface RaycastHit {
+    /** Intersected object */
+    object: THREE.Object3D;
+    /** Intersection point */
+    point: THREE.Vector3;
+    /** Distance from camera */
+    distance: number;
+    /** UV coordinates (if available) */
+    uv?: THREE.Vector2;
+    /** Face normal */
+    face?: THREE.Face;
+    /** Face index */
+    faceIndex?: number;
+    /** Instance ID (for instanced meshes) */
+    instanceId?: number;
+}
+export interface GridHit {
+    /** Grid X coordinate */
+    gridX: number;
+    /** Grid Z coordinate */
+    gridZ: number;
+    /** World position */
+    worldPosition: THREE.Vector3;
+    /** Intersected object type */
+    objectType?: 'tile' | 'unit' | 'feature';
+    /** Object ID if available */
+    objectId?: string;
+}
+export interface UseRaycasterOptions {
+    /** Camera reference */
+    camera: THREE.Camera | null;
+    /** Canvas element for coordinate conversion */
+    canvas: HTMLCanvasElement | null;
+    /** Grid cell size */
+    cellSize?: number;
+    /** Grid offset X */
+    offsetX?: number;
+    /** Grid offset Z */
+    offsetZ?: number;
+}
+export interface UseRaycasterReturn {
+    /** Raycaster instance */
+    raycaster: React.MutableRefObject<THREE.Raycaster>;
+    /** Mouse vector instance */
+    mouse: React.MutableRefObject<THREE.Vector2>;
+    /** Get intersection at client coordinates */
+    getIntersection: (clientX: number, clientY: number, objects: THREE.Object3D[]) => RaycastHit | null;
+    /** Get all intersections at client coordinates */
+    getAllIntersections: (clientX: number, clientY: number, objects: THREE.Object3D[]) => RaycastHit[];
+    /** Get grid coordinates at client position */
+    getGridCoordinates: (clientX: number, clientY: number) => {
+        x: number;
+        z: number;
+    } | null;
+    /** Get tile at client position from scene */
+    getTileAtPosition: (clientX: number, clientY: number, scene: THREE.Scene) => GridHit | null;
+    /** Convert client coordinates to normalized device coordinates */
+    clientToNDC: (clientX: number, clientY: number) => {
+        x: number;
+        y: number;
+    };
+    /** Check if point is within canvas bounds */
+    isWithinCanvas: (clientX: number, clientY: number) => boolean;
+}
+/**
+ * Hook for 3D raycasting operations
+ *
+ * @example
+ * ```tsx
+ * const { getIntersection, getGridCoordinates } = useRaycaster({
+ *     camera,
+ *     canvas: canvasRef.current
+ * });
+ *
+ * const handleClick = (e: MouseEvent) => {
+ *     const hit = getIntersection(e.clientX, e.clientY, tileMeshes);
+ *     if (hit) {
+ *         const grid = getGridCoordinates(e.clientX, e.clientY);
+ *         console.log('Clicked grid:', grid);
+ *     }
+ * };
+ * ```
+ */
+export declare function useRaycaster(options: UseRaycasterOptions): UseRaycasterReturn;
+export default useRaycaster;

package/dist/components/game/shared/hooks/useSceneGraph.d.ts

@@ -0,0 +1,67 @@
+import * as THREE from 'three';
+import type { JsonObject } from '@almadar/core';
+export type NodeType = 'tile' | 'unit' | 'feature' | 'highlight' | 'effect';
+export interface SceneGraphNode {
+    /** Unique node identifier */
+    id: string;
+    /** Node type classification */
+    type: NodeType;
+    /** Three.js object */
+    mesh: THREE.Object3D;
+    /** World position */
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Grid position */
+    gridPosition: {
+        x: number;
+        z: number;
+    };
+    /** Optional metadata */
+    metadata?: JsonObject;
+}
+export interface UseSceneGraphReturn {
+    /** Reference to the nodes map */
+    nodesRef: React.MutableRefObject<Map<string, SceneGraphNode>>;
+    /** Add a node to the scene */
+    addNode: (node: SceneGraphNode) => void;
+    /** Remove a node from the scene */
+    removeNode: (id: string) => void;
+    /** Get a node by ID */
+    getNode: (id: string) => SceneGraphNode | undefined;
+    /** Update node position */
+    updateNodePosition: (id: string, x: number, y: number, z: number) => void;
+    /** Update node grid position */
+    updateNodeGridPosition: (id: string, gridX: number, gridZ: number) => void;
+    /** Get node at grid position */
+    getNodeAtGrid: (x: number, z: number, type?: NodeType) => SceneGraphNode | undefined;
+    /** Get all nodes of a specific type */
+    getNodesByType: (type: NodeType) => SceneGraphNode[];
+    /** Get all nodes within a bounding box */
+    getNodesInBounds: (minX: number, maxX: number, minZ: number, maxZ: number) => SceneGraphNode[];
+    /** Clear all nodes */
+    clearNodes: () => void;
+    /** Count nodes by type */
+    countNodes: (type?: NodeType) => number;
+}
+/**
+ * Hook for managing the 3D scene graph
+ *
+ * @example
+ * ```tsx
+ * const { addNode, removeNode, getNodeAtGrid } = useSceneGraph();
+ *
+ * // Add a tile
+ * addNode({
+ *     id: 'tile-0-0',
+ *     type: 'tile',
+ *     mesh: tileMesh,
+ *     position: { x: 0, y: 0, z: 0 },
+ *     gridPosition: { x: 0, z: 0 }
+ * });
+ * ```
+ */
+export declare function useSceneGraph(): UseSceneGraphReturn;
+export default useSceneGraph;

package/dist/components/game/shared/hooks/useThree.d.ts

@@ -0,0 +1,58 @@
+import * as THREE from 'three';
+import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js';
+import { AssetLoader } from '../lib/AssetLoader';
+export type CameraMode = 'isometric' | 'perspective' | 'top-down';
+export interface UseThreeOptions {
+    /** Camera mode for viewing the scene */
+    cameraMode?: CameraMode;
+    /** Initial camera position [x, y, z] */
+    cameraPosition?: [number, number, number];
+    /** Background color */
+    backgroundColor?: string;
+    /** Enable shadows */
+    shadows?: boolean;
+    /** Enable grid helper */
+    showGrid?: boolean;
+    /** Grid size */
+    gridSize?: number;
+    /** Asset loader instance */
+    assetLoader?: AssetLoader;
+}
+export interface UseThreeReturn {
+    /** Canvas element reference (for React Three Fiber) */
+    canvasRef: React.RefObject<HTMLCanvasElement | null>;
+    /** Three.js renderer */
+    renderer: THREE.WebGLRenderer | null;
+    /** Three.js scene */
+    scene: THREE.Scene | null;
+    /** Three.js camera */
+    camera: THREE.Camera | null;
+    /** Orbit controls */
+    controls: OrbitControls | null;
+    /** Is scene ready */
+    isReady: boolean;
+    /** Canvas dimensions */
+    dimensions: {
+        width: number;
+        height: number;
+    };
+    /** Set camera position */
+    setCameraPosition: (x: number, y: number, z: number) => void;
+    /** Look at a specific point */
+    lookAt: (x: number, y: number, z: number) => void;
+    /** Reset camera to initial position */
+    resetCamera: () => void;
+    /** Fit view to bounds */
+    fitView: (bounds: {
+        minX: number;
+        maxX: number;
+        minZ: number;
+        maxZ: number;
+    }) => void;
+}
+/**
+ * Hook for managing a Three.js scene
+ * This is a lower-level hook used by GameCanvas3D
+ */
+export declare function useThree(options?: UseThreeOptions): UseThreeReturn;
+export default useThree;