feat: rebranding

.github/workflows/main.yml

@@ -1,4 +1,4 @@
-name: Build StarStudio
+name: Build StarEngine
 
 on:
   push:
@@ -16,23 +16,30 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@v4
         with:
-            submodules: recursive
+          submodules: recursive
+          fetch-depth: 0
+
+      - name: Checkout correct commit for GLFW submodule
+        run: |
+          cd StarEngine/vendor/GLFW
+          git fetch origin 9544dde61dc927b5f5d8a3b393e2ede295d3abd4
+          git checkout 9544dde61dc927b5f5d8a3b393e2ede295d3abd4
 
       - name: Set up MSBuild
         uses: microsoft/setup-msbuild@v1.0.2
 
       - uses: abel0b/setup-premake@v2.4
         with:
-            version: "5.0.0-beta4"
+          version: "5.0.0-beta4"
 
       - name: Generate project files with Premake
         run: premake5 vs2022
 
       - name: Build project with MSBuild
-        run: MSBuild /m /p:Configuration=Debug StarStudio.sln
+        run: MSBuild /m /p:Configuration=Debug StarEngine.sln
 
       - name: Upload executable
         uses: actions/upload-artifact@v4
         with:
-          name: StarStudio-Windows
+          name: StarEngine-Windows
           path: "bin/Debug-windows-x86_64/Sandbox/Sandbox.exe"

.gitmodules

@@ -1,12 +1,13 @@
-[submodule "StarStudio/vendor/spdlog"]
-	path = StarStudio/vendor/spdlog
-	url = https://github.com/gabime/spdlog/
-[submodule "StarStudio/vendor/GLFW"]
-	path = StarStudio/vendor/GLFW
-	url = https://github.com/TheCherno/glfw/
-[submodule "StarStudio/vendor/imgui"]
-	path = StarStudio/vendor/imgui
+[submodule "StarEngine/vendor/GLFW"]
+	path = StarEngine/vendor/GLFW
+	url = https://github.com/starbounded-dev/glfw
+[submodule "StarEngine/vendor/spdlog"]
+	path = StarEngine/vendor/spdlog
+	url = https://github.com/gabime/spdlog
+[submodule "StarEngine/vendor/imgui"]
+	path = StarEngine/vendor/imgui
 	url = https://github.com/starbounded-dev/imgui
-[submodule "StarStudio/vendor/glm"]
-	path = StarStudio/vendor/glm
-	url = https://github.com/g-truc/glm
+	branch = docking
+[submodule "StarEngine/vendor/glm"]
+	path = StarEngine/vendor/glm
+	url = https://github.com/g-truc/glm

Sandbox/src/ExampleLayer.cpp

@@ -5,33 +5,33 @@
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtc/type_ptr.hpp>
 
