Vector3f o = vars.vect1.set(r.getOrigin()); Vector3f d = vars.vect2.set(r.getDirection()); inv.mult(r.getOrigin(), r.getOrigin()); inv.multNormal(r.getDirection(), r.getDirection()); float[] origins = {r.getOrigin().x, r.getOrigin().y, r.getOrigin().z}; float[] invDirections = {1f / r.getDirection().x, 1f / r.getDirection().y, 1f / r.getDirection().z}; r.getDirection().normalizeLocal(); float t = r.intersects(v1, v2, v3); if (!Float.isInfinite(t)) { if (worldMatrix != null) { worldMatrix.mult(v2, v2); worldMatrix.mult(v3, v3); float t_world = new Ray(o, d).intersects(v1, v2, v3); t = t_world; r.setOrigin(o); r.setDirection(d);
Vector3f p2 = segEnd; Vector3f p3 = ray.origin; Vector3f p4 = vars.vect3.set(ray.getDirection()).multLocal(Math.min(ray.getLimit(), 1000)).addLocal(ray.getOrigin()); Vector3f p13 = vars.vect4.set(p1).subtractLocal(p3); Vector3f p43 = vars.vect5.set(p4).subtractLocal(p3);
/** * <code>intersectWhere</code> determines if the Ray intersects a triangle. It then * stores the point of intersection in the given loc vector * @param t the Triangle to test against. * @param loc * storage vector to save the collision point in (if the ray * collides) * @return true if the ray collides. */ public boolean intersectWhere(Triangle t, Vector3f loc) { return intersectWhere(t.get(0), t.get(1), t.get(2), loc); }
/** * Constructor instantiates a new <code>Ray</code> object. The origin and * direction are given. * @param origin the origin of the ray. * @param direction the direction the ray travels in. */ public Ray(Vector3f origin, Vector3f direction) { setOrigin(origin); setDirection(direction); }
/** * Copies information from a source ray into this ray. * * @param source * the ray to copy information from */ public void set(Ray source) { origin.set(source.getOrigin()); direction.set(source.getDirection()); }
private static CollisionResults pick(Camera cam, Vector2f mouseLoc, Node node) { CollisionResults results = new CollisionResults(); Ray ray = new Ray(); Vector3f pos = new Vector3f(mouseLoc.x, mouseLoc.y, -1); Vector3f dir = new Vector3f(mouseLoc.x, mouseLoc.y, 1); dir.subtractLocal(pos).normalizeLocal(); ray.setOrigin(pos); ray.setDirection(dir); node.collideWith(ray, results); return results; } }
public static void main(String[] args){ Ray r = new Ray(Vector3f.ZERO, Vector3f.UNIT_X); BoundingBox bbox = new BoundingBox(new Vector3f(5, 0, 0), 1, 1, 1); CollisionResults res = new CollisionResults(); bbox.collideWith(r, res); System.out.println("Bounding:" +bbox); System.out.println("Ray: "+r); System.out.println("Num collisions: "+res.size()); for (int i = 0; i < res.size(); i++){ System.out.println("--- Collision #"+i+" ---"); float dist = res.getCollision(i).getDistance(); Vector3f pt = res.getCollision(i).getContactPoint(); System.out.println("distance: "+dist); System.out.println("point: "+pt); } }
public static Ray transformRayFromZupToJMECoordinate(Ray zupRay) { Vector3f origin = new Vector3f(zupRay.getOrigin()); Vector3f direction = new Vector3f(zupRay.getDirection()); transformFromZupToJMECoordinates(origin); transformFromZupToJMECoordinates(direction); return new Ray(origin, direction); }
@Test public void testBoxRayCollision() { BoundingBox box = new BoundingBox(Vector3f.ZERO, 1, 1, 1); Ray ray = new Ray(Vector3f.ZERO, Vector3f.UNIT_Z); // XXX: seems incorrect, ray inside box should only generate // one result... checkCollision(box, ray, 2); ray.setOrigin(new Vector3f(0, 0, -5)); checkCollision(box, ray, 2); // XXX: is this right? the ray origin is on the box's side.. ray.setOrigin(new Vector3f(0, 0, 2f)); checkCollision(box, ray, 0); ray.setOrigin(new Vector3f(0, 0, -2f)); checkCollision(box, ray, 2); // parallel to the edge, touching the side ray.setOrigin(new Vector3f(0, 1f, -2f)); checkCollision(box, ray, 2); // still parallel, but not touching the side ray.setOrigin(new Vector3f(0, 1f + FastMath.ZERO_TOLERANCE, -2f)); checkCollision(box, ray, 0); }
ray.setOrigin(sceneCam.getLocation()); ray.setDirection(sceneCam.getDirection()); if (!ray.intersectsWherePlane(plane, targetLocation)) { ray.setDirection(ray.getDirection().negateLocal()); ray.intersectsWherePlane(plane, targetLocation); inv = true;
public Vector3f getTerrainIntersection(Ray worldPick, CollisionResults results) { worldPickRay.set(worldPick); List<TerrainPickData> pickData = new ArrayList<TerrainPickData>(); root.findPick(worldPick.clone(), pickData); Collections.sort(pickData); return null; workRay.set(worldPick); tracer.setGridOrigin(patch.getWorldTranslation()); workRay.getOrigin().set(worldPick.getDirection()).multLocal(pd.cr.getDistance()-.1f).addLocal(worldPick.getOrigin());
public void startWalk(final Ray walkRay) { this.walkRay.set(walkRay); Vector3f direction = this.walkRay.getDirection(); Vector3f start = this.walkRay.getOrigin().subtract(gridOrigin);
camera.getScreenCoordinates(((Ray)other).getOrigin(),tmp); tmpv2.x = tmp.x; tmpv2.y = tmp.y;
public final void intersectWhere(Ray r, Geometry[] geoms, float sceneMin, float sceneMax, CollisionResults results){ for (OCTTriangle t : tris){ float d = r.intersects(t.get1(), t.get2(), t.get3()); if (Float.isInfinite(d)) continue; Vector3f contactPoint = new Vector3f(r.getDirection()).multLocal(d).addLocal(r.getOrigin()); CollisionResult result = new CollisionResult(geoms[t.getGeometryIndex()], contactPoint, d, t.getTriangleIndex()); results.addCollision(result); } for (int i = 0; i < 8; i++){ Octnode child = children[i]; if (child == null) continue; if (child.bbox.intersects(r)){ child.intersectWhere(r, geoms, sceneMin, sceneMax, results); } } }
private void detect() { ray.setOrigin(position); ray.setLimit(distance); rot.multLocal(rayDir); ray.setDirection(rayDir); collisionResults.clear();
final float[] fAWxDdU = vars.fAWxDdU; fWdU[0] = ray.getDirection().dot(Vector3f.UNIT_X); fAWdU[0] = FastMath.abs(fWdU[0]); fDdU[0] = diff.dot(Vector3f.UNIT_X); fWdU[1] = ray.getDirection().dot(Vector3f.UNIT_Y); fAWdU[1] = FastMath.abs(fWdU[1]); fDdU[1] = diff.dot(Vector3f.UNIT_Y); fWdU[2] = ray.getDirection().dot(Vector3f.UNIT_Z); fAWdU[2] = FastMath.abs(fWdU[2]); fDdU[2] = diff.dot(Vector3f.UNIT_Z); Vector3f wCrossD = ray.getDirection().cross(diff, vars.vect2);
private int collideWithRay(Ray ray, CollisionResults results) { if (picker == null) picker = new BresenhamTerrainPicker(this); Vector3f intersection = picker.getTerrainIntersection(ray, results); if (intersection != null) { if (ray.getLimit() < Float.POSITIVE_INFINITY) { if (results.getClosestCollision().getDistance() <= ray.getLimit()) return 1; // in range else return 0; // out of range } else return 1; } else return 0; }
public void update(){ int w = image.getWidth(); int h = image.getHeight(); float wr = (float) cam.getWidth() / image.getWidth(); float hr = (float) cam.getHeight() / image.getHeight(); scene.updateGeometricState(); for (int y = 0; y < h; y++){ for (int x = 0; x < w; x++){ Vector2f v = new Vector2f(x * wr,y * hr); Vector3f pos = cam.getWorldCoordinates(v, 0.0f); Vector3f dir = cam.getWorldCoordinates(v, 0.3f); dir.subtractLocal(pos).normalizeLocal(); Ray r = new Ray(pos, dir); results.clear(); scene.collideWith(r, results); if (results.size() > 0){ image.setRGB(x, h - y - 1, 0xFFFFFFFF); }else{ image.setRGB(x, h - y - 1, 0xFF000000); } } } label.repaint(); }
public static Ray transformRayFromJMECoordinateToZup(Ray jmeRay) { Vector3f origin = new Vector3f(jmeRay.getOrigin()); Vector3f direction = new Vector3f(jmeRay.getDirection()); transformFromJMECoordinatesToZup(origin); transformFromJMECoordinatesToZup(direction); return new Ray(origin, direction); }
public float distanceSquared(Ray r) { Vector3f kDiff = r.getOrigin().subtract(origin); float fA01 = -r.getDirection().dot(direction); float fB0 = kDiff.dot(r.getDirection()); float fB1 = -kDiff.dot(direction); float fC = kDiff.lengthSquared();