288 lines
6.7 KiB
TypeScript
288 lines
6.7 KiB
TypeScript
/*
|
|
* Copyright (c) Erin Catto
|
|
* Licensed under the MIT license
|
|
*/
|
|
|
|
import { World, Vec2, DynamicTree, AABB, Math, Testbed, RayCastInput, RayCastOutput } from "planck";
|
|
|
|
class Actor {
|
|
aabb = new AABB();
|
|
fraction: number;
|
|
overlap: boolean;
|
|
proxyId: number | null = null;
|
|
}
|
|
|
|
const testbed = Testbed.mount();
|
|
const world = new World();
|
|
testbed.start(world);
|
|
|
|
const ACTOR_COUNT = 128;
|
|
const WORLD_EXTENT = 15.0;
|
|
const PROXY_EXTENT = 0.5;
|
|
|
|
let automated = false;
|
|
|
|
const tree = new DynamicTree<Actor>();
|
|
const actors: Actor[] = [];
|
|
|
|
for (let i = 0; i < ACTOR_COUNT; ++i) {
|
|
const actor = new Actor();
|
|
actors[i] = actor;
|
|
getRandomAABB(actor.aabb);
|
|
actor.proxyId = tree.createProxy(actor.aabb, actor);
|
|
}
|
|
|
|
const queryAABB = new AABB({ x: -3.0, y: -4.0 + WORLD_EXTENT }, { x: 5.0, y: 6.0 + WORLD_EXTENT });
|
|
|
|
function queryCallback(proxyId: number) {
|
|
const actor = tree.getUserData(proxyId);
|
|
actor.overlap = AABB.testOverlap(queryAABB, actor.aabb);
|
|
return true;
|
|
}
|
|
|
|
function runQuery(tree: DynamicTree<Actor>) {
|
|
tree.query(queryAABB, queryCallback);
|
|
|
|
for (let i = 0; i < actors.length; ++i) {
|
|
if (actors[i].proxyId == null) {
|
|
continue;
|
|
}
|
|
|
|
const overlap = AABB.testOverlap(queryAABB, actors[i].aabb);
|
|
// console.assert(overlap == actors[i].overlap);
|
|
}
|
|
}
|
|
|
|
const rayCastInput: RayCastInput = {
|
|
// p1: { x: 0.0, y: 2.0 + worldExtent },
|
|
// p2: { x: 0.0, y: -2.0 + worldExtent },
|
|
p1: { x: -5.0, y: 5.0 + WORLD_EXTENT },
|
|
p2: { x: 7.0, y: -4.0 + WORLD_EXTENT },
|
|
maxFraction: 1.0,
|
|
};
|
|
|
|
const rayCastResult = {} as {
|
|
actor: Actor | null;
|
|
output: RayCastOutput | null;
|
|
input: RayCastInput;
|
|
};
|
|
|
|
function rayCastCallback(input: RayCastInput, proxyId: number) {
|
|
const actor = tree.getUserData(proxyId);
|
|
|
|
const output = {} as RayCastOutput;
|
|
const hit = actor.aabb.rayCast(output, input);
|
|
|
|
if (hit) {
|
|
rayCastResult.output = output;
|
|
rayCastResult.actor = actor;
|
|
rayCastResult.actor.fraction = output.fraction;
|
|
return output.fraction;
|
|
}
|
|
|
|
return input.maxFraction;
|
|
}
|
|
|
|
function runRayCast() {
|
|
rayCastResult.actor = null;
|
|
rayCastResult.output = null;
|
|
|
|
rayCastResult.input = {
|
|
p1: Vec2.clone(rayCastInput.p1),
|
|
p2: Vec2.clone(rayCastInput.p2),
|
|
maxFraction: rayCastInput.maxFraction,
|
|
};
|
|
|
|
// Ray cast against the dynamic tree.
|
|
tree.rayCast(rayCastResult.input, rayCastCallback);
|
|
|
|
// Brute force ray cast.
|
|
let bruteActor: Actor | null = null;
|
|
let bruteOutput: RayCastOutput | null = null;
|
|
|
|
for (let i = 0; i < actors.length; ++i) {
|
|
const actor = actors[i];
|
|
if (actor.proxyId == null) {
|
|
continue;
|
|
}
|
|
|
|
const output = {} as RayCastOutput;
|
|
const hit = actor.aabb.rayCast(output, rayCastResult.input);
|
|
if (hit) {
|
|
bruteActor = actor;
|
|
bruteOutput = output;
|
|
rayCastResult.input.maxFraction = output.fraction;
|
|
}
|
|
}
|
|
|
|
if (bruteActor != null) {
|
|
// console.assert(bruteOutput?.fraction == rayCastOutput.fraction);
|
|
}
|
|
|
|
return rayCastResult;
|
|
}
|
|
|
|
testbed.step = function () {
|
|
for (let i = 0; i < actors.length; ++i) {
|
|
actors[i].fraction = 1.0;
|
|
actors[i].overlap = false;
|
|
}
|
|
|
|
if (automated == true) {
|
|
const actionCount = Math.max(1, actors.length >> 2);
|
|
|
|
for (let i = 0; i < actionCount; ++i) {
|
|
runAction();
|
|
}
|
|
}
|
|
|
|
runQuery(tree);
|
|
const rayCastResult = runRayCast();
|
|
|
|
for (let i = 0; i < actors.length; ++i) {
|
|
const actor = actors[i];
|
|
if (actor.proxyId == null) continue;
|
|
|
|
let c = testbed.color(0.9, 0.9, 0.9);
|
|
if (actor == rayCastResult.actor && actor.overlap) {
|
|
c = testbed.color(0.9, 0.6, 0.6);
|
|
} else if (actor == rayCastResult.actor) {
|
|
c = testbed.color(0.6, 0.9, 0.6);
|
|
} else if (actor.overlap) {
|
|
c = testbed.color(0.6, 0.6, 0.9);
|
|
}
|
|
|
|
testbed.drawAABB(actor.aabb, c);
|
|
}
|
|
|
|
testbed.drawAABB(queryAABB, testbed.color(0.7, 0.7, 0.7));
|
|
testbed.drawSegment(rayCastResult.input.p1, rayCastResult.input.p2, testbed.color(0.9, 0.9, 0.9));
|
|
testbed.drawPoint(rayCastResult.input.p1, 6.0, testbed.color(0.2, 0.9, 0.2));
|
|
testbed.drawPoint(rayCastResult.input.p2, 6.0, testbed.color(0.9, 0.2, 0.2));
|
|
|
|
if (rayCastResult.actor) {
|
|
const p = Vec2.combine(
|
|
1 - rayCastResult.actor.fraction,
|
|
rayCastResult.input.p1,
|
|
rayCastResult.actor.fraction,
|
|
rayCastResult.input.p2,
|
|
);
|
|
testbed.drawPoint(p, 6.0, testbed.color(0.2, 0.2, 0.9));
|
|
}
|
|
|
|
const height = tree.getHeight();
|
|
testbed.status("dynamic tree height", height);
|
|
};
|
|
|
|
testbed.keydown = function (code, char) {
|
|
switch (char) {
|
|
case "Z":
|
|
automated = !automated;
|
|
break;
|
|
|
|
case "C":
|
|
createProxy();
|
|
break;
|
|
|
|
case "X":
|
|
destroyProxy();
|
|
break;
|
|
|
|
case "M":
|
|
moveProxy();
|
|
break;
|
|
}
|
|
};
|
|
|
|
function getRandomAABB(aabb: AABB) {
|
|
// aabb.lowerBound.x = -proxyExtent;
|
|
// aabb.lowerBound.y = -proxyExtent + worldExtent;
|
|
aabb.lowerBound.x = Math.random(-WORLD_EXTENT, WORLD_EXTENT);
|
|
aabb.lowerBound.y = Math.random(0.0, 2.0 * WORLD_EXTENT);
|
|
|
|
aabb.upperBound.x = aabb.lowerBound.x + 2.0 * PROXY_EXTENT;
|
|
aabb.upperBound.y = aabb.lowerBound.y + 2.0 * PROXY_EXTENT;
|
|
}
|
|
|
|
function moveAABB(aabb: AABB) {
|
|
const d = {
|
|
x: Math.random(-0.5, 0.5),
|
|
y: Math.random(-0.5, 0.5),
|
|
};
|
|
// d.x = 2.0;
|
|
// d.y = 0.0;
|
|
aabb.lowerBound.add(d);
|
|
aabb.upperBound.add(d);
|
|
|
|
const c0 = Vec2.mid(aabb.lowerBound, aabb.upperBound);
|
|
const min = {
|
|
x: -WORLD_EXTENT,
|
|
y: 0.0,
|
|
};
|
|
const max = {
|
|
x: WORLD_EXTENT,
|
|
y: 2.0 * WORLD_EXTENT,
|
|
};
|
|
const c = Vec2.clampVec2(c0, min, max);
|
|
|
|
aabb.lowerBound.add(c).sub(c0);
|
|
aabb.upperBound.add(c).sub(c0);
|
|
}
|
|
|
|
function createProxy() {
|
|
for (let i = 0; i < actors.length; ++i) {
|
|
const j = (Math.random() * actors.length) | 0;
|
|
const actor = actors[j];
|
|
if (actor.proxyId == null) {
|
|
getRandomAABB(actor.aabb);
|
|
actor.proxyId = tree.createProxy(actor.aabb, actor);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
function destroyProxy() {
|
|
for (let i = 0; i < actors.length; ++i) {
|
|
const j = (Math.random() * actors.length) | 0;
|
|
const actor = actors[j];
|
|
if (actor.proxyId != null) {
|
|
tree.destroyProxy(actor.proxyId);
|
|
actor.proxyId = null;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
function moveProxy() {
|
|
for (let i = 0; i < actors.length; ++i) {
|
|
const j = (Math.random() * actors.length) | 0;
|
|
const actor = actors[j];
|
|
if (actor.proxyId == null) {
|
|
continue;
|
|
}
|
|
|
|
const aabb0 = actor.aabb;
|
|
moveAABB(actor.aabb);
|
|
const displacement = Vec2.sub(actor.aabb.getCenter(), aabb0.getCenter());
|
|
tree.moveProxy(actor.proxyId, actor.aabb, displacement);
|
|
return;
|
|
}
|
|
}
|
|
|
|
function runAction() {
|
|
const choice = (Math.random() * 20) | 0;
|
|
|
|
switch (choice) {
|
|
case 0:
|
|
createProxy();
|
|
break;
|
|
|
|
case 1:
|
|
destroyProxy();
|
|
break;
|
|
|
|
default:
|
|
moveProxy();
|
|
}
|
|
}
|