anonymous_namespace{main.cpp}::SoftwareRenderer Class Reference

Public Member Functions
void	begin_frame ()
void	begin_frame (bool show_intro)
void	draw_block (BlockType type, float x, float y, float z, float half_extent, const mxvk::vec4D &tint)
void	draw_block_image (BlockType type, int left, int top, int width, int height)
void	draw_digit (int x, int y, int digit, int scale, mxvk::MXCOLOR color)
void	draw_mesh (const MeshInstance &instance)
void	draw_pause_indicator ()
void	draw_rectangle (int left, int top, int width, int height, mxvk::MXCOLOR color)
void	draw_solid_cube (float x, float y, float z, float half_extent, mxvk::MXCOLOR color)
void	draw_text (TTF_Font *font, const std::string &text, int x, int y, const SDL_Color &color)
void	draw_wildcard (float x, float y, float z, float half_extent, const mxvk::vec4D &color)
int	height () const
int	height () const
void	resolve_multisampling ()
void	set_view (float yaw, float pitch, float distance)
	SoftwareRenderer (int width, int height)
	SoftwareRenderer (int width, int height, const std::string &data_root, bool enable_warp_fix, bool enable_mipmapping, float mip_bias)
SDL_Surface *	surface () const
SDL_Surface *	surface () const
int	width () const
int	width () const

Detailed Description

Definition at line 125 of file main.cpp.

Constructor & Destructor Documentation

SoftwareRenderer() [1/2]

anonymous_namespace{main.cpp}::SoftwareRenderer::SoftwareRenderer ( int width, int height )

inline

Definition at line 127 of file main.cpp.

            : frame_width(width),
              frame_height(height),
              depth_buffer(static_cast<std::size_t>(width) * static_cast<std::size_t>(height)) {
            frame_surface.reset(SDL_CreateSurface(width, height, SDL_PIXELFORMAT_RGBA32));
            if (frame_surface == nullptr) {
                throw mxvk::Exception(std::format("3dmath_pong: failed to create framebuffer: {}", SDL_GetError()));
            }
            frame_format = SDL_GetPixelFormatDetails(frame_surface->format);
            if (frame_format == nullptr) {
                throw mxvk::Exception(std::format("3dmath_pong: failed to query framebuffer format: {}", SDL_GetError()));
            }
            camera_rotation.BuildXYZ(17.0f, -8.0f, 0.0f);
        }

SoftwareRenderer() [2/2]

anonymous_namespace{main.cpp}::SoftwareRenderer::SoftwareRenderer ( int width, int height, const std::string & data_root, bool enable_warp_fix, bool enable_mipmapping, float mip_bias )

inline

Definition at line 343 of file main.cpp.

            : frame_width(width),
              frame_height(height),
              depth_buffer(static_cast<std::size_t>(width) * static_cast<std::size_t>(height) * MSAA_SAMPLE_COUNT),
              color_buffer(static_cast<std::size_t>(width) * static_cast<std::size_t>(height) * MSAA_SAMPLE_COUNT),
              background(load_texture(data_root + "/level1.png")),
              intro(load_texture(data_root + "/intro1.png")),
              warp_fix_enabled(enable_warp_fix),
              mipmapping_enabled(enable_mipmapping),
              mip_level_bias(mip_bias) {
            frame_surface.reset(SDL_CreateSurface(width, height, SDL_PIXELFORMAT_RGBA32));
            if (!frame_surface) {
                throw mxvk::Exception(std::format("3dmath_puzzle_drop: failed to create framebuffer: {}", SDL_GetError()));
            }
            for (const char *filename : BLOCK_TEXTURE_FILES) {
                block_textures.push_back(load_texture(data_root + "/" + filename, mipmapping_enabled));
            }
        }

Member Function Documentation

begin_frame() [1/2]

void anonymous_namespace{main.cpp}::SoftwareRenderer::begin_frame ( )

inline

Definition at line 154 of file main.cpp.

                           {
            std::ranges::fill(depth_buffer, std::numeric_limits<float>::infinity());
            for (int y = 0; y < frame_height; ++y) {
                const float fraction = static_cast<float>(y) / static_cast<float>(frame_height - 1);
                const int red = static_cast<int>(4.0f + fraction * 5.0f);
                const int green = static_cast<int>(10.0f + fraction * 12.0f);
                const int blue = static_cast<int>(24.0f + fraction * 20.0f);
                const mxvk::MXCOLOR color = mxvk::MXVK_RGB(red, green, blue);
                for (int x = 0; x < frame_width; ++x) {
                    put_pixel(x, y, color);
                }
            }
        }

