@plasius/renderer 1.0.0

package/dist/renderer.js

@@ -0,0 +1,165 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import * as THREE from "three/webgpu";
+import { Canvas, } from "@react-three/fiber";
+import { useRef, useEffect, Suspense } from "react";
+import { Html, useProgress } from "@react-three/drei";
+import { createXrManager } from "@plasius/gpu-xr";
+import { BsHeadsetVr } from "react-icons/bs";
+import { CgWebsite } from "react-icons/cg";
+import { RenderStore } from "./renderStateProvider.js";
+import styles from "./styles/renderer.module.css";
+import { Scene } from "./scene.js";
+import { Player } from "./player/player.js";
+import { AdaptiveDPR } from "./adaptivedpr.js";
+import { bindSessionToRenderer, rendererVrSessionInit, } from "./xr/rendererXrBridge.js";
+import { createRendererCameraManager, ManagedCameraController, } from "./camera/managedCameraController.js";
+function Loader() {
+    const { progress } = useProgress();
+    return _jsxs(Html, { center: true, children: [progress, " % loaded"] });
+}
+var Perf;
+(function (Perf) {
+    Perf[Perf["Low"] = 0] = "Low";
+    Perf[Perf["Medium"] = 1] = "Medium";
+    Perf[Perf["High"] = 2] = "High";
+    Perf[Perf["Ultra"] = 3] = "Ultra";
+})(Perf || (Perf = {}));
+function Renderer({ cameraPosition, cameraRotation, multiview = true, children, }) {
+    const canvasRef = useRef(null);
+    const sceneRef = useRef(null);
+    const rendererRef = useRef(null);
+    const xrManagerRef = useRef(null);
+    const cameraManagerRef = useRef(null);
+    const { useVR, cameraRigProfile } = RenderStore.useStore();
+    const dispatch = RenderStore.useDispatch();
+    if (!cameraManagerRef.current) {
+        cameraManagerRef.current = createRendererCameraManager({
+            maxParallelViews: multiview ? 2 : 1,
+            maxHotCameras: 3,
+        });
+    }
+    const cameraManager = cameraManagerRef.current;
+    useEffect(() => {
+        return () => {
+            cameraManager.clear();
+        };
+    }, [cameraManager]);
+    useEffect(() => {
+        const xrManager = createXrManager({
+            onSessionStart: (session) => {
+                void bindSessionToRenderer(rendererRef.current, session).catch(() => {
+                    dispatch({ type: "set_vr_mode", payload: false });
+                });
+            },
+            onSessionEnd: () => {
+                dispatch({ type: "set_vr_mode", payload: false });
+            },
+        });
+        xrManagerRef.current = xrManager;
+        void xrManager.probeSupport(["immersive-vr"]).catch(() => {
+            // Ignore probe failures; entering VR will surface actionable errors.
+        });
+        return () => {
+            const current = xrManagerRef.current;
+            xrManagerRef.current = null;
+            if (current) {
+                void current.dispose();
+            }
+        };
+    }, [dispatch]);
+    useEffect(() => {
+        const canvas = canvasRef.current;
+        const xrManager = xrManagerRef.current;
+        if (!canvas || !xrManager) {
+            return;
+        }
+        const fullscreenChangeHandler = () => {
+            if (!document.fullscreenElement) {
+                dispatch({ type: "set_vr_mode", payload: false });
+            }
+        };
+        const enterVRHandler = async () => {
+            try {
+                if (!document.fullscreenElement) {
+                    await canvas.requestFullscreen();
+                }
+                canvas.addEventListener("fullscreenchange", fullscreenChangeHandler);
+                await xrManager.enterVr(rendererVrSessionInit);
+            }
+            catch {
+                dispatch({ type: "set_vr_mode", payload: false });
+            }
+        };
+        const exitVRHandler = async () => {
+            await xrManager.exitSession();
+            if (document.fullscreenElement === canvas) {
+                await document.exitFullscreen().catch(() => { });
+            }
+        };
+        if (!useVR) {
+            void exitVRHandler();
+            return () => {
+                canvas.removeEventListener("fullscreenchange", fullscreenChangeHandler);
+            };
+        }
+        void enterVRHandler();
+        return () => {
+            canvas.removeEventListener("fullscreenchange", fullscreenChangeHandler);
+        };
+    }, [useVR, dispatch]);
+    return (_jsxs(_Fragment, { children: [_jsx("button", { title: useVR ? "Exit VR" : "Enter VR", onClick: () => dispatch({ type: "set_vr_mode", payload: !useVR }), className: styles.vrButton, children: useVR ? _jsx(CgWebsite, { size: 24 }) : _jsx(BsHeadsetVr, { size: 24 }) }), _jsx(Suspense, { fallback: _jsx("div", { style: { height: "100%" } }), children: _jsxs(Canvas, { shadows: "soft", tabIndex: 0, ref: canvasRef, className: `${styles.canvas} ${!useVR ? styles.fixed : styles.absolute}`, style: { width: "100%", height: "100%" }, camera: {
+                        position: cameraPosition.toArray(),
+                        rotation: cameraRotation.toArray(),
+                        near: 0.1,
+                        far: 1000,
+                        fov: 50,
+                    }, dpr: useVR ? 1 : [1, 4], gl: async (props) => {
+                        const params = {
+                            ...props,
+                            multiview,
+                        };
+                        const renderer = new THREE.WebGPURenderer(params);
+                        await renderer.init();
+                        if (useVR && "setPixelRatio" in renderer) {
+                            renderer.setPixelRatio(1);
+                        }
+                        if ("setClearColor" in renderer) {
+                            renderer.setClearColor("lightblue");
+                        }
+                        if ("outputColorSpace" in renderer) {
+                            renderer.outputColorSpace = THREE.SRGBColorSpace;
+                        }
+                        if ("xr" in renderer) {
+                            renderer.xr.enabled = true;
+                        }
+                        renderer.getContextAttributes = () => ({
+                            antialias: props.antialias ?? true,
+                            alpha: props.alpha ?? true,
+                            stencil: props.stencil ?? true,
+                            depth: props.depth ?? true,
+                            powerPreference: props.powerPreference ?? "high-performance",
+                            xrCompatible: true,
+                        });
+                        return renderer;
+                    }, onCreated: (state) => {
+                        // In XR, keep DPR stable to avoid stereo stitching issues
+                        if (useVR && "setPixelRatio" in state.gl) {
+                            // Cap DPR to a reasonable value for HMDs; many runtimes manage internal resolution
+                            state.gl.setPixelRatio(1);
+                        }
+                        if ("setClearColor" in state.gl) {
+                            state.gl.setClearColor("lightblue");
+                        }
+                        if ("setSize" in state.gl) {
+                            state.gl.setSize(state.size.width, state.size.height);
+                        }
+                        if ("outputColorSpace" in state.gl) {
+                            state.gl.outputColorSpace = THREE.SRGBColorSpace;
+                        }
+                        rendererRef.current = state.gl;
+                    }, children: [!useVR && _jsx(AdaptiveDPR, {}), _jsxs(Suspense, { fallback: Loader(), children: [!useVR && (_jsx(ManagedCameraController, { manager: cameraManager, profile: cameraRigProfile, cameraId: "main" })), _jsxs(Scene, { ref: sceneRef, children: [_jsx(Player, { cameraManager: cameraManager, cameraId: "main" }), children] })] })] }) })] }));
+}
+function WrappedRenderer(props) {
+    return (_jsx(RenderStore.Provider, { children: _jsx(Renderer, { ...props }) }));
+}
+export { WrappedRenderer as Renderer };

