From d22effdfa3558918b09735498fd51116ee081df0 Mon Sep 17 00:00:00 2001 From: Riyyi Date: Fri, 19 Jan 2024 21:11:11 +0100 Subject: [PATCH] Renderer: De-duplicate code between renderer types --- src/inferno/application.cpp | 6 +- src/inferno/render/buffer.h | 42 ++-- src/inferno/render/renderer.cpp | 363 ++++++++++------------------ src/inferno/render/renderer.h | 95 +++----- src/inferno/system/textareasystem.h | 2 +- 5 files changed, 188 insertions(+), 320 deletions(-) diff --git a/src/inferno/application.cpp b/src/inferno/application.cpp index 61862ee..be7f759 100644 --- a/src/inferno/application.cpp +++ b/src/inferno/application.cpp @@ -169,9 +169,9 @@ int Application::run() RenderCommand::clear(); std::pair projectionView = m_scene->cameraProjectionView(); - RendererCubemap::the().beginScene(projectionView.first, projectionView.second); // camera, lights, environment - Renderer2D::the().beginScene(projectionView.first, projectionView.second); // camera, lights, environment - RendererCharacter::the().beginScene(); + RendererCubemap::the().beginScene(projectionView.first, projectionView.second); // camera, lights, environment + Renderer2D::the().beginScene(projectionView.first, projectionView.second); // camera, lights, environment + RendererCharacter::the().beginScene(projectionView.first, projectionView.second); // camera, lights, environment m_scene->render(); // RendererCharacter::the().drawCharacter(character, f->texture()); diff --git a/src/inferno/render/buffer.h b/src/inferno/render/buffer.h index 70f7fc4..e0ddf67 100644 --- a/src/inferno/render/buffer.h +++ b/src/inferno/render/buffer.h @@ -42,17 +42,17 @@ public: static uint32_t getTypeCount(const BufferElementType type); static uint32_t getTypeGL(const BufferElementType type); - inline BufferElementType getType() const { return m_type; } - inline std::string getName() const { return m_name; } - inline uint32_t getSize() const { return m_size; } - inline uint32_t getOffset() const { return m_offset; } - inline bool getNormalized() const { return m_normalized; } - - inline void setType(const BufferElementType& type) { m_type = type; } - inline void setName(const std::string& name) { m_name = name; } - inline void setSize(const uint32_t& size) { m_size = size; } - inline void setOffset(const uint32_t& offset) { m_offset = offset; } - inline void setNormalized(const bool& normalized) { m_normalized = normalized; } + BufferElementType getType() const { return m_type; } + std::string getName() const { return m_name; } + uint32_t getSize() const { return m_size; } + uint32_t getOffset() const { return m_offset; } + bool getNormalized() const { return m_normalized; } + + void setType(const BufferElementType& type) { m_type = type; } + void setName(const std::string& name) { m_name = name; } + void setSize(const uint32_t& size) { m_size = size; } + void setOffset(const uint32_t& offset) { m_offset = offset; } + void setNormalized(const bool& normalized) { m_normalized = normalized; } private: BufferElementType m_type; @@ -70,14 +70,14 @@ public: BufferLayout() {} BufferLayout(const std::initializer_list& elements); - inline const std::vector& getElements() const { return m_elements; } - inline uint32_t getStride() const { return m_stride; } + const std::vector& getElements() const { return m_elements; } + uint32_t getStride() const { return m_stride; } // Iterators - inline std::vector::iterator begin() { return m_elements.begin(); } - inline std::vector::iterator end() { return m_elements.end(); } - inline std::vector::const_iterator begin() const { return m_elements.begin(); } - inline std::vector::const_iterator end() const { return m_elements.end(); } + std::vector::iterator begin() { return m_elements.begin(); } + std::vector::iterator end() { return m_elements.end(); } + std::vector::const_iterator begin() const { return m_elements.begin(); } + std::vector::const_iterator end() const { return m_elements.end(); } protected: void calculateOffsetsAndStride(); @@ -101,7 +101,7 @@ public: void uploadData(const void* data, uint32_t size); - inline const BufferLayout& getLayout() const { return m_layout; } + const BufferLayout& getLayout() const { return m_layout; } inline void setLayout(const BufferLayout& layout) { m_layout = layout; } @@ -121,7 +121,7 @@ public: void bind() const; void unbind() const; - inline uint32_t getCount() const { return m_count; } + uint32_t getCount() const { return m_count; } private: uint32_t m_id { 0 }; @@ -142,8 +142,8 @@ public: void addVertexBuffer(std::shared_ptr vertexBuffer); void setIndexBuffer(std::shared_ptr indexBuffer); - inline const std::vector>& getVertexBuffers() const { return m_vertexBuffers; } - inline std::shared_ptr getIndexBuffer() const { return m_indexBuffer; } + std::shared_ptr at(size_t i) const { return m_vertexBuffers.at(i); } + std::shared_ptr getIndexBuffer() const { return m_indexBuffer; } private: uint32_t m_id { 0 }; diff --git a/src/inferno/render/renderer.cpp b/src/inferno/render/renderer.cpp index 869597f..764b018 100644 --- a/src/inferno/render/renderer.cpp +++ b/src/inferno/render/renderer.cpp @@ -18,86 +18,171 @@ namespace Inferno { -uint32_t Renderer::m_supportedTextureUnitPerBatch = 0; +template +void Renderer::beginScene(glm::mat4, glm::mat4) +{ +} + +template +void Renderer::endScene() +{ + nextBatch(); +} + +// ----------------------------------------- + +template +uint32_t Renderer::m_maxSupportedTextureSlots = 0; -void Renderer::initialize() +template +void Renderer::initialize() { // Get amount of texture units supported by the GPU - uint32_t constTextureUnitCount = textureUnitPerBatch; uint32_t gpuTextureUnitCount = RenderCommand::textureUnitAmount(); - m_supportedTextureUnitPerBatch = std::min(constTextureUnitCount, gpuTextureUnitCount); + m_maxSupportedTextureSlots = std::min(maxTextureSlots, gpuTextureUnitCount); // Texture unit 0 is reserved for no texture - m_textureUnits[0] = nullptr; + m_textureSlots[0] = nullptr; // Create texture unit samplers - int32_t samplers[textureUnitPerBatch]; - for (uint32_t i = 0; i < textureUnitPerBatch; i++) { + int32_t samplers[maxTextureSlots]; + for (uint32_t i = 0; i < maxTextureSlots; i++) { samplers[i] = i; } // Create shader loadShader(); m_shader->bind(); - m_shader->setInt("u_textures", samplers, textureUnitPerBatch); + m_shader->setInt("u_textures", samplers, maxTextureSlots); m_shader->unbind(); // Create vertex array m_vertexArray = std::make_shared(); + + // CPU + // --------------------------------- + + // Generate indices + + uint32_t* indices = new uint32_t[maxIndices]; + + uint32_t offset = 0; + for (uint32_t i = 0; i < maxIndices; i += indexPerQuad) { + indices[i + 0] = offset + 0; + indices[i + 1] = offset + 1; + indices[i + 2] = offset + 2; + indices[i + 3] = offset + 2; + indices[i + 4] = offset + 3; + indices[i + 5] = offset + 0; + + offset += vertexPerQuad; + } + + // GPU + // --------------------------------- + + // Create index buffer + auto indexBuffer = std::make_shared(indices, sizeof(uint32_t) * maxIndices); + m_vertexArray->setIndexBuffer(indexBuffer); + delete[] indices; } -void Renderer::destroy() +template +void Renderer::destroy() { + delete[] m_vertexBufferBase; } -uint32_t Renderer::addTextureUnit(std::shared_ptr texture) +template +uint32_t Renderer::addTextureUnit(std::shared_ptr texture) { if (texture == nullptr) { return 0; } // Create a new batch if the texture unit limit has been reached - if (m_textureUnitIndex >= m_supportedTextureUnitPerBatch) { + if (m_textureSlotIndex >= m_maxSupportedTextureSlots) { nextBatch(); } // If texure was already added - for (uint32_t i = 1; i < m_textureUnitIndex; i++) { - if (m_textureUnits[i] == texture) { + for (uint32_t i = 1; i < m_textureSlotIndex; i++) { + if (m_textureSlots[i] == texture) { return i; } } // Add texture - uint32_t textureUnitIndex = m_textureUnitIndex; - m_textureUnits[textureUnitIndex] = texture; - m_textureUnitIndex++; + uint32_t textureSlotIndex = m_textureSlotIndex; + m_textureSlots[textureSlotIndex] = texture; + m_textureSlotIndex++; - return textureUnitIndex; + return textureSlotIndex; } -void Renderer::bind() +template +void Renderer::bind() { m_shader->bind(); - for (uint32_t i = 1; i < m_textureUnitIndex; i++) { - m_textureUnits[i]->bind(i); + for (uint32_t i = 1; i < m_textureSlotIndex; i++) { + m_textureSlots[i]->bind(i); } m_vertexArray->bind(); } -void Renderer::unbind() +template +void Renderer::unbind() { m_vertexArray->unbind(); - for (uint32_t i = 1; i < m_textureUnitIndex; i++) { - m_textureUnits[i]->unbind(); + for (uint32_t i = 1; i < m_textureSlotIndex; i++) { + m_textureSlots[i]->unbind(); } m_shader->unbind(); } +template +void Renderer::flush() +{ + if (m_quadIndex == 0) { + return; + } + + // Upload vertex data to GPU + m_vertexArray->at(0)->uploadData( + m_vertexBufferBase, + m_quadIndex * vertexPerQuad * sizeof(T)); + + bind(); + + // Render + bool depthTest = RenderCommand::depthTest(); + RenderCommand::setDepthTest(m_enableDepthBuffer); + RenderCommand::drawIndexed(*m_vertexArray, m_quadIndex * indexPerQuad); + RenderCommand::setDepthTest(depthTest); + + unbind(); +} + +template +void Renderer::startBatch() +{ + m_quadIndex = 0; + m_vertexBufferPtr = m_vertexBufferBase; + + m_textureSlotIndex = 1; +} + +template +void Renderer::nextBatch() +{ + flush(); + startBatch(); +} + // ----------------------------------------- Renderer2D::Renderer2D(s) @@ -108,8 +193,8 @@ Renderer2D::Renderer2D(s) // --------------------------------- // Create array for storing quads vertices - m_vertexBufferBase = std::make_unique(vertexCount); - m_vertexBufferPtr = m_vertexBufferBase.get(); + m_vertexBufferBase = new QuadVertex[maxVertices]; + m_vertexBufferPtr = m_vertexBufferBase; // Set default quad vertex positions m_vertexPositions[0] = { -0.5f, -0.5f, 0.0f, 1.0f }; @@ -117,27 +202,11 @@ Renderer2D::Renderer2D(s) m_vertexPositions[2] = { 0.5f, 0.5f, 0.0f, 1.0f }; m_vertexPositions[3] = { -0.5f, 0.5f, 0.0f, 1.0f }; - // Generate indices - - uint32_t* indices = new uint32_t[indexCount]; - - uint32_t offset = 0; - for (uint32_t i = 0; i < indexCount; i += indexPerQuad) { - indices[i + 0] = offset + 0; - indices[i + 1] = offset + 1; - indices[i + 2] = offset + 2; - indices[i + 3] = offset + 2; - indices[i + 4] = offset + 3; - indices[i + 5] = offset + 0; - - offset += vertexPerQuad; - } - // GPU // --------------------------------- // Create vertex buffer - auto vertexBuffer = std::make_shared(sizeof(QuadVertex) * vertexCount); + auto vertexBuffer = std::make_shared(sizeof(QuadVertex) * maxVertices); vertexBuffer->setLayout({ { BufferElementType::Vec3, "a_position" }, { BufferElementType::Vec4, "a_color" }, @@ -146,19 +215,9 @@ Renderer2D::Renderer2D(s) }); m_vertexArray->addVertexBuffer(vertexBuffer); - // Create index buffer - auto indexBuffer = std::make_shared(indices, sizeof(uint32_t) * indexCount); - m_vertexArray->setIndexBuffer(indexBuffer); - delete[] indices; - ruc::info("Renderer2D initialized"); } -Renderer2D::~Renderer2D() -{ - Renderer::destroy(); -} - void Renderer2D::beginScene(glm::mat4 cameraProjection, glm::mat4 cameraView) { m_shader->bind(); @@ -166,11 +225,6 @@ void Renderer2D::beginScene(glm::mat4 cameraProjection, glm::mat4 cameraView) m_shader->unbind(); } -void Renderer2D::endScene() -{ - nextBatch(); -} - void Renderer2D::drawQuad(const TransformComponent& transform, glm::vec4 color) { drawQuad(transform, color, nullptr); @@ -189,7 +243,7 @@ void Renderer2D::drawQuad(const TransformComponent& transform, glm::vec4 color, void Renderer2D::drawQuad(const TransformComponent& transform, glm::mat4 color, std::shared_ptr texture) { // Create a new batch if the quad limit has been reached - if (m_quadIndex >= quadCount) { + if (m_quadIndex >= maxQuads) { nextBatch(); } @@ -219,39 +273,6 @@ void Renderer2D::loadShader() m_shader = ShaderManager::the().load("assets/glsl/batch-quad"); } -void Renderer2D::flush() -{ - if (m_quadIndex == 0) { - return; - } - - // Upload vertex data to GPU - m_vertexArray->getVertexBuffers().at(0)->uploadData( - m_vertexBufferBase.get(), - m_quadIndex * vertexPerQuad * sizeof(QuadVertex)); - - bind(); - - // Render - RenderCommand::drawIndexed(*m_vertexArray, m_quadIndex * indexPerQuad); - - unbind(); -} - -void Renderer2D::startBatch() -{ - m_quadIndex = 0; - m_vertexBufferPtr = m_vertexBufferBase.get(); - - m_textureUnitIndex = 1; -} - -void Renderer2D::nextBatch() -{ - flush(); - startBatch(); -} - // ----------------------------------------- RendererCubemap::RendererCubemap(s) @@ -262,8 +283,8 @@ RendererCubemap::RendererCubemap(s) // --------------------------------- // Create array for storing quads vertices - m_vertexBufferBase = std::make_unique(vertexCount); - m_vertexBufferPtr = m_vertexBufferBase.get(); + m_vertexBufferBase = new CubemapVertex[maxVertices]; + m_vertexBufferPtr = m_vertexBufferBase; // Set default cubemap vertex positions @@ -303,27 +324,13 @@ RendererCubemap::RendererCubemap(s) m_vertexPositions[22] = { 0.5f, -0.5f, 0.5f, 1.0f }; m_vertexPositions[23] = { 0.5f, -0.5f, -0.5f, 1.0f }; - // Generate indices - - uint32_t* indices = new uint32_t[indexCount]; - - uint32_t offset = 0; - for (uint32_t i = 0; i < indexCount; i += indexPerQuad) { - indices[i + 0] = offset + 0; - indices[i + 1] = offset + 1; - indices[i + 2] = offset + 2; - indices[i + 3] = offset + 2; - indices[i + 4] = offset + 3; - indices[i + 5] = offset + 0; - - offset += vertexPerQuad; - } - // GPU // --------------------------------- + m_enableDepthBuffer = false; + // Create vertex buffer - auto vertexBuffer = std::make_shared(sizeof(CubemapVertex) * vertexCount); + auto vertexBuffer = std::make_shared(sizeof(CubemapVertex) * maxVertices); vertexBuffer->setLayout({ { BufferElementType::Vec3, "a_position" }, { BufferElementType::Vec4, "a_color" }, @@ -331,19 +338,9 @@ RendererCubemap::RendererCubemap(s) }); m_vertexArray->addVertexBuffer(vertexBuffer); - // Create index buffer - auto indexBuffer = std::make_shared(indices, sizeof(uint32_t) * indexCount); - m_vertexArray->setIndexBuffer(indexBuffer); - delete[] indices; - ruc::info("RendererCubemap initialized"); } -RendererCubemap::~RendererCubemap() -{ - Renderer::destroy(); -} - void RendererCubemap::beginScene(glm::mat4 cameraProjection, glm::mat4 cameraView) { // We want the skybox fixed in position, so only retain the rotation and scale. @@ -359,11 +356,6 @@ void RendererCubemap::beginScene(glm::mat4 cameraProjection, glm::mat4 cameraVie m_shader->unbind(); } -void RendererCubemap::endScene() -{ - nextBatch(); -} - void RendererCubemap::drawCubemap(const TransformComponent& transform, glm::vec4 color, std::shared_ptr texture) { drawCubemap(transform, glm::mat4(color, color, color, color), texture); @@ -372,13 +364,13 @@ void RendererCubemap::drawCubemap(const TransformComponent& transform, glm::vec4 void RendererCubemap::drawCubemap(const TransformComponent& transform, glm::mat4 color, std::shared_ptr texture) { // Create a new batch if the quad limit has been reached - if (m_quadIndex >= quadCount) { + if (m_quadIndex >= maxQuads) { nextBatch(); } uint32_t textureUnitIndex = addTextureUnit(texture); - // Add the quads 4 vertices + // Add the quads 4 vertices, 6 times, once per cube side for (uint32_t i = 0; i < vertexPerQuad * quadPerCube; i++) { m_vertexBufferPtr->position = transform.transform * m_vertexPositions[i]; m_vertexBufferPtr->color = color[i % 4]; @@ -394,42 +386,6 @@ void RendererCubemap::loadShader() m_shader = ShaderManager::the().load("assets/glsl/batch-cubemap"); } -void RendererCubemap::flush() -{ - if (m_quadIndex == 0) { - return; - } - - // Upload vertex data to GPU - m_vertexArray->getVertexBuffers().at(0)->uploadData( - m_vertexBufferBase.get(), - m_quadIndex * vertexPerQuad * sizeof(CubemapVertex)); - - bind(); - - // Render - bool depthTest = RenderCommand::depthTest(); - RenderCommand::setDepthTest(false); - RenderCommand::drawIndexed(*m_vertexArray, m_quadIndex * indexPerQuad); - RenderCommand::setDepthTest(depthTest); - - unbind(); -} - -void RendererCubemap::startBatch() -{ - m_quadIndex = 0; - m_vertexBufferPtr = m_vertexBufferBase.get(); - - m_textureUnitIndex = 1; -} - -void RendererCubemap::nextBatch() -{ - flush(); - startBatch(); -} - // ----------------------------------------- RendererCharacter::RendererCharacter(s) @@ -440,30 +396,16 @@ RendererCharacter::RendererCharacter(s) // --------------------------------- // Create array for storing quads vertices - m_vertexBufferBase = std::make_unique(vertexCount); - m_vertexBufferPtr = m_vertexBufferBase.get(); - - // Generate indices - - uint32_t* indices = new uint32_t[indexCount]; - - uint32_t offset = 0; - for (uint32_t i = 0; i < indexCount; i += indexPerQuad) { - indices[i + 0] = offset + 0; - indices[i + 1] = offset + 1; - indices[i + 2] = offset + 2; - indices[i + 3] = offset + 2; - indices[i + 4] = offset + 3; - indices[i + 5] = offset + 0; - - offset += vertexPerQuad; - } + m_vertexBufferBase = new CharacterVertex[maxVertices]; + m_vertexBufferPtr = m_vertexBufferBase; // GPU // --------------------------------- + m_enableDepthBuffer = false; + // Create vertex buffer - auto vertexBuffer = std::make_shared(sizeof(CharacterVertex) * vertexCount); + auto vertexBuffer = std::make_shared(sizeof(CharacterVertex) * maxVertices); vertexBuffer->setLayout({ { BufferElementType::Vec3, "a_position" }, { BufferElementType::Vec4, "a_color" }, @@ -478,32 +420,13 @@ RendererCharacter::RendererCharacter(s) }); m_vertexArray->addVertexBuffer(vertexBuffer); - // Create index buffer - auto indexBuffer = std::make_shared(indices, sizeof(uint32_t) * indexCount); - m_vertexArray->setIndexBuffer(indexBuffer); - delete[] indices; - ruc::info("RendererCharacter initialized"); } -RendererCharacter::~RendererCharacter() -{ - Renderer::destroy(); -} - -void RendererCharacter::beginScene() -{ -} - -void RendererCharacter::endScene() -{ - nextBatch(); -} - void RendererCharacter::drawCharacter(std::array& characterQuad, std::shared_ptr texture) { // Create a new batch if the quad limit has been reached - if (m_quadIndex >= quadCount) { + if (m_quadIndex >= maxQuads) { nextBatch(); } @@ -534,40 +457,4 @@ void RendererCharacter::loadShader() m_shader = ShaderManager::the().load("assets/glsl/batch-font"); } -void RendererCharacter::flush() -{ - if (m_quadIndex == 0) { - return; - } - - // Upload vertex data to GPU - m_vertexArray->getVertexBuffers().at(0)->uploadData( - m_vertexBufferBase.get(), - m_quadIndex * vertexPerQuad * sizeof(CharacterVertex)); - - bind(); - - // Render - bool depthTest = RenderCommand::depthTest(); - RenderCommand::setDepthTest(false); - RenderCommand::drawIndexed(*m_vertexArray, m_quadIndex * indexPerQuad); - RenderCommand::setDepthTest(depthTest); - - unbind(); -} - -void RendererCharacter::startBatch() -{ - m_quadIndex = 0; - m_vertexBufferPtr = m_vertexBufferBase.get(); - - m_textureUnitIndex = 1; -} - -void RendererCharacter::nextBatch() -{ - flush(); - startBatch(); -} - } // namespace Inferno diff --git a/src/inferno/render/renderer.h b/src/inferno/render/renderer.h index ce2795f..db24f79 100644 --- a/src/inferno/render/renderer.h +++ b/src/inferno/render/renderer.h @@ -52,15 +52,25 @@ struct CharacterVertex { // ------------------------------------- +template class Renderer { public: static constexpr const uint32_t vertexPerQuad = 4; static constexpr const uint32_t indexPerQuad = 6; static constexpr const uint32_t quadPerCube = 6; - static constexpr const uint32_t textureUnitPerBatch = 32; + + // When to start a new batch + static constexpr const uint32_t maxQuads = 20000; + static constexpr const uint32_t maxVertices = maxQuads * vertexPerQuad; + static constexpr const uint32_t maxIndices = maxQuads * indexPerQuad; + static constexpr const uint32_t maxTextureSlots = 32; + + virtual void beginScene(glm::mat4 cameraProjection, glm::mat4 cameraView); + virtual void endScene(); protected: Renderer() {} + virtual ~Renderer() { destroy(); }; void initialize(); void destroy(); @@ -69,41 +79,47 @@ protected: void bind(); void unbind(); + virtual void loadShader() = 0; - virtual void flush() = 0; - virtual void startBatch() = 0; - virtual void nextBatch() = 0; + virtual void flush(); + virtual void startBatch(); + virtual void nextBatch(); - uint32_t m_quadIndex = 0; +protected: + // CPU quad vertices + uint32_t m_quadIndex { 0 }; + T* m_vertexBufferBase { nullptr }; + T* m_vertexBufferPtr { nullptr }; // Texture units - static uint32_t m_supportedTextureUnitPerBatch; - uint32_t m_textureUnitIndex = 1; - std::array, textureUnitPerBatch> m_textureUnits; + static uint32_t m_maxSupportedTextureSlots; + uint32_t m_textureSlotIndex { 1 }; + std::array, maxTextureSlots> m_textureSlots; // GPU objects + bool m_enableDepthBuffer { true }; std::shared_ptr m_shader; std::shared_ptr m_vertexArray; }; +// TOOD: +// - Deduplicate flush() +// v Add bool for disabling depth buffer +// - Add Size for uploadData (this is prob not needed, we got T already) +// - Decide if its worth to remove template from Renderer, just cast vertexBufferPtr before usage + // ------------------------------------- class Renderer2D final - : public Renderer + : public Renderer , public ruc::Singleton { public: Renderer2D(s); - virtual ~Renderer2D(); + virtual ~Renderer2D() {}; using Singleton::destroy; - // When to start a new batch - static constexpr const uint32_t quadCount = 1000; - static constexpr const uint32_t vertexCount = quadCount * vertexPerQuad; - static constexpr const uint32_t indexCount = quadCount * indexPerQuad; - - void beginScene(glm::mat4 cameraProjectionView, glm::mat4 cameraView); - void endScene(); + virtual void beginScene(glm::mat4 cameraProjection, glm::mat4 cameraView) override; void drawQuad(const TransformComponent& transform, glm::vec4 color); void drawQuad(const TransformComponent& transform, glm::mat4 color); @@ -112,13 +128,6 @@ public: private: void loadShader() override; - void flush() override; - void startBatch() override; - void nextBatch() override; - - // CPU quad vertices - std::unique_ptr m_vertexBufferBase; - QuadVertex* m_vertexBufferPtr { nullptr }; // Default quad vertex positions glm::vec4 m_vertexPositions[vertexPerQuad]; @@ -126,35 +135,21 @@ private: // ------------------------------------- class RendererCubemap final - : public Renderer + : public Renderer , public ruc::Singleton { public: RendererCubemap(s); - virtual ~RendererCubemap(); + virtual ~RendererCubemap() {}; using Singleton::destroy; - // When to start a new batch - static constexpr const uint32_t cubemapCount = 166; - static constexpr const uint32_t quadCount = cubemapCount * quadPerCube; - static constexpr const uint32_t vertexCount = quadCount * vertexPerQuad; - static constexpr const uint32_t indexCount = quadCount * indexPerQuad; - - void beginScene(glm::mat4 cameraProjectionView, glm::mat4 cameraView); - void endScene(); + virtual void beginScene(glm::mat4 cameraProjection, glm::mat4 cameraView) override; void drawCubemap(const TransformComponent& transform, glm::vec4 color, std::shared_ptr texture); void drawCubemap(const TransformComponent& transform, glm::mat4 color, std::shared_ptr texture); private: void loadShader() override; - void flush() override; - void startBatch() override; - void nextBatch() override; - - // CPU quad vertices - std::unique_ptr m_vertexBufferBase; - CubemapVertex* m_vertexBufferPtr { nullptr }; // Default cubemap vertex positions glm::vec4 m_vertexPositions[vertexPerQuad * quadPerCube]; @@ -163,32 +158,18 @@ private: // ------------------------------------- class RendererCharacter final - : public Renderer + : public Renderer , public ruc::Singleton { public: RendererCharacter(s); - virtual ~RendererCharacter(); + virtual ~RendererCharacter() {}; using Singleton::destroy; - static const uint32_t quadCount = 1000; - static const uint32_t vertexCount = quadCount * vertexPerQuad; - static const uint32_t indexCount = quadCount * indexPerQuad; - - void beginScene(); - void endScene(); - void drawCharacter(std::array& characterQuad, std::shared_ptr texture); private: void loadShader() override; - void flush() override; - void startBatch() override; - void nextBatch() override; - - // CPU quad vertices - std::unique_ptr m_vertexBufferBase; - CharacterVertex* m_vertexBufferPtr { nullptr }; }; } // namespace Inferno diff --git a/src/inferno/system/textareasystem.h b/src/inferno/system/textareasystem.h index e54c7bb..6885d8d 100644 --- a/src/inferno/system/textareasystem.h +++ b/src/inferno/system/textareasystem.h @@ -21,7 +21,7 @@ namespace Inferno { using Characters = std::vector>; -using CharacterQuad = std::array; +using CharacterQuad = std::array::vertexPerQuad>; class Font; class Scene;