Before adding new layer popping mechanisms

open_engine/include/open_engine/renderer/renderer2d.hpp

@@ -0,0 +1,27 @@
+#ifndef RENDERER2D_HPP
+#define RENDERER2D_HPP
+
+#include "open_engine/core.hpp"
+#include "open_engine/orthographic_camera.hpp"
+#include "open_engine/renderer/texture.hpp"
+
+#include <glm/fwd.hpp>
+
+namespace OpenEngine {
+    class Renderer2D
+    {
+        public:
+            static void Init();
+            static void Shutdown();
+
+            static void BeginScene(const OrthographicCamera& camera);
+            static void EndScene();
+
+            static void DrawQuad(const glm::vec2& position, const glm::vec2& size, const glm::vec4& color);
+            static void DrawQuad(const glm::vec3& position, const glm::vec2& size, const glm::vec4& color);
+            static void DrawQuad(const glm::vec2& position, const glm::vec2& size, const Ref<Texture2D>& texture);
+            static void DrawQuad(const glm::vec3& position, const glm::vec2& size, const Ref<Texture2D>& texture);
+    };
+}
+
+#endif // RENDERER2D_HPP

open_engine/src/open_engine/renderer/renderer2d.cpp

@@ -0,0 +1,108 @@
+#include <pch.hpp>
+
+#include <renderer/render_command.hpp>
+#include <renderer/shader.hpp>
+#include <renderer/vertex_array.hpp>
+#include <renderer/renderer2d.hpp>
+
+#include <glm/fwd.hpp>
+#include <glm/ext/matrix_transform.hpp>
+
+namespace OpenEngine {
+    struct Renderer2DData
+    {
+        Ref<VertexArray> vertex_array;
+        Ref<Shader> flat_color_shader;
+        Ref<Shader> texture_shader;
+    };
+
+    static Renderer2DData* renderer_data;
+
+    void Renderer2D::Init()
+    {
+        renderer_data = new Renderer2DData();
+        renderer_data->vertex_array = VertexArray::Create();
+
+        float square_vertices[5 * 4] = {
+            -0.5f, -0.5f, 0.0f, 0.0f, 0.0f,
+            0.5f, -0.5f, 0.0f, 1.0f, 0.0f,
+            0.5f, 0.5f, 0.0f, 1.0f, 1.0f,
+            -0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
+        };
+
+        Ref<VertexBuffer> vertex_buffer;
+        vertex_buffer.reset(VertexBuffer::Create(square_vertices, sizeof(square_vertices)));
+
+        BufferLayout layout = {
+            { ShaderDataType::Float3, "a_Position" },
+            { ShaderDataType::Float2, "a_TextCoord" }
+        };
+
+        vertex_buffer->SetLayout(layout);
+        renderer_data->vertex_array->AddVertexBuffer(vertex_buffer);
+
+        uint32_t indices[6] = { 0, 1, 2, 2, 3, 0 };
+        Ref<IndexBuffer> index_buffer;
+        index_buffer.reset(IndexBuffer::Create(indices, sizeof(indices) / sizeof(uint32_t)));
+
+        renderer_data->vertex_array->SetIndexBuffer(index_buffer);
+        renderer_data->flat_color_shader = Shader::Create("assets/shaders/flat_color.glsl");
+        renderer_data->texture_shader = Shader::Create("assets/shaders/texture.glsl");
+
+        renderer_data->texture_shader->Bind();
+        renderer_data->texture_shader->SetInt("u_Texture", 0);
+    }
+
+    void Renderer2D::Shutdown()
+    {
+        delete renderer_data;
+    }
+
+    void Renderer2D::BeginScene(const OrthographicCamera& camera)
+    {
+        renderer_data->flat_color_shader->Bind();
+        renderer_data->flat_color_shader->SetMat4("u_ViewProjection", camera.GetViewProjectionMatrix());
+
+        renderer_data->texture_shader->Bind();
+        renderer_data->texture_shader->SetMat4("u_ViewProjection", camera.GetViewProjectionMatrix());
+    }
+
+    void Renderer2D::EndScene()
+    {
+    }
+
+    void Renderer2D::DrawQuad(const glm::vec2& position, const glm::vec2& size, const Ref<Texture2D>& texture)
+    {
+        DrawQuad(glm::vec3(position, 0.0f), size, texture);
+    }
+    void Renderer2D::DrawQuad(const glm::vec3& position, const glm::vec2& size, const Ref<Texture2D>& texture)
+    {
+        renderer_data->texture_shader->Bind();
+
+        glm::mat4 transform = glm::translate(glm::mat4(1.0f), position) *
+            glm::scale(glm::mat4(1.0f), {size.x, size.y, 1.0f});
+        renderer_data->flat_color_shader->SetMat4("u_Transform", transform);
+
+        texture->Bind();
+
+        renderer_data->vertex_array->Bind();
+        RenderCommand::DrawIndexed(renderer_data->vertex_array);
+    }
+
+    void Renderer2D::DrawQuad(const glm::vec2& position, const glm::vec2& size, const glm::vec4& color)
+    {
+        DrawQuad(glm::vec3(position, 0.0f), size, color);
+    }
+    void Renderer2D::DrawQuad(const glm::vec3& position, const glm::vec2& size, const glm::vec4& color)
+    {
+        renderer_data->flat_color_shader->Bind();
+        renderer_data->flat_color_shader->SetVec4("u_Color", color);
+
+        glm::mat4 transform = glm::translate(glm::mat4(1.0f), position) *
+            glm::scale(glm::mat4(1.0f), {size.x, size.y, 1.0f});
+        renderer_data->flat_color_shader->SetMat4("u_Transform", transform);
+
+        renderer_data->vertex_array->Bind();
+        RenderCommand::DrawIndexed(renderer_data->vertex_array);
+    }
+}