mirror of
https://github.com/liabru/matter-js.git
synced 2024-11-30 10:20:52 -05:00
136 lines
4.2 KiB
JavaScript
136 lines
4.2 KiB
JavaScript
/**
|
|
* The `Matter.Query` module contains methods for performing collision queries.
|
|
*
|
|
* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).
|
|
*
|
|
* @class Query
|
|
*/
|
|
|
|
var Query = {};
|
|
|
|
module.exports = Query;
|
|
|
|
var Vector = require('../geometry/Vector');
|
|
var Collision = require('./Collision');
|
|
var Bounds = require('../geometry/Bounds');
|
|
var Bodies = require('../factory/Bodies');
|
|
var Vertices = require('../geometry/Vertices');
|
|
|
|
(function() {
|
|
|
|
/**
|
|
* Returns a list of collisions between `body` and `bodies`.
|
|
* @method collides
|
|
* @param {body} body
|
|
* @param {body[]} bodies
|
|
* @return {collision[]} Collisions
|
|
*/
|
|
Query.collides = function(body, bodies) {
|
|
var collisions = [],
|
|
bodiesLength = bodies.length,
|
|
bounds = body.bounds,
|
|
collides = Collision.collides,
|
|
overlaps = Bounds.overlaps;
|
|
|
|
for (var i = 0; i < bodiesLength; i++) {
|
|
var bodyA = bodies[i],
|
|
partsALength = bodyA.parts.length,
|
|
partsAStart = partsALength === 1 ? 0 : 1;
|
|
|
|
if (overlaps(bodyA.bounds, bounds)) {
|
|
for (var j = partsAStart; j < partsALength; j++) {
|
|
var part = bodyA.parts[j];
|
|
|
|
if (overlaps(part.bounds, bounds)) {
|
|
var collision = collides(part, body);
|
|
|
|
if (collision) {
|
|
collisions.push(collision);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return collisions;
|
|
};
|
|
|
|
/**
|
|
* Casts a ray segment against a set of bodies and returns all collisions, ray width is optional. Intersection points are not provided.
|
|
* @method ray
|
|
* @param {body[]} bodies
|
|
* @param {vector} startPoint
|
|
* @param {vector} endPoint
|
|
* @param {number} [rayWidth]
|
|
* @return {collision[]} Collisions
|
|
*/
|
|
Query.ray = function(bodies, startPoint, endPoint, rayWidth) {
|
|
rayWidth = rayWidth || 1e-100;
|
|
|
|
var rayAngle = Vector.angle(startPoint, endPoint),
|
|
rayLength = Vector.magnitude(Vector.sub(startPoint, endPoint)),
|
|
rayX = (endPoint.x + startPoint.x) * 0.5,
|
|
rayY = (endPoint.y + startPoint.y) * 0.5,
|
|
ray = Bodies.rectangle(rayX, rayY, rayLength, rayWidth, { angle: rayAngle }),
|
|
collisions = Query.collides(ray, bodies);
|
|
|
|
for (var i = 0; i < collisions.length; i += 1) {
|
|
var collision = collisions[i];
|
|
collision.body = collision.bodyB = collision.bodyA;
|
|
}
|
|
|
|
return collisions;
|
|
};
|
|
|
|
/**
|
|
* Returns all bodies whose bounds are inside (or outside if set) the given set of bounds, from the given set of bodies.
|
|
* @method region
|
|
* @param {body[]} bodies
|
|
* @param {bounds} bounds
|
|
* @param {bool} [outside=false]
|
|
* @return {body[]} The bodies matching the query
|
|
*/
|
|
Query.region = function(bodies, bounds, outside) {
|
|
var result = [];
|
|
|
|
for (var i = 0; i < bodies.length; i++) {
|
|
var body = bodies[i],
|
|
overlaps = Bounds.overlaps(body.bounds, bounds);
|
|
if ((overlaps && !outside) || (!overlaps && outside))
|
|
result.push(body);
|
|
}
|
|
|
|
return result;
|
|
};
|
|
|
|
/**
|
|
* Returns all bodies whose vertices contain the given point, from the given set of bodies.
|
|
* @method point
|
|
* @param {body[]} bodies
|
|
* @param {vector} point
|
|
* @return {body[]} The bodies matching the query
|
|
*/
|
|
Query.point = function(bodies, point) {
|
|
var result = [];
|
|
|
|
for (var i = 0; i < bodies.length; i++) {
|
|
var body = bodies[i];
|
|
|
|
if (Bounds.contains(body.bounds, point)) {
|
|
for (var j = body.parts.length === 1 ? 0 : 1; j < body.parts.length; j++) {
|
|
var part = body.parts[j];
|
|
|
|
if (Bounds.contains(part.bounds, point)
|
|
&& Vertices.contains(part.vertices, point)) {
|
|
result.push(body);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
};
|
|
|
|
})();
|