begin_frame() [2/2]

void anonymous_namespace{main.cpp}::SoftwareRenderer::begin_frame ( bool show_intro )

inline

Definition at line 379 of file main.cpp.

                                          {
            std::ranges::fill(depth_buffer, std::numeric_limits<float>::infinity());
            draw_flat_image(show_intro ? intro : background);
            if (!show_intro) {
                fill_translucent_rectangle(0, 0, frame_width, frame_height, mxvk::MXVK_RGB(3, 8, 16), 150);
            }
        }

draw_block()

void anonymous_namespace{main.cpp}::SoftwareRenderer::draw_block ( BlockType type, float x, float y, float z, float half_extent, const mxvk::vec4D & tint )

inline

Definition at line 419 of file main.cpp.

                                                                                                             {
            draw_cube(&block_textures[static_cast<std::size_t>(texture_index(type))], x, y, z, half_extent, tint);
        }

draw_block_image()

void anonymous_namespace{main.cpp}::SoftwareRenderer::draw_block_image ( BlockType type, int left, int top, int width, int height )

inline

Definition at line 458 of file main.cpp.

                                                                                        {
            if (!is_play_block(type) || width <= 0 || height <= 0) {
                return;
            }
 
            const Texture &texture = block_textures[static_cast<std::size_t>(texture_index(type))];
            const int first_x = std::clamp(left, 0, frame_width);
            const int first_y = std::clamp(top, 0, frame_height);
            const int last_x = std::clamp(left + width, 0, frame_width);
            const int last_y = std::clamp(top + height, 0, frame_height);
            for (int y = first_y; y < last_y; ++y) {
                const int source_y = std::clamp((y - top) * texture.height / height, 0, texture.height - 1);
                auto *row = static_cast<std::uint8_t *>(frame_surface->pixels) + static_cast<std::size_t>(y * frame_surface->pitch);
                for (int x = first_x; x < last_x; ++x) {
                    const int source_x = std::clamp((x - left) * texture.width / width, 0, texture.width - 1);
                    const mxvk::MXCOLOR color = texture.pixels[static_cast<std::size_t>(source_y * texture.width + source_x)];
                    blend_pixel(row + static_cast<std::size_t>(x * 4), color);
                }
            }
        }

draw_digit()

void anonymous_namespace{main.cpp}::SoftwareRenderer::draw_digit ( int x, int y, int digit, int scale, mxvk::MXCOLOR color )

inline

Definition at line 216 of file main.cpp.

                                                                               {
            static constexpr std::array<std::uint8_t, 10> SEGMENTS = {
                0b1111110,
                0b0110000,
                0b1101101,
                0b1111001,
                0b0110011,
                0b1011011,
                0b1011111,
                0b1110000,
                0b1111111,
                0b1111011,
            };
            const std::uint8_t segments = SEGMENTS[static_cast<std::size_t>(std::clamp(digit, 0, 9))];
            const auto horizontal = [this, scale, color](int left, int top) {
                fill_rectangle(left + scale, top, scale * 3, scale, color);
            };
            const auto vertical = [this, scale, color](int left, int top) {
                fill_rectangle(left, top + scale, scale, scale * 3, color);
            };
            if ((segments & 0b1000000U) != 0U)
                horizontal(x, y);
            if ((segments & 0b0100000U) != 0U)
                vertical(x + scale * 4, y);
            if ((segments & 0b0010000U) != 0U)
                vertical(x + scale * 4, y + scale * 4);
            if ((segments & 0b0001000U) != 0U)
                horizontal(x, y + scale * 7);
            if ((segments & 0b0000100U) != 0U)
                vertical(x, y + scale * 4);
            if ((segments & 0b0000010U) != 0U)
                vertical(x, y);
            if ((segments & 0b0000001U) != 0U)
                horizontal(x, y + scale * 3);
        }

draw_mesh()

void anonymous_namespace{main.cpp}::SoftwareRenderer::draw_mesh ( const MeshInstance & instance )

inline

