raycaster | quick port of A first-person engine | Game Engine library

Since you put your script directly on the Desktop, you made that your project folder. So when you try to load a model, ursina will search all your files and folders on the desktop for a file matching that name.

Move your scripts and relevant assets into a separate folder.

For a gaze-based cursor at the center of the screen, what you have is almost right.

The entry in objects: needs to match a selector, so .sign for the class or #sign for the id.

However, the entity with class "sign" does not have any geometry, so the raycaster will never hit it. One solution is to give the children the same class of "sign" - then the raycaster will hit them, and the event will bubble up to the parent entity where it can trigger the animation.

Full code:

Try computing your mouse coordinates like so:

It appears that all I needed to prevent this click-through from happening was to add event.stopPropogation() to my event listeners on my Plane. Now I no longer click through the Plane

There are two issue in your fiddle:

• You are not updating the world matrix of the mesh before raycasting.
• The second parameter of Raycaster.set() expects a direction vector which has to have unit length.
• You have to use intersectObject() not intersectObjects().

Here is a working example:

This is a common problem when trying to recreate the calculations of a physics engine. Since your bullet is too small and sometimes travels beyond the wall in between frames, I see two options:

1. On frame x+1 you could calculate how much distance has been traveled since frame x, and use that as the size of the bullet. If the plane is crossed in the distance travelled between x -> x1, then you know you've had a collision.
2. If collision points don't move, you could use a THREE.Raycaster and calculate the point of collision pre-emptively, so you'll know where the bullet will hit before that point is reached:

I was now able to solve this myself to some extent. It's surprisingly easy if we start with symmetric offsets:

Using a narrower FOV angle (green) to calculate the camera position will offset the projected points by a certain amount in the final image. If we find the right angle, the points end up at the exact offset we are looking for.

We can calculate this angle using basic trigonometry. We calculate the distance to the Normalized Device Coordinate plane (i.e. height/width of -1 to 1; blue in the image) and then apply the offset (percentage value ranging from 0.0 to 1.0) and create a new angle:

tan(FOV / 2) = 1 / dist => dist = 1 / tan(FOV / 2)

tan(FOVg / 2) = (1 - offset) / dist => FOVg = atan((1 - offset) / dist) * 2

Repeat this for the horizontal FOV (modified by aspect ratio), using the same or a different offset value. Then apply the existing zoom-to-fit logic given these new angles.

This approach works well for symmetric offsets. The same would likely be possible for asymmetric offsets by calculating 4 individual new angles. The tricky part is to calculate the proper camera position and zoom using those...

The load method takes a callback. It doesn't return anything that you can call resolve with. Instead of all this promiseTextureBack code, just use the loadAsync method which returns a promise:

I recommend a simple algorithm with two steps:

• First, check if the given point is in the view frustum at all. The code for implementing this feature is shared in: three.js - check if object is still in view of the camera.
• If the test passes, you have to verify whether the point is occluded by a 3D object or not. A typical way for checking this is a line-of-sight test. Meaning you setup a raycaster from your camera's position and the direction that points from your camera to the given point. You then test if 3D objects in your scene intersect with this ray. If there is no intersection, the point is not occluded. Otherwise it is and you can hide the respective label.