mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-21 18:52:18 +00:00
Tests that made their own engine object now use createFakeEngine() with its scripting hooks or an override of the one member under test, so they follow the contract when it changes. 125 such literals in 74 test files go down to two that are not globe engines on purpose; report-qa-harness counts them, and the baseline keeps the number from growing.
156 lines
5.5 KiB
JavaScript
156 lines
5.5 KiB
JavaScript
import { createFakeEngine } from '../testing/fakeEngine.js';
|
|
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import {
|
|
BasicDepthPacking,
|
|
DataTexture,
|
|
MeshBasicMaterial,
|
|
RGBADepthPacking,
|
|
ShaderLib,
|
|
} from 'three';
|
|
import {
|
|
SCENE_DEPTH_BIAS,
|
|
createSceneDepthTest,
|
|
withSceneDepthTest,
|
|
} from './sceneDepth.js';
|
|
import { createPackRenderer } from '../../scenes/dataPacks/display.js';
|
|
import { createNavaraMeshes } from './meshes.js';
|
|
|
|
const count = (text, part) => text.split(part).length - 1;
|
|
|
|
test('the scene-depth test goes after the log depth and brings packing once', () => {
|
|
for (const source of [
|
|
ShaderLib.basic.fragmentShader,
|
|
'#include <common>\n#include <packing>\nvoid main() {\n#include <logdepthbuf_fragment>\n}',
|
|
]) {
|
|
const patched = withSceneDepthTest(source);
|
|
assert.equal(count(patched, '#include <packing>'), 1);
|
|
assert.equal(count(patched, 'uniform sampler2D tGevSceneDepth;'), 1);
|
|
const depth = patched.indexOf('#include <logdepthbuf_fragment>');
|
|
const test = patched.indexOf('if (uGevSceneDepthOn > 0.5)');
|
|
assert.ok(depth >= 0 && test > depth, 'tested after gl_FragDepth is set');
|
|
assert.ok(
|
|
patched.indexOf('uniform float uGevSceneDepthOn;') <
|
|
patched.indexOf('void main() {'),
|
|
);
|
|
assert.match(
|
|
patched,
|
|
/packedDepthOccluded\(gevDepth, gevScene, 5e-6\)\)\s*discard;/,
|
|
);
|
|
}
|
|
assert.ok(SCENE_DEPTH_BIAS > 0 && SCENE_DEPTH_BIAS < 1e-4);
|
|
assert.throws(() => withSceneDepthTest('void main() {}'), /logdepthbuf/);
|
|
});
|
|
|
|
test('the test binds the MRT pass packed depth before each draw, and only packed RGBA depth', () => {
|
|
const depth = createSceneDepthTest();
|
|
const material = depth.material(new MeshBasicMaterial());
|
|
const shader = {
|
|
uniforms: {},
|
|
vertexShader: ShaderLib.basic.vertexShader,
|
|
fragmentShader: ShaderLib.basic.fragmentShader,
|
|
};
|
|
material.onBeforeCompile(shader, null);
|
|
assert.match(material.customProgramCacheKey(), /_gevSceneDepth$/);
|
|
assert.equal(shader.uniforms.tGevSceneDepth, depth.uniforms.tGevSceneDepth);
|
|
assert.match(shader.fragmentShader, /discard;/);
|
|
|
|
const drawn = [];
|
|
const object = depth.object({
|
|
userData: {},
|
|
onBeforeRender: (renderer) => drawn.push(renderer),
|
|
});
|
|
const texture = new DataTexture();
|
|
const mrt = { depthBuffer: texture, depthBufferPacking: RGBADepthPacking };
|
|
const renderer = { getRenderTarget: () => ({ width: 640, height: 360 }) };
|
|
// Before the descriptor attaches its context the test stays off.
|
|
object.onBeforeRender(renderer);
|
|
assert.equal(depth.uniforms.uGevSceneDepthOn.value, 0);
|
|
depth.attach({ findEffect: (key) => (key === 'mrt' ? mrt : undefined) });
|
|
object.onBeforeRender(renderer);
|
|
assert.equal(depth.uniforms.tGevSceneDepth.value, texture);
|
|
assert.equal(depth.uniforms.uGevSceneDepthOn.value, 1);
|
|
assert.deepEqual(depth.uniforms.uGevTargetSize.value.toArray(), [640, 360]);
|
|
assert.deepEqual(drawn, [renderer, renderer], 'the mesh hook still runs');
|
|
// Another packing would be read wrong: the mesh draws as before.
|
|
mrt.depthBufferPacking = BasicDepthPacking;
|
|
object.onBeforeRender(renderer);
|
|
assert.equal(depth.uniforms.uGevSceneDepthOn.value, 0);
|
|
assert.equal(depth.uniforms.tGevSceneDepth.value, null);
|
|
});
|
|
|
|
/** An overlay that exposes the scene's packed depth to its meshes. */
|
|
function fakeView() {
|
|
const created = [];
|
|
const mrt = {
|
|
depthBuffer: new DataTexture(),
|
|
depthBufferPacking: RGBADepthPacking,
|
|
};
|
|
const ctx = { findEffect: (key) => (key === 'mrt' ? mrt : undefined) };
|
|
const view = {
|
|
forceUpdate() {},
|
|
};
|
|
const overlay = {
|
|
ctx,
|
|
add(object) {
|
|
created.push(object);
|
|
},
|
|
remove() {},
|
|
};
|
|
return { view, overlay, created, mrt };
|
|
}
|
|
|
|
/** Every renderable under an object compiles with the test and binds depth. */
|
|
function assertTested(object, mrt) {
|
|
const renderables = [];
|
|
object.traverse?.((child) => {
|
|
if (child.material) renderables.push(child);
|
|
});
|
|
if (!object.traverse && object.material) renderables.push(object);
|
|
assert.ok(renderables.length > 0);
|
|
for (const child of renderables) {
|
|
const shader = {
|
|
uniforms: { ...(child.material.uniforms ?? {}) },
|
|
vertexShader: '',
|
|
fragmentShader:
|
|
child.material.fragmentShader ?? ShaderLib.basic.fragmentShader,
|
|
};
|
|
child.material.onBeforeCompile(shader, null);
|
|
assert.match(shader.fragmentShader, /if \(uGevSceneDepthOn > 0\.5\)/);
|
|
assert.ok(shader.uniforms.tGevSceneDepth);
|
|
child.onBeforeRender(
|
|
{
|
|
getRenderTarget: () => ({ width: 8, height: 8 }),
|
|
getViewport: (target) => target.set(0, 0, 8, 8),
|
|
},
|
|
null,
|
|
null,
|
|
child.geometry,
|
|
child.material,
|
|
);
|
|
assert.equal(shader.uniforms.tGevSceneDepth.value, mrt.depthBuffer);
|
|
assert.equal(shader.uniforms.uGevSceneDepthOn.value, 1);
|
|
}
|
|
}
|
|
|
|
test('pack meshes draw in the overlay and test the scene depth', () => {
|
|
const packs = fakeView();
|
|
const owned = [];
|
|
const port = createNavaraMeshes(packs.view, {
|
|
overlay: packs.overlay,
|
|
camera: {},
|
|
picker: { registerMeshPicker: () => () => {} },
|
|
});
|
|
const engine = Object.assign(createFakeEngine(), { meshes: port.meshes });
|
|
createPackRenderer(engine).image(
|
|
{ id: 'p', placement: { bounds: [0, 0, 0.01, 0.01], height: 300 } },
|
|
{},
|
|
{ own: (fn) => owned.push(fn) },
|
|
);
|
|
assert.equal(packs.created.length, 1);
|
|
assertTested(packs.created[0], packs.mrt);
|
|
assert.equal(packs.created[0].children[0].material.depthTest, true);
|
|
for (const release of owned) release();
|
|
port.destroy();
|
|
});
|