First Triangle!

Engine/res/pixel.ps

@@ -0,0 +1,8 @@
+#version 450 core
+
+out vec4 FragColor;
+
+void main()
+{
+	FragColor = vec4(1.0, 0.0, 0.0, 1.0);
+}

Engine/res/vertex.vs

@@ -0,0 +1,8 @@
+#version 450 core
+
+layout(location = 0) in vec2 a_Position;
+
+void main()
+{
+	gl_Position = vec4(a_Position, 0.0, 1.0);
+}

Engine/src/Engine/Base.h

@@ -1,6 +1,10 @@
 #pragma once
 
-#include "Core/Logger.h"
+#ifndef LOGGER_H
+	#include "Core/Logger.h"
+#endif
+
+#include <memory>
 
 #if defined(LIGHT_PLATFORM_WINDOWS)
 	#define LT_BUILD_PLATFORM "Windows"

Engine/src/Engine/Core/Application.cpp

@@ -7,6 +7,7 @@
 #include "Events/Event.h"
 
 #include "Graphics/GraphicsContext.h"
+#include "Graphics/Renderer.h"
 #include "Graphics/RenderCommand.h"
 
 #include "UserInterface/UserInterface.h"
@@ -34,6 +35,9 @@ namespace Light {
 			m_Window->PollEvents();
 
 			// Rendering
+			m_Window->GetGfxContext()->GetRenderer()->Draw();
+
+			// Buffer updates
 			m_Window->GetGfxContext()->GetRenderCommand()->SwapBuffers();
 			m_Window->GetGfxContext()->GetRenderCommand()->ClearBackBuffer();
 

Engine/src/Engine/Graphics/GraphicsContext.cpp

@@ -2,6 +2,9 @@
 #include "GraphicsContext.h"
 #include "OpenGL/glGraphicsContext.h"
 
+#include "Buffers.h"
+
+#include "Renderer.h"
 #include "RenderCommand.h"
 #include "UserInterface/UserInterface.h" 
 
@@ -14,8 +17,11 @@ namespace Light {
 		// terminate gfx context dependent classes
 		if (s_Context)
 		{
+			s_Context->m_Renderer.reset();
 			s_Context->m_RenderCommand.reset();
 			s_Context->m_UserInterface.reset();
+
+			delete s_Context;
 		}
 
 		// determine the default api
@@ -41,8 +47,7 @@ namespace Light {
 		// create gfx context dependent classes
 		s_Context->m_RenderCommand = std::unique_ptr<RenderCommand>(RenderCommand::Create(windowHandle));
 		s_Context->m_UserInterface = std::unique_ptr<UserInterface>(UserInterface::Create(windowHandle));
-		// ...Renderer
-		// ...UserInterface...
+		s_Context->m_Renderer = std::unique_ptr<Renderer>(Renderer::Create(s_Context->m_RenderCommand));
 
 		// sanity check
 		LT_ENGINE_ASSERT(s_Context->m_RenderCommand, "GraphicsContext::Create: RenderCommand creation failed");

Engine/src/Engine/Graphics/GraphicsContext.h

@@ -6,6 +6,7 @@ struct GLFWwindow;
 
 namespace Light {
 
+	class Renderer;
 	class RenderCommand;
 	class UserInterface;
 
@@ -23,7 +24,8 @@ namespace Light {
 	private:
 		static GraphicsContext* s_Context;
 
-		std::unique_ptr<RenderCommand> m_RenderCommand;
+		std::unique_ptr<Renderer> m_Renderer;
+		std::shared_ptr<RenderCommand> m_RenderCommand;
 		std::unique_ptr<UserInterface> m_UserInterface;
 
 	protected:
@@ -39,6 +41,7 @@ namespace Light {
 
 		static inline GraphicsAPI GetGraphicsAPI() { return s_Context->m_GraphicsAPI; }
 
+		inline Renderer* GetRenderer() { return m_Renderer.get(); }
 		inline RenderCommand* GetRenderCommand() { return m_RenderCommand.get(); }
 		inline UserInterface* GetUserInterface() { return m_UserInterface.get(); }
 

Engine/src/Engine/Graphics/RenderCommand.h

@@ -8,7 +8,6 @@ namespace Light {
 
 	class RenderCommand
 	{
-	private:
 	public:
 		RenderCommand(const RenderCommand&) = delete;
 		RenderCommand& operator=(const RenderCommand&) = delete;

Engine/src/Engine/Graphics/Renderer.cpp

@@ -0,0 +1,63 @@
+#include "ltpch.h"
+#include "Renderer.h"
+
+#include "GraphicsContext.h"
+
+#include "RenderCommand.h"
+
+namespace Light {
+
+	Renderer* Renderer::m_Context;
+
+	Renderer::Renderer(std::shared_ptr<RenderCommand> renderCommand)
+		: m_RenderCommand(renderCommand)
+	{
+		m_Context = this;
+
+ 		m_Shader = std::unique_ptr<Shader>(Shader::Create(
+R"(
+#version 450 core
+
+layout(location = 0) in vec2 a_Position;
+
+void main()
+{
+	gl_Position = vec4(a_Position, 0.0, 1.0);
+})",
+R"(
+#version 450 core
+
+out vec4 FragColor;
+
+void main()
+{
+	FragColor = vec4(1.0, 0.0, 0.0, 1.0);
+}
+)"));
+
+		float vertices[] =
+		{
+			-0.5f, -0.5f,
+			 0.5f, -0.5f,
+			 0.0f,  0.5f,
+		};
+
+		m_VertexBuffer = std::unique_ptr<VertexBuffer>(VertexBuffer::Create(2 * 3, vertices));
+		m_VertexLayout = std::unique_ptr<VertexLayout>(VertexLayout::Create(m_VertexBuffer.get(), { VertexElementType::Float2 }));
+	}
+
+	Renderer* Renderer::Create(std::shared_ptr<RenderCommand> renderCommand)
+	{
+		return new Renderer(renderCommand);
+	}
+
+	void Renderer::Draw()
+	{
+		m_Shader->Bind();
+		m_VertexBuffer->Bind();
+		m_VertexLayout->Bind();
+		m_RenderCommand->Draw(3u);
+	}
+
+
+}

Engine/src/Engine/Graphics/Renderer.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "Base.h"
+
+#include "Shader.h"
+#include "Buffers.h"
+#include "VertexLayout.h"
+
+#include <memory>
+
+namespace Light {
+
+	class RenderCommand;
+
+	class Renderer
+	{
+	private:
+		static Renderer* m_Context;
+
+		std::shared_ptr<RenderCommand> m_RenderCommand;
+
+		std::unique_ptr<Shader> m_Shader;
+		std::unique_ptr<VertexBuffer> m_VertexBuffer;
+		std::unique_ptr<VertexLayout> m_VertexLayout;
+	public:
+		static Renderer* Create(std::shared_ptr<RenderCommand> renderCommand);
+		
+		void Draw();
+
+	private:
+		Renderer(std::shared_ptr<RenderCommand> renderCommand);
+	};
+
+}

Engine/src/Engine/Graphics/Shader.h

@@ -1,10 +1,11 @@
 #pragma once
 
+#include "Base.h"
+
 namespace Light {
 
 	class Shader
 	{
-	private:
 	public:
 		static Shader* Create(const std::string& vertexPath, const std::string& pixelPath);
 

Engine/src/Engine/Graphics/VertexLayout.cpp

@@ -3,11 +3,10 @@
 #include "OpenGL/glVertexLayout.h"
 
 #include "GraphicsContext.h"
-#include "Buffers.h"
 
 namespace Light {
 
-	VertexLayout* VertexLayout::Create(VertexBuffer* buffer, const std::vector<VertexElementType> elements)
+	VertexLayout* VertexLayout::Create(VertexBuffer* buffer, const std::vector<VertexElementType>& elements)
 	{
 		switch (GraphicsContext::GetGraphicsAPI())
 		{

Engine/src/Engine/Graphics/VertexLayout.h

@@ -19,7 +19,9 @@ namespace Light {
 	class VertexLayout
 	{
 	public:
-		static VertexLayout* Create(VertexBuffer* buffer, const std::vector<VertexElementType> elements);
+		static VertexLayout* Create(VertexBuffer* buffer, const std::vector<VertexElementType>& elements);
+
+		virtual ~VertexLayout() = default;;
 
 		virtual void Bind() = 0;
 		virtual void UnBind() = 0;

Engine/src/Engine/Layer/LayerStack.h

@@ -7,10 +7,13 @@ namespace Light {
 	class Layer;
 	class Event;
 
+	template <typename T>
+	using Raw = T*;
+
 	class LayerStack
 	{
 	private:
-		static LayerStack* s_Context;
+		static Raw<LayerStack> s_Context;
 
 		std::vector<Layer*> m_Layers;
 

Engine/src/LightEngine.h

@@ -14,6 +14,7 @@
 // Graphics
 #include "Graphics/GraphicsContext.h"
 #include "Graphics/RenderCommand.h"
+#include "Graphics/Renderer.h"
 
 // Layer
 #include "Layer/Layer.h"

Engine/src/Platform/GraphicsAPI/OpenGL/glGraphicsContext.cpp

@@ -2,11 +2,15 @@
 #include "glGraphicsContext.h"
 
 // Required for forward declaration
+#include "Graphics/Renderer.h"
 #include "Graphics/RenderCommand.h"
+#include "Graphics/Shader.h"
+#include "Graphics/Buffers.h"
+#include "Graphics/VertexLayout.h"
 #include "UserInterface/UserInterface.h" 
 
 #include <glad/glad.h>
-#include <GLFW/glfw3.h>
+#include <glfw/glfw3.h>
 
 namespace Light {
 

Engine/src/Platform/GraphicsAPI/OpenGL/glShader.cpp

@@ -1,7 +1,7 @@
 #include "ltpch.h"
 #include "glShader.h"
 
-#include <GLAD/glad.h>
+#include <glad/glad.h>
 
 namespace Light {
 

Engine/src/Platform/GraphicsAPI/OpenGL/glVertexLayout.cpp

@@ -13,7 +13,7 @@ namespace Light {
 		LT_ENGINE_ASSERT(dynamic_cast<glVertexBuffer*>(buffer), "glVertexLayout::glVertexLayout: failed to cast VertexBuffer to glVertexBuffer");
 
 		// elements desc
-		std::vector<glVertexElementDesc> elementsDesc(elements.size());
+		std::vector<glVertexElementDesc> elementsDesc;
 
 		unsigned int stride = 0u;
 		for(const auto& element : elements)

Sandbox/imgui.ini

@@ -4,13 +4,13 @@ Size=400,400
 Collapsed=0
 
 [Window][Dear ImGui Demo]
-Pos=276,-1
-Size=521,536
-Collapsed=0
+Pos=-3,0
+Size=524,134
+Collapsed=1
 
 [Window][Dear ImGui Metrics/Debugger]
-Pos=263,318
-Size=346,290
+Pos=-5,16
+Size=525,114
 Collapsed=0
 
 [Table][0xC9935533,3]