Java Code Examples for com.jme3.collision.CollisionResult#getContactPoint()

/**
 * Find where on the terrain the mouse intersects.
 */
protected Vector3f getTerrainCollisionPoint() {

    if (editorController.getTerrain(null) == null) {
        return null;
    }

    CollisionResults results = new CollisionResults();
    Ray ray = new Ray();
    Vector3f pos = cam.getWorldCoordinates(new Vector2f(mouseX, mouseY), 0).clone();
    Vector3f dir = cam.getWorldCoordinates(new Vector2f(mouseX, mouseY), 0.3f).clone();
    dir.subtractLocal(pos).normalizeLocal();
    ray.setOrigin(pos);
    ray.setDirection(dir);
    editorController.getTerrain(null).collideWith(ray, results);
    if (results == null) {
        return null;
    }
    final CollisionResult result = results.getClosestCollision();
    if (result == null) {
        return null;
    }
    return result.getContactPoint();
}
 

/**
 * Metod for changing target position.
 *
 * @param tpf time per frame
 */
protected void changeTargetPosition(float tpf) {
    time -= tpf;
    Vector3f forward;

    if (this.agent.getVelocity() != null) {
        forward = this.agent.getVelocity().normalize();
    } else {
        forward = this.agent.fordwardVector();
    }

    if (forward.equals(Vector3f.UNIT_Y)) {
        forward = forward.add(new Vector3f(0, 0, SphereWanderBehavior.SIDE_REFERENCE_OFFSET));
    }

    //Update sphere position  
    this.wanderSphere.setCenter(this.agent.getLocalTranslation().add(forward.mult(SphereWanderBehavior.OFFSET_DISTANCE + this.agent.getRadius() + this.sphereRadius)));

    if (time <= 0) {
        this.calculateNewRandomDir();
        time = timeInterval;
    }

    Vector3f sideVector = forward.cross(Vector3f.UNIT_Y).normalize();
    Vector3f rayDir = (this.agent.offset(wanderSphere.getCenter())).add(sideVector.mult(this.randomDirection.x));//.add(Vector3f.UNIT_Y.mult(this.randomDirection.y));       

    Ray ray = new Ray(this.agent.getLocalTranslation(), rayDir);
    CollisionResults results = new CollisionResults();
    this.wanderSphere.collideWith(ray, results);

    CollisionResult collisionResult = results.getCollision(1); //The collision with the second hemisphere
    this.targetPosition = collisionResult.getContactPoint();
}
 

private Vector3f getWorldIntersection() {
    Vector3f origin = cam.getWorldCoordinates(new Vector2f(settings.getWidth() / 2, settings.getHeight() / 2), 0.0f);
    Vector3f direction = cam.getWorldCoordinates(new Vector2f(settings.getWidth() / 2, settings.getHeight() / 2), 0.3f);
    direction.subtractLocal(origin).normalizeLocal();

    Ray ray = new Ray(origin, direction);
    CollisionResults results = new CollisionResults();
    int numCollisions = terrain.collideWith(ray, results);
    if (numCollisions > 0) {
        CollisionResult hit = results.getClosestCollision();
        return hit.getContactPoint();
    }
    return null;
}
 

public static Point2D getPointedCoord(Node n, Ray r) {
	CollisionResult collision = getCollision(n, r);
	if (collision == null) {
		return null;
	}
	// return Translator.toPoint2D(collision.getContactPoint());
	Vector3f p = collision.getContactPoint();
	return new Point2D(p.x, p.y);
}
 

private Vector3f getWorldIntersection() {
    Vector3f origin = cam.getWorldCoordinates(new Vector2f(settings.getWidth() / 2, settings.getHeight() / 2), 0.0f);
    Vector3f direction = cam.getWorldCoordinates(new Vector2f(settings.getWidth() / 2, settings.getHeight() / 2), 0.3f);
    direction.subtractLocal(origin).normalizeLocal();

    Ray ray = new Ray(origin, direction);
    CollisionResults results = new CollisionResults();
    int numCollisions = terrain.collideWith(ray, results);
    if (numCollisions > 0) {
        CollisionResult hit = results.getClosestCollision();
        return hit.getContactPoint();
    }
    return null;
}
 

protected Vector3f pickWorldLocation(Camera cam, Vector2f mouseLoc, Node rootNode) {
    CollisionResult cr = pick(cam, mouseLoc, rootNode);
    if (cr != null) {
        return cr.getContactPoint();
    } else {
        return null;
    }
}
 