Definition at line 168 of file main.cpp.

                                                     {
            mxvk::Mat4D object_rotation;
            object_rotation.BuildXYZ(instance.rotation.x, instance.rotation.y, instance.rotation.z);
 
            std::vector<mxvk::vec4D> camera_vertices(instance.mesh.vertices.size());
            std::vector<mxvk::vec4D> projected_vertices(instance.mesh.vertices.size());
            for (std::size_t index = 0; index < instance.mesh.vertices.size(); ++index) {
                const mxvk::vec4D &vertex = instance.mesh.vertices[index];
                mxvk::vec4D transformed(
                    vertex.x * instance.scale.x,
                    vertex.y * instance.scale.y,
                    vertex.z * instance.scale.z,
                    1.0f);
                transformed = object_rotation.MulVec(transformed);
                transformed += instance.position;
                transformed = camera_rotation.MulVec(transformed);
                transformed.z += CAMERA_DISTANCE;
                camera_vertices[index] = transformed;
                projected_vertices[index] = project(transformed);
            }
 
            const mxvk::vec4D light_direction = normalized({-0.35f, -0.65f, -1.0f, 0.0f});
            for (const Triangle &triangle : instance.mesh.triangles) {
                const mxvk::vec4D &a = camera_vertices[triangle.indices[0]];
                const mxvk::vec4D &b = camera_vertices[triangle.indices[1]];
                const mxvk::vec4D &c = camera_vertices[triangle.indices[2]];
                mxvk::vec4D normal = mxvk::vec4D().Build(a, b).CrossProduct(mxvk::vec4D().Build(a, c));
                normal.Normalize();
 
                const mxvk::vec4D center = (a + b + c) * (1.0f / 3.0f);
                const mxvk::vec4D view_direction(-center.x, -center.y, -center.z, 0.0f);
                if (normal.DotProduct(view_direction) <= 0.0f) {
                    if (!instance.mesh.two_sided) {
                        continue;
                    }
                    normal = normal * -1.0f;
                }
 
                const float diffuse = std::max(0.0f, normal.DotProduct(light_direction));
                const float intensity = std::clamp(0.32f + diffuse * 0.68f, 0.0f, 1.0f);
                rasterize_triangle(
                    projected_vertices[triangle.indices[0]],
                    projected_vertices[triangle.indices[1]],
                    projected_vertices[triangle.indices[2]],
                    mxvk::shade_color(instance.color, intensity));
            }
        }

draw_pause_indicator()

void anonymous_namespace{main.cpp}::SoftwareRenderer::draw_pause_indicator ( )

inline

Definition at line 252 of file main.cpp.

                                    {
            fill_rectangle(frame_width - 17, 8, 3, 12, mxvk::MXVK_RGB(255, 220, 92));
            fill_rectangle(frame_width - 10, 8, 3, 12, mxvk::MXVK_RGB(255, 220, 92));
        }

draw_rectangle()

void anonymous_namespace{main.cpp}::SoftwareRenderer::draw_rectangle ( int left, int top, int width, int height, mxvk::MXCOLOR color )

inline

Definition at line 445 of file main.cpp.

                                                                                         {
            const int first_x = std::clamp(left, 0, frame_width);
            const int first_y = std::clamp(top, 0, frame_height);
            const int last_x = std::clamp(left + width, 0, frame_width);
            const int last_y = std::clamp(top + height, 0, frame_height);
            for (int y = first_y; y < last_y; ++y) {
                auto *row = static_cast<std::uint8_t *>(frame_surface->pixels) + static_cast<std::size_t>(y * frame_surface->pitch);
                for (int x = first_x; x < last_x; ++x) {
                    write_pixel(row + static_cast<std::size_t>(x * 4), color);
                }
            }
        }

draw_solid_cube()

void anonymous_namespace{main.cpp}::SoftwareRenderer::draw_solid_cube ( float x, float y, float z, float half_extent, mxvk::MXCOLOR color )

inline

Definition at line 436 of file main.cpp.

                                                                                              {
            const mxvk::vec4D tint(
                static_cast<float>(mxvk::color_r(color)) / 255.0f,
                static_cast<float>(mxvk::color_g(color)) / 255.0f,
                static_cast<float>(mxvk::color_b(color)) / 255.0f,
                1.0f);
            draw_cube(nullptr, x, y, z, half_extent, tint);
        }

draw_text()

void anonymous_namespace{main.cpp}::SoftwareRenderer::draw_text ( TTF_Font * font, const std::string & text, int x, int y, const SDL_Color & color )

inline

Definition at line 479 of file main.cpp.

                                                                                                    {
            if (font == nullptr || text.empty()) {
                return;
            }
 
            SurfacePtr text_surface(TTF_RenderText_Blended(font, text.c_str(), 0, color));
            if (!text_surface) {
                return;
            }
            SDL_SetSurfaceBlendMode(text_surface.get(), SDL_BLENDMODE_BLEND);
            const SDL_Rect destination{x, y, text_surface->w, text_surface->h};
            SDL_BlitSurface(text_surface.get(), nullptr, frame_surface.get(), &destination);
        }

draw_wildcard()