-#include "StarStudio.h"
+#include "StarEngine.h"
 
 ExampleLayer::ExampleLayer()
 	: Layer("ExampleLayer"), m_CameraController(1280.0f / 720.0f)
 {
-	m_VertexArray = StarStudio::VertexArray::Create();
+	m_VertexArray = StarEngine::VertexArray::Create();
 
 	float vertices[3 * 7] = {
 		-0.5f, -0.5f, 0.0f, 0.8f, 0.2f, 0.8f, 1.0f,
 		 0.5f, -0.5f, 0.0f, 0.2f, 0.3f, 0.8f, 1.0f,
 		 0.0f,  0.5f, 0.0f, 0.8f, 0.8f, 0.2f, 1.0f
 	};
 
-	StarStudio::Ref<StarStudio::VertexBuffer> vertexBuffer = StarStudio::VertexBuffer::Create(vertices, sizeof(vertices));
-	StarStudio::BufferLayout layout = {
-		{ StarStudio::ShaderDataType::Float3, "a_Position" },
-		{ StarStudio::ShaderDataType::Float4, "a_Color" }
+	StarEngine::Ref<StarEngine::VertexBuffer> vertexBuffer = StarEngine::VertexBuffer::Create(vertices, sizeof(vertices));
+	StarEngine::BufferLayout layout = {
+		{ StarEngine::ShaderDataType::Float3, "a_Position" },
+		{ StarEngine::ShaderDataType::Float4, "a_Color" }
 	};
 
 	vertexBuffer->SetLayout(layout);
 	m_VertexArray->AddVertexBuffer(vertexBuffer);
 
 	uint32_t indices[3] = { 0, 1, 2 };
-	StarStudio::Ref<StarStudio::IndexBuffer> indexBuffer = StarStudio::IndexBuffer::Create(indices, sizeof(indices) / sizeof(uint32_t));
+	StarEngine::Ref<StarEngine::IndexBuffer> indexBuffer = StarEngine::IndexBuffer::Create(indices, sizeof(indices) / sizeof(uint32_t));
 	m_VertexArray->SetIndexBuffer(indexBuffer);
 
-	m_SquareVA = StarStudio::VertexArray::Create();
+	m_SquareVA = StarEngine::VertexArray::Create();
 
 	float squareVertices[5 * 4] = {
 		-0.5f, -0.5f, 0.0f, 0.0f, 0.0f,
@@ -40,16 +40,16 @@ ExampleLayer::ExampleLayer()
 		-0.5f,  0.5f, 0.0f, 0.0f, 1.0f
 	};
 
-	StarStudio::Ref<StarStudio::VertexBuffer> squareVB = StarStudio::VertexBuffer::Create(squareVertices, sizeof(squareVertices));
+	StarEngine::Ref<StarEngine::VertexBuffer> squareVB = StarEngine::VertexBuffer::Create(squareVertices, sizeof(squareVertices));
 	squareVB->SetLayout({
-		{ StarStudio::ShaderDataType::Float3, "a_Position" },
-		{ StarStudio::ShaderDataType::Float2, "a_TexCoord" }
+		{ StarEngine::ShaderDataType::Float3, "a_Position" },
+		{ StarEngine::ShaderDataType::Float2, "a_TexCoord" }
 		});
 
 	m_SquareVA->AddVertexBuffer(squareVB);
 
 	uint32_t squareIndices[6] = { 0, 1, 2, 2, 3, 0 };
-	StarStudio::Ref<StarStudio::IndexBuffer> squareIB = StarStudio::IndexBuffer::Create(squareIndices, sizeof(squareIndices) / sizeof(uint32_t));
+	StarEngine::Ref<StarEngine::IndexBuffer> squareIB = StarEngine::IndexBuffer::Create(squareIndices, sizeof(squareIndices) / sizeof(uint32_t));
 	m_SquareVA->SetIndexBuffer(squareIB);
 
 	std::string vertexSrc = R"(
@@ -82,7 +82,7 @@ ExampleLayer::ExampleLayer()
 			}
 		)";
 
-	m_Shader = StarStudio::Shader::Create("VertexPosColor", vertexSrc, fragmentSrc);
+	m_Shader = StarEngine::Shader::Create("VertexPosColor", vertexSrc, fragmentSrc);
 	std::string flatColorShaderVertexSrc = R"(
 			#version 330 core
 
@@ -110,11 +110,11 @@ ExampleLayer::ExampleLayer()
 			}
 		)";
 
-	m_FlatColorShader = StarStudio::Shader::Create("FlatColor", flatColorShaderVertexSrc, flatColorShaderFragmentSrc);
+	m_FlatColorShader = StarEngine::Shader::Create("FlatColor", flatColorShaderVertexSrc, flatColorShaderFragmentSrc);
 	auto textureShader = m_ShaderLibrary.Load("assets/shaders/Texture.glsl");
 
-	m_Texture = StarStudio::Texture2D::Create("assets/textures/Checkerboard.png");
-	m_starLogoTexture = StarStudio::Texture2D::Create("assets/textures/starLogo.png");
+	m_Texture = StarEngine::Texture2D::Create("assets/textures/Checkerboard.png");
+	m_starLogoTexture = StarEngine::Texture2D::Create("assets/textures/starLogo.png");
 
 	textureShader->Bind();
 	textureShader->SetInt("u_Texture", 0);
@@ -130,16 +130,16 @@ void ExampleLayer::OnDetach()
 
 }
 