package/dist/scene.d.ts

@@ -0,0 +1,7 @@
+import { type ReactNode } from "react";
+import { Group } from "three";
+export interface SceneProps {
+    children?: ReactNode[];
+}
+export declare const Scene: import("react").ForwardRefExoticComponent<SceneProps & import("react").RefAttributes<Group<import("three").Object3DEventMap>>>;
+//# sourceMappingURL=scene.d.ts.map

package/dist/scene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene.d.ts","sourceRoot":"","sources":["../src/scene.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAInD,OAAO,EAAW,KAAK,EAAE,MAAM,OAAO,CAAC;AAEvC,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,SAAS,EAAE,CAAC;CACxB;AAGD,eAAO,MAAM,KAAK,gIA8BhB,CAAC"}

package/dist/scene.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { forwardRef } from "react";
+import { Physics } from "@react-three/rapier";
+import { Environment } from "@react-three/drei";
+import { Landscape } from "./landscape.js";
+import { Vector3 } from "three";
+// Use forwardRef to make ref work
+export const Scene = forwardRef(function Scene(props, ref) {
+    return (_jsxs("group", { ref: ref, children: [_jsx(Environment, { preset: "dawn", background: false, environmentIntensity: 0.5 }), _jsx("ambientLight", { color: 0xe1e1e1, intensity: 0.3 }), _jsx("directionalLight", { color: 0xf0f0f0, intensity: 1.0, position: new Vector3(5, 10, -10), castShadow: true, "shadow-mapSize-width": 2048, "shadow-mapSize-height": 2048, "shadow-bias": -0.0005, "shadow-camera-left": -20, "shadow-camera-right": 20, "shadow-camera-top": 20, "shadow-camera-bottom": -20, "shadow-camera-near": 0.5, "shadow-camera-far": 100 }), _jsxs(Physics, { gravity: [0, -9.81, 0], children: [_jsx(Landscape, {}), props.children] })] }));
+});

