raytracing.cpp

#include <iostream>
#include <SDL3/SDL.h>

#define _USE_MATH_DEFINES
#include <math.h>

#define WIDTH 1300
#define HEIGHT 600

#define RAYS_N 1000
#define RAY_THICKNESS 2

#define COLOR_WHITE 0xffffffff
#define COLOR_BLACK 0x00000000
#define COLOR_YELLOW 0xFFC014
#define COLOR_ORANGE 0xffd43b

struct Circle{
    double x;
    double y;
    double r;
};

struct Ray{
    double x_0, y_0;
    double x_e, y_e;
    double angle;
};

void fillCircle(SDL_Surface* surface, struct Circle circle, Uint32 color){
    double radius_squared = pow(circle.r, 2);
    for(double x = circle.x - circle.r; x <= circle.x + circle.r; ++x){
        for(double y = circle.y - circle.r; y < circle.y + circle.r; ++y){
            double distance_squared = pow(x - circle.x, 2) + pow(y - circle.y, 2); 
            if(distance_squared < radius_squared){
                SDL_Rect pixel = (SDL_Rect){static_cast<int>(x), static_cast<int>(y), 1, 1};
                SDL_FillSurfaceRect(surface, &pixel, color);
            }
        }
    }

    return;
}

void generateRays(struct Circle circle, struct Ray rays[RAYS_N]){
    for(int i = 0; i < RAYS_N; ++i){
        double angle = (static_cast<double>(i) / RAYS_N) * 2.0 * M_PI; 
        struct Ray ray = {circle.x, circle.y, angle, 0, 0};
        rays[i].angle = angle;
        rays[i].x_0 = circle.x;
        rays[i].y_0 = circle.y;
    }

    return;
}

void fillRays(SDL_Surface* surface, struct Ray rays[RAYS_N], Uint32 color, struct Circle obstacle){
    double radius_squared = pow(obstacle.r, 2);
    for(int i = 0; i < RAYS_N; ++i){
        struct Ray ray = rays[i];
        
        int end_of_screen = 0;
        int obstacle_hit = 0;

        double step = 1;
        double x_draw = ray.x_0;
        double y_draw = ray.y_0;
        while(!end_of_screen && !obstacle_hit){
            x_draw += step * cos(ray.angle);
            y_draw += step * sin(ray.angle);
            
            SDL_Rect pixel = (SDL_Rect){static_cast<int>(x_draw), static_cast<int>(y_draw), RAY_THICKNESS, RAY_THICKNESS};
            SDL_FillSurfaceRect(surface, &pixel, color);
            
            if(x_draw < 0 || x_draw > WIDTH) end_of_screen = 1;
            if(y_draw < 0 || y_draw > HEIGHT) end_of_screen = 1;
            double distance_squared = pow(x_draw - obstacle.x, 2) + pow(y_draw - obstacle.y, 2); 
            if(distance_squared < radius_squared){
                break;
            }
        }
    }

    return;
}

void moveObstacle(struct Circle* obstacle, double& speed){
    obstacle->y += speed;
    if (obstacle->y - obstacle->r <= 0 || obstacle->y + obstacle->r >= HEIGHT) {
        speed = -speed;
    }

    return;
}

int main(){
    SDL_Init(SDL_INIT_VIDEO);
    SDL_Window* window = SDL_CreateWindow("Raytracing", WIDTH, HEIGHT, 0);

    SDL_Surface* surface = SDL_GetWindowSurface(window);
    
    SDL_Rect rect = (SDL_Rect) {200,200,200,200};
    struct Circle circle = {200.0, 200.0, 40.0};
    struct Circle obstacle = {900.0, 250.0, 120.0};
    SDL_Rect erase_rect = (SDL_Rect){0, 0, WIDTH, HEIGHT};

    struct Ray rays[RAYS_N];
    generateRays(circle, rays);

    int simulation_running = 1;
    SDL_Event event;
    double obstacleSpeed = 5;
    while(simulation_running){
        while(SDL_PollEvent(&event)){
            if(event.type == SDL_EVENT_QUIT){
                simulation_running = 0;
            }

            if(event.type == SDL_EVENT_MOUSE_MOTION && (event.motion.state & SDL_BUTTON_LMASK)){
                circle.x = event.motion.x;
                circle.y = event.motion.y;
                generateRays(circle, rays);

            }
        }
        SDL_FillSurfaceRect(surface, &erase_rect, COLOR_BLACK);
        fillRays(surface, rays, COLOR_ORANGE, obstacle);
        fillCircle(surface, circle, COLOR_WHITE);

        fillCircle(surface, obstacle, COLOR_WHITE);

        SDL_UpdateWindowSurface(window);
        SDL_Delay(20);
        
        moveObstacle(&obstacle, obstacleSpeed);
    }

    return 0;
}