@jgengine/shell 0.4.0 → 0.6.0

package/dist/weather/weatherGeometry.js

@@ -0,0 +1,14 @@
+import * as THREE from "three";
+import { createWeatherSeedAttributes } from "./weatherMath.js";
+export function createWeatherQuadGeometry(maxCount, seed) {
+    const count = Math.max(0, Math.floor(maxCount));
+    const geometry = new THREE.InstancedBufferGeometry();
+    geometry.setAttribute("position", new THREE.BufferAttribute(new Float32Array([-0.5, -0.5, 0, 0.5, -0.5, 0, 0.5, 0.5, 0, -0.5, 0.5, 0]), 3));
+    geometry.setAttribute("uv", new THREE.BufferAttribute(new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]), 2));
+    geometry.setIndex([0, 1, 2, 0, 2, 3]);
+    const attributes = createWeatherSeedAttributes(count, seed);
+    geometry.setAttribute("aSpawn", new THREE.InstancedBufferAttribute(attributes.spawn, 3));
+    geometry.setAttribute("aDrift", new THREE.InstancedBufferAttribute(attributes.drift, 1));
+    geometry.instanceCount = count;
+    return geometry;
+}

package/dist/weather/weatherMath.d.ts

@@ -0,0 +1,7 @@
+export declare function clampWeatherRatio(value: number): number;
+export declare function resolveWeatherInstanceCount(maxCount: number, density: number): number;
+export interface WeatherSeedAttributes {
+    spawn: Float32Array;
+    drift: Float32Array;
+}
+export declare function createWeatherSeedAttributes(maxCount: number, seed: number): WeatherSeedAttributes;

package/dist/weather/weatherMath.js

@@ -0,0 +1,30 @@
+export function clampWeatherRatio(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    if (value <= 0)
+        return 0;
+    if (value >= 1)
+        return 1;
+    return value;
+}
+export function resolveWeatherInstanceCount(maxCount, density) {
+    const safeMax = Math.max(0, Math.floor(maxCount));
+    return Math.floor(safeMax * clampWeatherRatio(density));
+}
+export function createWeatherSeedAttributes(maxCount, seed) {
+    const count = Math.max(0, Math.floor(maxCount));
+    const spawn = new Float32Array(count * 3);
+    const drift = new Float32Array(count);
+    let state = seed >>> 0;
+    const next = () => {
+        state = (state * 1664525 + 1013904223) >>> 0;
+        return state / 4294967296;
+    };
+    for (let index = 0; index < count; index += 1) {
+        spawn[index * 3] = next();
+        spawn[index * 3 + 1] = next();
+        spawn[index * 3 + 2] = next();
+        drift[index] = next();
+    }
+    return { spawn, drift };
+}

package/dist/weather/weatherUniforms.d.ts