package/dist/shaders/fragment/landscapeFragmentShader.js

@@ -0,0 +1,141 @@
+import * as TSL from "three/tsl";
+
+// Fragment shader
+export const landscapeFragmentShader = TSL.Fn((shader) => {
+  const vHeight = shader.input.float("vHeight");
+  const fragColor = shader.uniforms.vec4("fragColor");
+
+  const lowColor = TSL.vec3(0.5, 0.8, 0.3); // Grass
+  const highColor = TSL.vec3(1.0, 1.0, 1.0); // Snow
+
+  const mixFactor = TSL.smoothstep(0.0, 2.0, vHeight);
+  const baseColor = TSL.mix(lowColor, highColor, mixFactor);
+
+  TSL.assign(fragColor, TSL.vec4(baseColor, 1.0));
+});
+
+/*import * as TSL from "three/tsl";
+
+// Fragment shader
+export const landscapeFragmentShader = TSL.Fn((shader) => {
+  const vUv = shader.input.vec2("vUv");
+  const vHeight = shader.input.float("vHeight");
+  const vPos = shader.input.vec3("vPos");
+
+  const time = shader.uniforms.float("time");
+  const fragColor = shader.uniforms.vec4("fragColor");
+
+  const applyWind = (normal, pos) => {
+    const windDir = TSL.vec2(
+      TSL.sin(TSL.add(TSL.mul(pos.x, 0.1), TSL.mul(time, 0.3))),
+      TSL.cos(TSL.add(TSL.mul(pos.y, 0.1), TSL.mul(time, 0.3)))
+    );
+    const strength = TSL.add(
+      0.2,
+      TSL.mul(
+        0.1,
+        TSL.sin(TSL.add(TSL.dot(pos, TSL.vec2(0.3, 0.7)), TSL.mul(time, 0.5)))
+      )
+    );
+    const wind = TSL.mul(
+      TSL.normalize(TSL.vec3(windDir.x, windDir.y, 0.0)),
+      strength
+    );
+    return TSL.normalize(TSL.add(normal, TSL.mul(wind, 0.4)));
+  };
+
+  const calculateNormal = (height, uv, pos) => {
+    const eps = 0.01;
+    const hL = TSL.smoothstep(-2.0, 4.5, TSL.sub(height, eps));
+    const hR = TSL.smoothstep(-2.0, 4.5, TSL.add(height, eps));
+    const hD = TSL.smoothstep(-2.0, 4.5, TSL.sub(height, eps));
+    const hU = TSL.smoothstep(-2.0, 4.5, TSL.add(height, eps));
+    const normal = TSL.normalize(
+      TSL.vec3(TSL.sub(hL, hR), TSL.sub(hD, hU), 2.0)
+    );
+    return applyWind(normal, pos.xz);
+  };
+
+  const grassWave = (uv, height) => {
+    const baseFreq = 40.0;
+    const speed = 0.5;
+    const wave1 = TSL.sin(
+      TSL.mul(TSL.add(TSL.add(uv.x, uv.y), TSL.mul(time, speed)), baseFreq)
+    );
+    const wave2 = TSL.cos(
+      TSL.mul(
+        TSL.add(TSL.sub(uv.x, uv.y), TSL.mul(time, TSL.mul(speed, 1.2))),
+        TSL.mul(baseFreq, 0.8)
+      )
+    );
+    const pattern = TSL.mul(TSL.add(wave1, wave2), 0.03);
+    const density = TSL.smoothstep(0.3, 0.7, height);
+    return TSL.mul(pattern, density);
+  };
+
+  const grassDensityFactor = (coords) =>
+    TSL.smoothstep(
+      0.4,
+      0.9,
+      TSL.fract(
+        TSL.mul(
+          TSL.sin(TSL.dot(TSL.mul(coords, 0.2), TSL.vec2(12.9898, 78.233))),
+          43758.5453
+        )
+      )
+    );
+
+  const sand = TSL.vec3(0.76, 0.7, 0.5);
+  const grass = TSL.vec3(0.4, 0.8, 0.2);
+  const stone = TSL.vec3(0.5, 0.5, 0.5);
+  const snow = TSL.vec3(0.95, 0.95, 0.95);
+
+  const low = TSL.smoothstep(-2.0, 0.0, vHeight);
+  const high = TSL.smoothstep(1.0, 3.0, vHeight);
+
+  let base = TSL.mix(sand, grass, low);
+  base = TSL.mix(base, stone, high);
+  base = TSL.mix(base, snow, TSL.smoothstep(2.5, 4.5, vHeight));
+
+  const normal = calculateNormal(vHeight, vUv, vPos);
+  const slope = TSL.dot(TSL.vec3(0.0, 0.0, 1.0), normal);
+  const snowBlend = TSL.smoothstep(0.8, 1.0, slope);
+  base = TSL.mix(
+    base,
+    snow,
+    TSL.mul(snowBlend, TSL.smoothstep(1.5, 4.5, vHeight))
+  );
+
+  const tintNoise = TSL.fract(
+    TSL.mul(TSL.sin(TSL.dot(vPos.xz, TSL.vec2(91.91, 47.47))), 43758.5453)
+  );
+  const tint = TSL.mix(
+    TSL.vec3(-0.05, 0.05, -0.02),
+    TSL.vec3(0.05, -0.03, 0.02),
+    tintNoise
+  );
+  base = TSL.add(base, tint);
+
+  const density = grassDensityFactor(vPos.xz);
+  base = TSL.mix(base, TSL.vec3(0.25, 0.4, 0.15), TSL.sub(1.0, density));
+
+  const lightDir = TSL.normalize(TSL.vec3(0.3, 0.5, 1.0));
+  let lighting = TSL.clamp(TSL.dot(lightDir, normal), 0.3, 1.0);
+  lighting = TSL.mul(lighting, TSL.add(0.8, TSL.mul(0.4, density)));
+
+  const grassMotion = TSL.mul(grassWave(vUv, vHeight), density);
+  const animatedGrass = TSL.vec3(0.0, TSL.mul(grassMotion, 0.4), 0.0);
+
+  const fresnel = TSL.pow(
+    TSL.sub(1.0, TSL.dot(TSL.normalize(TSL.vec3(0.0, 0.0, 1.0)), normal)),
+    3.0
+  );
+  const fresnelColor = TSL.mul(TSL.vec3(0.2, 0.5, 0.1), fresnel);
+
+  const finalColor = TSL.mul(
+    TSL.add(TSL.add(base, animatedGrass), fresnelColor),
+    lighting
+  );
+  TSL.assign(fragColor, TSL.vec4(finalColor, 1.0));
+});
+*/

