Examples with CollisionResults com.jme3.collision.CollisionResults used on opensource projects

Example 26 with CollisionResults

use of com.jme3.collision.CollisionResults in project jmonkeyengine by jMonkeyEngine.

the class TerrainQuad method findPick.

/**
     * Gather the terrain patches that intersect the given ray (toTest).
     * This only tests the bounding boxes
     * @param toTest
     * @param results
     */
public void findPick(Ray toTest, List<TerrainPickData> results) {
    if (getWorldBound() != null) {
        if (getWorldBound().intersects(toTest)) {
            // further checking needed.
            for (int i = 0; i < getQuantity(); i++) {
                if (children.get(i) instanceof TerrainPatch) {
                    TerrainPatch tp = (TerrainPatch) children.get(i);
                    tp.ensurePositiveVolumeBBox();
                    if (tp.getWorldBound().intersects(toTest)) {
                        CollisionResults cr = new CollisionResults();
                        toTest.collideWith(tp.getWorldBound(), cr);
                        if (cr != null && cr.getClosestCollision() != null) {
                            cr.getClosestCollision().getDistance();
                            results.add(new TerrainPickData(tp, cr.getClosestCollision()));
                        }
                    }
                } else if (children.get(i) instanceof TerrainQuad) {
                    ((TerrainQuad) children.get(i)).findPick(toTest, results);
                }
            }
        }
    }
}

Example 27 with CollisionResults

use of com.jme3.collision.CollisionResults in project jmonkeyengine by jMonkeyEngine.

the class BresenhamTerrainPicker method getTerrainIntersection.

public Vector3f getTerrainIntersection(Ray worldPick, CollisionResults results) {
    worldPickRay.set(worldPick);
    List<TerrainPickData> pickData = new ArrayList<TerrainPickData>();
    root.findPick(worldPick.clone(), pickData);
    Collections.sort(pickData);
    if (pickData.isEmpty())
        return null;
    workRay.set(worldPick);
    for (TerrainPickData pd : pickData) {
        TerrainPatch patch = pd.targetPatch;
        tracer.getGridSpacing().set(patch.getWorldScale());
        tracer.setGridOrigin(patch.getWorldTranslation());
        workRay.getOrigin().set(worldPick.getDirection()).multLocal(pd.cr.getDistance() - .1f).addLocal(worldPick.getOrigin());
        tracer.startWalk(workRay);
        final Vector3f intersection = new Vector3f();
        final Vector2f loc = tracer.getGridLocation();
        if (tracer.isRayPerpendicularToGrid()) {
            Triangle hit = new Triangle();
            checkTriangles(loc.x, loc.y, workRay, intersection, patch, hit);
            float distance = worldPickRay.origin.distance(intersection);
            CollisionResult cr = new CollisionResult(intersection, distance);
            cr.setGeometry(patch);
            cr.setContactNormal(hit.getNormal());
            results.addCollision(cr);
            return intersection;
        }
        while (loc.x >= -1 && loc.x <= patch.getSize() && loc.y >= -1 && loc.y <= patch.getSize()) {
            //System.out.print(loc.x+","+loc.y+" : ");
            // check the triangles of main square for intersection.
            Triangle hit = new Triangle();
            if (checkTriangles(loc.x, loc.y, workRay, intersection, patch, hit)) {
                // we found an intersection, so return that!
                float distance = worldPickRay.origin.distance(intersection);
                CollisionResult cr = new CollisionResult(intersection, distance);
                cr.setGeometry(patch);
                results.addCollision(cr);
                cr.setContactNormal(hit.getNormal());
                return intersection;
            }
            // because of how we get our height coords, we will
            // sometimes be off by a grid spot, so we check the next
            // grid space up.
            int dx = 0, dz = 0;
            Direction d = tracer.getLastStepDirection();
            switch(d) {
                case PositiveX:
                case NegativeX:
                    dx = 0;
                    dz = 1;
                    break;
                case PositiveZ:
                case NegativeZ:
                    dx = 1;
                    dz = 0;
                    break;
            }
            if (checkTriangles(loc.x + dx, loc.y + dz, workRay, intersection, patch, hit)) {
                // we found an intersection, so return that!
                float distance = worldPickRay.origin.distance(intersection);
                CollisionResult cr = new CollisionResult(intersection, distance);
                results.addCollision(cr);
                cr.setGeometry(patch);
                cr.setContactNormal(hit.getNormal());
                return intersection;
            }
            tracer.next();
        }
    }
    return null;
}

Example 28 with CollisionResults

use of com.jme3.collision.CollisionResults in project chordatlas by twak.

the class Tweed method getClicked.