-void ExampleLayer::OnUpdate(StarStudio::Timestep ts)
+void ExampleLayer::OnUpdate(StarEngine::Timestep ts)
 {
 	// Update
 	m_CameraController.OnUpdate(ts);
 
 	// Render
-	StarStudio::RenderCommand::SetClearColor({ 0.1f, 0.1f, 0.1f, 1 });
-	StarStudio::RenderCommand::Clear();
+	StarEngine::RenderCommand::SetClearColor({ 0.1f, 0.1f, 0.1f, 1 });
+	StarEngine::RenderCommand::Clear();
 
-	StarStudio::Renderer::BeginScene(m_CameraController.GetCamera());
+	StarEngine::Renderer::BeginScene(m_CameraController.GetCamera());
 
 	glm::mat4 scale = glm::scale(glm::mat4(1.0f), glm::vec3(0.1f));
 
@@ -152,21 +152,21 @@ void ExampleLayer::OnUpdate(StarStudio::Timestep ts)
 		{
 			glm::vec3 pos(x * 0.11f, y * 0.11f, 0.0f);
 			glm::mat4 transform = glm::translate(glm::mat4(1.0f), pos) * scale;
-			StarStudio::Renderer::Submit(m_FlatColorShader, m_SquareVA, transform);
+			StarEngine::Renderer::Submit(m_FlatColorShader, m_SquareVA, transform);
 		}
 	}
 
 	auto textureShader = m_ShaderLibrary.Get("Texture");
 
 	m_Texture->Bind();
-	StarStudio::Renderer::Submit(textureShader, m_SquareVA, glm::scale(glm::mat4(1.0f), glm::vec3(1.5f)));
+	StarEngine::Renderer::Submit(textureShader, m_SquareVA, glm::scale(glm::mat4(1.0f), glm::vec3(1.5f)));
 	m_starLogoTexture->Bind();
-	StarStudio::Renderer::Submit(textureShader, m_SquareVA, glm::scale(glm::mat4(1.0f), glm::vec3(1.5f)));
+	StarEngine::Renderer::Submit(textureShader, m_SquareVA, glm::scale(glm::mat4(1.0f), glm::vec3(1.5f)));
 
 	// Triangle
 	// Hazel::Renderer::Submit(m_Shader, m_VertexArray);
 
-	StarStudio::Renderer::EndScene();
+	StarEngine::Renderer::EndScene();
 }
 
 void ExampleLayer::OnImGuiRender()
@@ -196,7 +196,7 @@ void ExampleLayer::OnImGuiRender()
 	ImGui::End();
 }
 
-void ExampleLayer::OnEvent(StarStudio::Event& e)
+void ExampleLayer::OnEvent(StarEngine::Event& e)
 {
 	m_CameraController.OnEvent(e);
 }

Sandbox/src/ExampleLayer.h

@@ -1,9 +1,9 @@
 #pragma once
 
-#include "StarStudio.h"
-#include "StarStudio/Renderer/OrthographicCameraController.h"
+#include "StarEngine.h"
+#include "StarEngine/Renderer/OrthographicCameraController.h"
 
-class ExampleLayer : public StarStudio::Layer
+class ExampleLayer : public StarEngine::Layer
 {
 
 public:
@@ -13,19 +13,19 @@ class ExampleLayer : public StarStudio::Layer
 	virtual void OnAttach() override;
 	virtual void OnDetach() override;
 
-	void OnUpdate(StarStudio::Timestep ts) override;
+	void OnUpdate(StarEngine::Timestep ts) override;
 	virtual void OnImGuiRender() override;
-	void OnEvent(StarStudio::Event& e) override;
+	void OnEvent(StarEngine::Event& e) override;
 private:
-	StarStudio::ShaderLibrary m_ShaderLibrary;
-	StarStudio::Ref<StarStudio::Shader> m_Shader;
-	StarStudio::Ref<StarStudio::VertexArray> m_VertexArray;
+	StarEngine::ShaderLibrary m_ShaderLibrary;
+	StarEngine::Ref<StarEngine::Shader> m_Shader;
+	StarEngine::Ref<StarEngine::VertexArray> m_VertexArray;
 
-	StarStudio::Ref<StarStudio::Shader> m_FlatColorShader;
-	StarStudio::Ref<StarStudio::VertexArray> m_SquareVA;
+	StarEngine::Ref<StarEngine::Shader> m_FlatColorShader;
+	StarEngine::Ref<StarEngine::VertexArray> m_SquareVA;
 
-	StarStudio::Ref<StarStudio::Texture2D> m_Texture, m_starLogoTexture;
+	StarEngine::Ref<StarEngine::Texture2D> m_Texture, m_starLogoTexture;
 
-	StarStudio::OrthographicCameraController m_CameraController;
+	StarEngine::OrthographicCameraController m_CameraController;
 	glm::vec3 m_SquareColor = { 0.2f, 0.3f, 0.8f };
 };