package/dist/shaders/landscapeShader.d.ts

@@ -0,0 +1,13 @@
+import * as THREE from "three/webgpu";
+declare class LandscapeShaderMaterial extends THREE.MeshStandardNodeMaterial {
+    constructor();
+}
+export { LandscapeShaderMaterial };
+declare module "@react-three/fiber" {
+    interface ThreeElements {
+        landscapeShaderMaterial: ThreeElements["meshStandardMaterial"] & {
+            ref?: React.Ref<THREE.MeshStandardNodeMaterial>;
+        };
+    }
+}
+//# sourceMappingURL=landscapeShader.d.ts.map

package/dist/shaders/landscapeShader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"landscapeShader.d.ts","sourceRoot":"","sources":["../../src/shaders/landscapeShader.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAOtC,cAAM,uBAAwB,SAAQ,KAAK,CAAC,wBAAwB;;CAkBnE;AAKD,OAAO,EAAE,uBAAuB,EAAE,CAAC;AAEnC,OAAO,QAAQ,oBAAoB,CAAC;IAClC,UAAU,aAAa;QACrB,uBAAuB,EAAE,aAAa,CAAC,sBAAsB,CAAC,GAAG;YAC/D,GAAG,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,wBAAwB,CAAC,CAAC;SACjD,CAAC;KACH;CACF"}

