Rasterizer.h

#pragma once

#include <vector>
#include <boost/math/constants/constants.hpp>
#include <vulkan/vulkan.h>
#include <Euclid/Render/RenderCore.h>
#include <config.h>

namespace Euclid
{
class RasCamera : public Camera
{
public:
    RasCamera() = default;

    RasCamera(const Eigen::Vector3f& position,
              const Eigen::Vector3f& focus,
              const Eigen::Vector3f& up,
              float tnear,
              float tfar);

    virtual ~RasCamera();

    Eigen::Matrix4f view() const;

    virtual Eigen::Matrix4f projection() const = 0;
};

class PerspRasCamera : public RasCamera
{
public:
    PerspRasCamera() : RasCamera(){};

    PerspRasCamera(const Eigen::Vector3f& position,
                   const Eigen::Vector3f& focus,
                   const Eigen::Vector3f& up,
                   float vfov,
                   float aspect,
                   float tnear,
                   float tfar);

    PerspRasCamera(const Eigen::Vector3f& position,
                   const Eigen::Vector3f& focus,
                   const Eigen::Vector3f& up,
                   float vfov,
                   unsigned width,
                   unsigned height,
                   float tnear,
                   float tfar);

    ~PerspRasCamera();

    void set_aspect(float aspect);

    void set_aspect(unsigned width, unsigned height);

    void set_fov(float vfov);

    virtual Eigen::Matrix4f projection() const override;

private:
    float _vfov = boost::math::float_constants::half_pi;
    float _aspect = 1.0f;
};

class OrthoRasCamera : public RasCamera
{
public:
    OrthoRasCamera() : RasCamera(){};

    OrthoRasCamera(const Eigen::Vector3f& position,
                   const Eigen::Vector3f& focus,
                   const Eigen::Vector3f& up,
                   float xextent,
                   float yextent,
                   float tnear,
                   float tfar);

    ~OrthoRasCamera();

    void set_extent(float xextent, float yextent);

    virtual Eigen::Matrix4f projection() const override;

private:
    float _xextent;
    float _yextent;
};

class Rasterizer
{
public:
    enum SampleCount
    {
        SAMPLE_COUNT_1 = 0x00000001,
        SAMPLE_COUNT_2 = 0x00000002,
        SAMPLE_COUNT_4 = 0x00000004,
        SAMPLE_COUNT_8 = 0x00000008,
    };

public:
    Rasterizer(uint32_t width = 256,
               uint32_t height = 256,
               SampleCount samples = SAMPLE_COUNT_1);

    ~Rasterizer();

    void attach_position_buffer(const float* positions, size_t size);

    void attach_normal_buffer(const float* normals, size_t size);

    void attach_color_buffer(const float* colors, size_t size);

    void attach_index_buffer(const unsigned* indices, size_t size);

    void release_buffers();

    void set_material(const Material& material);

    void set_light(const Light& light);

    void set_background(const Eigen::Array3f& color);

    void set_background(float r, float g, float b);

    void set_image(uint32_t width, uint32_t height, SampleCount samples);

    void render_shaded(const Eigen::Matrix4f& model,
                       const RasCamera& camera,
                       std::vector<uint8_t>& pixels,
                       bool interleaved = true);

    void render_unlit(const Eigen::Matrix4f& model,
                      const RasCamera& camera,
                      std::vector<uint8_t>& pixels,
                      bool interleaved = true);

    void render_depth(const Eigen::Matrix4f& model,
                      const RasCamera& camera,
                      std::vector<uint8_t>& pixels,
                      bool interleaved = true,
                      bool linear = true);

    void render_depth(const Eigen::Matrix4f& model,
                      const RasCamera& camera,
                      std::vector<float>& values,
                      bool linear = true);

private:
    enum ShaderType : int
    {
        SHADER_TYPE_SHADING = 0,
        SHADER_TYPE_VCOLOR,
        SHADER_TYPE_UNLIT,
        SHADER_TYPE_UNLIT_VCOLOR,
        SHADER_TYPE_DEPTH,
        SHADER_TYPE_COUNT
    };

private:
    void _create_instance();

    void _pick_physical_device();

    uint32_t _create_logical_device();

    void _create_command_pool(uint32_t queue_family_index);

    void _create_descriptor_pool();

    void _create_descriptors();

    void _create_render_pass(VkSampleCountFlagBits samples);

    void _create_pipeline(uint32_t width,
                          uint32_t height,
                          VkSampleCountFlagBits samples,
                          ShaderType shader);

    void _render_scene(const Eigen::Matrix4f& model,
                       const RasCamera& camera,
                       const std::vector<VkBuffer>& active_buffers,
                       ShaderType shader);