private CollisionResult getClicked() {
    CollisionResults results = new CollisionResults();
    Vector2f click2d = inputManager.getCursorPosition();
    Vector3f click3d = cam.getWorldCoordinates(new Vector2f(click2d.x, click2d.y), 0f).clone();
    Vector3f dir = cam.getWorldCoordinates(new Vector2f(click2d.x, click2d.y), 1f).subtractLocal(click3d).normalizeLocal();
    Ray ray = new Ray(click3d, dir);
    rootNode.collideWith(ray, results);
    if (results.size() > 0)
        return results.getClosestCollision();
    else
        return null;
}

Example 29 with CollisionResults

use of com.jme3.collision.CollisionResults in project chordatlas by twak.

the class SkelFootprint method meanModeHeightColor.

public static void meanModeHeightColor(Loop<Point2d> pts, SuperFace sf, BlockGen blockgen) {
    double[] minMax = Loopz.minMax2d(pts);
    double sample = 2;
    double missCost = 30;
    if (sf.colors != null)
        sf.colors.clear();
    sf.heights.clear();
    int insideGIS = 0, outsideGIS = 0;
    LoopL<Point2d> gis = blockgen.profileGen.gis;
    gis = Loopz.removeInnerEdges(gis);
    gis = Loopz.removeNegativeArea(gis, -1);
    gis = Loopz.mergeAdjacentEdges(gis, 1, 0.05);
    for (double x = minMax[0]; x < minMax[1]; x += sample) for (double y = minMax[2]; y < minMax[3]; y += sample) {
        x += Math.random() * sample - sample / 2;
        y += Math.random() * sample - sample / 2;
        Point2d p2d = new Point2d(x, y);
        if (Loopz.inside(p2d, pts)) {
            CollisionResults results = new CollisionResults();
            blockgen.gNode.collideWith(new Ray(Jme3z.toJmeV(x, 0, y), UP), results);
            CollisionResult cr = results.getFarthestCollision();
            double height;
            if (cr != null) {
                height = cr.getDistance();
                sf.heights.add(height);
                if (sf != null && sf.colors != null) {
                    ColorRGBA col = getColor(cr.getGeometry(), cr.getContactPoint(), cr.getTriangleIndex(), blockgen.tweed);
                    sf.colors.add(new float[] { col.r, col.g, col.b });
                }
            }
            if (Loopz.inside(p2d, gis)) {
                insideGIS++;
            // PaintThing.debug( Color.yellow, 1, p2d);
            } else {
                outsideGIS++;
            // PaintThing.debug( Color.green, 1, p2d);
            }
        }
    }
    if (sf.heights.size() < 2)
        sf.height = -Double.MAX_VALUE;
    else if (TweedSettings.settings.useGis && insideGIS < gisInterior * outsideGIS)
        sf.height = -missCost;
    else {
        sf.updateHeight();
    }
    sf.maxProfHeights = new ArrayList();
    for (HalfEdge e : sf) {
        SuperEdge se = ((SuperEdge) e);
        if (se.profLine != null)
            for (Prof p : ((SuperLine) se.profLine).getMega().getTween(e.start, e.end, 0.3)) sf.maxProfHeights.add(p.get(p.size() - 1).y);
    }
}

Example 30 with CollisionResults

use of com.jme3.collision.CollisionResults in project TeachingInSimulation by ScOrPiOzzy.

the class JmeUtil method getCollisionFromScreen.

@Nullable
public static CollisionResult getCollisionFromScreen(@NotNull final Spatial spatial, @NotNull final Camera camera, final float screenX, final float screenY) {
    final Vector2f point = new Vector2f(screenX, screenY);
    // final Vector3f click3d = camera.getWorldCoordinates(point, 0f);
    // final Vector3f dir = camera.getWorldCoordinates(point, 1f).subtract(click3d).normalize();
    Vector3f origin = camera.getWorldCoordinates(point, 0.0f);
    Vector3f direction = camera.getWorldCoordinates(point, 0.3f);
    direction.subtractLocal(origin).normalizeLocal();
    final Ray ray = new Ray();
    ray.setOrigin(origin);
    ray.setDirection(direction);
    final CollisionResults results = new CollisionResults();
    spatial.updateModelBound();
    spatial.collideWith(ray, results);
    if (results.size() < 1) {
        return null;
    }
    for (CollisionResult collisionResult : results) {
        if (collisionResult.getGeometry().getCullHint() == CullHint.Always) {
            continue;
        }
        Boolean mouseTransparent = collisionResult.getGeometry().getUserData(MouseEventState.TO_MOUSE_VISIBLE);
        if (mouseTransparent != null && !mouseTransparent.booleanValue()) {
            continue;
        }
        return collisionResult;
    }
    return null;
}