357 lines
8.7 KiB
TypeScript
357 lines
8.7 KiB
TypeScript
/*
|
|
* Copyright (c) Erin Catto
|
|
* Licensed under the MIT license
|
|
*/
|
|
|
|
// This test demonstrates how to use the world ray-cast feature.
|
|
// NOTE: we are intentionally filtering one of the polygons, therefore
|
|
// the ray will always miss one type of polygon.
|
|
|
|
import {
|
|
World,
|
|
Body,
|
|
Fixture,
|
|
Shape,
|
|
Vec2,
|
|
Transform,
|
|
Edge,
|
|
Circle,
|
|
Polygon,
|
|
Box,
|
|
Testbed,
|
|
RayCastOutput,
|
|
Vec2Value,
|
|
} from "planck";
|
|
|
|
const outputClosest = {
|
|
point: null as Vec2Value | null,
|
|
normal: null as Vec2Value | null,
|
|
};
|
|
|
|
function resetClosest() {
|
|
outputClosest.point = null;
|
|
outputClosest.normal = null;
|
|
}
|
|
|
|
// This callback finds the closest hit. Polygon 0 is filtered.
|
|
function callbackClosest(
|
|
fixture: Fixture,
|
|
point: Vec2Value,
|
|
normal: Vec2Value,
|
|
fraction: number,
|
|
): number {
|
|
const body = fixture.getBody();
|
|
const userData = body.getUserData();
|
|
if (userData !== undefined) {
|
|
if (userData === 0) {
|
|
// By returning -1, we instruct the calling code to ignore this fixture and
|
|
// continue the ray-cast to the next fixture.
|
|
return -1.0;
|
|
}
|
|
}
|
|
|
|
outputClosest.point = point;
|
|
outputClosest.normal = normal;
|
|
|
|
// By returning the current fraction, we instruct the calling code to clip the ray and
|
|
// continue the ray-cast to the next fixture. WARNING: do not assume that fixtures
|
|
// are reported in order. However, by clipping, we can always get the closest fixture.
|
|
return fraction;
|
|
}
|
|
|
|
const outputAny = {
|
|
point: null as Vec2Value | null,
|
|
normal: null as Vec2Value | null,
|
|
};
|
|
|
|
function resetAny() {
|
|
outputAny.point = null;
|
|
outputAny.normal = null;
|
|
}
|
|
|
|
// This callback finds any hit. Polygon 0 is filtered. For this type of query we are usually
|
|
// just checking for obstruction, so the actual fixture and hit point are irrelevant.
|
|
function callbackAny(
|
|
fixture: Fixture,
|
|
point: Vec2Value,
|
|
normal: Vec2Value,
|
|
fraction: number,
|
|
): number {
|
|
const body = fixture.getBody();
|
|
const userData = body.getUserData();
|
|
if (userData !== undefined) {
|
|
if (userData === 0) {
|
|
// By returning -1, we instruct the calling code to ignore this fixture
|
|
// and continue the ray-cast to the next fixture.
|
|
return -1.0;
|
|
}
|
|
}
|
|
outputAny.point = point;
|
|
outputAny.normal = normal;
|
|
|
|
// At this point we have a hit, so we know the ray is obstructed.
|
|
// By returning 0, we instruct the calling code to terminate the ray-cast.
|
|
return 0.0;
|
|
}
|
|
|
|
const outputMultiple = {
|
|
points: [] as Vec2Value[],
|
|
normals: [] as Vec2Value[],
|
|
};
|
|
// let MAX_COUNT = 3;
|
|
|
|
function resetMultiple() {
|
|
outputMultiple.points.length = 0;
|
|
outputMultiple.normals.length = 0;
|
|
}
|
|
|
|
// This ray cast collects multiple hits along the ray. Polygon 0 is filtered.
|
|
// The fixtures are not necessary reported in order, so we might not capture
|
|
// the closest fixture.
|
|
function callbackMultiple(
|
|
fixture: Fixture,
|
|
point: Vec2Value,
|
|
normal: Vec2Value,
|
|
fraction: number,
|
|
): number {
|
|
const body = fixture.getBody();
|
|
const userData = body.getUserData();
|
|
if (userData !== undefined) {
|
|
if (userData === 0) {
|
|
// By returning -1, we instruct the calling code to ignore this fixture
|
|
// and continue the ray-cast to the next fixture.
|
|
return -1.0;
|
|
}
|
|
}
|
|
|
|
outputMultiple.points.push(point);
|
|
outputMultiple.normals.push(normal);
|
|
|
|
// if (m_count == MAX_COUNT) {
|
|
// // At this point the buffer is full.
|
|
// // By returning 0, we instruct the calling code to terminate the ray-cast.
|
|
// return 0.0;
|
|
// }
|
|
|
|
// By returning 1, we instruct the caller to continue without clipping the
|
|
// ray.
|
|
return 1.0;
|
|
}
|
|
|
|
const world = new World({
|
|
gravity: { x: 0, y: -10 },
|
|
});
|
|
|
|
const testbed = Testbed.mount();
|
|
testbed.width = 40;
|
|
testbed.height = 40;
|
|
testbed.info("1-6: Drop new objects, Z: Change mode, X: Destroy an object");
|
|
testbed.start(world);
|
|
|
|
const MAX_BODIES = 256;
|
|
|
|
// mode
|
|
const CLOSEST = 1;
|
|
const ANY = 2;
|
|
const MULTIPLE = 3;
|
|
|
|
const bodies: Body[] = [];
|
|
const shapes: Shape[] = [];
|
|
|
|
let angle = 0.0;
|
|
let mode = CLOSEST;
|
|
|
|
shapes[0] = new Polygon([
|
|
{ x: -0.5, y: 0.0 },
|
|
{ x: 0.5, y: 0.0 },
|
|
{ x: 0.0, y: 1.5 },
|
|
]);
|
|
shapes[1] = new Polygon([
|
|
{ x: -0.1, y: 0.0 },
|
|
{ x: 0.1, y: 0.0 },
|
|
{ x: 0.0, y: 1.5 },
|
|
]);
|
|
|
|
const w = 1.0;
|
|
const b = w / (2.0 + Math.sqrt(2.0));
|
|
const s = Math.sqrt(2.0) * b;
|
|
|
|
shapes[2] = new Polygon([
|
|
{ x: 0.5 * s, y: 0.0 },
|
|
{ x: 0.5 * w, y: b },
|
|
{ x: 0.5 * w, y: b + s },
|
|
{ x: 0.5 * s, y: w },
|
|
{ x: -0.5 * s, y: w },
|
|
{ x: -0.5 * w, y: b + s },
|
|
{ x: -0.5 * w, y: b },
|
|
{ x: -0.5 * s, y: 0.0 },
|
|
]);
|
|
shapes[3] = new Box(0.5, 0.5);
|
|
|
|
shapes[4] = new Circle(0.5);
|
|
shapes[5] = new Edge({ x: -1.0, y: 0.0 }, { x: 1.0, y: 0.0 });
|
|
|
|
function createBody(index: number) {
|
|
if (bodies.length > MAX_BODIES) {
|
|
world.destroyBody(bodies.shift()!);
|
|
}
|
|
|
|
const body = world.createBody({
|
|
type: "static",
|
|
position: {
|
|
x: Math.random() * 20 - 10,
|
|
y: Math.random() * 20,
|
|
},
|
|
angle: Math.random() * 2 * Math.PI - Math.PI,
|
|
userData: index,
|
|
angularDamping: index === 4 ? 0.02 : 0,
|
|
});
|
|
|
|
const shape = shapes[index % shapes.length];
|
|
|
|
body.createFixture({
|
|
shape: shape,
|
|
friction: 0.3,
|
|
});
|
|
|
|
bodies.push(body);
|
|
}
|
|
|
|
function destroyBody() {
|
|
const body = bodies.shift();
|
|
if (body) world.destroyBody(body);
|
|
}
|
|
|
|
testbed.keydown = function (code, char) {
|
|
switch (char) {
|
|
case "Z":
|
|
if (mode === CLOSEST) {
|
|
mode = ANY;
|
|
} else if (mode === ANY) {
|
|
mode = MULTIPLE;
|
|
} else if (mode === MULTIPLE) {
|
|
mode = CLOSEST;
|
|
}
|
|
break;
|
|
case "X":
|
|
destroyBody();
|
|
break;
|
|
case "1":
|
|
createBody(0);
|
|
break;
|
|
case "2":
|
|
createBody(1);
|
|
break;
|
|
case "3":
|
|
createBody(2);
|
|
break;
|
|
case "4":
|
|
createBody(3);
|
|
break;
|
|
case "5":
|
|
createBody(4);
|
|
break;
|
|
case "6":
|
|
createBody(5);
|
|
break;
|
|
}
|
|
|
|
updateStatus();
|
|
};
|
|
|
|
function updateStatus() {
|
|
switch (mode) {
|
|
case CLOSEST:
|
|
testbed.status("Ray-cast mode", "Closest - find closest fixture along the ray");
|
|
break;
|
|
|
|
case ANY:
|
|
testbed.status("Ray-cast mode", "Any - check for obstruction");
|
|
break;
|
|
|
|
case MULTIPLE:
|
|
testbed.status("Ray-cast mode", "Multiple - gather multiple fixtures");
|
|
break;
|
|
}
|
|
}
|
|
|
|
testbed.step = function () {
|
|
const advanceRay = true;
|
|
|
|
const L = 11.0;
|
|
const point1 = { x: 0.0, y: 10.0 };
|
|
const d = { x: L * Math.cos(angle), y: L * Math.sin(angle) };
|
|
const point2 = Vec2.add(point1, d);
|
|
|
|
if (mode === CLOSEST) {
|
|
resetClosest();
|
|
world.rayCast(point1, point2, callbackClosest);
|
|
const output = outputClosest;
|
|
|
|
if (output && output.point && output.normal) {
|
|
testbed.drawPoint(output.point, 5.0, testbed.color(0.4, 0.9, 0.4));
|
|
testbed.drawSegment(point1, output.point, testbed.color(0.8, 0.8, 0.8));
|
|
const head = Vec2.combine(1, output.point, 2, output.normal);
|
|
testbed.drawSegment(output.point, head, testbed.color(0.9, 0.9, 0.4));
|
|
} else {
|
|
testbed.drawSegment(point1, point2, testbed.color(0.8, 0.8, 0.8));
|
|
}
|
|
} else if (mode === ANY) {
|
|
resetAny();
|
|
world.rayCast(point1, point2, callbackAny);
|
|
const output = outputAny;
|
|
|
|
if (output && output.point && output.normal) {
|
|
testbed.drawPoint(output.point, 5.0, testbed.color(0.4, 0.9, 0.4));
|
|
testbed.drawSegment(point1, output.point, testbed.color(0.8, 0.8, 0.8));
|
|
const head = Vec2.combine(1, output.point, 2, output.normal);
|
|
testbed.drawSegment(output.point, head, testbed.color(0.9, 0.9, 0.4));
|
|
} else {
|
|
testbed.drawSegment(point1, point2, testbed.color(0.8, 0.8, 0.8));
|
|
}
|
|
} else if (mode === MULTIPLE) {
|
|
resetMultiple();
|
|
world.rayCast(point1, point2, callbackMultiple);
|
|
testbed.drawSegment(point1, point2, testbed.color(0.8, 0.8, 0.8));
|
|
const output = outputMultiple;
|
|
|
|
for (let i = 0; i < output.points.length; ++i) {
|
|
const p = output.points[i];
|
|
const n = output.normals[i];
|
|
testbed.drawPoint(p, 5.0, testbed.color(0.4, 0.9, 0.4));
|
|
testbed.drawSegment(point1, p, testbed.color(0.8, 0.8, 0.8));
|
|
const head = Vec2.combine(1, p, 0.5, n);
|
|
testbed.drawSegment(p, head, testbed.color(0.9, 0.9, 0.4));
|
|
}
|
|
}
|
|
|
|
if (advanceRay) {
|
|
angle += (0.25 * Math.PI) / 180.0;
|
|
}
|
|
|
|
if (false) {
|
|
// This case was failing.
|
|
const shape = new Box(22.875, 3.0);
|
|
|
|
const input = {
|
|
p1: { x: 10.2725, y: 1.71372 },
|
|
p2: { x: 10.2353, y: 2.21807 },
|
|
maxFraction: 0.56762173,
|
|
};
|
|
|
|
const xf = new Transform({ x: 23.0, y: 5.0 });
|
|
|
|
const output = {} as RayCastOutput;
|
|
let hit = shape.rayCast(output, input, xf, 0);
|
|
hit = false;
|
|
|
|
const color = testbed.color(1.0, 1.0, 1.0);
|
|
const vs = shape.m_vertices.map((v) => Transform.mul(xf, v));
|
|
|
|
testbed.drawPolygon(vs, color);
|
|
testbed.drawSegment(input.p1, input.p2, color);
|
|
}
|
|
};
|
|
|
|
updateStatus();
|