package/dist/shaders/landscapeShader.js

@@ -0,0 +1,25 @@
+import * as THREE from "three/webgpu";
+import { extend } from "@react-three/fiber";
+// ✅ Define a class that extends the material
+class LandscapeShaderMaterial extends THREE.MeshStandardNodeMaterial {
+    constructor() {
+        super({ color: new THREE.Color(0.4, 0.7, 0.2) });
+        /*
+            // Append your vertex shader to the existing position pipeline
+            if (this.positionNode)
+              this.positionNode = shader(() =>
+                add(this.positionNode!, landscapeVertexShader)
+              );
+            else this.positionNode = landscapeVertexShader;
+            // Append your fragment shader to the existing color pipeline
+            if (this.colorNode)
+              this.colorNode = shader(() =>
+                add(this.colorNode!, landscapeFragmentShader)
+              );
+            else this.colorNode = landscapeFragmentShader;
+            */
+    }
+}
+// ✅ Register the class with R3F so you can use it as a JSX tag
+extend({ LandscapeShaderMaterial });
+export { LandscapeShaderMaterial };

package/dist/shaders/vertex/landscapeVertexShader.js

@@ -0,0 +1,67 @@
+import * as TSL from "three/tsl";
+
+// Vertex shader
+export const landscapeVertexShader = TSL.Fn((shader) => {
+  const position = shader.input.vec3("position");
+  const uv = shader.input.vec2("uv");
+  const time = shader.uniforms.float("time");
+
+  let vHeight = shader.output.float("vHeight");
+  const clipPosition = output.vec4("gl_Position");
+
+  const waveZ = TSL.mul(
+    TSL.sin(TSL.add(TSL.mul(position.x, 0.5), TSL.mul(time, 1.0))),
+    1.0
+  );
+
+  const newPos = TSL.vec3(position.x, position.y, TSL.add(position.z, waveZ));
+
+  TSL.assign(vHeight, newPos.z);
+  TSL.assign(clipPosition, TSL.vec4(newPos, 1.0));
+});
+/*
+
+
+// Vertex shader
+export const landscapeVertexShader = TSL.Fn((shader) => {
+  const position = shader.input.vec3("position");
+  const uv = shader.input.vec2("uv");
+
+  const time = shader.uniforms.float("time");
+  const seed = shader.uniforms.float("seed");
+
+  let vUv = shader.output.vec2("vUv");
+  let vHeight = shader.output.float("vHeight");
+  let vPos = shader.output.vec3("vPos");
+
+  const clipPosition = output.vec4("gl_Position");
+
+  const random = (st) =>
+    fract(
+      mul(
+        sin(dot(st, vec2(add(12.9898, seed), add(78.233, seed)))),
+        43758.5453123
+      )
+    );
+
+  assign(vUv, uv);
+  assign(vPos, position);
+
+  const rnd = random(position.xy);
+  const waveZ = add(
+    mul(
+      add(
+        sin(add(mul(position.x, 0.2), time)),
+        cos(add(mul(position.y, 0.2), time))
+      ),
+      0.75
+    ),
+    sub(mul(rnd, 2.0), 1.0)
+  );
+
+  const newPos = vec3(position.x, position.y, add(position.z, waveZ));
+
+  assign(vHeight, newPos.z);
+  assign(clipPosition, vec4(newPos, 1.0));
+});
+*/