Sandbox/src/Sandbox2D.cpp

@@ -15,59 +15,59 @@ Sandbox2D::Sandbox2D()
 
 void Sandbox2D::OnAttach()
 {
-	SS_PROFILE_FUNCTION();
+	SE_PROFILE_FUNCTION();
 
-	m_CheckerboardTexture = StarStudio::Texture2D::Create("assets/textures/Checkerboard.png");
+	m_CheckerboardTexture = StarEngine::Texture2D::Create("assets/textures/Checkerboard.png");
 }
 
 void Sandbox2D::OnDetach()
 {
-	SS_PROFILE_FUNCTION();
+	SE_PROFILE_FUNCTION();
 }
 
-void Sandbox2D::OnUpdate(StarStudio::Timestep ts)
+void Sandbox2D::OnUpdate(StarEngine::Timestep ts)
 {
-	SS_PROFILE_FUNCTION();
+	SE_PROFILE_FUNCTION();
 
 	// Update
 	m_CameraController.OnUpdate(ts);
 	// Render
-	StarStudio::Renderer2D::ResetStats();
+	StarEngine::Renderer2D::ResetStats();
 	{
-		SS_PROFILE_SCOPE("Renderer Prep");
-		StarStudio::RenderCommand::SetClearColor({ 0.1f, 0.1f, 0.1f, 1 });
-		StarStudio::RenderCommand::Clear();
+		SE_PROFILE_SCOPE("Renderer Prep");
+		StarEngine::RenderCommand::SetClearColor({ 0.1f, 0.1f, 0.1f, 1 });
+		StarEngine::RenderCommand::Clear();
 	}
 
 	{
 		static float rotation = 0.0f;
 		rotation += ts * 50.0f;
 
-		SS_PROFILE_SCOPE("Renderer Draw");
-		StarStudio::Renderer2D::BeginScene(m_CameraController.GetCamera());
-		StarStudio::Renderer2D::DrawRotatedQuad({ 1.0f, 0.0f }, { 0.8f, 0.8f }, -45.0f, { 0.8f, 0.2f, 0.3f, 1.0f });
-		StarStudio::Renderer2D::DrawQuad({ -1.0f, 0.0f }, { 0.8f, 0.8f }, { 0.8f, 0.2f, 0.3f, 1.0f });
-		StarStudio::Renderer2D::DrawQuad({ 0.5f, -0.5f }, { 0.5f, 0.75f }, m_SquareColor);
-		StarStudio::Renderer2D::DrawQuad({ 0.0f, 0.0f, -0.1f }, { 20.0f, 20.0f }, m_CheckerboardTexture, 10.0f);
-		StarStudio::Renderer2D::DrawRotatedQuad({ -2.0f, 0.0f, 0.0f }, { 1.0f, 1.0f }, rotation, m_CheckerboardTexture, 20.0f);
-		StarStudio::Renderer2D::EndScene();
+		SE_PROFILE_SCOPE("Renderer Draw");
+		StarEngine::Renderer2D::BeginScene(m_CameraController.GetCamera());
+		StarEngine::Renderer2D::DrawRotatedQuad({ 1.0f, 0.0f }, { 0.8f, 0.8f }, -45.0f, { 0.8f, 0.2f, 0.3f, 1.0f });
+		StarEngine::Renderer2D::DrawQuad({ -1.0f, 0.0f }, { 0.8f, 0.8f }, { 0.8f, 0.2f, 0.3f, 1.0f });
+		StarEngine::Renderer2D::DrawQuad({ 0.5f, -0.5f }, { 0.5f, 0.75f }, m_SquareColor);
+		StarEngine::Renderer2D::DrawQuad({ 0.0f, 0.0f, -0.1f }, { 20.0f, 20.0f }, m_CheckerboardTexture, 10.0f);
+		StarEngine::Renderer2D::DrawRotatedQuad({ -2.0f, 0.0f, 0.0f }, { 1.0f, 1.0f }, rotation, m_CheckerboardTexture, 20.0f);
+		StarEngine::Renderer2D::EndScene();
 
-		StarStudio::Renderer2D::BeginScene(m_CameraController.GetCamera());
+		StarEngine::Renderer2D::BeginScene(m_CameraController.GetCamera());
 		for (float y = -5.0f; y < 5.0f; y += 0.5f)
 		{
 			for (float x = -5.0f; x < 5.0f; x += 0.5f)
 			{
 				glm::vec4 color = { (x + 5.0f) / 10.0f, 0.4f, (y + 5.0f) / 10.0f, 0.7f };
-				StarStudio::Renderer2D::DrawQuad({ x, y }, { 0.45f, 0.45f }, color);
+				StarEngine::Renderer2D::DrawQuad({ x, y }, { 0.45f, 0.45f }, color);
 			}
 		}
-		StarStudio::Renderer2D::EndScene();
+		StarEngine::Renderer2D::EndScene();
 	}
 }
 
 void Sandbox2D::OnImGuiRender()
 {
-	SS_PROFILE_FUNCTION();
+	SE_PROFILE_FUNCTION();
 
 	ImGuiContext& g = *GImGui;
 	ImGuiIO& io = g.IO;
@@ -96,12 +96,12 @@ void Sandbox2D::OnImGuiRender()
 
 	if (ImGui::Checkbox("VSync", &m_VSync)) {
 		// Toggle VSync when the checkbox is clicked
-		StarStudio::Application::Get().GetWindow().SetVSync(m_VSync);
+		StarEngine::Application::Get().GetWindow().SetVSync(m_VSync);
 	}
 
 	ImGui::Text("Settings");
 
-	auto stats = StarStudio::Renderer2D::GetStats();
+	auto stats = StarEngine::Renderer2D::GetStats();
 	ImGui::Text("Renderer2D Stats:");
 	ImGui::Text("Draw Calls: %d", stats.DrawCalls);
 	ImGui::Text("Quads: %d", stats.QuadCount);
@@ -112,7 +112,7 @@ void Sandbox2D::OnImGuiRender()
 
 }
 
