gistlib - sfml raycasting in csharp

To perform raycasting with SFML in C#, you can follow these steps:

Create a window using SFML. Make sure to include the required SFML libraries in your project.


main.cs
using SFML.Graphics;
using SFML.System;
using SFML.Window;

RenderWindow window = new RenderWindow(new VideoMode(800, 600), "SFML Raycasting");
144 chars
6 lines

Define a player position and orientation. You may also need to define a map of walls (represented as rectangles).


main.cs
Vector2f playerPosition = new Vector2f(100, 100);
float playerRotation = 0.0f;

RectangleShape[] walls = new RectangleShape[4];
walls[0] = new RectangleShape(new Vector2f(100, 10));
walls[0].Position = new Vector2f(200, 200);

// Define the other walls here
258 chars
9 lines

In the game loop, cast rays from the player to the walls to determine which parts of the walls should be drawn.


main.cs
while(window.IsOpen)
{
    window.Clear();

    // Cast rays from player to walls and determine which parts
    // of the walls should be drawn

    // Draw the walls
    foreach(RectangleShape wall in walls)
    {
        window.Draw(wall);
    }

    window.Display();
}
273 chars
16 lines

To cast rays from the player to the walls, you can use the following algorithm:


main.cs
for(int x = 0; x < window.Size.X; x++)
{
    // Determine the angle of the ray
    float rayAngle = (playerRotation - fieldOfView / 2) + (fieldOfView / window.Size.X) * x;
    
    // Cast the ray
    Vector2f rayDirection = new Vector2f(MathF.Cos(rayAngle), MathF.Sin(rayAngle));
    Vector2f wallHit = CastRay(playerPosition, rayDirection, walls);
    
    // Draw the part of the wall that was hit
    float distance = Vector2f.Distance(playerPosition, wallHit);
    float wallHeight = wallHeightFactor / distance;
    float wallTop = (window.Size.Y - wallHeight) / 2;
    float wallBottom = (window.Size.Y + wallHeight) / 2;
    float wallTextureX = (int)(wallHit.X % wallTexture.Width);

    // Draw the wall part onto the screen
    RectangleShape wallPart = new RectangleShape(new Vector2f(1, wallHeight));
    wallPart.Texture = wallTexture;
    wallPart.TextureRect = new IntRect((int)wallTextureX, 0, 1, (int)wallHeight);
    wallPart.Position = new Vector2f(x, wallTop);
    window.Draw(wallPart);
}
1011 chars
24 lines

The CastRay function should determine the point at which a ray intersects with a wall. You can use the following algorithm:


main.cs
public static Vector2f CastRay(Vector2f origin, Vector2f direction, RectangleShape[] walls)
{
    float minDistance = float.MaxValue;
    Vector2f closestHit = Vector2f.Zero;

    foreach(RectangleShape wall in walls)
    {
        Vector2f p1 = wall.Position;
        Vector2f p2 = wall.Position + new Vector2f(wall.Size.X, 0);
        Vector2f p3 = wall.Position + new Vector2f(wall.Size.X, wall.Size.Y);
        Vector2f p4 = wall.Position + new Vector2f(0, wall.Size.Y);

        if(RayLineIntersection(origin, direction, p1, p2, out Vector2f hitPoint))
        {
            float distance = Vector2f.Distance(origin, hitPoint);
            
            if(distance < minDistance)
            {
                closestHit = hitPoint;
                minDistance = distance;
            }
        }
        
        // Check the other 3 sides of the wall
    }

    return closestHit;
}

public static bool RayLineIntersection(Vector2f origin, Vector2f direction,
    Vector2f lineStart, Vector2f lineEnd, out Vector2f hitPoint)
{
    // Algorithm to determine intersection point between line segment
    // and infinite ray, returns true if there is an intersect and fills
    // hitPoint with the point of intersection
}
1227 chars
37 lines

You may also want to use a texture for the walls instead of just drawing rectangles. To do this, you can load a texture and apply it to the wall rectangles in step 3.

sfml raycasting in csharp

similar csharp code snippets

related categories