package/dist/styles/renderer.module.css

@@ -0,0 +1,90 @@
+.canvas {
+  width: 100%;
+  height: 100%;
+  min-width: 640px;
+  min-height: 480px;
+  top: 0px;
+  left: 0px;
+  display: block;
+  z-index: 0;
+}
+
+.vrButton {
+  top: 67px;
+  position: absolute;
+  right: 15px;
+  z-index: 1000;
+  background-color: rgba(225, 18, 222, 0.8);
+  border: none;
+  border-radius: 5px;
+  padding: 10px;
+  cursor: pointer;
+  transition: background-color 0.3s;
+}
+  
+.vrButton .fullscreen {
+  top: 15px;
+}
+
+.vrButton:hover {
+  background-color: rgba(200, 10, 200, 0.8);
+  border: 2px solid #fff;
+  box-shadow: 0 0 10px rgba(255, 255, 255, 0.5);
+}
+  .vrButton:active {
+    background-color: rgba(175, 5, 175, 0.8);
+  }
+  .vrButton:disabled {
+    background-color: rgba(150, 0, 150, 0.8);
+    cursor: not-allowed;
+  }
+  .vrButton:disabled:hover {
+    background-color: rgba(150, 0, 150, 0.8);
+  }
+  .vrButton:focus {
+    outline: none;
+    box-shadow: 0 0 0 2px rgba(225, 18, 222, 0.8);
+  }
+  .vrButton:focus-visible {
+    outline: none;
+    box-shadow: 0 0 0 2px rgba(225, 18, 222, 0.8);
+  }
+  .vrButton:focus:not(:focus-visible) {
+    box-shadow: none;
+  }
+  
+  .performanceContainer {
+    position: absolute;
+    bottom: 15px;
+    left: 15px;
+    width: 80px;
+    height: 48px;
+    z-index: 1000;
+    background-color: rgba(220, 220, 220, 0.5);
+    padding: 10px;
+    border-radius: 5px;
+  }
+  
+  .performanceContainer p {
+    margin: 0;
+    font-size: 14px;
+  }
+  .performanceContainer span {
+    font-weight: bold;
+  }
+  .performanceContainer .performanceText {
+    font-size: 16px;
+    color: #202020;
+  }
+  .performanceContainer .frameRateText {
+    font-size: 16px;
+    color: #202020;
+  }
+/* Custom canvas classes for VR/AR mode switching */
+.fixed {
+  position: fixed;
+}
+
+.absolute {
+  position: absolute;
+}

package/dist/worldSpaceCompositor.d.ts

