184 lines
9.6 KiB
JavaScript
184 lines
9.6 KiB
JavaScript
import assert from "node:assert/strict";
|
|
import fs from "node:fs";
|
|
import factory from "../../web/app/src/vendor/blender/web_engine.js";
|
|
|
|
const root = new URL("../../", import.meta.url);
|
|
const wasmBinary = fs.readFileSync(new URL("web/app/src/vendor/blender/web_engine.wasm", root));
|
|
const fixture = fs.readFileSync(new URL("tests/files/web/basic_scene.blend", root));
|
|
|
|
function open(engine, handle, bytes) {
|
|
const pointer = engine._malloc(bytes.byteLength);
|
|
try {
|
|
engine.HEAPU8.set(bytes, pointer);
|
|
assert.equal(engine._web_engine_open_blend(handle, pointer, bytes.byteLength), 0,
|
|
engine.UTF8ToString(engine._web_engine_last_error_message()));
|
|
}
|
|
finally { engine._free(pointer); }
|
|
}
|
|
|
|
function output(engine, handle, fn, owned = false) {
|
|
const dataOut = engine._malloc(4);
|
|
const lengthOut = engine._malloc(4);
|
|
try {
|
|
assert.equal(fn(handle, dataOut, lengthOut), 0, engine.UTF8ToString(engine._web_engine_last_error_message()));
|
|
const pointer = engine.HEAPU32[dataOut >>> 2];
|
|
const length = engine.HEAPU32[lengthOut >>> 2];
|
|
const bytes = engine.HEAPU8.slice(pointer, pointer + length);
|
|
if (owned) engine._web_engine_free_buffer(pointer);
|
|
return bytes;
|
|
}
|
|
finally {
|
|
engine._free(dataOut);
|
|
engine._free(lengthOut);
|
|
}
|
|
}
|
|
|
|
function snapshot(engine, handle) {
|
|
return JSON.parse(new TextDecoder().decode(output(engine, handle, engine._web_engine_get_scene_snapshot)));
|
|
}
|
|
|
|
function command(engine, handle, payload) {
|
|
const bytes = new TextEncoder().encode(JSON.stringify(payload));
|
|
const pointer = engine._malloc(bytes.byteLength);
|
|
try {
|
|
engine.HEAPU8.set(bytes, pointer);
|
|
assert.equal(engine._web_engine_apply_command(handle, pointer, bytes.byteLength), 0,
|
|
`${payload.type}: ${engine.UTF8ToString(engine._web_engine_last_error_message())}`);
|
|
}
|
|
finally { engine._free(pointer); }
|
|
}
|
|
|
|
function reject(engine, handle, payload, code) {
|
|
const bytes = new TextEncoder().encode(JSON.stringify(payload));
|
|
const pointer = engine._malloc(bytes.byteLength);
|
|
try {
|
|
engine.HEAPU8.set(bytes, pointer);
|
|
assert.notEqual(engine._web_engine_apply_command(handle, pointer, bytes.byteLength), 0);
|
|
assert.match(engine.UTF8ToString(engine._web_engine_last_error_message()), new RegExp(code));
|
|
}
|
|
finally { engine._free(pointer); }
|
|
}
|
|
|
|
function close(actual, expected, label) {
|
|
assert.ok(Math.abs(actual - expected) <= 1e-5, `${label}: ${actual} != ${expected}`);
|
|
}
|
|
|
|
function assertLighting(scene) {
|
|
const camera = scene.cameras.find((item) => item.id === "camera:Camera.001");
|
|
const light = scene.lights.find((item) => item.id === "light:Area");
|
|
const world = scene.worlds.find((item) => item.id === "world:World");
|
|
const definition = scene.scenes.find((item) => item.id === "scene:Scene");
|
|
assert.equal(camera.projection, "PERSPECTIVE");
|
|
assert.equal(camera.depthOfField.enabled, false);
|
|
assert.equal(camera.depthOfField.focusDistance, 10);
|
|
assert.equal(light.energy, 800);
|
|
assert.equal(light.exposure, 0);
|
|
assert.equal(light.castsShadow, true);
|
|
assert.equal(light.temperature, 6500);
|
|
assert.equal(world.mist.enabled, false);
|
|
assert.equal(world.mist.type, "QUADRATIC");
|
|
assert.equal(definition.renderEngine, "BLENDER_EEVEE");
|
|
assert.equal(definition.colorManagement.displayDevice, "sRGB");
|
|
assert.equal(definition.colorManagement.viewTransform, "AgX");
|
|
assert.equal(definition.colorManagement.look, "None");
|
|
assert.equal(definition.colorManagement.exposure, 0);
|
|
assert.equal(definition.colorManagement.whiteBalanceStatus, "AVAILABLE");
|
|
close(definition.colorManagement.temperature, 6500, "scene temperature");
|
|
close(definition.colorManagement.tint, 10, "scene tint");
|
|
return { camera, light, world, definition };
|
|
}
|
|
|
|
function assertEdited(scene) {
|
|
const camera = scene.cameras.find((item) => item.id === "camera:Camera.001");
|
|
const light = scene.lights.find((item) => item.id === "light:Area");
|
|
const world = scene.worlds.find((item) => item.id === "world:World");
|
|
const definition = scene.scenes.find((item) => item.id === "scene:Scene");
|
|
assert.equal(camera.projection, "ORTHOGRAPHIC");
|
|
close(camera.lensMm, 35, "camera lens");
|
|
close(camera.sensorWidthMm, 32, "camera sensor width");
|
|
close(camera.sensorHeightMm, 18, "camera sensor height");
|
|
assert.equal(camera.sensorFit, 1);
|
|
close(camera.shift[0], 0.1, "camera shift x");
|
|
close(camera.shift[1], -0.2, "camera shift y");
|
|
close(camera.near, 0.2, "camera near");
|
|
close(camera.far, 500, "camera far");
|
|
close(camera.orthoScale, 8, "camera ortho scale");
|
|
assert.equal(camera.depthOfField.enabled, true);
|
|
close(camera.depthOfField.focusDistance, 4.5, "camera focus distance");
|
|
close(camera.depthOfField.apertureFStop, 1.8, "camera aperture f-stop");
|
|
assert.equal(camera.depthOfField.apertureBlades, 7);
|
|
close(camera.depthOfField.apertureRotation, 0.25, "camera aperture rotation");
|
|
close(camera.depthOfField.apertureRatio, 1.2, "camera aperture ratio");
|
|
close(light.energy, 400, "light energy");
|
|
close(light.exposure, 1, "light exposure");
|
|
assert.equal(light.castsShadow, false);
|
|
assert.equal(light.useTemperature, true);
|
|
close(light.temperature, 5000, "light temperature");
|
|
assert.deepEqual(light.color, [0.25, 0.5, 0.75]);
|
|
close(light.radius, 0.3, "light radius");
|
|
close(light.spotAngle, 1.1, "light spot angle");
|
|
close(light.spotBlend, 0.25, "light spot blend");
|
|
close(light.areaSize, 3, "light area size");
|
|
close(light.areaSizeY, 2, "light area size y");
|
|
close(light.areaSpread, 2.4, "light area spread");
|
|
close(light.sunAngle, 0.1, "light sun angle");
|
|
assert.equal(world.mist.enabled, true);
|
|
assert.equal(world.mist.type, "LINEAR");
|
|
close(world.mist.start, 2, "mist start");
|
|
close(world.mist.depth, 50, "mist depth");
|
|
close(world.mist.intensity, 0.2, "mist intensity");
|
|
close(definition.colorManagement.exposure, 0, "preserved scene exposure");
|
|
close(definition.colorManagement.gamma, 1, "preserved scene gamma");
|
|
assert.equal(definition.colorManagement.whiteBalanceStatus, "BLOCKED");
|
|
assert.equal(definition.colorManagement.temperature, undefined);
|
|
assert.equal(definition.colorManagement.tint, undefined);
|
|
return { camera, light, world, definition };
|
|
}
|
|
|
|
const engine = await factory({ wasmBinary: wasmBinary.slice() });
|
|
const handle = engine._web_engine_create();
|
|
open(engine, handle, fixture);
|
|
const before = assertLighting(snapshot(engine, handle));
|
|
command(engine, handle, { type: "setObjectVisibility", objectId: "object:BasicCube", visible: true });
|
|
assert.equal(snapshot(engine, handle).scenes.find((item) => item.id === before.definition.id).colorManagement.whiteBalanceStatus, "AVAILABLE");
|
|
reject(engine, handle, { type: "setCameraProperties", dataId: before.camera.id, properties: { near: 10, far: 1 } }, "RENDER_PROPERTY_INVALID");
|
|
assert.equal(snapshot(engine, handle).cameras.find((item) => item.id === before.camera.id).near, before.camera.near);
|
|
command(engine, handle, { type: "setCameraProperties", dataId: before.camera.id, properties: {
|
|
projection: "ORTHOGRAPHIC", lensMm: 35, sensorWidthMm: 32, sensorHeightMm: 18,
|
|
sensorFit: 1, shift: [0.1, -0.2], near: 0.2, far: 500, orthoScale: 8,
|
|
depthOfField: { enabled: true, focusDistance: 4.5, apertureFStop: 1.8, apertureBlades: 7, apertureRotation: 0.25, apertureRatio: 1.2 },
|
|
} });
|
|
let cameraEdited = snapshot(engine, handle);
|
|
assert.equal(cameraEdited.scenes.find((item) => item.id === before.definition.id).colorManagement.whiteBalanceStatus, "BLOCKED");
|
|
assert.equal(cameraEdited.cameras.find((item) => item.id === before.camera.id).projection, "ORTHOGRAPHIC");
|
|
assert.equal(engine._web_engine_undo(handle), 0, engine.UTF8ToString(engine._web_engine_last_error_message()));
|
|
assert.equal(snapshot(engine, handle).cameras.find((item) => item.id === before.camera.id).projection, "PERSPECTIVE");
|
|
assert.equal(engine._web_engine_redo(handle), 0, engine.UTF8ToString(engine._web_engine_last_error_message()));
|
|
cameraEdited = snapshot(engine, handle);
|
|
assert.equal(cameraEdited.cameras.find((item) => item.id === before.camera.id).projection, "ORTHOGRAPHIC");
|
|
command(engine, handle, { type: "setLightProperties", dataId: before.light.id, properties: {
|
|
color: [0.25, 0.5, 0.75], energy: 400, exposure: 1, castsShadow: false,
|
|
temperature: 5000, useTemperature: true, radius: 0.3, spotAngle: 1.1, spotBlend: 0.25,
|
|
areaSize: 3, areaSizeY: 2, areaSpread: 2.4, sunAngle: 0.1,
|
|
} });
|
|
assert.equal(snapshot(engine, handle).scenes.find((item) => item.id === before.definition.id).colorManagement.whiteBalanceStatus, "BLOCKED");
|
|
command(engine, handle, { type: "setWorldProperties", dataId: before.world.id, properties: {
|
|
color: [0.1, 0.2, 0.3], exposure: 0.5,
|
|
mist: { enabled: true, type: "LINEAR", start: 2, depth: 50, intensity: 0.2, height: 3 },
|
|
} });
|
|
assert.equal(snapshot(engine, handle).scenes.find((item) => item.id === before.definition.id).colorManagement.whiteBalanceStatus, "BLOCKED");
|
|
assertEdited(snapshot(engine, handle));
|
|
assert.equal(engine._web_engine_undo(handle), 0, engine.UTF8ToString(engine._web_engine_last_error_message()));
|
|
assert.equal(snapshot(engine, handle).worlds.find((item) => item.id === before.world.id).mist.enabled, false);
|
|
assert.equal(engine._web_engine_redo(handle), 0, engine.UTF8ToString(engine._web_engine_last_error_message()));
|
|
assertEdited(snapshot(engine, handle));
|
|
const saved = output(engine, handle, engine._web_engine_save_blend, true);
|
|
engine._web_engine_destroy(handle);
|
|
|
|
const reopened = engine._web_engine_create();
|
|
open(engine, reopened, saved);
|
|
assertEdited(snapshot(engine, reopened));
|
|
engine._web_engine_destroy(reopened);
|
|
|
|
process.stdout.write("lighting-roundtrip-ok camera-writer-dof=passed light-shadow-exposure=passed world-mist=passed color-management-reader=passed white-balance-gate=passed undo-redo=passed save-reopen=passed\n");
|