gistlib - opentk raycasting in csharp

To perform raycasting in C# using OpenTK, you can follow the steps below:

Define a ray by its origin and direction. For example, you can create a Ray class:


main.cs
class Ray {
    public Vector3 Origin { get; set; }
    public Vector3 Direction { get; set; }
}
97 chars
5 lines

In your rendering loop, for each pixel on the screen, create a ray that passes through that pixel. You can use the UnProject method of Matrix4 to transform the pixel coordinates from screen space to world space.


main.cs
int mouseX, mouseY; // mouse coordinates
Matrix4 projectionMatrix, viewMatrix; // camera matrices
Vector4 viewport; // viewport size and position

// calculate ray origin and direction from mouse coordinates
Vector3 near = OpenTK.Graphics.Glu.UnProject(
    new Vector3(mouseX, mouseY, 0), // near plane
    viewMatrix, projectionMatrix, viewport);
Vector3 far = OpenTK.Graphics.Glu.UnProject(
    new Vector3(mouseX, mouseY, 1), // far plane
    viewMatrix, projectionMatrix, viewport);
Vector3 direction = Vector3.Normalize(far - near);
Ray ray = new Ray { Origin = near, Direction = direction };
599 chars
14 lines

For each object in your scene that can be hit by the ray, calculate the intersection point of the ray with the object's geometry. You can use the Ray.Intersects method to test for intersection with a bounding box or a sphere, and then check the actual geometry of the object only if the test was positive.


main.cs
class Sphere {
    public Vector3 Center { get; set; }
    public float Radius { get; set; }

    public float? Intersects(Ray ray) {
        Vector3 oc = ray.Origin - Center;
        float a = Vector3.Dot(ray.Direction, ray.Direction);
        float b = 2 * Vector3.Dot(oc, ray.Direction);
        float c = Vector3.Dot(oc, oc) - Radius * Radius;
        float discriminant = b * b - 4 * a * c;
        if (discriminant < 0) {
            return null; // no intersection
        }
        float t = (-b - (float)Math.Sqrt(discriminant)) / (2 * a);
        if (t < 0) {
            t = (-b + (float)Math.Sqrt(discriminant)) / (2 * a);
            if (t < 0) {
                return null; // behind ray origin
            }
        }
        return t; // hit at t units along the ray
    }
}

// example usage
Sphere sphere = new Sphere { Center = new Vector3(0, 0, 5), Radius = 1 };
float? t = sphere.Intersects(ray);
if (t.HasValue) {
    Vector3 hit = ray.Origin + t.Value * ray.Direction;
    // draw the hit point or do other processing
}
1044 chars
32 lines

You can also calculate the normal vector of the surface at the intersection point, by taking the gradient of the implicit equation of the object's geometry at that point, or by approximating it using neighboring vertices or texture coordinates.


main.cs
// example calculation of sphere normal
Vector3 normal = Vector3.Normalize(hit - sphere.Center);
97 chars
3 lines

opentk raycasting in csharp

similar csharp code snippets

related categories