@@ -0,0 +1,50 @@
+export declare const WORLD_SPACE_SURFACE_LAYERS: readonly ["screen", "overlay", "alert"];
+export type WorldSpaceSurfaceLayer = (typeof WORLD_SPACE_SURFACE_LAYERS)[number];
+export declare const WORLD_SPACE_OCCLUSION_MODES: readonly ["world", "overlay", "always-visible"];
+export type WorldSpaceOcclusionMode = (typeof WORLD_SPACE_OCCLUSION_MODES)[number];
+export interface WorldSpaceOcclusionPolicy {
+    mode: WorldSpaceOcclusionMode;
+    depthTest: boolean;
+    depthWrite: boolean;
+    polygonOffset: boolean;
+    polygonOffsetFactor: number;
+    polygonOffsetUnits: number;
+    renderOrderOffset: number;
+    fadeWhenOccluded: boolean;
+}
+export interface WorldSpaceSurfaceInput {
+    id: string;
+    slot: string;
+    layer: WorldSpaceSurfaceLayer;
+    priority?: number;
+    occlusionMode?: WorldSpaceOcclusionMode;
+    exclusiveSlot?: boolean;
+}
+export interface ComposedWorldSpaceSurface extends WorldSpaceSurfaceInput {
+    exclusiveSlot: boolean;
+    occlusionMode: WorldSpaceOcclusionMode;
+    occlusionPolicy: WorldSpaceOcclusionPolicy;
+    renderOrder: number;
+    slotIndex: number;
+}
+export interface WorldSpaceCompositionCollision {
+    slot: string;
+    surfaceIds: string[];
+    reason: "exclusive-slot-conflict";
+}
+export interface WorldSpaceCompositionResult {
+    surfaces: ComposedWorldSpaceSurface[];
+    collisions: WorldSpaceCompositionCollision[];
+}
+export interface WorldSpaceCompositionOptions {
+    slotOrder?: string[];
+    startingRenderOrder?: number;
+    slotStep?: number;
+    priorityStep?: number;
+}
+export declare function resolveWorldSpaceOcclusionPolicy(mode: WorldSpaceOcclusionMode): WorldSpaceOcclusionPolicy;
+export declare function resolveWorldSpaceRenderOrder(surface: WorldSpaceSurfaceInput, options?: WorldSpaceCompositionOptions & {
+    slotIndex?: number;
+}): number;
+export declare function composeWorldSpaceSurfaces(surfaces: readonly WorldSpaceSurfaceInput[], options?: WorldSpaceCompositionOptions): WorldSpaceCompositionResult;
+//# sourceMappingURL=worldSpaceCompositor.d.ts.map

package/dist/worldSpaceCompositor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worldSpaceCompositor.d.ts","sourceRoot":"","sources":["../src/worldSpaceCompositor.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,0BAA0B,yCAI7B,CAAC;AAEX,MAAM,MAAM,sBAAsB,GAChC,CAAC,OAAO,0BAA0B,CAAC,CAAC,MAAM,CAAC,CAAC;AAE9C,eAAO,MAAM,2BAA2B,iDAI9B,CAAC;AAEX,MAAM,MAAM,uBAAuB,GACjC,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/C,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,uBAAuB,CAAC;IAC9B,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,OAAO,CAAC;IACpB,aAAa,EAAE,OAAO,CAAC;IACvB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gBAAgB,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,sBAAsB;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,sBAAsB,CAAC;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,uBAAuB,CAAC;IACxC,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,yBAA0B,SAAQ,sBAAsB;IACvE,aAAa,EAAE,OAAO,CAAC;IACvB,aAAa,EAAE,uBAAuB,CAAC;IACvC,eAAe,EAAE,yBAAyB,CAAC;IAC3C,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,8BAA8B;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,MAAM,EAAE,yBAAyB,CAAC;CACnC;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,EAAE,yBAAyB,EAAE,CAAC;IACtC,UAAU,EAAE,8BAA8B,EAAE,CAAC;CAC9C;AAED,MAAM,WAAW,4BAA4B;IAC3C,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAiHD,wBAAgB,gCAAgC,CAC9C,IAAI,EAAE,uBAAuB,GAC5B,yBAAyB,CAE3B;AAED,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,sBAAsB,EAC/B,OAAO,GAAE,4BAA4B,GAAG;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,GAClE,MAAM,CAiBR;AAED,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,SAAS,sBAAsB,EAAE,EAC3C,OAAO,GAAE,4BAAiC,GACzC,2BAA2B,CA0D7B"}