@Override
@JmeThread
public void processTransform() {

    final EditorTransformSupport editorControl = getEditorControl();
    final LocalObjects local = LocalObjects.get();

    final Camera camera = editorControl.getCamera();
    final InputManager inputManager = EditorUtil.getInputManager();
    final Vector2f cursorPosition = inputManager.getCursorPosition();
    final CollisionResults results = local.nextCollisionResults();

    final Vector3f position = camera.getWorldCoordinates(cursorPosition, 0f, local.nextVector());
    final Vector3f direction = camera.getWorldCoordinates(cursorPosition, 1f, local.nextVector())
            .subtractLocal(position)
            .normalizeLocal();

    final Ray ray = local.nextRay();
    ray.setOrigin(position);
    ray.setDirection(direction);

    final Node collisionPlane = getCollisionPlane();
    collisionPlane.collideWith(ray, results);

    final CollisionResult result = results.getClosestCollision();
    final Transform transform = editorControl.getTransformCenter();

    // Complex trigonometry formula based on sin(angle)*distance
    if (result == null || transform == null) {
        return;
    }

    final Node parentNode = getParentNode();

    final Vector3f translation = parentNode.getLocalTranslation();
    final Vector3f contactPoint = result.getContactPoint(); // get a point of collisionPlane

    //set new deltaVector if it's not set
    if (Float.isNaN(editorControl.getTransformDeltaX())) {
        editorControl.setTransformDeltaX(translation.getX() - contactPoint.getX());
        editorControl.setTransformDeltaY(translation.getY() - contactPoint.getY());
        editorControl.setTransformDeltaZ(translation.getZ() - contactPoint.getZ());
    }

    // add delta of the picked place
    contactPoint.addLocal(editorControl.getTransformDeltaX(), editorControl.getTransformDeltaY(),
            editorControl.getTransformDeltaZ());

    final Vector3f difference = contactPoint.subtract(translation, local.nextVector());
    float distanceToContactPoint = translation.distance(contactPoint);

    // Picked vector
    final PickedAxis pickedAxis = editorControl.getPickedAxis();
    final TransformationMode transformationMode = editorControl.getTransformationMode();
    final Vector3f pickedVector = transformationMode.getPickedVector(transform, pickedAxis, camera);
    final Quaternion rotation = parentNode.getLocalRotation();

    // the main formula for constraint axis
    final Vector3f normalizedDifference = local.nextVector(difference).normalizeLocal();

    float angle = normalizedDifference.angleBetween(rotation.mult(pickedVector, local.nextVector())
            .normalizeLocal());

    float distanceVec2 = distanceToContactPoint * FastMath.sin(angle);

    // fix if angle>90 degrees
    Vector3f perpendicularVec = collisionPlane.getLocalRotation()
            .mult(Vector3f.UNIT_X, local.nextVector())
            .multLocal(distanceVec2);

    Vector3f checkVec = contactPoint.add(perpendicularVec, local.nextVector())
            .subtractLocal(contactPoint)
            .normalizeLocal();

    float angleCheck = checkVec.angleBetween(normalizedDifference);

    if (angleCheck < FastMath.HALF_PI) {
        perpendicularVec.negateLocal();
    }

    // find distance to move
    float distanceToMove = contactPoint.addLocal(perpendicularVec).distance(translation);

    // invert value if it's needed for negative movement
    if (angle > FastMath.HALF_PI) {
        distanceToMove = -distanceToMove;
    }

    translateObjects(pickedAxis, notNull(editorControl.getToTransform()), transform, distanceToMove);
}
 

/**
 * Update editing nodes.
 */
@JmeThread
private void updatePaintingNodes() {

    if (!isPaintingMode()) {
        return;
    }

    final Node cursorNode = getCursorNode();
    final PaintingControl control = PaintingUtils.getPaintingControl(cursorNode);
    final Spatial paintedModel = PaintingUtils.getPaintedModel(control);
    if (paintedModel == null) {
        return;
    }

    final CollisionResults collisions = GeomUtils.getCollisionsFromCursor(paintedModel, getCamera());
    if (collisions.size() < 1) {
        return;
    }

    CollisionResult result = null;

    for (final CollisionResult collision : collisions) {

        final Geometry geometry = collision.getGeometry();
        final Object parent = NodeUtils.findParent(geometry, spatial ->
                spatial.getUserData(KEY_IGNORE_RAY_CAST) == Boolean.TRUE);

        if (parent == null) {
            result = collision;
            break;
        }
    }

    if (result == null) {
        result = collisions.getClosestCollision();
    }

    final Vector3f contactPoint = result.getContactPoint();
    final Vector3f contactNormal = result.getContactNormal();

    final LocalObjects local = LocalObjects.get();
    final Quaternion rotation = local.nextRotation();
    rotation.lookAt(contactNormal, Vector3f.UNIT_Y);

    cursorNode.setLocalRotation(rotation);
    cursorNode.setLocalTranslation(contactPoint);
}