From 5e63272f24a00bcef314bc870212ada55b961680 Mon Sep 17 00:00:00 2001 From: "Zed A. Shaw" Date: Thu, 16 Jan 2025 12:50:25 -0500 Subject: [PATCH] Brought in some of amit's code to study and try out. amt/ has it. --- amt/main.cpp | 67 +++++ amt/matrix.hpp | 184 ++++++++++++++ amt/pixel.hpp | 582 +++++++++++++++++++++++++++++++++++++++++++ amt/raycaster.cpp | 395 +++++++++++++++++++++++++++++ amt/raycaster.hpp | 95 +++++++ meson.build | 7 + tests/amt_matrix.cpp | 74 ++++++ 7 files changed, 1404 insertions(+) create mode 100644 amt/main.cpp create mode 100644 amt/matrix.hpp create mode 100644 amt/pixel.hpp create mode 100644 amt/raycaster.cpp create mode 100644 amt/raycaster.hpp create mode 100644 tests/amt_matrix.cpp diff --git a/amt/main.cpp b/amt/main.cpp new file mode 100644 index 0000000..9ee9e15 --- /dev/null +++ b/amt/main.cpp @@ -0,0 +1,67 @@ +#include "amt/raycaster.hpp" + +#define RAY_VIEW_WIDTH 960 +#define RAY_VIEW_HEIGHT 720 +#define RAY_VIEW_X (1280 - RAY_VIEW_WIDTH) +#define RAY_VIEW_Y 0 + +static const int SCREEN_HEIGHT=720; +static const int SCREEN_WIDTH=1280; + +using Matrix = amt::Matrix; + +Matrix MAP{ + {8,8,8,8,8,8,8,8,8}, + {8,0,2,0,0,0,0,0,8}, + {8,0,7,0,0,5,6,0,8}, + {8,0,0,0,0,0,0,0,8}, + {8,8,0,0,0,0,0,8,8}, + {8,0,0,1,3,4,0,0,8}, + {8,0,0,0,0,0,8,8,8}, + {8,0,0,0,0,0,0,0,8}, + {8,8,8,8,8,8,8,8,8} +}; + +int main() { + using KB = sf::Keyboard; + + sf::RenderWindow window(sf::VideoMode(SCREEN_WIDTH, SCREEN_HEIGHT), "Zed's Ray Caster Game Thing"); + + //ZED this should set with a function + float player_x = MAP.cols() / 2; + float player_y = MAP.rows() / 2; + + Raycaster rayview(window, MAP, RAY_VIEW_WIDTH, RAY_VIEW_HEIGHT); + rayview.set_position(RAY_VIEW_X, RAY_VIEW_Y); + rayview.position_camera(player_x, player_y); + + double moveSpeed = 0.1; + double rotSpeed = 0.1; + + while(window.isOpen()) { + rayview.render(); + // DRAW GUI + window.display(); + + if(KB::isKeyPressed(KB::W)) { + rayview.run(moveSpeed, 1); + } else if(KB::isKeyPressed(KB::S)) { + rayview.run(moveSpeed, -1); + } + + if(KB::isKeyPressed(KB::D)) { + rayview.rotate(rotSpeed, -1); + } else if(KB::isKeyPressed(KB::A)) { + rayview.rotate(rotSpeed, 1); + } + + sf::Event event; + while(window.pollEvent(event)) { + if(event.type == sf::Event::Closed) { + window.close(); + } + } + } + + return 0; +} diff --git a/amt/matrix.hpp b/amt/matrix.hpp new file mode 100644 index 0000000..73c2eaf --- /dev/null +++ b/amt/matrix.hpp @@ -0,0 +1,184 @@ +#pragma once + +#include +#include +#include +#include +#include +#include + +namespace amt { + + template + struct Matrix { + using value_type = T; + using pointer = value_type*; + using const_pointer = value_type const*; + using reference = value_type&; + using const_reference = value_type const&; + using iterator = pointer; + using const_iterator = const_pointer; + using reverse_iterator = std::reverse_iterator; + using const_reverse_iterator = std::reverse_iterator; + using difference_type = std::ptrdiff_t; + using size_type = std::size_t; + + template + struct View { + using base_type = std::conditional_t; + base_type data; + size_type size; + + constexpr reference operator[](size_type k) noexcept requires (!IsConst) { + assert(k < size && "Out of bound access"); + return data[k]; + } + + constexpr const_reference operator[](size_type k) const noexcept { + assert(k < size && "Out of bound access"); + return data[k]; + } + }; + + constexpr Matrix() noexcept = default; + Matrix(Matrix const& other) + : Matrix(other.rows(), other.cols()) + { + std::copy(other.begin(), other.end(), begin()); + } + Matrix& operator=(Matrix const& other) { + if (this == &other) return *this; + auto temp = Matrix(other); + swap(temp, *this); + return *this; + } + constexpr Matrix(Matrix && other) noexcept + : m_data(other.m_data) + , m_row(other.m_row) + , m_col(other.m_col) + { + other.m_data = nullptr; + } + constexpr Matrix& operator=(Matrix && other) noexcept { + if (this == &other) return *this; + swap(*this, other); + return *this; + } + ~Matrix() { + if (m_data) delete[] m_data; + } + + + Matrix(size_type row, size_type col) + : m_data(new value_type[row * col]) + , m_row(row) + , m_col(col) + {} + + Matrix(size_type row, size_type col, value_type def) + : Matrix(row, col) + { + std::fill(begin(), end(), def); + } + + Matrix(std::initializer_list> li) + : m_row(li.size()) + { + for (auto const& row: li) { + m_col = std::max(m_col, row.size()); + } + + auto const size = m_row * m_col; + + if (size == 0) return; + + m_data = new value_type[size]; + std::fill_n(m_data, size, 0); + + for (auto r = 0ul; auto const& row: li) { + for (auto c = 0ul; auto const& col: row) { + this->operator()(r, c++) = col; + } + ++r; + } + } + + constexpr bool empty() const noexcept { return size() == 0; } + constexpr size_type size() const noexcept { return rows() * cols(); } + constexpr size_type rows() const noexcept { return m_row; } + constexpr size_type cols() const noexcept { return m_col; } + constexpr auto data() noexcept -> pointer { return m_data; } + constexpr auto data() const noexcept -> const_pointer { return m_data; } + + constexpr iterator begin() noexcept { return m_data; } + constexpr iterator end() noexcept { return m_data + size(); } + constexpr const_iterator begin() const noexcept { return m_data; } + constexpr const_iterator end() const noexcept { return m_data + size(); } + constexpr reverse_iterator rbegin() noexcept { return std::reverse_iterator(end()); } + constexpr reverse_iterator rend() noexcept { return std::reverse_iterator(begin()); } + constexpr const_reverse_iterator rbegin() const noexcept { return std::reverse_iterator(end()); } + constexpr const_reverse_iterator rend() const noexcept { return std::reverse_iterator(begin()); } + + constexpr auto operator()(size_type r, size_type c) noexcept -> reference { + auto const index = r * m_col + c; // column-major; + assert(index < size() && "Out of bound access"); + return m_data[index]; + } + + constexpr auto operator()(size_type r, size_type c) const noexcept -> const_reference { + auto const index = r * m_col + c; // column-major; + assert(index < size() && "Out of bound access"); + return m_data[index]; + } + + constexpr auto operator[](size_type r) noexcept -> View { + auto const base = r * m_col; + assert(r < rows() && "Out of bound access"); + return { .data = m_data + base, .size = m_col }; + } + + constexpr auto operator[](size_type r) const noexcept -> View { + auto const base = r * m_col; + assert(r < rows() && "Out of bound access"); + return { .data = m_data + base, .size = m_col }; + } + + friend void swap(Matrix& lhs, Matrix& rhs) noexcept { + using std::swap; + swap(lhs.m_data, rhs.m_data); + swap(lhs.m_row, rhs.m_row); + swap(lhs.m_col, rhs.m_col); + } + + private: + pointer m_data; + size_type m_row{}; + size_type m_col{}; + }; + +} // namespace amt + +#if 0 +#include +namespace std { + template + struct formatter> { + constexpr auto parse(format_parse_context& ctx) { + return ctx.begin(); + } + + auto format(amt::Matrix const& m, auto& ctx) const { + std::string s = "[\n"; + for (auto r = std::size_t{}; r < m.rows(); ++r) { + for (auto c = std::size_t{}; c < m.cols(); ++c) { + s += std::format("{}, ", m(r, c)); + } + s += '\n'; + } + s += "]"; + return format_to(ctx.out(), "{}", s); + } + }; + +} // namespace std +#endif diff --git a/amt/pixel.hpp b/amt/pixel.hpp new file mode 100644 index 0000000..b38040a --- /dev/null +++ b/amt/pixel.hpp @@ -0,0 +1,582 @@ +#ifndef AMT_PIXEL_HPP +#define AMT_PIXEL_HPP + +#include "matrix.hpp" +#include +#include +#include +#include +#include +#include + +namespace amt { + + enum class PixelFormat { + rgba, + abgr, + rgb , + bgr , + ga , // gray scale and alpha + ag , // alpha and gray scale + g // gray scale + }; + + inline static constexpr auto get_pixel_format_from_channel(std::size_t c, bool little_endian = false) -> PixelFormat { + switch (c) { + case 1: return PixelFormat::g; + case 2: return little_endian ? PixelFormat::ag : PixelFormat::ga; + case 3: return little_endian ? PixelFormat::bgr : PixelFormat::rgb; + case 4: return little_endian ? PixelFormat::abgr : PixelFormat::abgr; + } + throw std::runtime_error(std::string("get_pixel_format_from_channel: unknown channel ") + std::to_string(c)); + } + + namespace detail { + static constexpr auto compare_float(float l, float r) noexcept -> bool { + return std::abs(l - r) < std::numeric_limits::epsilon(); + } + } // namespace detail + + enum class BlendMode { + normal, + multiply, + screen, + overlay, + darken, + lighten, + colorDodge, + colorBurn, + hardLight, + softLight, + difference, + exclusion + }; + + struct RGBA { + using pixel_t = std::uint8_t; + pixel_t r{}; // 0-255 + pixel_t g{}; // 0-255 + pixel_t b{}; // 0-255 + pixel_t a{}; // 0-255 + + constexpr RGBA() noexcept = default; + constexpr RGBA(RGBA const&) noexcept = default; + constexpr RGBA(RGBA &&) noexcept = default; + constexpr RGBA& operator=(RGBA const&) noexcept = default; + constexpr RGBA& operator=(RGBA &&) noexcept = default; + constexpr ~RGBA() noexcept = default; + + constexpr RGBA(pixel_t r, pixel_t g, pixel_t b, pixel_t a = 0xff) noexcept + : r(r) + , g(g) + , b(b) + , a(a) + {} + + constexpr RGBA(pixel_t color, pixel_t a = 0xff) noexcept + : RGBA(color, color, color, a) + {} + + // NOTE: RRGGBBAA + constexpr static auto from_hex(std::uint32_t color) noexcept -> RGBA { + return RGBA( + ((color >> (8 * 3)) & 0xff), + ((color >> (8 * 2)) & 0xff), + ((color >> (8 * 1)) & 0xff), + ((color >> (8 * 0)) & 0xff) + ); + } + + // NOTE: RRGGBBAA + constexpr auto to_hex() const noexcept -> std::uint32_t { + auto r = static_cast(this->r); + auto b = static_cast(this->b); + auto g = static_cast(this->g); + auto a = static_cast(this->a); + return (r << (8 * 3)) | (g << (8 * 2)) | (b << (8 * 1)) | (a << (8 * 0)); + } + + constexpr auto blend(RGBA color, BlendMode mode) const noexcept -> RGBA { + auto ab = normalize(a); + auto as = normalize(color.a); + // αs x 1 + αb x (1 – αs) + auto alpha = to_pixel(as + ab * (1 - as)); + auto nr = blend_helper(normalize(r), normalize(color.r), normalize(a), mode); + auto ng = blend_helper(normalize(g), normalize(color.g), normalize(a), mode); + auto nb = blend_helper(normalize(b), normalize(color.b), normalize(a), mode); + + return RGBA( + to_pixel(nr), + to_pixel(ng), + to_pixel(nb), + alpha + ); + } + private: + static constexpr auto normalize(pixel_t p) noexcept -> float { + return float(p) / 255; + } + + static constexpr auto to_pixel(float p) noexcept -> pixel_t { + return static_cast(std::clamp(p, 0.f, 1.f) * 255); + } + + static constexpr auto apply_op(pixel_t l, pixel_t r, auto&& fn) noexcept -> pixel_t { + return RGBA::to_pixel(fn(RGBA::normalize(l), RGBA::normalize(r))); + } + + static constexpr auto blend_helper(float bg, float fg, float alpha, BlendMode mode) noexcept -> float { + constexpr auto mix_helper = [](float s, float b, float a) -> float { + // (1 - αb) x Cs + αb x B(Cb, Cs) + return (1 - a) * s + a * b; + }; + + switch (mode) { + case BlendMode::normal: return mix_helper(bg, fg, alpha); + case BlendMode::multiply: { + return mix_helper(bg, bg * fg, alpha); + } + case BlendMode::screen: { + constexpr auto fn = [](float b, float s) -> float { + // Cb + Cs -(Cb x Cs) + return b + s - (b * s); + }; + auto bf = fn(bg, fg); + return mix_helper(bg, bf, alpha); + } + case BlendMode::overlay: { + // HardLight(Cs, Cb) + auto hl = blend_helper(bg, fg, alpha, BlendMode::hardLight); + return mix_helper(bg, hl, alpha); + } + case BlendMode::darken: return mix_helper(bg, std::min(bg, fg), alpha); + case BlendMode::lighten: return mix_helper(bg, std::max(bg, fg), alpha); + case BlendMode::colorDodge: { + constexpr auto fn = [](float b, float s) -> float { + if (b == 0) return 0; + if (s == 255) return 255; + return std::min(1.f, b / (1.f - s)); + }; + auto bf = fn(bg, fg); + return mix_helper(bg, bf, alpha); + } + case BlendMode::colorBurn: { + constexpr auto fn = [](float b, float s) -> float { + if (b == 255) return 255; + if (s == 0) return 0; + return 1.f - std::min(1.f, (1.f - b) / s); + }; + auto bf = fn(bg, fg); + return mix_helper(bg, bf, alpha); + } + case BlendMode::hardLight: { + constexpr auto fn = [](float b, float s, float a) -> float { + if (s <= 0.5f) { + return RGBA::blend_helper(b, 2.f * s, a, BlendMode::multiply); + } else { + return RGBA::blend_helper(b, 2.f * s - 1.f, a, BlendMode::screen); + } + }; + + auto bf = fn(bg, fg, alpha); + return mix_helper(bg, bf, alpha); + } + case BlendMode::softLight: { + constexpr auto fn = [](float b, float s) -> float { + if (s <= 0.5f) { + // B(Cb, Cs) = Cb - (1 - 2 x Cs) x Cb x (1 - Cb) + return b - (1.f - 2.f * s) * b * (1 - b); + } else { + float d{}; + + if (b <= 0.5f) { + // D(Cb) = ((16 * Cb - 12) x Cb + 4) x Cb + d = ((16 * b - 12) * b + 4) * b; + } else { + // D(Cb) = sqrt(Cb) + d = std::sqrt(b); + } + + // B(Cb, Cs) = Cb + (2 x Cs - 1) x (D(Cb) - Cb) + return b + (2 * s - 1) * (d - b); + } + }; + + auto bf = fn(bg, fg); + return mix_helper(bg, bf, alpha); + } + case BlendMode::difference: { + // B(Cb, Cs) = | Cb - Cs | + return mix_helper(bg, (bg > fg ? (bg - fg) : (fg - bg)), alpha); + } + case BlendMode::exclusion: { + constexpr auto fn = [](float b, float s) -> float { + // B(Cb, Cs) = Cb + Cs - 2 x Cb x Cs + return b + s - 2 * b * s; + }; + + auto bf = fn(bg, fg); + return mix_helper(bg, bf, alpha); + } + } + } + + }; + + struct HSLA { + using pixel_t = float; + pixel_t h{}; // hue: 0-360 + pixel_t s{}; // saturation: 0-100% + pixel_t l{}; // lightness: 0-100% + pixel_t a{}; // alpha: 0-100% + + constexpr HSLA() noexcept = default; + constexpr HSLA(HSLA const&) noexcept = default; + constexpr HSLA(HSLA &&) noexcept = default; + constexpr HSLA& operator=(HSLA const&) noexcept = default; + constexpr HSLA& operator=(HSLA &&) noexcept = default; + constexpr ~HSLA() noexcept = default; + + constexpr HSLA(pixel_t h, pixel_t s, pixel_t l, pixel_t a = 100) noexcept + : h(h) + , s(s) + , l(l) + , a(a) + {} + + constexpr HSLA(RGBA color) noexcept { + auto tr = float(color.r) / 255; + auto tg = float(color.g) / 255; + auto tb = float(color.b) / 255; + auto ta = float(color.a) / 255; + + auto min = std::min({tr, tg, tb}); + auto max = std::max({tr, tg, tb}); + auto c = max - min; + + float hue = 0; + float s = 0; + auto l = (max + min) / 2; + + if (!detail::compare_float(c, 0)) { + auto temp_max = std::max({color.r, color.g, color.b}); + if (temp_max == color.r) { + auto seg = (tg - tb) / c; + auto shift = (seg < 0 ? 360.f : 0.f) / 60.f; + hue = seg + shift; + } else if (temp_max == color.g) { + auto seg = (tb - tr) / c; + auto shift = 120.f / 60.f; + hue = seg + shift; + } else { + auto seg = (tr - tg) / c; + auto shift = 240.f / 60.f; + hue = seg + shift; + } + s = c / (1 - std::abs(2 * l - 1)); + } + + hue = hue * 60.f + 360.f; + auto q = static_cast(static_cast(hue / 360.f)); + hue -= q * 360.f; + + this->h = hue; + this->s = s * 100.f; + this->l = l * 100.f; + this->a = ta * 100.f; + } + + constexpr operator RGBA() const noexcept { + auto th = std::clamp(h, 0.f, 360.f) / 360; + auto ts = std::clamp(s, 0.f, 100.f) / 100; + auto tl = std::clamp(l, 0.f, 100.f) / 100; + auto ta = std::clamp(a, 0.f, 100.f) / 100; + if (detail::compare_float(ts, 0)) return RGBA(to_int(tl), to_int(ta)); + + float const q = tl < 0.5 ? tl * (1 + ts) : tl + ts - tl * ts; + float const p = 2 * tl - q; + + return RGBA( + to_int(convert_hue(p, q, th + 1.f / 3)), + to_int(convert_hue(p, q, th)), + to_int(convert_hue(p, q, th - 1.f / 3)), + to_int(ta) + ); + } + + constexpr auto blend(HSLA color, BlendMode mode) const noexcept -> HSLA { + auto lhs = RGBA(*this); + auto rhs = RGBA(color); + return HSLA(lhs.blend(rhs, mode)); + } + private: + + static constexpr auto to_int(float a, float max = 1) noexcept -> std::uint8_t { + return static_cast((a / max) * 255); + } + + static constexpr auto convert_hue(float p, float q, float t) noexcept -> float { + if (t < 0) t += 1; + if (t > 1) t -= 1; + if (t * 6 < 1) return p + (q - p) * 6 * t; + if (t * 2 < 1) return q; + if (t * 3 < 2) return p + (q - p) * (2.f / 3 - t) * 6; + return p; + } + }; + + namespace detail { + template + inline static constexpr auto parse_pixel_helper(RGBA color, std::uint8_t* out_ptr) noexcept { + if constexpr (F == PixelFormat::rgba) { + out_ptr[0] = color.r; + out_ptr[1] = color.g; + out_ptr[2] = color.b; + out_ptr[3] = color.a; + } else if constexpr (F == PixelFormat::abgr) { + out_ptr[0] = color.a; + out_ptr[1] = color.b; + out_ptr[2] = color.g; + out_ptr[3] = color.r; + } else if constexpr (F == PixelFormat::rgb) { + out_ptr[0] = color.r; + out_ptr[1] = color.g; + out_ptr[2] = color.b; + } else if constexpr (F == PixelFormat::bgr) { + out_ptr[0] = color.b; + out_ptr[1] = color.g; + out_ptr[2] = color.r; + } else if constexpr (F == PixelFormat::ga) { + out_ptr[0] = color.r; + out_ptr[1] = color.a; + } else if constexpr (F == PixelFormat::ag) { + out_ptr[0] = color.a; + out_ptr[1] = color.r; + } else { + out_ptr[0] = color.r; + } + } + + template + inline static constexpr auto parse_pixel_helper(std::uint8_t const* in_ptr) noexcept -> RGBA { + if constexpr (F == PixelFormat::rgba) { + return { + in_ptr[0], + in_ptr[1], + in_ptr[2], + in_ptr[3] + }; + } else if constexpr (F == PixelFormat::abgr) { + return { + in_ptr[3], + in_ptr[2], + in_ptr[1], + in_ptr[0] + }; + } else if constexpr (F == PixelFormat::rgb) { + return { + in_ptr[0], + in_ptr[1], + in_ptr[2], + 0xff + }; + } else if constexpr (F == PixelFormat::bgr) { + return { + in_ptr[2], + in_ptr[1], + in_ptr[0], + 0xff + }; + } else if constexpr (F == PixelFormat::ga) { + return { + in_ptr[0], + in_ptr[1], + }; + } else if constexpr (F == PixelFormat::ag) { + return { + in_ptr[1], + in_ptr[0], + }; + } else { + return { in_ptr[0], 0xff }; + } + } + } // namespace detail + + inline static constexpr auto get_pixel_format_channel(PixelFormat format) noexcept -> std::size_t { + switch (format) { + case PixelFormat::rgba: case PixelFormat::abgr: return 4u; + case PixelFormat::rgb: case PixelFormat::bgr: return 3u; + case PixelFormat::ga: case PixelFormat::ag: return 2u; + case PixelFormat::g: return 1u; + } + assert(false && "unreachable"); + } + + struct PixelBuf { + private: + public: + using value_type = RGBA; + using base_type = Matrix; + using pointer = typename base_type::pointer; + using const_pointer = typename base_type::const_pointer; + using reference = typename base_type::reference; + using const_reference = typename base_type::const_reference; + using iterator = typename base_type::iterator; + using const_iterator = typename base_type::const_iterator; + using reverse_iterator = typename base_type::reverse_iterator; + using const_reverse_iterator = typename base_type::const_reverse_iterator; + using difference_type = typename base_type::difference_type; + using size_type = typename base_type::size_type; + + PixelBuf(size_type r, size_type c) + : m_data(r, c) + {} + PixelBuf(size_type r, size_type c, RGBA color) + : m_data(r, c, color) + {} + + PixelBuf(std::uint8_t const* in, size_type r, size_type c, PixelFormat format = PixelFormat::rgba) + : PixelBuf(r, c) + { + assert(in != nullptr); + + switch (format) { + case PixelFormat::rgba: from_helper(in, data(), size()); break; + case PixelFormat::abgr: from_helper(in, data(), size()); break; + case PixelFormat::rgb: from_helper(in, data(), size()); break; + case PixelFormat::bgr: from_helper(in, data(), size()); break; + case PixelFormat::ga: from_helper(in, data(), size()); break; + case PixelFormat::ag: from_helper(in, data(), size()); break; + case PixelFormat::g: from_helper(in, data(), size()); break; + } + } + + PixelBuf(PixelBuf const&) = default; + PixelBuf(PixelBuf &&) noexcept = default; + PixelBuf& operator=(PixelBuf const&) = default; + PixelBuf& operator=(PixelBuf &&) noexcept = default; + ~PixelBuf() = default; + + constexpr auto size() const noexcept -> size_type { return m_data.size(); } + constexpr auto rows() const noexcept -> size_type { return m_data.rows(); } + constexpr auto cols() const noexcept -> size_type { return m_data.cols(); } + constexpr auto data() noexcept -> pointer { return m_data.data(); } + constexpr auto data() const noexcept -> const_pointer { return m_data.data(); } + auto to_raw_buf() noexcept -> std::uint8_t* { return reinterpret_cast(data()); } + auto to_raw_buf() const noexcept -> std::uint8_t const* { return reinterpret_cast(data()); } + constexpr auto raw_buf_size() const noexcept { return size() * sizeof(RGBA); } + + constexpr auto begin() noexcept -> iterator { return m_data.begin(); } + constexpr auto end() noexcept -> iterator { return m_data.end(); } + constexpr auto begin() const noexcept -> const_iterator { return m_data.begin(); } + constexpr auto end() const noexcept -> const_iterator { return m_data.end(); } + constexpr auto rbegin() noexcept -> reverse_iterator { return m_data.rbegin(); } + constexpr auto rend() noexcept -> reverse_iterator { return m_data.rend(); } + constexpr auto rbegin() const noexcept -> const_reverse_iterator { return m_data.rbegin(); } + constexpr auto rend() const noexcept -> const_reverse_iterator { return m_data.rend(); } + + constexpr auto operator[](size_type r) noexcept { return m_data[r]; } + constexpr auto operator[](size_type r) const noexcept { return m_data[r]; } + constexpr auto operator()(size_type r, size_type c) noexcept -> reference { return m_data(r, c); } + constexpr auto operator()(size_type r, size_type c) const noexcept -> const_reference { return m_data(r, c); } + + constexpr auto fill(RGBA color) noexcept -> void { + std::fill(begin(), end(), color); + } + + constexpr auto copy_to(std::uint8_t* out, PixelFormat format = PixelFormat::rgba) const noexcept { + assert(out != nullptr); + + switch (format) { + case PixelFormat::rgba: copy_to_helper(data(), out, size());return; + case PixelFormat::abgr: copy_to_helper(data(), out, size());return; + case PixelFormat::rgb: copy_to_helper(data(), out, size());return; + case PixelFormat::bgr: copy_to_helper(data(), out, size());return; + case PixelFormat::ga: copy_to_helper(data(), out, size());return; + case PixelFormat::ag: copy_to_helper(data(), out, size());return; + case PixelFormat::g: copy_to_helper(data(), out, size());return; + } + assert(false && "unreachable"); + } + + + private: + template + constexpr auto copy_to_helper(const_pointer in, std::uint8_t* out, size_type size) const noexcept -> void { + constexpr auto channels = get_pixel_format_channel(F); + for (auto i = size_type{}; i < size; ++i) { + detail::parse_pixel_helper(in[i], out + i * channels); + } + } + + template + constexpr auto from_helper(std::uint8_t const* in, pointer out, size_type size) const noexcept -> void { + constexpr auto channels = get_pixel_format_channel(F); + for (auto i = size_type{}; i < size; ++i) { + out[i] = detail::parse_pixel_helper(in + i * channels); + } + } + + private: + base_type m_data; + }; + + + +} // namespace amt + +#include +namespace std { + template <> + struct formatter { + constexpr auto parse(format_parse_context& ctx) { + return ctx.begin(); + } + + auto format(amt::RGBA const& color, auto& ctx) const { + return format_to(ctx.out(), "rgba({}, {}, {}, {})", color.r, color.g, color.b, color.a); + } + }; + + template <> + struct formatter { + constexpr auto parse(format_parse_context& ctx) { + return ctx.begin(); + } + + auto format(amt::HSLA const& color, auto& ctx) const { + return format_to(ctx.out(), "hsla({:.1f}deg, {:.1f}%, {:.1f}%, {:.1f}%)", color.h, color.s, color.l, color.a); + } + }; + + template <> + struct formatter { + bool hsla = false; + + constexpr auto parse(format_parse_context& ctx) { + auto it = ctx.begin(); + while (it != ctx.end() && *it != '}') { + if (*it == 'h') hsla = true; + ++it; + } + return it; + } + + auto format(amt::PixelBuf const& buf, auto& ctx) const { + std::string s = "[\n"; + for (auto r = std::size_t{}; r < buf.rows(); ++r) { + for (auto c = std::size_t{}; c < buf.cols(); ++c) { + auto color = buf(r, c); + if (hsla) s += std::format("{}, ", amt::HSLA(color)); + else s += std::format("{}, ", color); + } + s += '\n'; + } + s += "]"; + return format_to(ctx.out(), "{}", s); + } + }; +} // namespace std + +#endif // AMT_PIXEL_HPP diff --git a/amt/raycaster.cpp b/amt/raycaster.cpp new file mode 100644 index 0000000..aaddaa2 --- /dev/null +++ b/amt/raycaster.cpp @@ -0,0 +1,395 @@ +#include "amt/raycaster.hpp" + +using namespace fmt; +using std::make_unique; + +#define rgba_color(r,g,b,a) (r<<(0*8))|(g<<(1*8))|(b<<(2*8))|(a<<(3*8)) +#define gray_color(c) rgba_color(c, c, c, 255) + + +std::vector TexturePack::load_image(const char *filename) { + std::vector texture(TEXTURE_WIDTH * TEXTURE_HEIGHT); + sf::Image img; + bool good = img.loadFromFile(filename); + dbc::check(good, format("failed to load {}", filename)); + + uint32_t *pixbuf = (uint32_t *)img.getPixelsPtr(); + std::copy_n(pixbuf, texture.size(), texture.begin()); + + return texture; +} + +void TexturePack::load_textures() { + images.emplace_back(load_image("assets/tile16.png")); + images.emplace_back(load_image("assets/tile02.png")); + images.emplace_back(load_image("assets/tile03.png")); + images.emplace_back(load_image("assets/tile32.png")); + images.emplace_back(load_image("assets/tile05.png")); + images.emplace_back(load_image("assets/tile17.png")); + images.emplace_back(load_image("assets/tile10.png")); + images.emplace_back(load_image("assets/tile01.png")); + images.emplace_back(load_image("assets/portal.png")); +} + +std::vector& TexturePack::get(size_t num) { + return images[num]; +} + +Sprite &TexturePack::get_sprite(size_t sprite_num) { + return SPRITE[sprite_num]; +} + + + +Raycaster::Raycaster(sf::RenderWindow& window, Matrix &map, int width, int height) : + $width(width), $height(height), + $window(window), + $map(map), + spriteOrder(textures.NUM_SPRITES), + spriteDistance(textures.NUM_SPRITES), + ZBuffer(width) +{ + $window.setVerticalSyncEnabled(true); + view_texture.create($width, $height); + view_sprite.setTexture(view_texture); + view_sprite.setPosition(0, 0); + pixels = make_unique($width * $height); + textures.load_textures(); +} + +void Raycaster::set_position(int x, int y) { + view_sprite.setPosition(x, y); +} + +void Raycaster::position_camera(float player_x, float player_y) { + // x and y start position + posX = player_x; + posY = player_y; +} + +void Raycaster::draw_pixel_buffer() { + view_texture.update((uint8_t *)pixels.get(), $width, $height, 0, 0); + // BUG: can I do this once and just update it? + $window.draw(view_sprite); +} + +void Raycaster::clear() { + std::fill_n(pixels.get(), $width * $height, 0); + $window.clear(); +} + +void Raycaster::sprite_casting() { + const int textureWidth = textures.TEXTURE_WIDTH; + const int textureHeight = textures.TEXTURE_HEIGHT; + + // sort sprites from far to close + for(int i = 0; i < textures.NUM_SPRITES; i++) { + spriteOrder[i] = i; + // this is just the distance calculation + spriteDistance[i] = ((posX - textures.SPRITE[i].x) * + (posX - textures.SPRITE[i].x) + + (posY - textures.SPRITE[i].y) * + (posY - textures.SPRITE[i].y)); + } + + sort_sprites(spriteOrder, spriteDistance, textures.NUM_SPRITES); + + // after sorting the sprites, do the projection + for(int i = 0; i < textures.NUM_SPRITES; i++) { + int sprite_index = spriteOrder[i]; + Sprite& sprite_rec = textures.get_sprite(sprite_index); + double spriteX = sprite_rec.x - posX; + double spriteY = sprite_rec.y - posY; + auto& sprite_texture = textures.get(sprite_rec.texture); + + //transform sprite with the inverse camera matrix + // [ planeX dirX ] -1 [ dirY -dirX ] + // [ ] = 1/(planeX*dirY-dirX*planeY) * [ ] + // [ planeY dirY ] [ -planeY planeX ] + + double invDet = 1.0 / (planeX * dirY - dirX * planeY); // required for correct matrix multiplication + + double transformX = invDet * (dirY * spriteX - dirX * spriteY); + //this is actually the depth inside the screen, that what Z is in 3D, the distance of sprite to player, matching sqrt(spriteDistance[i]) + + double transformY = invDet * (-planeY * spriteX + planeX * spriteY); + + int spriteScreenX = int(($width / 2) * (1 + transformX / transformY)); + + int vMoveScreen = int(sprite_rec.elevation * -1 / transformY); + + // calculate the height of the sprite on screen + //using "transformY" instead of the real distance prevents fisheye + int spriteHeight = abs(int($height / transformY)) / sprite_rec.vDiv; + + //calculate lowest and highest pixel to fill in current stripe + int drawStartY = -spriteHeight / 2 + $height / 2 + vMoveScreen; + if(drawStartY < 0) drawStartY = 0; + int drawEndY = spriteHeight / 2 + $height / 2 + vMoveScreen; + if(drawEndY >= $height) drawEndY = $height - 1; + + // calculate width the the sprite + // same as height of sprite, given that it's square + int spriteWidth = abs(int($height / transformY)) / sprite_rec.uDiv; + int drawStartX = -spriteWidth / 2 + spriteScreenX; + if(drawStartX < 0) drawStartX = 0; + int drawEndX = spriteWidth / 2 + spriteScreenX; + if(drawEndX > $width) drawEndX = $width; + + //loop through every vertical stripe of the sprite on screen + for(int stripe = drawStartX; stripe < drawEndX; stripe++) { + int texX = int(256 * (stripe - (-spriteWidth / 2 + spriteScreenX)) * textureWidth / spriteWidth) / 256; + // the conditions in the if are: + // 1) it's in front of the camera plane so you don't see things behind you + // 2) ZBuffer, with perpendicular distance + if(transformY > 0 && transformY < ZBuffer[stripe]) { + for(int y = drawStartY; y < drawEndY; y++) { + //256 and 128 factors to avoid floats + int d = (y - vMoveScreen) * 256 - $height * 128 + spriteHeight * 128; + int texY = ((d * textureHeight) / spriteHeight) / 256; + //get current color from the texture + // BUG: this crashes sometimes when the math goes out of bounds + uint32_t color = sprite_texture[textureWidth * texY + texX]; + // poor person's transparency, get current color from the texture + if((color & 0x00FFFFFF) != 0) { + RGBA pixel = color; + pixels[pixcoord(stripe, y)] = pixel; + } + } + } + } + } +} + +void Raycaster::cast_rays() { + double perpWallDist; + + // WALL CASTING + for(int x = 0; x < $width; x++) { + // calculate ray position and direction + double cameraX = 2 * x / double($width) - 1; // x-coord in camera space + double rayDirX = dirX + planeX * cameraX; + double rayDirY = dirY + planeY * cameraX; + + // which box of the map we're in + int mapX = int(posX); + int mapY = int(posY); + + // length of ray from current pos to next x or y-side + double sideDistX; + double sideDistY; + + // length of ray from one x or y-side to next x or y-side + double deltaDistX = std::abs(1.0 / rayDirX); + double deltaDistY = std::abs(1.0 / rayDirY); + + int stepX = 0; + int stepY = 0; + int hit = 0; + int side = 0; + + // calculate step and initial sideDist + if(rayDirX < 0) { + stepX = -1; + sideDistX = (posX - mapX) * deltaDistX; + } else { + stepX = 1; + sideDistX = (mapX + 1.0 - posX) * deltaDistX; + } + + if(rayDirY < 0) { + stepY = -1; + sideDistY = (posY - mapY) * deltaDistY; + } else { + stepY = 1; + sideDistY = (mapY + 1.0 - posY) * deltaDistY; + } + + // perform DDA + while(hit == 0) { + if(sideDistX < sideDistY) { + sideDistX += deltaDistX; + mapX += stepX; + side = 0; + } else { + sideDistY += deltaDistY; + mapY += stepY; + side = 1; + } + + if($map[mapX][mapY] > 0) hit = 1; + } + + if(side == 0) { + perpWallDist = (sideDistX - deltaDistX); + } else { + perpWallDist = (sideDistY - deltaDistY); + } + + int lineHeight = int($height / perpWallDist); + + int drawStart = -lineHeight / 2 + $height / 2 + PITCH; + if(drawStart < 0) drawStart = 0; + + int drawEnd = lineHeight / 2 + $height / 2 + PITCH; + if(drawEnd >= $height) drawEnd = $height - 1; + + auto &texture = textures.get($map[mapX][mapY] - 1); + + // calculate value of wallX + double wallX; // where exactly the wall was hit + if(side == 0) { + wallX = posY + perpWallDist * rayDirY; + } else { + wallX = posX + perpWallDist * rayDirX; + } + wallX -= floor((wallX)); + + // x coorindate on the texture + int texX = int(wallX * double(textures.TEXTURE_WIDTH)); + if(side == 0 && rayDirX > 0) texX = textures.TEXTURE_WIDTH - texX - 1; + if(side == 1 && rayDirY < 0) texX = textures.TEXTURE_WIDTH - texX - 1; + + // LODE: an integer-only bresenham or DDA like algorithm could make the texture coordinate stepping faster + + // How much to increase the texture coordinate per screen pixel + double step = 1.0 * textures.TEXTURE_HEIGHT / lineHeight; + // Starting texture coordinate + double texPos = (drawStart - PITCH - $height / 2 + lineHeight / 2) * step; + + for(int y = drawStart; y < drawEnd; y++) { + int texY = (int)texPos & (textures.TEXTURE_HEIGHT - 1); + texPos += step; + RGBA pixel = texture[textures.TEXTURE_HEIGHT * texY + texX]; + pixels[pixcoord(x, y)] = pixel; + } + + // SET THE ZBUFFER FOR THE SPRITE CASTING + ZBuffer[x] = perpWallDist; + } +} + +void Raycaster::draw_ceiling_floor() { + const int textureWidth = textures.TEXTURE_WIDTH; + const int textureHeight = textures.TEXTURE_HEIGHT; + + auto& floorTexture = textures.get(textures.floor); + auto& ceilingTexture = textures.get(textures.ceiling); + + for(int y = $height / 2 + 1; y < $height; ++y) { + // rayDir for leftmost ray (x=0) and rightmost (x = w) + float rayDirX0 = dirX - planeX; + float rayDirY0 = dirY - planeY; + float rayDirX1 = dirX + planeX; + float rayDirY1 = dirY + planeY; + + // current y position compared to the horizon + int p = y - $height / 2; + + // vertical position of the camera + // 0.5 will the camera at the center horizon. For a + // different value you need a separate loop for ceiling + // and floor since they're no longer symmetrical. + float posZ = 0.5 * $height; + + // horizontal distance from the camera to the floor for the current row + // 0.5 is the z position exactly in the middle between floor and ceiling + // See NOTE in Lode's code for more. + float rowDistance = posZ / p; + + // calculate the real world step vector we have to add for each x (parallel to camera plane) + // adding step by step avoids multiplications with a wight in the inner loop + float floorStepX = rowDistance * (rayDirX1 - rayDirX0) / $width; + float floorStepY = rowDistance * (rayDirY1 - rayDirY0) / $width; + + + // real world coordinates of the leftmost column. + // This will be updated as we step to the right + float floorX = posX + rowDistance * rayDirX0; + float floorY = posY + rowDistance * rayDirY0; + + for(int x = 0; x < $width; ++x) { + // the cell coord is simply taken from the int parts of + // floorX and floorY. + int cellX = int(floorX); + int cellY = int(floorY); + + // get the texture coordinat from the fractional part + int tx = int(textureWidth * (floorX - cellX)) & (textureWidth - 1); + int ty = int(textureWidth * (floorY - cellY)) & (textureHeight - 1); + + floorX += floorStepX; + floorY += floorStepY; + + // now get the pixel from the texture + uint32_t color; + // this uses the previous ty/tx fractional parts of + // floorX cellX to find the texture x/y. How? + + // FLOOR + color = floorTexture[textureWidth * ty + tx]; + pixels[pixcoord(x, y)] = color; + + // CEILING + color = ceilingTexture[textureWidth * ty + tx]; + pixels[pixcoord(x, $height - y - 1)] = color; + } + } +} + +void Raycaster::render() { + draw_ceiling_floor(); + cast_rays(); + sprite_casting(); + draw_pixel_buffer(); +} + +bool Raycaster::empty_space(int new_x, int new_y) { + dbc::check((size_t)new_x < $map.cols(), + format("x={} too wide={}", new_x, $map.cols())); + dbc::check((size_t)new_y < $map.rows(), + format("y={} too high={}", new_y, $map.rows())); + + return $map[new_x][new_y] == 0; +} + + +void Raycaster::sort_sprites(std::vector& order, std::vector& dist, int amount) +{ + std::vector> sprites(amount); + + for(int i = 0; i < amount; i++) { + sprites[i].first = dist[i]; + sprites[i].second = order[i]; + } + + std::sort(sprites.begin(), sprites.end()); + + // restore in reverse order + for(int i = 0; i < amount; i++) { + dist[i] = sprites[amount - i - 1].first; + order[i] = sprites[amount - i - 1].second; + } +} + +void Raycaster::run(double speed, int dir) { + double speed_and_dir = speed * dir; + if(empty_space(int(posX + dirX * speed_and_dir), int(posY))) { + posX += dirX * speed_and_dir; + } + + if(empty_space(int(posX), int(posY + dirY * speed_and_dir))) { + posY += dirY * speed_and_dir; + } +} + +void Raycaster::rotate(double speed, int dir) { + double speed_and_dir = speed * dir; + double oldDirX = dirX; + dirX = dirX * cos(speed_and_dir) - dirY * sin(speed_and_dir); + dirY = oldDirX * sin(speed_and_dir) + dirY * cos(speed_and_dir); + + double oldPlaneX = planeX; + planeX = planeX * cos(speed_and_dir) - planeY * sin(speed_and_dir); + planeY = oldPlaneX * sin(speed_and_dir) + planeY * cos(speed_and_dir); +} diff --git a/amt/raycaster.hpp b/amt/raycaster.hpp new file mode 100644 index 0000000..9cfe107 --- /dev/null +++ b/amt/raycaster.hpp @@ -0,0 +1,95 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include "amt/matrix.hpp" +#include +#include +#include "dbc.hpp" +#include + +using Matrix = amt::Matrix; + +struct Sprite { + double x; + double y; + int texture; + // ZED: this should be a separate transform parameter + double elevation=0; + int uDiv=1; + int vDiv=1; +}; + +using RGBA = uint32_t; + +struct TexturePack { + int NUM_SPRITES=1; + int NUM_TEXTURES=11; + int TEXTURE_WIDTH=256; // must be power of two + int TEXTURE_HEIGHT=256; // must be power of two + + std::vector> images; + std::vector SPRITE{{4.0, 3.55, 8}}; + const int floor = 3; + const int ceiling = 6; + + void load_textures(); + std::vector load_image(const char *filename); + Sprite &get_sprite(size_t sprite_num); + std::vector& get(size_t num); +}; + +struct Raycaster { + int PITCH=0; + + TexturePack textures; + double posX = 0; + double posY = 0; + + // initial direction vector + double dirX = -1; + double dirY = 0; + + // the 2d raycaster version of camera plane + double planeX = 0; + double planeY = 0.66; + sf::Texture view_texture; + sf::Sprite view_sprite; + + //ZED: USE smart pointer for this + std::unique_ptr pixels = nullptr; + + int $width; + int $height; + sf::RenderWindow& $window; + Matrix& $map; + std::vector spriteOrder; + std::vector spriteDistance; + std::vector ZBuffer; // width + + Raycaster(sf::RenderWindow& window, Matrix &map, int width, int height); + + void draw_pixel_buffer(); + void clear(); + void cast_rays(); + void draw_ceiling_floor(); + void sprite_casting(); + void sort_sprites(std::vector& order, std::vector& dist, int amount); + void render(); + + bool empty_space(int new_x, int new_y); + + void run(double speed, int dir); + void rotate(double speed, int dir); + void position_camera(float player_x, float player_y); + + void set_position(int x, int y); + inline size_t pixcoord(int x, int y) { + return ((y) * $width) + (x); + } + +}; diff --git a/meson.build b/meson.build index c87ef8b..7000c4f 100644 --- a/meson.build +++ b/meson.build @@ -28,3 +28,10 @@ executable('zedcaster', [ 'main.cpp' ], dependencies: dependencies) + +executable('amtcaster', [ + 'dbc.cpp', + 'amt/raycaster.cpp', + 'amt/main.cpp' + ], + dependencies: dependencies) diff --git a/tests/amt_matrix.cpp b/tests/amt_matrix.cpp new file mode 100644 index 0000000..e8ea6b9 --- /dev/null +++ b/tests/amt_matrix.cpp @@ -0,0 +1,74 @@ +#include +#include +#include "matrix.hpp" +#include "pixel.hpp" + +using namespace amt; + +int main() { + + auto const format = PixelFormat::abgr; + PixelBuf b(2, 2, RGBA(0x01, 0x02, 0x03, 0x04)); + b[1][1] = HSLA(280, 20, 50, 80); + std::println("{:h}", b); + + + std::uint8_t ps[4 * 4] = {}; + b.copy_to(ps, format); + + /*for (auto i = 0zu; i < sizeof(ps); ++i) {*/ + /* std::println("[{}]: 0x{:0x}", i, ps[i]);*/ + /*}*/ + + PixelBuf test(ps, 2, 2, format); + + for (auto i = 0zu; auto color: test) { + std::println("[{}]: {}", i++, color); + } + + auto m = Matrix{ + {0, 1}, + {3, 4} + }; + + std::println("{}", m); + + + + { + auto ca = RGBA::from_hex(0x333333ff); + auto cb = RGBA::from_hex(0xaabbccff); + std::println("========= RGBA ==========="); + std::println("Normal: 0x{:0x}", ca.blend(cb, BlendMode::normal).to_hex()); + std::println("Multiply: 0x{:0x}", ca.blend(cb, BlendMode::multiply).to_hex()); + std::println("Screen: 0x{:0x}", ca.blend(cb, BlendMode::screen).to_hex()); + std::println("Overlay: 0x{:0x}", ca.blend(cb, BlendMode::overlay).to_hex()); + std::println("darken: 0x{:0x}", ca.blend(cb, BlendMode::darken).to_hex()); + std::println("lighten: 0x{:0x}", ca.blend(cb, BlendMode::lighten).to_hex()); + std::println("Dodge: 0x{:0x}", ca.blend(cb, BlendMode::colorDodge).to_hex()); + std::println("Burn: 0x{:0x}", ca.blend(cb, BlendMode::colorBurn).to_hex()); + std::println("hard light: 0x{:0x}", ca.blend(cb, BlendMode::hardLight).to_hex()); + std::println("soft light: 0x{:0x}", ca.blend(cb, BlendMode::softLight).to_hex()); + std::println("difference: 0x{:0x}", ca.blend(cb, BlendMode::difference).to_hex()); + std::println("exclusion: 0x{:0x}", ca.blend(cb, BlendMode::exclusion).to_hex()); + } + + { + HSLA ca = RGBA::from_hex(0x333333ff); + HSLA cb = RGBA::from_hex(0xaabbccff); + std::println("========= HSLA ==========="); + std::println("Normal: {}", ca.blend(cb, BlendMode::normal)); + std::println("Multiply: {}", ca.blend(cb, BlendMode::multiply)); + std::println("Screen: {}", ca.blend(cb, BlendMode::screen)); + std::println("Overlay: {}", ca.blend(cb, BlendMode::overlay)); + std::println("darken: {}", ca.blend(cb, BlendMode::darken)); + std::println("lighten: {}", ca.blend(cb, BlendMode::lighten)); + std::println("Dodge: {}", ca.blend(cb, BlendMode::colorDodge)); + std::println("Burn: {}", ca.blend(cb, BlendMode::colorBurn)); + std::println("hard light: {}", ca.blend(cb, BlendMode::hardLight)); + std::println("soft light: {}", ca.blend(cb, BlendMode::softLight)); + std::println("difference: {}", ca.blend(cb, BlendMode::difference)); + std::println("exclusion: {}", ca.blend(cb, BlendMode::exclusion)); + } + +}