path: root/src/raycast.zig

// This file is part of ZiRC
//
// Copyright (C) 2021, tslil clingman
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.

const std = @import("std");

const RenderWindow = @import("sfml").graphics.RenderWindow;
const Sprite = @import("sfml").graphics.Sprite;
const Texture = @import("sfml").graphics.Texture;
const Image = @import("sfml").graphics.Image;
const Colour = @import("sfml").graphics.Color;

usingnamespace @import("map.zig");
usingnamespace @import("renderConstants.zig");

pub const RenderWallFunction: type = fn (
    window: RenderWindow,
    sprite: Sprite,
    col: i32, // which column we're in
    top: f32, // top of wall
    draw_frac: f32,
    length: f32, // length of slice to be drawn
    texfrac: f32,
    texture: u8, // which texture index
) void;

pub fn Player(PlaneWidth: f32, PlaneHeight: f32) type {
    return struct {
        pos_x: f32,
        pos_y: f32,
        ang: f32,
        vel_x: f32 = 0,
        vel_y: f32 = 0,
        acc_x: f32 = 0,
        acc_y: f32 = 0,
        fov: f32 = std.math.pi / 3.0,
        height: f32 = 1.8, // TODO
        // z_buffer: std.BoundedArray(f32, PlaneWidth * PlaneHeight),

        const FOV: f32 = std.math.pi / 3.0;
        const PlanePixels = PlaneWidth * PlaneHeight;
        // given the desired width of the image, how far away must
        // the projection plane be from the camera?
        const PlaneDist = PlaneWidth / (2 * std.math.tan(FOV / 2));

        // standing still at the given location, looking in direction ang,
        pub fn new(pos_x: f32, pos_y: f32, ang: f32) !@This() {
            // const infs = [_]f32{std.math.inf(f32)} ** PlanePixels;
            return Player(PlaneWidth, PlaneHeight){
                .pos_x = pos_x,
                .pos_y = pos_y,
                .ang = ang,
                // TODO: is there some clever way to avoid this long name?
                // .z_buffer = try std.BoundedArray(f32, PlanePixels).fromSlice(&infs),
            };
        }

        pub fn tick(self: *@This()) void {
            const dt = 1 / 30.0;
            const v_min = 0.8;
            const v_decay = 1.25;

            self.pos_x += self.vel_x * dt;
            self.pos_y += self.vel_y * dt;

            self.vel_x /= v_decay;
            if (std.math.fabs(self.vel_x) < v_min) self.vel_x = 0;
            self.vel_y /= v_decay;
            if (std.math.fabs(self.vel_y) < v_min) self.vel_y = 0;

            self.vel_x += self.acc_x * dt;
            self.vel_y += self.acc_y * dt;
        }

        pub fn renderWorld(
            self: *@This(),
            window: RenderWindow,
            walls_sprite: Sprite,
            map: Map,
            // the abstract the rendering call
            renderWall: RenderWallFunction,
        ) void {
            // var i: usize = 0;
            // while (i < self.z_buffer.len) : (i += 1) {
            //     self.z_buffer.set(i, std.math.inf(f32));
            // }
            self.renderWalls(window, walls_sprite, map, renderWall);
        }

        fn renderWalls(
            self: *@This(),
            window: RenderWindow,
            walls_sprite: Sprite,
            map: Map,
            renderWall: RenderWallFunction,
        ) void {
            const floor = std.math.floor;

            var col: i32 = 0;
            var ra: f32 = 0.5 * FOV + self.ang;
            const ra_step = FOV / PlaneWidth;
            while (col < PlaneWidth) : ({
                col += 1;
                ra -= ra_step;
            }) {
                const cosra = std.math.cos(ra);
                const sinra = std.math.sin(ra);

                // Observe that sqrt(1+tan^2) = abs(1/cos) sqrt(cos^2+sin^2) =
                // abs(1/cos). Similarly so for cot, hence we obtain the following
                // lengths for the hypotenuses assuming that x (respectively y) are
                // unit length and the angle is ra.
                const dy_for_x_step = std.math.fabs(1 / cosra);
                const dx_for_y_step = std.math.fabs(1 / sinra);

                var step_x: i32 = -1;
                var step_y: i32 = -1;

                var dist_x: f32 = undefined;
                var dist_y: f32 = undefined;

                var ipos_x: i32 = @floatToInt(i32, floor(self.pos_x));
                var ipos_y: i32 = @floatToInt(i32, floor(self.pos_y));

                // looking right
                if (cosra >= 0) {
                    step_x = 1;
                    // assuming unit size grid cells
                    dist_y = (@intToFloat(f32, ipos_x) + 1 - self.pos_x) * dy_for_x_step;
                } else {
                    dist_y = (self.pos_x - @intToFloat(f32, ipos_x)) * dy_for_x_step;
                }

                if (sinra >= 0) {
                    step_y = 1;
                    dist_x = (@intToFloat(f32, ipos_y) + 1 - self.pos_y) * dx_for_y_step;
                } else {
                    dist_x = (self.pos_y - @intToFloat(f32, ipos_y)) * dx_for_y_step;
                }

                var distance: f32 = 0;
                var still_drawing = true;
                var highest_point: f32 = 0;
                var horizontal_hit: bool = undefined;
                while (still_drawing and map.inBounds(ipos_x, ipos_y)) : ({
                    // Find the next cell on our path
                    if (dist_y < dist_x) {
                        horizontal_hit = false;
                        distance = dist_y;
                        dist_y += dy_for_x_step;
                        ipos_x += step_x;
                    } else {
                        horizontal_hit = true;
                        distance = dist_x;
                        dist_x += dx_for_y_step;
                        ipos_y += step_y;
                    }
                }) {
                    var cell = map.lookup(ipos_x, ipos_y);

                    // the correct distance is the shortest distance from the plane
                    // of projection to the point, that is, perpendicular distance
                    const perp_distance = distance * std.math.cos(self.ang - ra);

                    // project the top of the wall
                    const top = PlaneHeight / 2 + PlaneDist * (cell.height - self.height) / perp_distance;

                    // We have a wall to draw if it protrudes above what we have so far drawn
                    if (top > highest_point) {

                        // did we extend beyond the top of the plane?
                        if (top > PlaneHeight) still_drawing = false;

                        // compute the height of this wall
                        const total_length = PlaneDist * cell.height / perp_distance;

                        // as well as the fraction we'll be drawing
                        const draw_length = top - highest_point;
                        const draw_frac = std.math.clamp(draw_length / total_length, 0, 1);

                        // we need the raw Euclidean distance to calculate the
                        // fractional part of the relevant coordinate for texture
                        // mapping of the walls
                        const hit_coordinate = if (horizontal_hit) distance * cosra + self.pos_x else distance * sinra + self.pos_y;
                        var texfrac = std.math.modf(hit_coordinate).fpart;
                        // we also want to be sure that we're consistently orienting
                        // textures, in this case clockwise
                        if ((horizontal_hit and sinra < 0) or (!horizontal_hit and cosra > 0)) texfrac = 1 - texfrac;

                        // draw the wall
                        renderWall(window, walls_sprite, col, top, total_length, draw_frac, texfrac, cell.wall_texture);

                        // record that there's a wall here in the z_buffer
                        // var y = @floatToInt(i32, top);
                        // while (y > @floatToInt(i32, highest_point)) : (y -= 1) {
                        //     const index = @intCast(usize, col * @floatToInt(i32, PlaneHeight) + y);
                        //     self.z_buffer.set(index, perp_distance);
                        // }

                        highest_point = top;
                    }
                }
            }
        }

        pub fn renderFloorsToTexture(self: @This(), floors_image: Image, rendered_floors_texture: Texture, map: Map) !void {
            var pixels = [_]Colour{Colour.Black} ** (PlaneWidth * PlaneHeight / 2);

            const ang_step = FOV / PlaneWidth;
            var row: usize = 0;
            while (row < PlaneHeight / 2) : (row += 1) {
                const row_dist = self.height * PlaneDist / @intToFloat(f32, row + 1);

                var col: usize = 0;
                var ang = 0.5 * FOV + self.ang;
                var ang_diff: f32 = 0.5 * FOV;

                while (col < PlaneWidth) : ({
                    col += 1;
                    ang -= ang_step;
                    ang_diff -= ang_step;
                }) {
                    const perp_dist = row_dist / std.math.cos(ang_diff);
                    const x = self.pos_x + perp_dist * std.math.cos(ang);
                    const y = self.pos_y + perp_dist * std.math.sin(ang);

                    const sx = std.math.modf(x);
                    const sy = std.math.modf(y);

                    const ix = @floatToInt(i32, sx.ipart);
                    const iy = @floatToInt(i32, sy.ipart);

                    if (map.inBounds(ix, iy)) {
                        const tex = @as(c_uint, map.lookup(ix, iy).floor_texture);
                        const toff = tex * @floatToInt(c_uint, 1 + TextureDim);
                        const px = @floatToInt(c_uint, TextureDim * std.math.fabs(sx.fpart));
                        const py = @floatToInt(c_uint, TextureDim * std.math.fabs(sy.fpart));

                        const val = floors_image.getPixel(.{ .x = toff + px, .y = py });

                        pixels[row * @floatToInt(usize, PlaneWidth) + col] = val;
                    }
                }
            }

            try rendered_floors_texture.updateFromPixels(&pixels, null);
        }
    };
}