mirror of
https://github.com/liabru/matter-js.git
synced 2024-12-26 13:49:01 -05:00
259 lines
No EOL
8.1 KiB
JavaScript
259 lines
No EOL
8.1 KiB
JavaScript
/* eslint-env es6 */
|
|
/* eslint no-global-assign: 0 */
|
|
"use strict";
|
|
|
|
const mock = require('mock-require');
|
|
const { requireUncached } = require('./TestTools');
|
|
const consoleOriginal = global.console;
|
|
|
|
const runExample = options => {
|
|
const Matter = prepareMatter(options);
|
|
const logs = prepareEnvironment(Matter);
|
|
|
|
const Examples = requireUncached('../examples/index');
|
|
const example = Examples[options.name]();
|
|
|
|
const engine = example.engine;
|
|
const runner = example.runner;
|
|
|
|
runner.delta = 1000 / 60;
|
|
runner.isFixed = true;
|
|
|
|
let totalMemory = 0;
|
|
let totalDuration = 0;
|
|
let overlapTotal = 0;
|
|
let overlapCount = 0;
|
|
let i;
|
|
|
|
if (global.gc) {
|
|
global.gc();
|
|
}
|
|
|
|
try {
|
|
for (i = 0; i < options.updates; i += 1) {
|
|
const startTime = process.hrtime();
|
|
totalMemory += process.memoryUsage().heapUsed;
|
|
|
|
Matter.Runner.tick(runner, engine, i * runner.delta);
|
|
|
|
const duration = process.hrtime(startTime);
|
|
totalDuration += duration[0] * 1e9 + duration[1];
|
|
totalMemory += process.memoryUsage().heapUsed;
|
|
|
|
const pairsList = engine.pairs.list;
|
|
const pairsListLength = engine.pairs.list.length;
|
|
|
|
for (let p = 0; p < pairsListLength; p += 1) {
|
|
const pair = pairsList[p];
|
|
const separation = pair.separation - pair.slop;
|
|
|
|
if (pair.isActive && !pair.isSensor) {
|
|
overlapTotal += separation > 0 ? separation : 0;
|
|
overlapCount += 1;
|
|
}
|
|
}
|
|
}
|
|
} catch (err) {
|
|
err.message = `On example '${options.name}' update ${i}:\n\n ${err.message}`;
|
|
throw err;
|
|
}
|
|
|
|
resetEnvironment();
|
|
|
|
return {
|
|
name: options.name,
|
|
duration: totalDuration,
|
|
overlap: overlapTotal / (overlapCount || 1),
|
|
memory: totalMemory,
|
|
logs: logs,
|
|
extrinsic: captureExtrinsics(engine, Matter),
|
|
intrinsic: captureIntrinsics(engine, Matter),
|
|
};
|
|
};
|
|
|
|
const prepareMatter = (options) => {
|
|
const Matter = requireUncached(options.useDev ? '../build/matter.dev' : '../build/matter');
|
|
|
|
if (Matter.Common._nextId !== 0) {
|
|
throw 'Matter instance has already been used.';
|
|
}
|
|
|
|
const noop = () => ({ collisionFilter: {}, mouse: {} });
|
|
|
|
Matter.Render.create = () => ({ options: {}, bounds: { min: { x: 0, y: 0 }, max: { x: 800, y: 600 }}});
|
|
Matter.Render.run = Matter.Render.lookAt = noop;
|
|
Matter.Runner.create = Matter.Runner.run = noop;
|
|
Matter.MouseConstraint.create = Matter.Mouse.create = noop;
|
|
Matter.Common.info = Matter.Common.warn = Matter.Common.log;
|
|
|
|
if (options.stableSort) {
|
|
if (Matter.Collision) {
|
|
const MatterCollisionCollides = Matter.Collision.collides;
|
|
Matter.Collision.collides = function(bodyA, bodyB, pairs) {
|
|
const _bodyA = bodyA.id < bodyB.id ? bodyA : bodyB;
|
|
const _bodyB = bodyA.id < bodyB.id ? bodyB : bodyA;
|
|
return MatterCollisionCollides(_bodyA, _bodyB, pairs);
|
|
};
|
|
} else {
|
|
const MatterSATCollides = Matter.SAT.collides;
|
|
Matter.SAT.collides = function(bodyA, bodyB, previousCollision, pairActive) {
|
|
const _bodyA = bodyA.id < bodyB.id ? bodyA : bodyB;
|
|
const _bodyB = bodyA.id < bodyB.id ? bodyB : bodyA;
|
|
return MatterSATCollides(_bodyA, _bodyB, previousCollision, pairActive);
|
|
};
|
|
}
|
|
|
|
Matter.after('Detector.collisions', function() { this.sort(collisionCompareId); });
|
|
Matter.after('Composite.allBodies', function() { sortById(this); });
|
|
Matter.after('Composite.allConstraints', function() { sortById(this); });
|
|
Matter.after('Composite.allComposites', function() { sortById(this); });
|
|
|
|
Matter.before('Pairs.update', function(pairs) {
|
|
pairs.list.sort((pairA, pairB) => collisionCompareId(pairA.collision, pairB.collision));
|
|
});
|
|
|
|
Matter.after('Pairs.update', function(pairs) {
|
|
pairs.list.sort((pairA, pairB) => collisionCompareId(pairA.collision, pairB.collision));
|
|
});
|
|
}
|
|
|
|
if (options.jitter) {
|
|
Matter.after('Body.create', function() {
|
|
Matter.Body.applyForce(this, this.position, {
|
|
x: Math.cos(this.id * this.id) * options.jitter * this.mass,
|
|
y: Math.sin(this.id * this.id) * options.jitter * this.mass
|
|
});
|
|
});
|
|
}
|
|
|
|
return Matter;
|
|
};
|
|
|
|
const prepareEnvironment = Matter => {
|
|
mock('matter-js', Matter);
|
|
global.Matter = Matter;
|
|
|
|
const logs = [];
|
|
global.document = global.window = { addEventListener: () => {} };
|
|
global.console = {
|
|
log: (...args) => {
|
|
logs.push(args.join(' '));
|
|
}
|
|
};
|
|
|
|
return logs;
|
|
};
|
|
|
|
const resetEnvironment = () => {
|
|
global.console = consoleOriginal;
|
|
global.window = undefined;
|
|
global.document = undefined;
|
|
global.Matter = undefined;
|
|
mock.stopAll();
|
|
};
|
|
|
|
const captureExtrinsics = ({ world }, Matter) => ({
|
|
bodies: Matter.Composite.allBodies(world).reduce((bodies, body) => {
|
|
bodies[body.id] = [
|
|
body.position.x,
|
|
body.position.y,
|
|
body.positionPrev.x,
|
|
body.positionPrev.y,
|
|
body.angle,
|
|
body.anglePrev,
|
|
...body.vertices.reduce((flat, vertex) => (flat.push(vertex.x, vertex.y), flat), [])
|
|
];
|
|
|
|
return bodies;
|
|
}, {}),
|
|
constraints: Matter.Composite.allConstraints(world).reduce((constraints, constraint) => {
|
|
const positionA = Matter.Constraint.pointAWorld(constraint);
|
|
const positionB = Matter.Constraint.pointBWorld(constraint);
|
|
|
|
constraints[constraint.id] = [
|
|
positionA.x,
|
|
positionA.y,
|
|
positionB.x,
|
|
positionB.y
|
|
];
|
|
|
|
return constraints;
|
|
}, {})
|
|
});
|
|
|
|
const captureIntrinsics = ({ world }, Matter) => formatIntrinsics({
|
|
bodies: Matter.Composite.allBodies(world).reduce((bodies, body) => {
|
|
bodies[body.id] = body;
|
|
return bodies;
|
|
}, {}),
|
|
constraints: Matter.Composite.allConstraints(world).reduce((constraints, constraint) => {
|
|
constraints[constraint.id] = constraint;
|
|
return constraints;
|
|
}, {}),
|
|
composites: Matter.Composite.allComposites(world).reduce((composites, composite) => {
|
|
composites[composite.id] = {
|
|
bodies: Matter.Composite.allBodies(composite).map(body => body.id),
|
|
constraints: Matter.Composite.allConstraints(composite).map(constraint => constraint.id),
|
|
composites: Matter.Composite.allComposites(composite).map(composite => composite.id)
|
|
};
|
|
return composites;
|
|
}, {})
|
|
});
|
|
|
|
const formatIntrinsics = (obj, depth=0) => {
|
|
if (obj === Infinity) {
|
|
return 'Infinity';
|
|
} else if (typeof obj === 'number') {
|
|
return limitPrecision(obj);
|
|
} else if (Array.isArray(obj)) {
|
|
return obj.map(item => formatIntrinsics(item, depth + 1));
|
|
} else if (typeof obj !== 'object') {
|
|
return obj;
|
|
}
|
|
|
|
const result = Object.entries(obj)
|
|
.filter(([key]) => depth <= 1 || intrinsicProperties.includes(key))
|
|
.reduce((cleaned, [key, val]) => {
|
|
if (val && val.id && String(val.id) !== key) {
|
|
val = val.id;
|
|
}
|
|
|
|
if (Array.isArray(val) && !['composites', 'constraints', 'bodies'].includes(key)) {
|
|
val = `[${val.length}]`;
|
|
}
|
|
|
|
cleaned[key] = formatIntrinsics(val, depth + 1);
|
|
return cleaned;
|
|
}, {});
|
|
|
|
return Object.keys(result).sort()
|
|
.reduce((sorted, key) => (sorted[key] = result[key], sorted), {});
|
|
};
|
|
|
|
const intrinsicProperties = [
|
|
// Common
|
|
'id', 'label',
|
|
|
|
// Constraint
|
|
'angularStiffness', 'bodyA', 'bodyB', 'damping', 'length', 'stiffness',
|
|
|
|
// Body
|
|
'area', 'axes', 'collisionFilter', 'category', 'mask',
|
|
'group', 'density', 'friction', 'frictionAir', 'frictionStatic', 'inertia', 'inverseInertia', 'inverseMass', 'isSensor',
|
|
'isSleeping', 'isStatic', 'mass', 'parent', 'parts', 'restitution', 'sleepThreshold', 'slop',
|
|
'timeScale', 'vertices',
|
|
|
|
// Composite
|
|
'bodies', 'constraints', 'composites'
|
|
];
|
|
|
|
const collisionId = (collision) =>
|
|
Math.min(collision.bodyA.id, collision.bodyB.id) + Math.max(collision.bodyA.id, collision.bodyB.id) * 10000;
|
|
|
|
const collisionCompareId = (collisionA, collisionB) => collisionId(collisionA) - collisionId(collisionB);
|
|
|
|
const sortById = (objs) => objs.sort((objA, objB) => objA.id - objB.id);
|
|
|
|
const limitPrecision = (val, precision=3) => parseFloat(val.toPrecision(precision));
|
|
|
|
module.exports = { runExample }; |