@woosh/meep-engine 2.165.4 → 2.165.5

package/src/engine/graphics/shadows/ShadowMapRenderer.d.ts

@@ -18,6 +18,16 @@ export class ShadowMapRenderer {
      * @param {Light} light
      */
     update(renderer: THREE.WebGLRenderer, shadow: LightShadow, scene: Scene, light: Light): void;
+    /**
+     * Render each cube face of a point light shadow into its own viewport of
+     * the shadow map atlas (4x2 face grid, matching three.js cubeToUV layout)
+     * @param {THREE.WebGLRenderer} renderer
+     * @param {PointLightShadow} shadow
+     * @param {Scene} scene
+     * @param {THREE.PointLight} light
+     * @private
+     */
+    private __render_cube_faces;
     /**
      *
      * @param {LightShadow} shadow

package/src/engine/graphics/shadows/ShadowMapRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShadowMapRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/shadows/ShadowMapRenderer.js"],"names":[],"mappings":"AAuCA;IAGQ;;;;OAIG;IACH,mBAAsB;IAEtB;;;OAGG;IACH,gBAFU,MAAM,CAEkB;IAItC;;;;;;OAMG;IACH,iBALW,MAAM,aAAa,8BAEnB,KAAK,sBAuEf;IAED;;;;OAIG;IACH,sBAyCC;IAED;;;;;OAKG;IACH,qBA8BC;CACJ;mBAhNkB,uCAAuC;sBADnD,OAAO"}
+{"version":3,"file":"ShadowMapRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/shadows/ShadowMapRenderer.js"],"names":[],"mappings":"AAuCA;IAGQ;;;;OAIG;IACH,mBAAsB;IAEtB;;;OAGG;IACH,gBAFU,MAAM,CAEkB;IAItC;;;;;;OAMG;IACH,iBALW,MAAM,aAAa,8BAEnB,KAAK,sBAoFf;IAED;;;;;;;;OAQG;IACH,4BA8BC;IAED;;;;OAIG;IACH,sBAyCC;IAED;;;;;OAKG;IACH,qBAiDC;CACJ;mBAzRkB,uCAAuC;sBADnD,OAAO"}

package/src/engine/graphics/shadows/ShadowMapRenderer.js

@@ -102,18 +102,31 @@ export class ShadowMapRenderer {
 
         renderer.clear(true, true, false);
 
-        shadow.updateMatrices(light, 0);
+        if (shadow.isPointLightShadow === true) {
 
-        this.onBeforeRender.send3(renderer, shadow_camera, scene);
+            if (target.width > 0 && target.height > 0) {
+
+                this.__render_cube_faces(renderer, shadow, scene, light);
+
+                // no VSM pass: three.js point shadow sampling (getPointShadow)
+                // reads plain RGBA-packed distance regardless of shadow map type
+            }
 
-        if (target.width <= 0 || target.height <= 0) {
-            // no point in rendering
         } else {
-            // do the draw
-            renderer.render(scene, shadow_camera);
 
-            if (renderer.shadowMap.type === VSMShadowMap) {
-                this.__do_vsm_pass(shadow);
+            shadow.updateMatrices(light, 0);
+
+            this.onBeforeRender.send3(renderer, shadow_camera, scene);
+
+            if (target.width <= 0 || target.height <= 0) {
+                // no point in rendering
+            } else {
+                // do the draw
+                renderer.render(scene, shadow_camera);
+
+                if (renderer.shadowMap.type === VSMShadowMap) {
+                    this.__do_vsm_pass(shadow);
+                }
             }
         }
 
@@ -132,6 +145,47 @@ export class ShadowMapRenderer {
         renderer.info.render.frame++;
     }
 
+    /**
+     * Render each cube face of a point light shadow into its own viewport of
+     * the shadow map atlas (4x2 face grid, matching three.js cubeToUV layout)
+     * @param {THREE.WebGLRenderer} renderer
+     * @param {PointLightShadow} shadow
+     * @param {Scene} scene
+     * @param {THREE.PointLight} light
+     * @private
+     */
+    __render_cube_faces(renderer, shadow, scene, light) {
+        const target = shadow.map;
+        const shadow_camera = shadow.camera;
+        const map_size = shadow.mapSize;
+
+        const viewport_count = shadow.getViewportCount();
+
+        for (let i = 0; i < viewport_count; i++) {
+            // orient the shadow camera along the face direction
+            shadow.updateMatrices(light, i);
+
+            const viewport = shadow.getViewport(i);
+
+            target.viewport.set(
+                map_size.x * viewport.x,
+                map_size.y * viewport.y,
+                map_size.x * viewport.z,
+                map_size.y * viewport.w
+            );
+
+            // re-bind to apply the updated viewport
+            renderer.setRenderTarget(target);
+
+            this.onBeforeRender.send3(renderer, shadow_camera, scene);
+
+            renderer.render(scene, shadow_camera);
+        }
+
+        // leave the target with a full-size viewport to keep other consumers unaffected
+        target.viewport.set(0, 0, target.width, target.height);
+    }
+
     /**
      *
      * @param {LightShadow} shadow
@@ -191,6 +245,25 @@ export class ShadowMapRenderer {
 
         if (shadow.map === null) {
 
+            // point light shadows pack six cube faces into a 4x2 viewport
+            // atlas, other shadow types occupy the full target (extents 1x1)
+            const frame_extents = shadow.getFrameExtents();
+
+            // clamp so the atlas fits into a single texture, shrinking the
+            // per-face resolution if necessary (mirrors THREE.WebGLShadowMap)
+            const max_texture_size = renderer.capabilities.maxTextureSize;
+
+            if (_shadowMapSize.x * frame_extents.x > max_texture_size) {
+                _shadowMapSize.x = Math.floor(max_texture_size / frame_extents.x);
+            }
+
+            if (_shadowMapSize.y * frame_extents.y > max_texture_size) {
+                _shadowMapSize.y = Math.floor(max_texture_size / frame_extents.y);
+            }
+
+            const target_width = _shadowMapSize.x * frame_extents.x;
+            const target_height = _shadowMapSize.y * frame_extents.y;
+
             const pars = {
                 format: RGBAFormat,
                 scissorTest: false,
@@ -201,7 +274,7 @@ export class ShadowMapRenderer {
                 pars.minFilter = LinearFilter;
                 pars.magFilter = LinearFilter;
 
-                shadow.mapPass = new WebGLRenderTarget(_shadowMapSize.x, _shadowMapSize.y, Object.assign({
+                shadow.mapPass = new WebGLRenderTarget(target_width, target_height, Object.assign({
                     depthBuffer: false
                 }, pars));
 
@@ -211,7 +284,7 @@ export class ShadowMapRenderer {
 
             }
 
-            shadow.map = new WebGLRenderTarget(_shadowMapSize.x, _shadowMapSize.y, pars);
+            shadow.map = new WebGLRenderTarget(target_width, target_height, pars);
             shadow.map.texture.name = '.shadowMap';
 
             shadow.camera.updateProjectionMatrix();

package/src/engine/graphics/shadows/testPointShadowMapRendering.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=testPointShadowMapRendering.d.ts.map

package/src/engine/graphics/shadows/testPointShadowMapRendering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testPointShadowMapRendering.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/shadows/testPointShadowMapRendering.js"],"names":[],"mappings":""}

package/src/engine/graphics/shadows/testPointShadowMapRendering.js

@@ -0,0 +1,242 @@
+import {
+    initializeGameBinarySerializationRegistry
+} from "../../../../../model/game/GameBinarySerializationRegistry.js";
+import { enableEditor } from "../../../../editor/enableEditor.js";
+import Vector2 from "../../../core/geom/Vector2.js";
+import Vector3 from "../../../core/geom/Vector3.js";
+import { ArrayBufferLoader } from "../../asset/loaders/ArrayBufferLoader.js";
+import { AttachmentSystem } from "../../ecs/attachment/AttachmentSystem.js";
+import { SerializationMetadata } from "../../ecs/components/SerializationMetadata.js";
+import Entity from "../../ecs/Entity.js";
+import GUIElement from "../../ecs/gui/GUIElement.js";
+import GUIElementSystem from "../../ecs/gui/GUIElementSystem.js";
+import HeadsUpDisplaySystem from "../../ecs/gui/hud/HeadsUpDisplaySystem.js";
+import ViewportPosition from "../../ecs/gui/position/ViewportPosition.js";
+import ViewportPositionSystem from "../../ecs/gui/position/ViewportPositionSystem.js";
+import AnimationSystem from "../../ecs/systems/AnimationSystem.js";
+import ClingToTerrainSystem from "../../ecs/terrain/ecs/cling/ClingToTerrainSystem.js";
+import TerrainSystem from "../../ecs/terrain/ecs/TerrainSystem.js";
+import { Transform } from "../../ecs/transform/Transform.js";
+import { EngineConfiguration } from "../../EngineConfiguration.js";
+import { EngineHarness } from "../../EngineHarness.js";
+import InputControllerSystem from "../../input/ecs/systems/InputControllerSystem.js";
+import { InputSystem } from "../../input/ecs/systems/InputSystem.js";
+import { BehaviorSystem } from "../../intelligence/behavior/ecs/BehaviorSystem.js";
+import { loadSerializedScene } from "../../scene/SerializedScene.js";
+import { SoundEmitterSystem } from "../../sound/ecs/emitter/SoundEmitterSystem.js";
+import SoundControllerSystem from "../../sound/ecs/SoundControllerSystem.js";
+import SoundListenerSystem from "../../sound/ecs/SoundListenerSystem.js";
+import { CameraSystem } from "../ecs/camera/CameraSystem.js";
+import TopDownCameraControllerSystem from "../ecs/camera/topdown/TopDownCameraControllerSystem.js";
+import MeshHighlightSystem from "../ecs/highlight/system/MeshHighlightSystem.js";
+import { Light } from "../ecs/light/Light.js";
+import LightSystem from "../ecs/light/LightSystem.js";
+import { LightType } from "../ecs/light/LightType.js";
+import { ShadedGeometrySystem } from "../ecs/mesh-v2/ShadedGeometrySystem.js";
+import Mesh from "../ecs/mesh/Mesh.js";
+import { MeshSystem } from "../ecs/mesh/MeshSystem.js";
+import { PathDisplaySystem } from "../ecs/path/PathDisplaySystem.js";
+import Trail2DSystem from "../ecs/trail2d/Trail2DSystem.js";
+import WaterSystem from "../ecs/water/WaterSystem.js";
+import { ParticleEmitterSystem } from "../particles/ecs/ParticleEmitterSystem.js";
+import { buildCanvasViewFromTexture } from "../render/visibility/hiz/buildCanvasViewFromTexture.js";
+
+const eh = new EngineHarness();
+
+/**
+ *
+ * @param {Engine} engine
+ * @returns {EngineConfiguration}
+ */
+function makeConfig(engine) {
+
+    const config = new EngineConfiguration();
+
+    /**
+     *
+     * @type {SoundEngine}
+     */
+    const sound = engine.sound;
+    const graphics = engine.graphics;
+    const assetManager = engine.assetManager;
+    const devices = engine.devices;
+
+    const guiSystem = new GUIElementSystem(engine.gui.view, engine);
+    const headsUpDisplaySystem = new HeadsUpDisplaySystem(graphics);
+
+    config.addLoader('arraybuffer', new ArrayBufferLoader());
+
+    initializeGameBinarySerializationRegistry(engine.binarySerializationRegistry);
+
+    config.addManySystems(
+        new AttachmentSystem(),
+        new SoundEmitterSystem(assetManager, sound),
+        new SoundControllerSystem(),
+        new SoundListenerSystem(sound.context),
+        guiSystem,
+        new AnimationSystem(graphics.viewport.size),
+        new TopDownCameraControllerSystem(graphics),
+        new CameraSystem(engine.graphics),
+        new MeshSystem(engine),
+        new ClingToTerrainSystem(),
+        new TerrainSystem(graphics, assetManager),
+        new Trail2DSystem(engine),
+        new ViewportPositionSystem(graphics.viewport.size),
+        new InputControllerSystem(devices),
+        new InputSystem(devices),
+        new MeshHighlightSystem(engine),
+        new LightSystem(engine, {
+            shadowResolution: 2048
+        }),
+        headsUpDisplaySystem,
+        new BehaviorSystem(engine),
+        new PathDisplaySystem(engine),
+        new ParticleEmitterSystem(engine),
+        new ShadedGeometrySystem(engine),
+        new WaterSystem(graphics)
+    );
+
+    return config;
+}
+
+/**
+ *
+ * @param {Engine} engine
+ */
+function get_three_light(engine) {
+
+    return engine.graphics.scene.children.find(l => l.isPointLight && l.castShadow);
+}
+
+/**
+ * Preview the 4x2 cube face atlas of the point light's shadow map
+ * @param {Engine} engine
+ */
+function init_shadowmap_preview(engine) {
+    const ecd = engine.entityManager.dataset;
+
+    const graphics = engine.graphics;
+    const preview = buildCanvasViewFromTexture({
+        width: 1024,
+        height: 512,
+        renderer: graphics.renderer,
+        texture: null
+    });
+
+    graphics.on.postOpaquePass.add(() => {
+
+        const light = get_three_light(engine);
+
+        if (light !== undefined && light.shadow.map !== null) {
+            preview.texture = light.shadow.map.texture;
+
+            preview.render();
+        }
+    });
+
+
+    new Entity()
+        .add(ViewportPosition.fromJSON({
+            offset: new Vector2(10, 10)
+        }))
+        .add(GUIElement.fromView(preview.view))
+        .add(SerializationMetadata.Transient)
+        .build(ecd);
+}
+
+/**
+ * Point light above the character, casters placed on every axis so all six
+ * cube faces receive geometry
+ * @param {Engine} engine
+ * @param {Vector3} center
+ */
+function build_point_light_scene(engine, center) {
+    const ecd = engine.entityManager.dataset;
+
+    const CASTER_URL = "data/models/Conqueror Mech/Conqueror Mech.gltf";
+    const LIGHT_HEIGHT = 3;
+    const RING_RADIUS = 4;
+
+    // light itself
+    const light = new Light();
+    light.type.set(LightType.POINT);
+    light.color.setRGB(1.0, 0.85, 0.6);
+    light.intensity.set(2);
+    light.distance.set(20);
+    light.castShadow.set(true);
+
+    const light_transform = new Transform();
+    light_transform.position.set(center.x, center.y + LIGHT_HEIGHT, center.z);
+
+    new Entity()
+        .add(light)
+        .add(light_transform)
+        .add(SerializationMetadata.Transient)
+        .build(ecd);
+
+    // casters on +X/-X/+Z/-Z of the light; the ground receives -Y, the caster
+    // hovering above the light exercises the +Y face
+    const positions = [
+        [RING_RADIUS, 0, 0],
+        [-RING_RADIUS, 0, 0],
+        [0, 0, RING_RADIUS],
+        [0, 0, -RING_RADIUS],
+        [0, LIGHT_HEIGHT + 2, 0]
+    ];
+
+    for (const [x, y, z] of positions) {
+        const transform = new Transform();
+        transform.position.set(center.x + x, center.y + y, center.z + z);
+
+        new Entity()
+            .add(Mesh.fromURL(CASTER_URL))
+            .add(transform)
+            .add(SerializationMetadata.Transient)
+            .build(ecd);
+    }
+}
+
+/**
+ *
+ * @param {Engine} engine
+ * @returns {Promise<void>}
+ */
+async function main(engine) {
+
+    const ecd = engine.entityManager.dataset;
+    await loadSerializedScene('data/levels/character_creation/level.bin', ecd, engine);
+
+
+    // center the test scene on any placed mesh, fall back to the origin
+    let center = new Vector3(0, 0, 0);
+
+    ecd.traverseComponents(Mesh, (mesh, entity) => {
+        const transform = ecd.getComponent(entity, Transform);
+
+        if (transform !== undefined) {
+            center = transform.position;
+            return false;
+        }
+    });
+
+    build_point_light_scene(engine, center);
+
+    init_shadowmap_preview(engine);
+
+    window.light = get_three_light(engine);
+}
+
+async function init(engineHarness) {
+
+    const engine = await engineHarness.initialize();
+
+    const config = makeConfig(engine);
+
+    await config.apply(engine);
+
+    enableEditor(engine);
+
+    main(engine).catch(e => console.error('testPointShadowMapRendering failed:', e));
+}
+
+init(eh);