-void Sandbox2D::OnEvent(StarStudio::Event& e)
+void Sandbox2D::OnEvent(StarEngine::Event& e)
 {
 	m_CameraController.OnEvent(e);
 }

Sandbox/src/Sandbox2D.h

@@ -1,8 +1,9 @@
 #pragma once
-#include "StarStudio.h"
-#include "StarStudio/Renderer/OrthographicCameraController.h"
 
-class Sandbox2D : public StarStudio::Layer
+#include "StarEngine.h"
+#include "StarEngine/Renderer/OrthographicCameraController.h"
+
+class Sandbox2D : public StarEngine::Layer
 {
 public:
 	Sandbox2D();
@@ -11,19 +12,19 @@ class Sandbox2D : public StarStudio::Layer
 	virtual void OnAttach() override;
 	virtual void OnDetach() override;
 
-	void OnUpdate(StarStudio::Timestep ts) override;
+	void OnUpdate(StarEngine::Timestep ts) override;
 	virtual void OnImGuiRender() override;
-	void OnEvent(StarStudio::Event& e) override;
+	void OnEvent(StarEngine::Event& e) override;
 private:
-	StarStudio::OrthographicCameraController m_CameraController;
+	StarEngine::OrthographicCameraController m_CameraController;
 
 	bool m_VSync = true;
 
 	// Temp
-	StarStudio::Ref<StarStudio::VertexArray> m_SquareVA;
-	StarStudio::Ref<StarStudio::Shader> m_FlatColorShader;
+	StarEngine::Ref<StarEngine::VertexArray> m_SquareVA;
+	StarEngine::Ref<StarEngine::Shader> m_FlatColorShader;
 
-	StarStudio::Ref<StarStudio::Texture2D> m_CheckerboardTexture;
+	StarEngine::Ref<StarEngine::Texture2D> m_CheckerboardTexture;
 
 	glm::vec4 m_SquareColor = { 0.2f, 0.3f, 0.8f, 1.0f };
 };