167 lines
9.7 KiB
JavaScript
167 lines
9.7 KiB
JavaScript
const test = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const fs = require('node:fs');
|
|
const path = require('node:path');
|
|
const vm = require('node:vm');
|
|
|
|
function harness() {
|
|
// These tests exercise Z-axis rotations; Blockbench supplies full Three.js at runtime.
|
|
class Quaternion {
|
|
constructor() { this.angle = 0; }
|
|
setFromEuler(euler) { this.angle = euler.z; return this; }
|
|
multiply(other) { this.angle += other.angle; return this; }
|
|
invert() { this.angle = -this.angle; return this; }
|
|
toArray() { return [0, 0, Math.sin(this.angle / 2), Math.cos(this.angle / 2)]; }
|
|
fromArray(values) { this.angle = 2 * Math.atan2(values[2], values[3]); return this; }
|
|
}
|
|
class Euler {
|
|
constructor(x = 0, y = 0, z = 0) { Object.assign(this, { x, y, z }); }
|
|
setFromQuaternion(q) { this.x = this.y = 0; this.z = q.angle; return this; }
|
|
}
|
|
class Vector3 {
|
|
constructor(...values) { this.values = values; }
|
|
sub(other) { this.values = this.values.map((v, i) => v - other.values[i]); return this; }
|
|
add(other) { this.values = this.values.map((v, i) => v + other.values[i]); return this; }
|
|
applyQuaternion(q) {
|
|
const [x, y, z] = this.values, c = Math.cos(q.angle), s = Math.sin(q.angle);
|
|
this.values = [x * c - y * s, x * s + y * c, z]; return this;
|
|
}
|
|
toArray() { return this.values; }
|
|
}
|
|
class Group {
|
|
constructor(name, parent) { Object.assign(this, { name, origin: [1, 2, 3], rotation: [0, 0, 0], children: [], parent }); parent?.children.push(this); }
|
|
}
|
|
const h = { Group, Cube: class {}, THREE: { Quaternion, Euler, Vector3 },
|
|
Format: { id: 'geckolib_model', euler_order: 'ZYX' }, Plugin: { register() {} } };
|
|
const source = fs.readFileSync(path.join(__dirname, '..', 'AnimationDirector.js'), 'utf8').replace(' Plugin.register(PLUGIN_ID, {',
|
|
' globalThis.api = { cemTemplateCatalog, jemPresetParts, jemTransferSuggestions, validateJemChoices, jemAdditionBones, addJemEnergyVisibility, refreshJemEnergyFields, jemTransferTransform, createJemTransferProject };\n Plugin.register(PLUGIN_ID, {');
|
|
vm.runInNewContext(source, h);
|
|
return h;
|
|
}
|
|
|
|
test('JEM preset parent paths include attachment roots and nested groups', () => {
|
|
const h = harness();
|
|
const parts = h.api.jemPresetParts({ models: [{ part: 'body', submodels: [{ id: 'fur', submodels: [{ id: 'tip' }] }] }, { part: 'head' }] });
|
|
assert.deepEqual(Array.from(parts, (part) => [part.name, part.path]), [['body', '0'], ['fur', '0/0'], ['tip', '0/0/0'], ['head', '1']]);
|
|
});
|
|
|
|
test('JEM transfer compensates different parent rotations without rotating children twice', () => {
|
|
const h = harness(), body = new h.Group('actor1_body'), extra = new h.Group('actor1_extra', body);
|
|
body.rotation = [0, 0, 90]; extra.origin = [2, 2, 3]; extra.rotation = [0, 0, 10];
|
|
const suggestions = h.api.jemTransferSuggestions([body, extra], [{ name: 'body', path: '0' }], 1);
|
|
const addition = h.api.validateJemChoices(suggestions, { include_0: true, parent_0: '0' })[0];
|
|
const target = new h.Group('body'); target.origin = [10, 20, 30];
|
|
const transform = h.api.jemTransferTransform(addition, target);
|
|
transform.offset.forEach((value, axis) => assert.ok(Math.abs(value - [8, 19, 27][axis]) < 1e-8));
|
|
assert.ok(Math.abs(transform.rotation[2] - 100) < 1e-8);
|
|
assert.deepEqual(Array.from(addition.tree.rotation), [0, 0, 10]);
|
|
});
|
|
|
|
test('JEM creation rescales GeckoLib UVs but preserves per-texture UVs in other formats', () => {
|
|
for (const projectWide of [false, true]) {
|
|
const h = harness(), cubes = [];
|
|
h.Group.all = [];
|
|
h.Group.prototype.init = function() { h.Group.all.push(this); return this; };
|
|
h.Group.prototype.addTo = function(parent) { this.parent = parent; parent.children.push(this); return this; };
|
|
h.Cube = class {
|
|
constructor(data) { Object.assign(this, data); cubes.push(this); }
|
|
addTo(parent) { parent.children.push(this); return this; }
|
|
init() { return this; }
|
|
};
|
|
h.Texture = class {
|
|
constructor(data) { Object.assign(this, data, { uuid: 'texture' }); }
|
|
fromDataURL() { return this; }
|
|
add() { return this; }
|
|
};
|
|
h.Project = {};
|
|
h.Formats = { optifine_entity: { codec: { parse() { new h.Group('body').init(); } } } };
|
|
h.newProject = () => true;
|
|
h.Canvas = { updateAll() {} }; h.Blockbench = { showQuickMessage() {} };
|
|
const addition = { target: '0', parentOrigin: [0, 0, 0], parentRotation: [0, 0, 0, 1], rotationOrder: 'ZYX',
|
|
tree: { name: 'extra', origin: [0, 0, 0], rotation: [0, 0, 0], children: [{ cube: {
|
|
name: 'cube', from: [0, 0, 0], to: [1, 1, 1], box_uv: false,
|
|
faces: { north: { texture: 'old', uv: [0, 0, 16, 16] } } } }] } };
|
|
h.api.createJemTransferProject({ name: 'test', model: { models: [] } }, [addition],
|
|
[{ id: 'old', data: { uv_width: 32, uv_height: 32 }, image: 'mock' }], 'old',
|
|
{ width: 64, height: 64, projectWide }, false);
|
|
assert.deepEqual(Array.from(cubes[0].faces.north.uv), projectWide ? [0, 0, 8, 8] : [0, 0, 16, 16]);
|
|
}
|
|
});
|
|
|
|
test('suggests added subtrees once, strips actor prefixes and leaves vanilla hierarchy unchanged', () => {
|
|
const h = harness(), root = new h.Group('actor1_root'), body = new h.Group('actor1_body', root);
|
|
const d = new h.Group('actor1_d', body), tip = new h.Group('actor1_tip', d);
|
|
const head = new h.Group('actor1_head', root), extra = new h.Group('actor1_extra', root);
|
|
const suggestions = h.api.jemTransferSuggestions([root, body, d, tip, head, extra], [{ name: 'body', path: '0' }, { name: 'head', path: '1' }], 1);
|
|
assert.deepEqual(Array.from(suggestions, (item) => [item.name, item.target]), [['d', '0'], ['extra', '']]);
|
|
assert.equal(suggestions[0].root, d);
|
|
assert.equal(tip.parent, d);
|
|
assert.equal(body.name, 'actor1_body');
|
|
});
|
|
|
|
test('selected additions require parent mapping; unchecked additions are omitted', () => {
|
|
const h = harness(), body = new h.Group('actor1_body'), d = new h.Group('actor1_d', body);
|
|
const suggestions = h.api.jemTransferSuggestions([body, d], [{ name: 'body', path: '0' }], 1);
|
|
assert.throws(() => h.api.validateJemChoices(suggestions, { include_0: true, parent_0: '' }), /Choose a target parent/);
|
|
assert.throws(() => h.api.validateJemChoices(suggestions, { include_0: false }), /at least one/);
|
|
const chosen = h.api.validateJemChoices(suggestions, { include_0: true, parent_0: '0' });
|
|
assert.equal(chosen[0].tree.name, 'd');
|
|
assert.equal(chosen[0].target, '0');
|
|
assert.deepEqual(Array.from(chosen[0].parentOrigin), [1, 2, 3]);
|
|
});
|
|
|
|
test('CEM catalog integration handles its initial undefined return and dependency errors', async () => {
|
|
const h = harness();
|
|
await assert.rejects(h.api.cemTemplateCatalog(), /Install and enable/);
|
|
let calls = 0;
|
|
const catalog = { models: { wolf: {} }, entities: [{ id: 'wolf' }] };
|
|
h.window = { async loadCEMTemplateModels() { return ++calls === 1 ? undefined : catalog; } };
|
|
assert.equal(await h.api.cemTemplateCatalog(), catalog);
|
|
assert.equal(calls, 2);
|
|
});
|
|
|
|
test('energy visibility is opt-in per transferred bone including nested subbones', () => {
|
|
const h = harness(), body = new h.Group('actor1_body'), d = new h.Group('actor1_d', body);
|
|
new h.Group('actor1_tip', d);
|
|
const suggestions = h.api.jemTransferSuggestions([body, d, ...d.children], [{ name: 'body', path: '0' }], 1);
|
|
assert.deepEqual(Array.from(h.api.jemAdditionBones(suggestions[0]), (bone) => [bone.name, bone.path]), [['d', 'root'], ['tip', 'root_0']]);
|
|
const selected = h.api.validateJemChoices(suggestions, { include_0: true, parent_0: '0', energy_0_root_0: true });
|
|
assert.equal(selected[0].tree.energyVisibility, false);
|
|
assert.equal(selected[0].tree.children[0].group.energyVisibility, true);
|
|
});
|
|
|
|
test('energy expressions use the final unique bone name and preserve existing preset animations', () => {
|
|
const h = harness(), root = new h.Group('body'), nested = new h.Group('addition', root);
|
|
const tip = new h.Group('d3_2', nested);
|
|
root.cem_animations = [{ 'body.rx': 'existing_expression' }];
|
|
h.api.addJemEnergyVisibility(tip);
|
|
assert.equal(root.cem_animations.length, 2);
|
|
assert.equal(root.cem_animations[0]['body.rx'], 'existing_expression');
|
|
assert.equal(root.cem_animations[1]['d3_2.visible'], 'nbt(NeedsOfNatureEnergy,range:70-200)');
|
|
assert.equal(tip.cem_animations, undefined);
|
|
});
|
|
|
|
test('parent energy visibility disables descendants and omits redundant child expressions without clearing their choices', () => {
|
|
const h = harness(), body = new h.Group('actor1_body'), d = new h.Group('actor1_d', body);
|
|
const tip = new h.Group('actor1_tip', d), end = new h.Group('actor1_end', tip);
|
|
const suggestions = h.api.jemTransferSuggestions([body, d, tip, end], [{ name: 'body', path: '0' }], 1);
|
|
const fields = Object.fromEntries(['root', 'root_0', 'root_0_0'].map((path) => {
|
|
const input = {}, bar = { style: {}, querySelectorAll() { return [input]; } };
|
|
return [`energy_0_${path}`, { bar, input }];
|
|
}));
|
|
const dialog = { form: { form_data: fields } };
|
|
const result = { include_0: true, parent_0: '0', energy_0_root: true, energy_0_root_0: true, energy_0_root_0_0: true };
|
|
h.api.refreshJemEnergyFields(dialog, suggestions, result);
|
|
assert.equal(fields.energy_0_root.input.disabled, false);
|
|
assert.equal(fields.energy_0_root_0.input.disabled, true);
|
|
assert.equal(fields.energy_0_root_0_0.input.disabled, true);
|
|
const tree = h.api.validateJemChoices(suggestions, result)[0].tree;
|
|
assert.equal(tree.energyVisibility, true);
|
|
assert.equal(tree.children[0].group.energyVisibility, false);
|
|
result.energy_0_root = false;
|
|
h.api.refreshJemEnergyFields(dialog, suggestions, result);
|
|
assert.equal(fields.energy_0_root_0.input.disabled, false);
|
|
assert.equal(fields.energy_0_root_0_0.input.disabled, true);
|
|
assert.equal(h.api.validateJemChoices(suggestions, result)[0].tree.children[0].group.energyVisibility, true);
|
|
});
|