@@ -0,0 +1,18 @@
+import { type ReactNode } from "react";
+import * as THREE from "three";
+export type WeatherVector = readonly [number, number, number];
+export interface WeatherUniformSet {
+    time: THREE.IUniform<number>;
+    wind: THREE.IUniform<THREE.Vector3>;
+    lightning: THREE.IUniform<number>;
+}
+export interface WeatherUniformOptions {
+    wind?: WeatherVector;
+    lightning?: number;
+    timeScale?: number;
+}
+export declare function createWeatherUniformSet(options?: WeatherUniformOptions): WeatherUniformSet;
+export declare function WeatherUniformProvider({ children, ...options }: WeatherUniformOptions & {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useWeatherUniformSet(options?: WeatherUniformOptions): WeatherUniformSet;

package/dist/weather/weatherUniforms.js

@@ -0,0 +1,34 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from "react";
+import { useFrame } from "@react-three/fiber";
+import * as THREE from "three";
+const WeatherUniformContext = createContext(null);
+export function createWeatherUniformSet(options = {}) {
+    const wind = options.wind ?? [0, 0, 0];
+    return {
+        time: { value: 0 },
+        wind: { value: new THREE.Vector3(wind[0], wind[1], wind[2]) },
+        lightning: { value: options.lightning ?? 0 },
+    };
+}
+function useUniformTicker(uniforms, options, enabled = true) {
+    useFrame((_state, delta) => {
+        if (!enabled)
+            return;
+        const wind = options.wind ?? [0, 0, 0];
+        uniforms.time.value += delta * (options.timeScale ?? 1);
+        uniforms.wind.value.set(wind[0], wind[1], wind[2]);
+        uniforms.lightning.value = options.lightning ?? 0;
+    });
+}
+export function WeatherUniformProvider({ children, ...options }) {
+    const uniforms = useMemo(() => createWeatherUniformSet(options), []);
+    useUniformTicker(uniforms, options);
+    return _jsx(WeatherUniformContext.Provider, { value: uniforms, children: children });
+}
+export function useWeatherUniformSet(options = {}) {
+    const shared = useContext(WeatherUniformContext);
+    const local = useMemo(() => createWeatherUniformSet(options), []);
+    useUniformTicker(local, options, shared === null);
+    return shared ?? local;
+}

package/dist/world/InstancedBodies.d.ts

@@ -0,0 +1,17 @@
+import type { PhysicsWorld } from "@jgengine/core/physics/physicsWorld";
+export interface InstancedBodiesProps {
+    /** Physics world whose SoA buffers are streamed straight into the instance matrix. */
+    world: PhysicsWorld;
+    /** When true, color each instance by simulation state (sleeping / awake / contact) instead of its base color. */
+    debugTint?: boolean;
+    /** Per-body base RGB (length ≥ capacity·3), used when debugTint is off. Defaults to flat gray. */
+    baseColors?: Float32Array;
+    /** Bump to force a color re-upload after the world is rebuilt (e.g. reset). */
+    epoch?: number;
+}
+/**
+ * Renders a PhysicsWorld's box bodies as a single InstancedMesh — one draw call per batch.
+ * Transforms are written directly into `instanceMatrix.array` each frame (bodies never touch
+ * the per-entity React path). Reusable by any game: hand it a physics world and go.
+ */
+export declare function InstancedBodies({ world, debugTint, baseColors, epoch }: InstancedBodiesProps): import("react").JSX.Element;

package/dist/world/InstancedBodies.js

@@ -0,0 +1,84 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useFrame } from "@react-three/fiber";
+import { useEffect, useMemo, useRef } from "react";
+import * as THREE from "three";
+const SLEEPING_COLOR = new THREE.Color(0.32, 0.4, 0.62);
+const AWAKE_COLOR = new THREE.Color(0.45, 0.78, 0.5);
+const CONTACT_COLOR = new THREE.Color(0.96, 0.55, 0.18);
+const DEFAULT_BASE = new THREE.Color(0.62, 0.64, 0.68);
+/**
+ * Renders a PhysicsWorld's box bodies as a single InstancedMesh — one draw call per batch.
+ * Transforms are written directly into `instanceMatrix.array` each frame (bodies never touch
+ * the per-entity React path). Reusable by any game: hand it a physics world and go.
+ */
+export function InstancedBodies({ world, debugTint = false, baseColors, epoch = 0 }) {
+    const meshRef = useRef(null);
+    const geometry = useMemo(() => new THREE.BoxGeometry(1, 1, 1), []);
+    const material = useMemo(() => new THREE.MeshStandardMaterial({ roughness: 0.85, metalness: 0, vertexColors: false }), []);
+    const capacity = world.capacity;
+    const instanceColor = useMemo(() => new THREE.InstancedBufferAttribute(new Float32Array(capacity * 3), 3), [capacity]);
+    useEffect(() => {
+        const mesh = meshRef.current;
+        if (mesh === null)
+            return;
+        mesh.instanceColor = instanceColor;
+        mesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+        instanceColor.setUsage(THREE.DynamicDrawUsage);
+    }, [instanceColor]);
+    const lastTintRef = useRef(null);
+    useEffect(() => {
+        lastTintRef.current = null;
+    }, [epoch, debugTint]);
+    useFrame(() => {
+        const mesh = meshRef.current;
+        if (mesh === null)
+            return;
+        const count = world.count;
+        mesh.count = count;
+        const m = mesh.instanceMatrix.array;
+        const { posX, posY, posZ, halfX, halfY, halfZ } = world;
+        for (let i = 0; i < count; i += 1) {
+            const o = i * 16;
+            m[o] = halfX[i] * 2;
+            m[o + 5] = halfY[i] * 2;
+            m[o + 10] = halfZ[i] * 2;
+            m[o + 12] = posX[i];
+            m[o + 13] = posY[i];
+            m[o + 14] = posZ[i];
+            m[o + 15] = 1;
+        }
+        mesh.instanceMatrix.needsUpdate = true;
+        const c = instanceColor.array;
+        if (debugTint) {
+            const { contact } = world;
+            for (let i = 0; i < count; i += 1) {
+                const col = contact[i] !== 0 ? CONTACT_COLOR : world.isSleeping(i) ? SLEEPING_COLOR : AWAKE_COLOR;
+                const o = i * 3;
+                c[o] = col.r;
+                c[o + 1] = col.g;
+                c[o + 2] = col.b;
+            }
+            instanceColor.needsUpdate = true;
+        }
+        else if (lastTintRef.current !== false) {
+            if (baseColors !== undefined) {
+                c.set(baseColors.subarray(0, capacity * 3));
+            }
+            else {
+                for (let i = 0; i < capacity; i += 1) {
+                    const o = i * 3;
+                    c[o] = DEFAULT_BASE.r;
+                    c[o + 1] = DEFAULT_BASE.g;
+                    c[o + 2] = DEFAULT_BASE.b;
+                }
+            }
+            instanceColor.needsUpdate = true;
+        }
+        lastTintRef.current = debugTint;
+    });
+    useEffect(() => () => {
+        geometry.dispose();
+        material.dispose();
+    }, [geometry, material]);
+    return (_jsx("instancedMesh", { ref: meshRef, args: [geometry, material, capacity], frustumCulled: false, castShadow: false, receiveShadow: false }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jgengine/shell",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Game player shell for JGengine: React Three Fiber canvas, orbit camera, input tracking, HUD mounting, GameUiPreview, and a demo game. Consumers supply a GameRegistry.",
   "license": "AGPL-3.0-only",
   "type": "module",
@@ -10,8 +10,15 @@
     "url": "git+https://github.com/Noisemaker111/jgengine.git",
     "directory": "packages/shell"
   },
-  "files": ["dist"],
+  "files": [
+    "dist",
+    "CHANGELOG.md"
+  ],
   "exports": {
+    "./weather": {
+      "types": "./dist/weather/index.d.ts",
+      "default": "./dist/weather/index.js"
+    },
     "./*": {
       "types": "./dist/*.d.ts",
       "default": "./dist/*.js"
@@ -23,9 +30,9 @@
     "test": "bun test src"
   },
   "dependencies": {
-    "@jgengine/core": "^0.4.0",
-    "@jgengine/react": "^0.4.0",
-    "@jgengine/ws": "^0.4.0"
+    "@jgengine/core": "^0.6.0",
+    "@jgengine/react": "^0.6.0",
+    "@jgengine/ws": "^0.6.0"
   },
   "peerDependencies": {
     "@react-three/drei": "^10.0.0",