LucaP
08f3ac18c2
Exercise sign state updates and composition together, covering responsive placement, grounding, label reuse, resource ownership, and departure motion. Update poster and visual-model expectations while retaining behavioral checks. Validation: 46 focused tests passed before commit. The preceding full build:preview run passed all 673 tests plus typecheck, builds, prerender, artifact verification, and transfer budgets.
638 lines
24 KiB
TypeScript
638 lines
24 KiB
TypeScript
import { describe, expect, it, vi } from "vitest";
|
|
import * as THREE from "three";
|
|
import type { EnvironmentChapter } from "@/journey/types";
|
|
import { renderQualityFor } from "@/scene/render-quality";
|
|
import { SceneResourceBag } from "@/scene/resources";
|
|
import {
|
|
CHAPTER_PALETTES,
|
|
createMutableChapterPalette,
|
|
writeChapterPalette,
|
|
} from "@/scene/world/palette";
|
|
import { createRoad } from "@/scene/world/road";
|
|
import { createTerrain } from "@/scene/world/terrain";
|
|
import { createSun } from "@/scene/world/sun";
|
|
import { createAtmosphere } from "@/scene/world/atmosphere";
|
|
import { createPostProcessor } from "@/scene/post-processing";
|
|
import { createCar } from "@/scene/world/car";
|
|
import { createChaseCamera, createWorldFog } from "@/scene/world/environment";
|
|
import {
|
|
HORIZON_FOG_END,
|
|
HORIZON_FOG_START,
|
|
} from "@/scene/world/metrics";
|
|
import { createDriveDynamics } from "@/scene/drive-dynamics";
|
|
import { createTravelDistance } from "@/scene/world/travel-distance";
|
|
|
|
describe("procedural world models", () => {
|
|
it("uses the same linear horizon interval for scene-owned materials", () => {
|
|
const fog = createWorldFog(0x07101c);
|
|
|
|
expect(fog).toBeInstanceOf(THREE.Fog);
|
|
expect(fog.near).toBe(HORIZON_FOG_START);
|
|
expect(fog.far).toBe(HORIZON_FOG_END);
|
|
});
|
|
|
|
it("owns one monotonic forward-distance clock across cruise, input release, and delayed frames", () => {
|
|
const travel = createTravelDistance();
|
|
|
|
const cruise = travel.advance(0.1, 0.18, 0);
|
|
const accelerated = travel.advance(0.1, 1, 1);
|
|
const coast = travel.advance(0.1, 0.18, 0);
|
|
const delayed = travel.advance(4, 0.18, 0);
|
|
const malformed = travel.advance(Number.NaN, -1, Number.POSITIVE_INFINITY);
|
|
|
|
expect(cruise).toBeGreaterThan(0);
|
|
expect(accelerated).toBeGreaterThan(cruise);
|
|
expect(coast).toBeGreaterThan(accelerated);
|
|
expect(delayed).toBeGreaterThan(coast);
|
|
expect(delayed - coast).toBeCloseTo(cruise, 10);
|
|
expect(malformed).toBe(delayed);
|
|
expect(travel.snapshot()).toBe(delayed);
|
|
});
|
|
|
|
it("scales geometry and atmosphere work monotonically by live quality tier", () => {
|
|
const high = renderQualityFor("high", 3, false);
|
|
const medium = renderQualityFor("medium", 3, false);
|
|
const low = renderQualityFor("low", 3, false);
|
|
|
|
expect(high.roadSegments).toBeGreaterThan(medium.roadSegments);
|
|
expect(medium.roadSegments).toBeGreaterThan(low.roadSegments);
|
|
expect(high.terrainSegments).toBeGreaterThan(medium.terrainSegments);
|
|
expect(medium.terrainSegments).toBeGreaterThan(low.terrainSegments);
|
|
expect(high.streakCount).toBeGreaterThan(low.streakCount);
|
|
expect(low.postEffects).toBe(false);
|
|
});
|
|
|
|
it("builds a shader road whose motion is entirely uniform-driven", () => {
|
|
const resources = new SceneResourceBag();
|
|
const road = createRoad(resources, renderQualityFor("high", 1, false));
|
|
const surface = road.group.getObjectByName(
|
|
"road-surface",
|
|
) as ShaderRenderable;
|
|
|
|
expect(surface).toBeInstanceOf(THREE.Mesh);
|
|
expect(surface.geometry.index).not.toBeNull();
|
|
expect(surface.geometry.getAttribute("position").count).toBeGreaterThan(
|
|
1_000,
|
|
);
|
|
surface.geometry.computeBoundingBox();
|
|
expect(surface.geometry.boundingBox?.min.z).toBeLessThan(-700);
|
|
expect(surface.material.uniforms).toMatchObject({
|
|
uDistance: { value: 0 },
|
|
uSpeed: { value: 0 },
|
|
uAcceleration: { value: 0 },
|
|
uFogColor: { value: expect.any(THREE.Color) },
|
|
});
|
|
expect(surface.material.fragmentShader).toContain("centerLane");
|
|
expect(surface.material.fragmentShader).toContain("outerEdge");
|
|
|
|
const positionArray = surface.geometry.getAttribute("position").array;
|
|
const before = resources.snapshot();
|
|
for (let index = 0; index < 300; index += 1) {
|
|
road.update(index * 0.5, 0.65, 0.4);
|
|
}
|
|
|
|
expect(resources.snapshot()).toEqual(before);
|
|
expect(surface.geometry.getAttribute("position").array).toBe(positionArray);
|
|
expect(surface.material.uniforms.uDistance?.value).toBe(149.5);
|
|
expect(surface.material.uniforms.uSpeed?.value).toBe(0.65);
|
|
expect(surface.material.uniforms.uAcceleration?.value).toBe(0.4);
|
|
resources.dispose();
|
|
});
|
|
|
|
it("builds one wide indexed line terrain with a flat road-center mask", () => {
|
|
const resources = new SceneResourceBag();
|
|
const terrain = createTerrain(
|
|
resources,
|
|
renderQualityFor("medium", 1, false),
|
|
);
|
|
const lines = terrain.group.getObjectByName(
|
|
"terrain-grid",
|
|
) as ShaderRenderable;
|
|
|
|
expect(lines).toBeInstanceOf(THREE.LineSegments);
|
|
expect(lines.geometry.index).not.toBeNull();
|
|
lines.geometry.computeBoundingBox();
|
|
expect(lines.geometry.boundingBox).not.toBeNull();
|
|
expect(lines.geometry.boundingBox?.min.z).toBeLessThan(-700);
|
|
expect(
|
|
(lines.geometry.boundingBox?.max.x ?? 0) -
|
|
(lines.geometry.boundingBox?.min.x ?? 0),
|
|
).toBeGreaterThan(120);
|
|
|
|
const roadMask = lines.geometry.getAttribute("roadMask");
|
|
expect(roadMask).toBeDefined();
|
|
const maskValues = Array.from(roadMask.array as ArrayLike<number>);
|
|
expect(Math.min(...maskValues)).toBe(0);
|
|
expect(Math.max(...maskValues)).toBeGreaterThan(0.99);
|
|
expect(lines.material.uniforms).toMatchObject({
|
|
uDistance: { value: 0 },
|
|
uSpeed: { value: 0 },
|
|
uFlowDistance: { value: 0 },
|
|
uRouteProgress: { value: 0 },
|
|
uRelief: { value: expect.any(Number) },
|
|
uFogColor: { value: expect.any(THREE.Color) },
|
|
});
|
|
expect(lines.material.vertexShader).toContain("multiOctaveNoise");
|
|
expect(lines.material.vertexShader).toContain("mod(point, 256.0)");
|
|
|
|
const indexArray = lines.geometry.index?.array;
|
|
const positionArray = lines.geometry.getAttribute("position").array;
|
|
const lowColor = lines.material.uniforms.uLowColor?.value;
|
|
const highColor = lines.material.uniforms.uHighColor?.value;
|
|
const before = resources.snapshot();
|
|
for (let index = 0; index < 300; index += 1) {
|
|
terrain.update(index * 0.4, 0.7, "builds", index / 299);
|
|
}
|
|
|
|
expect(resources.snapshot()).toEqual(before);
|
|
expect(lines.geometry.index?.array).toBe(indexArray);
|
|
expect(lines.geometry.getAttribute("position").array).toBe(positionArray);
|
|
expect(lines.material.uniforms.uLowColor?.value).toBe(lowColor);
|
|
expect(lines.material.uniforms.uHighColor?.value).toBe(highColor);
|
|
expect(lines.material.uniforms.uRouteProgress?.value).toBe(1);
|
|
resources.dispose();
|
|
});
|
|
|
|
it("writes deterministic chapter blends into stable color allocations", () => {
|
|
const target = createMutableChapterPalette("deep-night");
|
|
const colorReferences = [
|
|
target.sky,
|
|
target.fog,
|
|
target.terrainLow,
|
|
target.terrainHigh,
|
|
target.sun,
|
|
target.haze,
|
|
];
|
|
|
|
expect(Object.keys(CHAPTER_PALETTES)).toEqual([
|
|
"deep-night",
|
|
"systems",
|
|
"infrastructure",
|
|
"builds",
|
|
"pre-dawn",
|
|
"destination",
|
|
] satisfies EnvironmentChapter[]);
|
|
expect(writeChapterPalette(target, "deep-night", "destination", 0.5)).toBe(
|
|
target,
|
|
);
|
|
const first = paletteSnapshot(target);
|
|
expect(writeChapterPalette(target, "deep-night", "destination", 0.5)).toBe(
|
|
target,
|
|
);
|
|
expect(paletteSnapshot(target)).toEqual(first);
|
|
expect([
|
|
target.sky,
|
|
target.fog,
|
|
target.terrainLow,
|
|
target.terrainHigh,
|
|
target.sun,
|
|
target.haze,
|
|
]).toEqual(colorReferences);
|
|
expect(target.warmth).toBeGreaterThan(
|
|
CHAPTER_PALETTES["deep-night"].warmth,
|
|
);
|
|
expect(target.warmth).toBeLessThan(CHAPTER_PALETTES.destination.warmth);
|
|
});
|
|
|
|
it("updates the sun's palette and motion inputs without reallocating its disc and halo", () => {
|
|
const resources = new SceneResourceBag();
|
|
const sun = createSun(resources);
|
|
const disc = sun.group.getObjectByName("horizon-sun") as ShaderRenderable;
|
|
const halo = sun.group.getObjectByName("horizon-halo");
|
|
const limb = sun.group.getObjectByName("sun-limb-glow");
|
|
const bleed = sun.group.getObjectByName("horizon-light-bleed");
|
|
|
|
expect(disc).toBeInstanceOf(THREE.Mesh);
|
|
expect(halo).toBeInstanceOf(THREE.Sprite);
|
|
expect(limb).toBeInstanceOf(THREE.Mesh);
|
|
expect(bleed).toBeInstanceOf(THREE.Sprite);
|
|
expect((disc as unknown as { position: { z: number } }).position.z).toBeLessThan(-650);
|
|
expect(disc.material.uniforms).toMatchObject({
|
|
uScanBands: { value: 11 },
|
|
uWarmth: { value: CHAPTER_PALETTES["deep-night"].warmth },
|
|
uTime: { value: 0 },
|
|
uDriveEnergy: { value: 0 },
|
|
});
|
|
expect(resources.snapshot().owned.texture).toBe(1);
|
|
const allocation = resources.snapshot();
|
|
const color = disc.material.uniforms.uColor!.value as { getHex(): number };
|
|
const initialColor = color.getHex();
|
|
|
|
const palette = createMutableChapterPalette("destination");
|
|
sun.update(palette, 1, 3.2, 1);
|
|
expect(disc.material.uniforms.uWarmth?.value).toBe(1);
|
|
expect(disc.material.uniforms.uRouteProgress?.value).toBe(1);
|
|
expect(disc.material.uniforms.uDriveEnergy?.value).toBe(1);
|
|
expect(disc.material.uniforms.uTime?.value).toBe(3.2);
|
|
expect(disc.material.uniforms.uColor?.value).toBe(color);
|
|
expect(color.getHex()).not.toBe(initialColor);
|
|
expect(resources.snapshot()).toEqual(allocation);
|
|
resources.dispose();
|
|
});
|
|
|
|
it("builds deterministic stars, a palette-driven sky, and quality-capped speed streaks", () => {
|
|
const highResources = new SceneResourceBag();
|
|
const lowResources = new SceneResourceBag();
|
|
const highQuality = renderQualityFor("high", 1, false);
|
|
const lowQuality = renderQualityFor("low", 1, true);
|
|
const high = createAtmosphere(highResources, highQuality);
|
|
const low = createAtmosphere(lowResources, lowQuality);
|
|
const highStars = high.group.getObjectByName(
|
|
"atmosphere-stars",
|
|
) as ShaderRenderable;
|
|
const lowStars = low.group.getObjectByName(
|
|
"atmosphere-stars",
|
|
) as ShaderRenderable;
|
|
const highStreaks = high.group.getObjectByName(
|
|
"speed-streaks",
|
|
) as ShaderRenderable;
|
|
const lowStreaks = low.group.getObjectByName(
|
|
"speed-streaks",
|
|
) as ShaderRenderable;
|
|
|
|
expect(highStars.geometry.getAttribute("position").count).toBe(
|
|
highQuality.starCount,
|
|
);
|
|
expect(lowStars.geometry.getAttribute("position").count).toBe(
|
|
lowQuality.starCount,
|
|
);
|
|
expect(highStars.material.uniforms).toMatchObject({
|
|
uPointScale: { value: 18 },
|
|
uMaxPointSize: { value: 4.5 },
|
|
});
|
|
expect(highStreaks.geometry.getAttribute("position").count).toBe(
|
|
highQuality.streakCount * 2,
|
|
);
|
|
expect(lowStreaks.geometry.getAttribute("position").count).toBe(
|
|
lowQuality.streakCount * 2,
|
|
);
|
|
const sky = high.group.getObjectByName("atmosphere-sky") as ShaderRenderable & {
|
|
frustumCulled: boolean;
|
|
};
|
|
sky.geometry.computeBoundingBox();
|
|
expect(sky.geometry.boundingBox?.min.x).toBeCloseTo(-1, 6);
|
|
expect(sky.geometry.boundingBox?.max.x).toBeCloseTo(1, 6);
|
|
expect(sky.frustumCulled).toBe(false);
|
|
expect(sky.material.depthTest).toBe(false);
|
|
const hazeColor = sky.material.uniforms.uHazeColor!.value as { getHex(): number };
|
|
const initialHaze = hazeColor.getHex();
|
|
expect(
|
|
(high.group.getObjectByName("distant-silhouettes") as { children: unknown[] })
|
|
.children,
|
|
).toHaveLength(3);
|
|
|
|
const highStarPositions = Array.from(
|
|
highStars.geometry.getAttribute("position").array,
|
|
);
|
|
const secondResources = new SceneResourceBag();
|
|
const secondHigh = createAtmosphere(secondResources, highQuality);
|
|
const secondStars = secondHigh.group.getObjectByName(
|
|
"atmosphere-stars",
|
|
) as ShaderRenderable;
|
|
expect(
|
|
Array.from(secondStars.geometry.getAttribute("position").array),
|
|
).toEqual(highStarPositions);
|
|
|
|
const palette = createMutableChapterPalette("builds");
|
|
const before = highResources.snapshot();
|
|
for (let index = 0; index < 300; index += 1) {
|
|
high.update(index, 0.7, 0.8, palette);
|
|
}
|
|
expect(highResources.snapshot()).toEqual(before);
|
|
expect(sky.material.uniforms.uHazeColor!.value).toBe(hazeColor);
|
|
expect(hazeColor.getHex()).toBe(palette.haze.getHex());
|
|
expect(hazeColor.getHex()).not.toBe(initialHaze);
|
|
expect(highStreaks.material.uniforms.uAcceleration?.value).toBe(0.8);
|
|
expect(highStreaks.material.uniforms.uVisibility?.value).toBeGreaterThan(0);
|
|
|
|
high.update(100, 1, 1, palette);
|
|
const acceleratedPhase = highStreaks.material.uniforms.uDistance?.value as number;
|
|
high.update(102, 0.18, 0, palette);
|
|
const coastPhase = highStreaks.material.uniforms.uDistance?.value as number;
|
|
expect(coastPhase).toBeGreaterThan(acceleratedPhase);
|
|
|
|
high.setViewportAspect(32 / 9);
|
|
expect(sky.material.uniforms.uAspect?.value).toBeCloseTo(32 / 9, 6);
|
|
|
|
highResources.dispose();
|
|
lowResources.dispose();
|
|
secondResources.dispose();
|
|
});
|
|
|
|
it("keeps independent inertial response curves for the road, chase rig, streaks, bloom, and suspension", () => {
|
|
const dynamics = createDriveDynamics();
|
|
const stableSnapshot = dynamics.snapshot();
|
|
|
|
dynamics.update(1, 1, 0.1);
|
|
const attack = { ...dynamics.snapshot() };
|
|
expect(dynamics.snapshot()).toBe(stableSnapshot);
|
|
expect(attack.roadEnergy).toBeGreaterThan(attack.cameraEnergy);
|
|
expect(attack.cameraEnergy).toBeGreaterThan(attack.bloomEnergy);
|
|
expect(attack.streakEnergy).toBeGreaterThan(0);
|
|
expect(attack.suspensionEnergy).toBeGreaterThan(0);
|
|
expect(attack.directionBias).toBeGreaterThan(0);
|
|
|
|
dynamics.update(0, 0, 0.1);
|
|
const coast = dynamics.snapshot();
|
|
expect(coast.roadEnergy).toBeLessThan(attack.roadEnergy);
|
|
expect(coast.streakEnergy / attack.streakEnergy).toBeGreaterThan(
|
|
coast.roadEnergy / attack.roadEnergy,
|
|
);
|
|
expect(coast.bloomEnergy).toBeGreaterThan(0);
|
|
|
|
dynamics.update(1, -1, 10);
|
|
expect(Object.values(dynamics.snapshot()).every(Number.isFinite)).toBe(true);
|
|
expect(dynamics.snapshot().directionBias).toBeLessThan(1);
|
|
});
|
|
|
|
it("disposes a composer and its passes exactly once", () => {
|
|
const resources = new SceneResourceBag();
|
|
const target = (width: number, height: number, depthBuffer: boolean) => ({
|
|
width,
|
|
height,
|
|
depthBuffer,
|
|
samples: 1,
|
|
dispose: vi.fn(),
|
|
});
|
|
const composer = {
|
|
addPass: vi.fn(),
|
|
setPixelRatio: vi.fn(),
|
|
setSize: vi.fn(),
|
|
render: vi.fn(),
|
|
dispose: vi.fn(),
|
|
renderTarget1: target(1_500, 1_000, true),
|
|
renderTarget2: target(1_500, 1_000, true),
|
|
};
|
|
const renderPass = {
|
|
scene: null,
|
|
camera: null,
|
|
setSize: vi.fn(),
|
|
dispose: vi.fn(),
|
|
};
|
|
const bloomPass = {
|
|
strength: 0.54,
|
|
radius: 0.42,
|
|
threshold: 0.88,
|
|
setSize: vi.fn(),
|
|
dispose: vi.fn(),
|
|
renderTargetBright: target(750, 500, false),
|
|
renderTargetsHorizontal: [target(375, 250, false)],
|
|
renderTargetsVertical: [target(375, 250, false)],
|
|
};
|
|
const outputPass = {
|
|
setSize: vi.fn(),
|
|
dispose: vi.fn(),
|
|
};
|
|
const processor = createPostProcessor(
|
|
resources,
|
|
{},
|
|
{
|
|
createComposer: () => composer,
|
|
createRenderPass: () => renderPass,
|
|
createBloomPass: () => bloomPass,
|
|
createOutputPass: () => outputPass,
|
|
},
|
|
);
|
|
|
|
processor.resize(1_200, 800, 1.25);
|
|
processor.setDynamics(0);
|
|
const restingBloom = { strength: bloomPass.strength, threshold: bloomPass.threshold };
|
|
processor.setDynamics(0.75);
|
|
expect(bloomPass.strength).toBeGreaterThan(restingBloom.strength);
|
|
expect(bloomPass.threshold).toBeLessThan(restingBloom.threshold);
|
|
processor.setDynamics(0);
|
|
expect(bloomPass.strength).toBe(restingBloom.strength);
|
|
expect(bloomPass.threshold).toBe(restingBloom.threshold);
|
|
processor.render({}, {});
|
|
const allocations = resources.gpuBudgetSnapshot({
|
|
tier: "high",
|
|
defaultFramebuffer: {
|
|
width: 1_500,
|
|
height: 1_000,
|
|
bytesPerPixel: 4,
|
|
attachments: 2,
|
|
samples: 4,
|
|
},
|
|
});
|
|
expect(
|
|
allocations.renderTargets.map((allocation) => allocation.id),
|
|
).toEqual(
|
|
expect.arrayContaining([
|
|
"composer-target-1",
|
|
"composer-target-2",
|
|
"bloom-bright",
|
|
"bloom-horizontal-0",
|
|
"bloom-vertical-0",
|
|
]),
|
|
);
|
|
processor.dispose();
|
|
processor.dispose();
|
|
resources.dispose();
|
|
|
|
expect(composer.addPass).toHaveBeenCalledTimes(3);
|
|
expect(composer.addPass).toHaveBeenLastCalledWith(outputPass);
|
|
expect(composer.setPixelRatio).toHaveBeenCalledWith(1.25);
|
|
expect(composer.setSize).toHaveBeenCalledWith(1_200, 800);
|
|
expect(composer.render).toHaveBeenCalledOnce();
|
|
expect(renderPass.dispose).toHaveBeenCalledOnce();
|
|
expect(bloomPass.dispose).toHaveBeenCalledOnce();
|
|
expect(outputPass.dispose).toHaveBeenCalledOnce();
|
|
expect(composer.dispose).toHaveBeenCalledOnce();
|
|
});
|
|
|
|
it("keeps the grand tourer anatomy readable in desktop and portrait chase views", () => {
|
|
const resources = new SceneResourceBag();
|
|
const car = createCar(resources);
|
|
for (const name of [
|
|
"rear-silhouette",
|
|
"rear-body-face",
|
|
"rear-light-bar",
|
|
"rear-glass",
|
|
"rear-glass-panel",
|
|
"rear-fascia",
|
|
"rear-wheel-left",
|
|
"rear-wheel-right",
|
|
"car-underglow",
|
|
"car-contact-shadow",
|
|
]) {
|
|
expect(car.group.getObjectByName(name), name).toBeDefined();
|
|
}
|
|
|
|
const desktopCamera = createChaseCamera(16 / 9);
|
|
const desktop = projectedBounds(car.group, desktopCamera);
|
|
expect(desktop.maxX - desktop.minX).toBeGreaterThan(0.28);
|
|
expect(desktop.minX).toBeGreaterThan(-0.96);
|
|
expect(desktop.maxX).toBeLessThan(0.96);
|
|
expect(desktop.minY).toBeGreaterThan(-0.99);
|
|
expect(desktop.maxY).toBeLessThan(-0.05);
|
|
|
|
car.setDetail("reduced");
|
|
// The live scene recenters and pulls the lens back on portrait displays.
|
|
// Use that settled framing fixture, not the initial desktop chase pose.
|
|
const portraitCamera = new THREE.PerspectiveCamera(61, 390 / 844, 0.1, 1200);
|
|
portraitCamera.position.set(0, 6.5, 31);
|
|
portraitCamera.lookAt(0, 3.5, -88);
|
|
portraitCamera.setViewOffset(390, 844, 0, -844 * 0.16, 390, 844);
|
|
const portrait = projectedBounds(car.group, portraitCamera);
|
|
expect(portrait.minX).toBeGreaterThan(-0.99);
|
|
expect(portrait.maxX).toBeLessThan(0.99);
|
|
expect(portrait.minY).toBeGreaterThan(-0.99);
|
|
expect(portrait.maxY).toBeLessThan(0.16);
|
|
expect(
|
|
(car.group.getObjectByName("secondary-detail") as { visible: boolean })
|
|
.visible,
|
|
).toBe(false);
|
|
resources.dispose();
|
|
});
|
|
|
|
it("wraps the authored GLB hierarchy without rebuilding it during animation", () => {
|
|
const resources = new SceneResourceBag();
|
|
const authored = new THREE.Group();
|
|
authored.name = "chase-car";
|
|
for (const name of [
|
|
"car-body",
|
|
"rear-glass",
|
|
"rear-light-bar",
|
|
"rear-diffuser",
|
|
"car-underglow-source",
|
|
]) {
|
|
const material = name === "rear-light-bar"
|
|
? new THREE.MeshStandardMaterial({ emissive: 0xff174f, emissiveIntensity: 8 })
|
|
: new THREE.MeshStandardMaterial();
|
|
const mesh = new THREE.Mesh(new THREE.BoxGeometry(1, 1, 1), material);
|
|
mesh.name = name;
|
|
authored.add(mesh);
|
|
}
|
|
|
|
const car = createCar(resources, authored);
|
|
const childCount = (car.group as { children: unknown[] }).children.length;
|
|
expect(
|
|
(car.group.getObjectByName("grand-tourer-model") as { rotation: { y: number } })
|
|
.rotation.y,
|
|
).toBeCloseTo(Math.PI, 6);
|
|
expect(car.group.getObjectByName("car-body")).toBeDefined();
|
|
const body = car.group.getObjectByName("car-body") as {
|
|
material: { emissive: { getHex(): number }; emissiveIntensity: number };
|
|
};
|
|
expect(body.material.emissive.getHex()).not.toBe(0);
|
|
expect(body.material.emissiveIntensity).toBeGreaterThan(0);
|
|
expect(body.material.emissiveIntensity).toBeLessThan(1);
|
|
const material = body.material;
|
|
const allocation = resources.snapshot();
|
|
expect(car.group.getObjectByName("rear-glass")).toBeDefined();
|
|
expect(car.group.getObjectByName("rear-light-bar")).toBeDefined();
|
|
expect(car.group.getObjectByName("car-underglow")).toBeDefined();
|
|
expect(car.group.getObjectByName("car-contact-shadow")).toBeDefined();
|
|
|
|
for (let frame = 0; frame < 60; frame += 1) {
|
|
car.update(0.8, 0.7, frame / 60);
|
|
}
|
|
expect((car.group as { children: unknown[] }).children).toHaveLength(childCount);
|
|
expect(body.material).toBe(material);
|
|
expect(resources.snapshot()).toEqual(allocation);
|
|
expect(resources.snapshot().owned.geometry).toBeGreaterThanOrEqual(6);
|
|
resources.dispose();
|
|
});
|
|
|
|
it("damps squat and light response without allocating or changing the scene graph", () => {
|
|
const resources = new SceneResourceBag();
|
|
const car = createCar(resources);
|
|
const light = car.group.getObjectByName("rear-light-bar") as {
|
|
material: { emissiveIntensity: number };
|
|
};
|
|
const underglow = car.group.getObjectByName("car-underglow") as {
|
|
material: { uniforms: Record<string, { value: number }> };
|
|
};
|
|
car.update(0.3, 0, 0);
|
|
const restingY = (car.group as { position: { y: number } }).position.y;
|
|
const restingLight = light.material.emissiveIntensity;
|
|
const restingGlow = underglow.material.uniforms.uOpacity?.value ?? 0;
|
|
const childCount = (car.group as { children: unknown[] }).children.length;
|
|
const allocation = resources.snapshot();
|
|
|
|
for (let frame = 1; frame <= 60; frame += 1) {
|
|
car.update(0.92, 1, frame / 60);
|
|
}
|
|
|
|
expect((car.group as { position: { y: number } }).position.y).toBeLessThan(
|
|
restingY,
|
|
);
|
|
expect(light.material.emissiveIntensity).toBeGreaterThan(restingLight);
|
|
expect(underglow.material.uniforms.uOpacity?.value).toBeGreaterThan(
|
|
restingGlow,
|
|
);
|
|
expect(
|
|
Math.abs((car.group as { rotation: { z: number } }).rotation.z),
|
|
).toBeLessThanOrEqual(0.006);
|
|
expect((car.group as { children: unknown[] }).children).toHaveLength(
|
|
childCount,
|
|
);
|
|
expect(resources.snapshot()).toEqual(allocation);
|
|
resources.dispose();
|
|
});
|
|
|
|
});
|
|
|
|
function paletteSnapshot(
|
|
palette: ReturnType<typeof createMutableChapterPalette>,
|
|
) {
|
|
return {
|
|
sky: palette.sky.getHex(),
|
|
fog: palette.fog.getHex(),
|
|
terrainLow: palette.terrainLow.getHex(),
|
|
terrainHigh: palette.terrainHigh.getHex(),
|
|
sun: palette.sun.getHex(),
|
|
haze: palette.haze.getHex(),
|
|
warmth: palette.warmth,
|
|
terrainEnergy: palette.terrainEnergy,
|
|
starVisibility: palette.starVisibility,
|
|
streakEnergy: palette.streakEnergy,
|
|
};
|
|
}
|
|
|
|
interface ShaderRenderable {
|
|
geometry: {
|
|
index: { array: ArrayLike<number> } | null;
|
|
boundingBox: { min: { x: number; z: number }; max: { x: number; z: number } } | null;
|
|
computeBoundingBox(): void;
|
|
getAttribute(name: string): { count: number; array: ArrayLike<number> };
|
|
};
|
|
material: {
|
|
uniforms: Record<string, { value: unknown }>;
|
|
vertexShader: string;
|
|
fragmentShader: string;
|
|
depthTest: boolean;
|
|
};
|
|
}
|
|
|
|
function projectedBounds(group: unknown, camera: unknown) {
|
|
const typedGroup = group as { updateMatrixWorld(force: boolean): void };
|
|
const typedCamera = camera as { updateMatrixWorld(force: boolean): void };
|
|
typedGroup.updateMatrixWorld(true);
|
|
typedCamera.updateMatrixWorld(true);
|
|
const bounds = new THREE.Box3().setFromObject(group);
|
|
const projected = boxCorners(bounds).map((point) => point.project(camera));
|
|
return {
|
|
minX: Math.min(...projected.map((point) => point.x)),
|
|
maxX: Math.max(...projected.map((point) => point.x)),
|
|
minY: Math.min(...projected.map((point) => point.y)),
|
|
maxY: Math.max(...projected.map((point) => point.y)),
|
|
};
|
|
}
|
|
|
|
function boxCorners(bounds: {
|
|
min: { x: number; y: number; z: number };
|
|
max: { x: number; y: number; z: number };
|
|
}) {
|
|
return [
|
|
new THREE.Vector3(bounds.min.x, bounds.min.y, bounds.min.z),
|
|
new THREE.Vector3(bounds.min.x, bounds.min.y, bounds.max.z),
|
|
new THREE.Vector3(bounds.min.x, bounds.max.y, bounds.min.z),
|
|
new THREE.Vector3(bounds.min.x, bounds.max.y, bounds.max.z),
|
|
new THREE.Vector3(bounds.max.x, bounds.min.y, bounds.min.z),
|
|
new THREE.Vector3(bounds.max.x, bounds.min.y, bounds.max.z),
|
|
new THREE.Vector3(bounds.max.x, bounds.max.y, bounds.min.z),
|
|
new THREE.Vector3(bounds.max.x, bounds.max.y, bounds.max.z),
|
|
];
|
|
}
|