void anonymous_namespace{main.cpp}::SoftwareRenderer::draw_wildcard ( float x, float y, float z, float half_extent, const mxvk::vec4D & color )

inline

Definition at line 423 of file main.cpp.

                                                                                                 {
            mxvk::vec4D neon(
                std::max(color.x, 0.08f),
                std::max(color.y, 0.08f),
                std::max(color.z, 0.08f),
                1.0f);
            const float brightest_channel = std::max({neon.x, neon.y, neon.z});
            neon.x /= brightest_channel;
            neon.y /= brightest_channel;
            neon.z /= brightest_channel;
            draw_cube(nullptr, x, y, z, half_extent, neon, true);
        }

height() [1/2]

int anonymous_namespace{main.cpp}::SoftwareRenderer::height ( ) const

inlinenodiscard

Definition at line 150 of file main.cpp.

                                         {
            return frame_height;
        }

height() [2/2]

int anonymous_namespace{main.cpp}::SoftwareRenderer::height ( ) const

inlinenodiscard

Definition at line 370 of file main.cpp.

                                         {
            return frame_height;
        }

resolve_multisampling()

void anonymous_namespace{main.cpp}::SoftwareRenderer::resolve_multisampling ( )

inline

Definition at line 387 of file main.cpp.

                                     {
            for (int y = 0; y < frame_height; ++y) {
                auto *row = static_cast<std::uint8_t *>(frame_surface->pixels) + static_cast<std::size_t>(y * frame_surface->pitch);
                for (int x = 0; x < frame_width; ++x) {
                    auto *pixel = row + static_cast<std::size_t>(x * 4);
                    const mxvk::MXCOLOR background_color =
                        (0xFFU << 24U) |
                        (static_cast<mxvk::MXCOLOR>(pixel[0]) << 16U) |
                        (static_cast<mxvk::MXCOLOR>(pixel[1]) << 8U) |
                        static_cast<mxvk::MXCOLOR>(pixel[2]);
                    const std::size_t pixel_index = static_cast<std::size_t>(y * frame_width + x);
                    const std::size_t first_sample = pixel_index * MSAA_SAMPLE_COUNT;
                    std::uint32_t red = 0;
                    std::uint32_t green = 0;
                    std::uint32_t blue = 0;
                    for (std::size_t sample = 0; sample < MSAA_SAMPLE_COUNT; ++sample) {
                        const std::size_t sample_index = first_sample + sample;
                        const mxvk::MXCOLOR color = std::isfinite(depth_buffer[sample_index])
                                                        ? color_buffer[sample_index]
                                                        : background_color;
                        red += mxvk::color_r(color);
                        green += mxvk::color_g(color);
                        blue += mxvk::color_b(color);
                    }
                    pixel[0] = static_cast<std::uint8_t>((red + MSAA_SAMPLE_COUNT / 2U) / MSAA_SAMPLE_COUNT);
                    pixel[1] = static_cast<std::uint8_t>((green + MSAA_SAMPLE_COUNT / 2U) / MSAA_SAMPLE_COUNT);
                    pixel[2] = static_cast<std::uint8_t>((blue + MSAA_SAMPLE_COUNT / 2U) / MSAA_SAMPLE_COUNT);
                    pixel[3] = 255;
                }
            }
        }

set_view()

void anonymous_namespace{main.cpp}::SoftwareRenderer::set_view ( float yaw, float pitch, float distance )

inline

Definition at line 374 of file main.cpp.

                                                              {
            camera_rotation.BuildXYZ(pitch, yaw, 0.0f);
            camera_distance = distance;
        }

surface() [1/2]

SDL_Surface * anonymous_namespace{main.cpp}::SoftwareRenderer::surface ( ) const

inlinenodiscard

Definition at line 142 of file main.cpp.

                                                   {
            return frame_surface.get();
        }

surface() [2/2]

SDL_Surface * anonymous_namespace{main.cpp}::SoftwareRenderer::surface ( ) const

inlinenodiscard

Definition at line 362 of file main.cpp.

                                                   {
            return frame_surface.get();
        }

width() [1/2]

int anonymous_namespace{main.cpp}::SoftwareRenderer::width ( ) const

inlinenodiscard

Definition at line 146 of file main.cpp.

                                        {
            return frame_width;
        }

width() [2/2]

int anonymous_namespace{main.cpp}::SoftwareRenderer::width ( ) const

inlinenodiscard

Definition at line 366 of file main.cpp.

                                        {
            return frame_width;
        }

---

The documentation for this class was generated from the following files:

• examples/3dmath_pong/main.cpp
• examples/3dmath_puzzle_drop/main.cpp