    void _copy_fb_to_host_buffer(VkImage src,
                                 VkImageAspectFlags aspect,
                                 VkBuffer dst);

    void _transfer_data(const void* data,
                        size_t byte_size,
                        VkBufferUsageFlagBits usage,
                        VkBuffer& buffer,
                        VkDeviceMemory& buffer_memory);

    uint32_t _find_proper_memory_type(uint32_t mem_type_bits,
                                      VkMemoryPropertyFlags prop_flags);

    void _create_buffer(VkBuffer& bufer,
                        VkDeviceMemory& buffer_memory,
                        VkDeviceSize size,
                        VkBufferUsageFlags usage,
                        VkMemoryPropertyFlags props);

    void _release_buffer(VkBuffer& buffer, VkDeviceMemory& buffer_memory);

    void _copy_buffer(VkBuffer src, VkBuffer dst, VkDeviceSize size);

    void _create_image(VkImage& image,
                       VkDeviceMemory& memory,
                       VkFormat format,
                       VkImageUsageFlags usage,
                       VkImageTiling tiling,
                       VkMemoryPropertyFlags prop_flags,
                       uint32_t width,
                       uint32_t height,
                       VkSampleCountFlagBits samples);

    void _release_image(VkImage& buffer, VkDeviceMemory& memory);

    void _create_image_view(VkImageView& view,
                            VkImage image,
                            VkFormat format,
                            VkImageAspectFlags aspect);

    void _create_framebuffer(uint32_t width, uint32_t height);

    VkShaderModule _load_shader(const char* path);

    void _update_ubo(const VkDescriptorBufferInfo& info,
                     uint32_t binding,
                     ShaderType shader);

private:
    static const Material _default_material;

    static const Light _default_light;

private:
    Material _material;
    Light _light;
    Eigen::Array3f _background = Eigen::Array3f::Zero();
    size_t _num_vertices;
    size_t _num_indices;
    uint32_t _width;
    uint32_t _height;
    SampleCount _samples;

    VkDebugUtilsMessengerEXT _debug_messenger;
    VkInstance _instance;
    VkPhysicalDevice _physical_device;
    VkPhysicalDeviceMemoryProperties _physical_device_memory_properties;
    VkDevice _device;
    VkQueue _queue;
    VkCommandPool _command_pool;
    VkDescriptorPool _descriptor_pool;
    std::vector<VkDescriptorSetLayout> _descriptor_set_layouts;
    std::vector<VkDescriptorSet> _descriptor_sets;
    std::vector<VkPipelineLayout> _pipeline_layouts;
    std::vector<VkPipeline> _pipelines;
    VkFramebuffer _framebuffer = VK_NULL_HANDLE;
    VkRenderPass _render_pass = VK_NULL_HANDLE;
    VkBuffer _position_buffer = VK_NULL_HANDLE;
    VkDeviceMemory _position_buffer_memory;
    VkBuffer _normal_buffer = VK_NULL_HANDLE;
    VkDeviceMemory _normal_buffer_memory;
    VkBuffer _color_buffer = VK_NULL_HANDLE;
    VkDeviceMemory _color_buffer_memory;
    VkBuffer _index_buffer = VK_NULL_HANDLE;
    VkDeviceMemory _index_buffer_memory;
    VkBuffer _transform_buffer = VK_NULL_HANDLE;
    VkDeviceMemory _transform_buffer_memory;
    VkBuffer _material_buffer = VK_NULL_HANDLE;
    VkDeviceMemory _material_buffer_memory;
    VkBuffer _light_buffer = VK_NULL_HANDLE;
    VkDeviceMemory _light_buffer_memory;
    VkBuffer _output_color_buffer = VK_NULL_HANDLE;
    VkDeviceMemory _output_color_buffer_memory;
    VkBuffer _output_depth_buffer = VK_NULL_HANDLE;
    VkDeviceMemory _output_depth_buffer_memory;
    VkImage _color_image = VK_NULL_HANDLE;
    VkDeviceMemory _color_image_memory;
    VkImageView _color_image_view = VK_NULL_HANDLE;
    VkImage _depth_image = VK_NULL_HANDLE;
    VkDeviceMemory _depth_image_memory;
    VkImageView _depth_image_view = VK_NULL_HANDLE;
    VkImage _color_resolve_image = VK_NULL_HANDLE;
    VkDeviceMemory _color_resolve_image_memory;
    VkImageView _color_resolve_image_view = VK_NULL_HANDLE;
    VkImage _depth_resolve_image = VK_NULL_HANDLE;
    VkDeviceMemory _depth_resolve_image_memory;
    VkImageView _depth_resolve_image_view = VK_NULL_HANDLE;
    std::vector<VkShaderModule> _shader_modules;
};

} // namespace Euclid

#include "src/Rasterizer.cpp"