README.org

@@ -48,5 +48,3 @@ $ cmake .. && make
 - [[https://www.glfw.org/docs/latest/build_guide.html#build_link_cmake_source][Build GLFW using CMake]]
 - [[https://learnopengl.com][Learn OpenGL]]
 - [[https://www.youtube.com/playlist?list=PLlrATfBNZ98dC-V-N3m0Go4deliWHPFwT][Game Engine]] by The Cherno
-- [[https://www.youtube.com/watch?v=mnIQEQoHHCU][OpenGL 3D Game Tutorial 32: Font Rendering]]
-- [[https://youtu.be/d8cfgcJR9Tk][OpenGL 3D Game Tutorial 33: Distance Field Text Rendering]]

assets/glsl/batch-cubemap.frag

@@ -1,49 +0,0 @@
-#version 450 core
-
-layout(location = 0) out vec4 color;
-
-in vec4 v_color;
-in vec3 v_textureCoordinates;
-in flat float v_textureIndex;
-
-uniform samplerCube u_textures[32];
-
-void main()
-{
-	vec4 textureColor = v_color;
-	switch(int(v_textureIndex)) {
-		case 0:  break; // Texture unit 0 is reserved for no texture
-		case 1:  textureColor *= texture(u_textures[1],  v_textureCoordinates); break;
-		case 2:  textureColor *= texture(u_textures[2],  v_textureCoordinates); break;
-		case 3:  textureColor *= texture(u_textures[3],  v_textureCoordinates); break;
-		case 4:  textureColor *= texture(u_textures[4],  v_textureCoordinates); break;
-		case 5:  textureColor *= texture(u_textures[5],  v_textureCoordinates); break;
-		case 6:  textureColor *= texture(u_textures[6],  v_textureCoordinates); break;
-		case 7:  textureColor *= texture(u_textures[7],  v_textureCoordinates); break;
-		case 8:  textureColor *= texture(u_textures[8],  v_textureCoordinates); break;
-		case 9:  textureColor *= texture(u_textures[9],  v_textureCoordinates); break;
-		case 10: textureColor *= texture(u_textures[10], v_textureCoordinates); break;
-		case 11: textureColor *= texture(u_textures[11], v_textureCoordinates); break;
-		case 12: textureColor *= texture(u_textures[12], v_textureCoordinates); break;
-		case 13: textureColor *= texture(u_textures[13], v_textureCoordinates); break;
-		case 14: textureColor *= texture(u_textures[14], v_textureCoordinates); break;
-		case 15: textureColor *= texture(u_textures[15], v_textureCoordinates); break;
-		case 16: textureColor *= texture(u_textures[16], v_textureCoordinates); break;
-		case 17: textureColor *= texture(u_textures[17], v_textureCoordinates); break;
-		case 18: textureColor *= texture(u_textures[18], v_textureCoordinates); break;
-		case 19: textureColor *= texture(u_textures[19], v_textureCoordinates); break;
-		case 20: textureColor *= texture(u_textures[20], v_textureCoordinates); break;
-		case 21: textureColor *= texture(u_textures[21], v_textureCoordinates); break;
-		case 22: textureColor *= texture(u_textures[22], v_textureCoordinates); break;
-		case 23: textureColor *= texture(u_textures[23], v_textureCoordinates); break;
-		case 24: textureColor *= texture(u_textures[24], v_textureCoordinates); break;
-		case 25: textureColor *= texture(u_textures[25], v_textureCoordinates); break;
-		case 26: textureColor *= texture(u_textures[26], v_textureCoordinates); break;
-		case 27: textureColor *= texture(u_textures[27], v_textureCoordinates); break;
-		case 28: textureColor *= texture(u_textures[28], v_textureCoordinates); break;
-		case 29: textureColor *= texture(u_textures[29], v_textureCoordinates); break;
-		case 30: textureColor *= texture(u_textures[30], v_textureCoordinates); break;
-		case 31: textureColor *= texture(u_textures[31], v_textureCoordinates); break;
-	}
-	color = textureColor;
-}

assets/glsl/batch-cubemap.vert

@@ -1,20 +0,0 @@
-#version 450 core
-
-layout(location = 0) in vec3 a_position;
-layout(location = 1) in vec4 a_color;
-layout(location = 2) in float a_textureIndex;
-
-out vec4 v_color;
-out vec3 v_textureCoordinates;
-out flat float v_textureIndex;
-
-uniform mat4 u_projectionView;
-
-void main()
-{
-	v_color = a_color;
-	v_textureCoordinates = a_position;
-	v_textureIndex = a_textureIndex;
-	// Vclip = Camera projection * Camera view * Model transform * Vlocal
-	gl_Position = u_projectionView * vec4(a_position, 1.0f);
-}

assets/scene/scene1.json

@@ -1,111 +1,50 @@
 {
 	"init": "assets/lua/scene1-init.lua",
-	"entities": [
+	"camera": {
-		{
+		"name": "Camera",
-			"id": { "id": 12312312 },
-			"tag": { "tag": "Camera" },
-			"transform" : {
 		"translate": [ 0.0, 0.0, 1.0 ],
 		"rotate": [ 0.0, 0.0, -1.0 ],
-				"scale": [1.0, 1.0, 1.0]
+		"scale": [ 1.0, 1.0, 1.0 ],
-			},
+		"type": "perspective",
-			"camera": { "type": "perspective" },
+		"script": {
-			"lua-scripts": [
+			"type": "lua",
-				{ "path": "assets/lua/cameracontroller.lua" }
+			"name": "assets/lua/cameracontroller.lua"
-			]
-		},
-		{
-			"id": { "id": 212563732 },
-			"tag": { "tag": "Skybox" },
-			"transform" : {
-				"translate": [0.0, 0.0, 0.0],
-				"rotate": [0.0, 0.0, 0.0],
-				"scale": [100.0, 100.0, 100.0]
-			},
-			"cubemap": {
-				"color": [ 1.0, 1.0, 1.0, 1.0 ],
-				"texture": "assets/gfx/skybox.jpg"
 		}
 	},
+	"quad": [
 		{
-			"id": { "id": 564564564 },
+			"name": "Quad",
-			"tag": { "tag": "Quad" },
-			"transform" : {
 			"translate": [ 0.0, 0.0, 0.0 ],
 			"rotate": [ 0.0, 0.0, 0.0 ],
-				"scale": [ 1.0, 1.0, 1.0 ]
+			"scale": [ 1.0, 1.0, 1.0 ],
-			},
-			"sprite": {
 			"color": [ 1.0, 1.0, 1.0, 1.0 ],
 			"texture": "assets/gfx/test.png"
-			}
 		},
 		{
-			"id": { "id": 97897897 },
+			"name": "Quad 2",
-			"tag": { "tag": "Quad 2" },
-			"transform" : {
 			"translate": [ 1.1, 0.0, 0.0 ],
 			"rotate": [ 0.0, 0.0, 0.0 ],
-				"scale": [ 1.0, 1.0, 1.0 ]
+			"scale": [ 1.0, 1.0, 1.0 ],
-			},
-			"sprite": {
 			"color": [ 0.5, 0.6, 0.8, 1.0 ],
 			"texture": "assets/gfx/test.png"
-			}
-		},
-		{
-			"id": { "id": 3424242 },
-			"tag": { "tag": "Quad 3" },
-			"transform" : {
-				"translate": [ 2.2, 1.0, 0.0 ],
-				"rotate": [ 0.0, 0.0, -20.0 ],
-				"scale": [ 1.0, 1.0, 1.0 ]
 		},
-			"sprite": {
-				"color": [ 1.0, 1.0, 1.0, 1.0 ],
-				"texture": "assets/gfx/test-inverted.png"
-			},
-			"children": [
 		{
-					"id": { "id": 4345472 },
+			"name": "Quad 3",
-					"tag": { "tag": "Quad 4" },
+			"translate": [ 2.2, 0.0, 0.0 ],
-					"transform" : {
-						"translate": [ 0.85, 0.0, 0.0 ],
 			"rotate": [ 0.0, 0.0, 0.0 ],
-						"scale": [ 0.5, 0.5, 1.0 ]
+			"scale": [ 1.0, 1.0, 1.0 ],
-					},
-					"sprite": {
 			"color": [ 1.0, 1.0, 1.0, 1.0 ],
 			"texture": "assets/gfx/test-inverted.png"
-					},
-					"children": [
-						{
-							"id": { "id": 5234723 },
-							"tag": { "tag": "Quad 5" },
-							"transform" : {
-								"translate": [ 1.0, 0.0, 0.0 ],
-								"rotate": [ 0.0, 0.0, -20.0 ],
-								"scale": [ 0.5, 0.5, 1.0 ]
-							},
-							"sprite": {
-								"color": [ 1.0, 1.0, 1.0, 1.0 ],
-								"texture": "assets/gfx/test-inverted.png"
-							}
-						}
-					]
 		}
-			]
+	],
-		},
+	"text": [
 		{
-			"id": { "id": 675754 },
+			"name": "Text",
-			"tag": { "tag": "Text" },
-			"text": {
 			"content": "Hello World!",
 			"font": "assets/fnt/open-sans",
 			"font-size": 24,
 			"line-spacing": 1.0,
 			"width": 150
 		}
-		}
 	]
 }

src/inferno/application.cpp

@@ -1,11 +1,9 @@
 /*
- * Copyright (C) 2022,2024 Riyyi
+ * Copyright (C) 2022 Riyyi
  *
  * SPDX-License-Identifier: MIT
  */
 
-#include <utility> // std::pair
-
 #include "glm/gtc/type_ptr.hpp" // glm::make_mat4
 #include "ruc/format/log.h"
 #include "ruc/meta/assert.h"
@@ -80,7 +78,6 @@ Application::~Application()
 	FontManager::destroy();
 	RendererCharacter::destroy();
 	Renderer2D::destroy();
-	RendererCubemap::destroy();
 	RenderCommand::destroy();
 	TextureManager::destroy();
 	ShaderManager::destroy();
@@ -167,15 +164,12 @@ int Application::run()
 		RenderCommand::clearColor({ 0.2f, 0.3f, 0.3f, 1.0f });
 		RenderCommand::clear();
 
-		std::pair<glm::mat4, glm::mat4> projectionView = m_scene->cameraProjectionView();
+		Renderer2D::the().beginScene(m_scene->cameraProjectionView()); // camera, lights, environment
-		RendererCubemap::the().beginScene(projectionView.first, projectionView.second); // camera, lights, environment
-		Renderer2D::the().beginScene(projectionView.first, projectionView.second);      // camera, lights, environment
 		RendererCharacter::the().beginScene();
 
 		m_scene->render();
 		// RendererCharacter::the().drawCharacter(character, f->texture());
 
-		RendererCubemap::the().endScene();
 		Renderer2D::the().endScene();
 		RendererCharacter::the().endScene();
 

src/inferno/component/cameracomponent.cpp

@@ -1,26 +0,0 @@
-/*
- * Copyright (C) 2023 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#include "ruc/format/print.h"
-#include "ruc/json/json.h"
-
-#include "inferno/component/cameracomponent.h"
-
-namespace Inferno {
-
-void fromJson(const ruc::Json& json, CameraComponent& value)
-{
-	VERIFY(json.type() == ruc::Json::Type::Object);
-
-	if (json.exists("type")) {
-		value.type = json.at("type").get<std::string>() == "orthographic" ? CameraType::Orthographic : CameraType::Perspective;
-	}
-	if (json.exists("zoom-level")) {
-		json.at("zoom-level").getTo(value.zoomLevel);
-	}
-}
-
-} // namespace Inferno

src/inferno/component/cameracomponent.h

@@ -8,7 +8,6 @@
 
 #include "glm/ext/matrix_float4x4.hpp" // glm::mat4
 #include "glm/ext/vector_float3.hpp"   // glm::vec3
-#include "ruc/json/json.h"
 
 namespace Inferno {
 
@@ -33,6 +32,4 @@ struct CameraComponent {
 	glm::mat4 projection { 1.0f }; // Identity matrix
 };
 
-void fromJson(const ruc::Json& json, CameraComponent& value);
-
 } // namespace Inferno

src/inferno/component/cubemap-component.cpp

@@ -1,27 +0,0 @@
-/*
- * Copyright (C) 2024 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#include "ruc/json/json.h"
-
-#include "inferno/component/cubemap-component.h"
-#include "inferno/component/spritecomponent.h" // TODO: Move glm::x toJson/fromJson to separate file
-#include "inferno/render/texture.h"
-
-namespace Inferno {
-
-void fromJson(const ruc::Json& json, CubemapComponent& value)
-{
-	VERIFY(json.type() == ruc::Json::Type::Object);
-
-	if (json.exists("color")) {
-		json.at("color").getTo(value.color);
-	}
-	if (json.exists("texture") && json.at("texture").type() == ruc::Json::Type::String) {
-		value.texture = TextureManager::the().load(json.at("texture").asString(), Texture::Type::Cubemap);
-	}
-}
-
-} // namespace Inferno

src/inferno/component/cubemap-component.h

@@ -1,25 +0,0 @@
-/*
- * Copyright (C) 2024 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#pragma once
-
-#include <memory> // std::shared_ptr
-
-#include "glm/ext/vector_float4.hpp" // glm::vec4
-#include "ruc/json/json.h"
-
-#include "inferno/render/texture.h"
-
-namespace Inferno {
-
-struct CubemapComponent {
-	glm::vec4 color { 1.0f };
-	std::shared_ptr<Texture> texture;
-};
-
-void fromJson(const ruc::Json& json, CubemapComponent& value);
-
-} // namespace Inferno

src/inferno/component/id-component.cpp

@@ -1,22 +0,0 @@
-/*
- * Copyright (C) 2023 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#include "ruc/json/json.h"
-
-#include "inferno/component/id-component.h"
-
-namespace Inferno {
-
-void fromJson(const ruc::Json& json, IDComponent& value)
-{
-	VERIFY(json.type() == ruc::Json::Type::Object);
-
-	if (json.exists("id")) {
-		json.at("id").getTo(value.id);
-	}
-}
-
-} // namespace Inferno

src/inferno/component/id-component.h

@@ -1,28 +0,0 @@
-/*
- * Copyright (C) 2023 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#pragma once
-
-#include "ruc/json/json.h"
-
-#include "inferno/uid.h"
-
-namespace Inferno {
-
-struct IDComponent {
-	UID id;
-
-	IDComponent() = default;
-	IDComponent(UID id)
-		: id(id)
-	{
-	}
-	IDComponent(const IDComponent&) = default;
-};
-
-void fromJson(const ruc::Json& json, IDComponent& value);
-
-} // namespace Inferno

src/inferno/component/luascriptcomponent.cpp

@@ -1,21 +0,0 @@
-/*
- * Copyright (C) 2023 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#include "ruc/json/json.h"
-
-#include "inferno/component/luascriptcomponent.h"
-
-namespace Inferno {
-
-void fromJson(const ruc::Json& json, LuaScriptComponent& value)
-{
-	VERIFY(json.type() == ruc::Json::Type::Object);
-
-	VERIFY(json.exists("path"), "path not found");
-	json.at("path").getTo(value.path);
-}
-
-} // namespace Inferno

src/inferno/component/luascriptcomponent.h

@@ -6,11 +6,9 @@
 
 #pragma once
 
-#include <string>
+#include <string>  // std::string
 #include <utility> // std::move
 
-#include "ruc/json/json.h"
-
 namespace Inferno {
 
 class LuaScript;
@@ -26,7 +24,4 @@ struct LuaScriptComponent {
 	{
 	}
 };
-
-void fromJson(const ruc::Json& json, LuaScriptComponent& value);
-
 } // namespace Inferno

src/inferno/component/nativescriptcomponent.cpp

@@ -1,21 +0,0 @@
-/*
- * Copyright (C) 2023 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#include "ruc/json/json.h"
-
-#include "inferno/component/nativescriptcomponent.h"
-
-namespace Inferno {
-
-void fromJson(const ruc::Json& json, NativeScriptComponent& value)
-{
-	VERIFY(json.type() == ruc::Json::Type::Object);
-
-	VERIFY(json.exists("name"), "name not found");
-	json.at("name").getTo(value.name);
-}
-
-} // namespace Inferno

src/inferno/component/nativescriptcomponent.h

@@ -7,7 +7,6 @@
 #pragma once
 
 #include <string>
-#include <utility> // std::move
 
 #include "inferno/script/nativescript.h"
 
@@ -15,29 +14,17 @@ namespace Inferno {
 
 struct NativeScriptComponent {
 	NativeScript* instance { nullptr };
-	std::string name;
 
 	NativeScript::InitializeFunction initialize { nullptr };
 	NativeScript::DestroyFunction destroy { nullptr };
 
 	// Dont allow manually setting instance during construction
 	NativeScriptComponent() {}
-	NativeScriptComponent(const std::string& name)
+	NativeScriptComponent(const std::string& binding)
-		: name(std::move(name))
 	{
-		bind();
+		initialize = NativeScriptBinding::the().initializeBinding(binding);
-	}
+		destroy = NativeScriptBinding::the().destroyBinding(binding);
-
-	void bind()
-	{
-		VERIFY(initialize == nullptr && destroy == nullptr, "NativeScript already bound");
-
-		VERIFY(name != "", "name not set");
-		initialize = NativeScriptBinding::the().initializeBinding(name);
-		destroy = NativeScriptBinding::the().destroyBinding(name);
 	}
 };
 
-void fromJson(const ruc::Json& json, NativeScriptComponent& value);
-
 } // namespace Inferno

src/inferno/component/tagcomponent.cpp

@@ -1,22 +0,0 @@
-/*
- * Copyright (C) 2023 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#include "ruc/json/json.h"
-
-#include "inferno/component/tagcomponent.h"
-
-namespace Inferno {
-
-void fromJson(const ruc::Json& json, TagComponent& value)
-{
-	VERIFY(json.type() == ruc::Json::Type::Object);
-
-	if (json.exists("tag")) {
-		json.at("tag").getTo(value.tag);
-	}
-}
-
-} // namespace Inferno

src/inferno/component/tagcomponent.h

@@ -9,8 +9,6 @@
 #include <string>  // std::string
 #include <utility> // std::move
 
-#include "ruc/json/json.h"
-
 namespace Inferno {
 
 struct TagComponent {
@@ -25,6 +23,4 @@ struct TagComponent {
 	operator const std::string&() const { return tag; }
 };
 
-void fromJson(const ruc::Json& json, TagComponent& value);
-
 } // namespace Inferno

src/inferno/component/textareacomponent.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2024 Riyyi
+ * Copyright (C) 2022 Riyyi
  *
  * SPDX-License-Identifier: MIT
  */
@@ -18,7 +18,7 @@ namespace Inferno {
 struct TextAreaComponent {
 	std::string content;
 	std::string font;
-	unsigned char fontSize { 12 };
+	unsigned char fontSize { 0 };
 	float lineSpacing { 1.0f };
 	uint32_t width { 0 };
 

src/inferno/component/transformcomponent.h

@@ -1,16 +1,11 @@
 /*
- * Copyright (C) 2022,2024 Riyyi
+ * Copyright (C) 2022 Riyyi
  *
  * SPDX-License-Identifier: MIT
  */
 
 #pragma once
 
-#include <cstdint> // uint32_t
-#include <optional>
-
-#include "entt/entity/entity.hpp"      // entt::null
-#include "entt/entity/fwd.hpp"         // entt::entity
 #include "glm/ext/matrix_float4x4.hpp" // glm::mat4
 #include "glm/ext/vector_float3.hpp"   // glm::vec3
 #include "ruc/format/format.h"
@@ -22,8 +17,6 @@ struct TransformComponent {
 	glm::vec3 translate { 0.0f, 0.0f, 0.0f };
 	glm::vec3 rotate { 0.0f, 0.0f, 0.0f };
 	glm::vec3 scale { 1.0f, 1.0f, 1.0f };
-	entt::entity parent { entt::null };
-
 	glm::mat4 transform { 1.0f }; // Identity matrix
 };
 

src/inferno/render/font.cpp

@@ -32,7 +32,7 @@ Font::Font(const std::string& name)
 	std::string font = ruc::File(path).data();
 	parseFont(font);
 
-	m_texture = Texture2D::create(image);
+	m_texture = std::make_shared<Texture>(image);
 }
 
 // TODO: Move this to ruc

src/inferno/render/renderer.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022,2024 Riyyi
+ * Copyright (C) 2022 Riyyi
  *
  * SPDX-License-Identifier: MIT
  */
@@ -216,10 +216,10 @@ Renderer2D::~Renderer2D()
 	Renderer::destroy();
 }
 
-void Renderer2D::beginScene(glm::mat4 cameraProjection, glm::mat4 cameraView)
+void Renderer2D::beginScene(glm::mat4 cameraProjectionView)
 {
 	m_shader->bind();
-	m_shader->setFloat("u_projectionView", cameraProjection * cameraView);
+	m_shader->setFloat("u_projectionView", cameraProjectionView);
 	m_shader->unbind();
 }
 
@@ -311,184 +311,6 @@ void Renderer2D::nextBatch()
 
 // -----------------------------------------
 
-RendererCubemap::RendererCubemap(s)
-{
-	Renderer::initialize();
-
-	// CPU
-	// ---------------------------------
-
-	// Create array for storing quads vertices
-	m_vertexBufferBase = std::make_unique<CubemapVertex[]>(vertexCount);
-	m_vertexBufferPtr = m_vertexBufferBase.get();
-
-	// Set default cubemap vertex positions
-
-	// Back face - v
-	m_vertexPositions[0] = { 0.5f, -0.5f, 0.5f, 1.0f };
-	m_vertexPositions[1] = { -0.5f, -0.5f, 0.5f, 1.0f };
-	m_vertexPositions[2] = { -0.5f, 0.5f, 0.5f, 1.0f };
-	m_vertexPositions[3] = { 0.5f, 0.5f, 0.5f, 1.0f };
-
-	// Left face - v
-	m_vertexPositions[7] = { -0.5f, 0.5f, 0.5f, 1.0f };
-	m_vertexPositions[6] = { -0.5f, 0.5f, -0.5f, 1.0f };
-	m_vertexPositions[5] = { -0.5f, -0.5f, -0.5f, 1.0f };
-	m_vertexPositions[4] = { -0.5f, -0.5f, 0.5f, 1.0f };
-
-	// Right face - v
-	m_vertexPositions[8] = { 0.5f, -0.5f, -0.5f, 1.0f };
-	m_vertexPositions[9] = { 0.5f, -0.5f, 0.5f, 1.0f };
-	m_vertexPositions[10] = { 0.5f, 0.5f, 0.5f, 1.0f };
-	m_vertexPositions[11] = { 0.5f, 0.5f, -0.5f, 1.0f };
-
-	// Front face - v
-	m_vertexPositions[12] = { -0.5f, -0.5f, -0.5f, 1.0f };
-	m_vertexPositions[13] = { 0.5f, -0.5f, -0.5f, 1.0f };
-	m_vertexPositions[14] = { 0.5f, 0.5f, -0.5f, 1.0f };
-	m_vertexPositions[15] = { -0.5f, 0.5f, -0.5f, 1.0f };
-
-	// Top face
-	m_vertexPositions[16] = { -0.5f, 0.5f, -0.5f, 1.0f };
-	m_vertexPositions[17] = { 0.5f, 0.5f, -0.5f, 1.0f };
-	m_vertexPositions[18] = { 0.5f, 0.5f, 0.5f, 1.0f };
-	m_vertexPositions[19] = { -0.5f, 0.5f, 0.5f, 1.0f };
-
-	// Bottom face
-	m_vertexPositions[20] = { -0.5f, -0.5f, -0.5f, 1.0f };
-	m_vertexPositions[21] = { -0.5f, -0.5f, 0.5f, 1.0f };
-	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
-	// ---------------------------------
-
-	// Create vertex buffer
-	auto vertexBuffer = std::make_shared<VertexBuffer>(sizeof(CubemapVertex) * vertexCount);
-	vertexBuffer->setLayout({
-		{ BufferElementType::Vec3, "a_position" },
-		{ BufferElementType::Vec4, "a_color" },
-		{ BufferElementType::Float, "a_textureIndex" },
-	});
-	m_vertexArray->addVertexBuffer(vertexBuffer);
-
-	// Create index buffer
-	auto indexBuffer = std::make_shared<IndexBuffer>(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.
-	// Set the translation of the camera's view matrix to 0, meaning:
-	// x x x 0
-	// x x x 0
-	// x x x 0
-	// 0 0 0 1
-	cameraView = glm::mat4(glm::mat3(cameraView));
-
-	m_shader->bind();
-	m_shader->setFloat("u_projectionView", cameraProjection * cameraView);
-	m_shader->unbind();
-}
-
-void RendererCubemap::endScene()
-{
-	nextBatch();
-}
-
-void RendererCubemap::drawCubemap(const TransformComponent& transform, glm::vec4 color, std::shared_ptr<Texture> texture)
-{
-	drawCubemap(transform, glm::mat4(color, color, color, color), texture);
-}
-
-void RendererCubemap::drawCubemap(const TransformComponent& transform, glm::mat4 color, std::shared_ptr<Texture> texture)
-{
-	// Create a new batch if the quad limit has been reached
-	if (m_quadIndex >= quadCount) {
-		nextBatch();
-	}
-
-	uint32_t textureUnitIndex = addTextureUnit(texture);
-
-	// Add the quads 4 vertices
-	for (uint32_t i = 0; i < vertexPerQuad * quadPerCube; i++) {
-		m_vertexBufferPtr->position = transform.transform * m_vertexPositions[i];
-		m_vertexBufferPtr->color = color[i % 4];
-		m_vertexBufferPtr->textureIndex = (float)textureUnitIndex;
-		m_vertexBufferPtr++;
-	}
-
-	m_quadIndex += quadPerCube;
-}
-
-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)
 {
 	Renderer::initialize();

src/inferno/render/renderer.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022,2024 Riyyi
+ * Copyright (C) 2022 Riyyi
  *
  * SPDX-License-Identifier: MIT
  */
@@ -27,13 +27,7 @@ struct QuadVertex {
 	glm::vec3 position { 0.0f, 0.0f, 0.0f };
 	glm::vec4 color { 1.0f, 1.0f, 1.0f, 1.0f };
 	glm::vec2 textureCoordinates { 0.0f, 0.0f };
-	float textureIndex = 0; // TODO: get int to pass to fragment correctly
+	float textureIndex = 0; // @Todo get int to pass to fragment correctly
-};
-
-struct CubemapVertex {
-	glm::vec3 position { 0.0f, 0.0f, 0.0f };
-	glm::vec4 color { 1.0f, 1.0f, 1.0f, 1.0f };
-	float textureIndex = 0; // TODO: get int to pass to fragment correctly
 };
 
 struct CharacterVertex {
@@ -72,10 +66,9 @@ public:
 
 class Renderer {
 public:
-	static constexpr const uint32_t vertexPerQuad = 4;
+	static const uint32_t vertexPerQuad = 4;
-	static constexpr const uint32_t indexPerQuad = 6;
+	static const uint32_t indexPerQuad = 6;
-	static constexpr const uint32_t quadPerCube = 6;
+	static const uint32_t textureUnitPerBatch = 32;
-	static constexpr const uint32_t textureUnitPerBatch = 32;
 
 protected:
 	Renderer() {}
@@ -115,12 +108,11 @@ public:
 
 	using Singleton<Renderer2D>::destroy;
 
-	// When to start a new batch
+	static const uint32_t quadCount = 1000;
-	static constexpr const uint32_t quadCount = 1000;
+	static const uint32_t vertexCount = quadCount * vertexPerQuad;
-	static constexpr const uint32_t vertexCount = quadCount * vertexPerQuad;
+	static const uint32_t indexCount = quadCount * indexPerQuad;
-	static constexpr const uint32_t indexCount = quadCount * indexPerQuad;
 
-	void beginScene(glm::mat4 cameraProjectionView, glm::mat4 cameraView);
+	void beginScene(glm::mat4 cameraProjectionView);
 	void endScene();
 
 	void drawQuad(const TransformComponent& transform, glm::vec4 color);
@@ -141,42 +133,6 @@ private:
 	// Default quad vertex positions
 	glm::vec4 m_vertexPositions[vertexPerQuad];
 };
-// -------------------------------------
-
-class RendererCubemap final
-	: public Renderer
-	, public ruc::Singleton<RendererCubemap> {
-public:
-	RendererCubemap(s);
-	virtual ~RendererCubemap();
-
-	using Singleton<RendererCubemap>::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();
-
-	void drawCubemap(const TransformComponent& transform, glm::vec4 color, std::shared_ptr<Texture> texture);
-	void drawCubemap(const TransformComponent& transform, glm::mat4 color, std::shared_ptr<Texture> texture);
-
-private:
-	void loadShader() override;
-	void flush() override;
-	void startBatch() override;
-	void nextBatch() override;
-
-	// CPU quad vertices
-	std::unique_ptr<CubemapVertex[]> m_vertexBufferBase;
-	CubemapVertex* m_vertexBufferPtr { nullptr };
-
-	// Default cubemap vertex positions
-	glm::vec4 m_vertexPositions[vertexPerQuad * quadPerCube];
-};
 
 // -------------------------------------
 

src/inferno/render/texture.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022,2024 Riyyi
+ * Copyright (C) 2022 Riyyi
  *
  * SPDX-License-Identifier: MIT
  */
@@ -19,47 +19,36 @@
 
 namespace Inferno {
 
-Texture::~Texture()
+Texture::Texture(const std::string& path)
-{
+	: m_path(std::move(path))
-	glDeleteTextures(1, &m_id);
-}
-
-void Texture::init(uint32_t width, uint32_t height, uint8_t channels)
-{
-	m_width = width;
-	m_height = height;
-
-	m_internalFormat = (channels == 3) ? GL_RGB8 : GL_RGBA8;
-	m_dataFormat = (channels == 3) ? GL_RGB : GL_RGBA;
-}
-
-// -----------------------------------------
-
-std::shared_ptr<Texture> Texture2D::create(const std::string& path)
 {
-	auto result = std::shared_ptr<Texture2D>(new Texture2D);
+	unsigned char* data = nullptr;
-	result->m_path = path;
-
 	int width = 0;
 	int height = 0;
 	int channels = 0;
-	unsigned char* data = nullptr;
 
 	// Load image data
 	stbi_set_flip_vertically_on_load(1);
 	data = stbi_load(path.c_str(), &width, &height, &channels, STBI_default);
 	VERIFY(data, "failed to load image: '{}'", path);
 
-	result->init(width, height, channels);
+	init(data, width, height, channels);
-	result->create(data);
 
 	// Clean resources
 	stbi_image_free(data);
+}
+
+Texture::Texture(unsigned char* data, uint32_t width, uint32_t height, uint8_t channels)
+{
+	init(data, width, height, channels);
+}
 
-	return result;
+Texture::~Texture()
+{
+	glDeleteTextures(1, &m_id);
 }
 
-void Texture2D::bind(uint32_t unit) const
+void Texture::bind(uint32_t unit) const
 {
 	// Set active unit
 	glActiveTexture(GL_TEXTURE0 + unit);
@@ -70,12 +59,31 @@ void Texture2D::bind(uint32_t unit) const
 	glActiveTexture(GL_TEXTURE0);
 }
 
-void Texture2D::unbind() const
+void Texture::unbind() const
 {
 	glBindTexture(GL_TEXTURE_2D, 0);
 }
 
-void Texture2D::create(unsigned char* data)
+// -----------------------------------------
+
+void Texture::init(unsigned char* data, uint32_t width, uint32_t height, uint8_t channels)
+{
+	m_width = width;
+	m_height = height;
+
+	if (channels == 4) {
+		m_internalFormat = GL_RGBA8;
+		m_dataFormat = GL_RGBA;
+	}
+	else if (channels == 3) {
+		m_internalFormat = GL_RGB8;
+		m_dataFormat = GL_RGB;
+	}
+
+	create(data);
+}
+
+void Texture::create(unsigned char* data)
 {
 	m_id = UINT_MAX;
 
@@ -101,10 +109,10 @@ void Texture2D::create(unsigned char* data)
 		data);             // Image data
 
 	// Set the texture wrapping / filtering options
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); // Magnify
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); // Minify
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);      // X
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);      // Y
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); // Minify
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); // Magnify
 
 	// Automatically generate all mipmap levels
 	glGenerateMipmap(GL_TEXTURE_2D);
@@ -115,94 +123,6 @@ void Texture2D::create(unsigned char* data)
 
 // -----------------------------------------
 
-std::shared_ptr<Texture> TextureCubemap::create(const std::string& path)
-{
-	auto result = std::shared_ptr<TextureCubemap>(new TextureCubemap);
-	result->m_path = path;
-
-	result->create();
-
-	return result;
-}
-
-void TextureCubemap::bind(uint32_t unit) const
-{
-	// Set active unit
-	glActiveTexture(GL_TEXTURE0 + unit);
-
-	glBindTexture(GL_TEXTURE_CUBE_MAP, m_id);
-
-	// Reset unit
-	glActiveTexture(GL_TEXTURE0);
-}
-
-void TextureCubemap::unbind() const
-{
-	glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
-}
-
-void TextureCubemap::create()
-{
-	m_id = UINT_MAX;
-
-	// Create texture object
-	glGenTextures(1, &m_id);
-
-	// Bind texture object
-	glBindTexture(GL_TEXTURE_CUBE_MAP, m_id);
-
-	// Set unpacking of pixel data to byte-alignment,
-	// this prevents alignment issues when using a single byte for color
-	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-
-	stbi_set_flip_vertically_on_load(0);
-
-	static constexpr const char* cubemapPaths[6] { "-px", "-nx", "-py", "-ny", "-pz", "-nz" };
-	size_t dotIndex = m_path.find_last_of('.');
-	std::string path = m_path.substr(0, dotIndex);
-	std::string extension = m_path.substr(dotIndex);
-
-	int width = 0;
-	int height = 0;
-	int channels = 0;
-	unsigned char* data = nullptr;
-	for (size_t i = 0; i < 6; ++i) {
-		std::string facePath = path + cubemapPaths[i] + extension;
-
-		// Load image data
-		data = stbi_load(facePath.c_str(), &width, &height, &channels, STBI_default);
-		VERIFY(data, "failed to load image: '{}'", facePath.c_str());
-
-		init(width, height, channels);
-
-		// Generate texture face
-		glTexImage2D(
-			GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, // Texture target
-			0,                                  // Midmap level, base starts at level 0
-			m_internalFormat,                   // Internal format
-			m_width, m_height,                  // Image width/height
-			0,                                  // Always 0 (legacy)
-			m_dataFormat,                       // Texture source format
-			GL_UNSIGNED_BYTE,                   // Texture source datatype
-			data);                              // Image data
-
-		// Clean resources
-		stbi_image_free(data);
-	}
-
-	// Set the texture wrapping / filtering options
-	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);    // Magnify
-	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);    // Minify
-	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); // X
-	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); // Y
-	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); // Z
-
-	// Unbind texture object
-	glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
-}
-
-// -----------------------------------------
-
 TextureManager::TextureManager(s)
 {
 	ruc::info("TextureManager initialized");
@@ -218,16 +138,15 @@ void TextureManager::add(const std::string& path, std::shared_ptr<Texture> textu
 	m_textureList.emplace(std::move(path), std::move(texture));
 }
 
-std::shared_ptr<Texture> TextureManager::load(const std::string& path, Texture::Type type)
+std::shared_ptr<Texture> TextureManager::load(const std::string& path)
 {
 	if (exists(path)) {
 		return get(path);
 	}
 
-	auto texture = (type == Texture::TwoDimensional) ? Texture2D::create(path) : TextureCubemap::create(path);
+	std::shared_ptr<Texture> texture = std::make_shared<Texture>(path);
 	add(path, texture);
-
+	return get(path);
-	return texture;
 }
 
 std::shared_ptr<Texture> TextureManager::get(const std::string& path)

src/inferno/render/texture.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022,2024 Riyyi
+ * Copyright (C) 2022 Riyyi
  *
  * SPDX-License-Identifier: MIT
  */
@@ -15,88 +15,33 @@
 
 namespace Inferno {
 
-class Texture2D;
-class TextureCubemap;
-
 class Texture {
 public:
+	Texture(const std::string& path);
+	Texture(unsigned char* data, uint32_t width, uint32_t height, uint8_t channels = 3);
 	virtual ~Texture();
 
-	enum Type : uint8_t {
+	void bind(uint32_t unit = 0) const;
-		TwoDimensional = 0,
+	void unbind() const;
-		Cubemap,
-	};
-
-	void init(uint32_t width, uint32_t height, uint8_t channels);
-
-	virtual void bind(uint32_t unit = 0) const = 0;
-	virtual void unbind() const = 0;
 
-	std::string path() const { return m_path; }
+	inline std::string path() const { return m_path; }
-	uint32_t width() const { return m_width; }
+	inline uint32_t width() const { return m_width; }
-	uint32_t height() const { return m_height; }
+	inline uint32_t height() const { return m_height; }
-	uint32_t id() const { return m_id; }
+	inline uint32_t id() const { return m_id; }
-	uint32_t internalFormat() const { return m_internalFormat; }
+	inline uint32_t internalFormat() const { return m_internalFormat; }
-	uint32_t dataFormat() const { return m_dataFormat; }
+	inline uint32_t dataFormat() const { return m_dataFormat; }
-
-	virtual bool is2D() const { return false; }
-	virtual bool isCubeMap() const { return false; }
-
-	friend Texture2D;
-	friend TextureCubemap;
-
-protected:
-	Texture() {}
 
 protected:
-	std::string m_path;
+	void init(unsigned char* data, uint32_t width, uint32_t height, uint8_t channels);
-	uint32_t m_width { 0 };
-	uint32_t m_height { 0 };
-	uint32_t m_id { 0 };
-	uint32_t m_internalFormat { 0 };
-	uint32_t m_dataFormat { 0 };
-};
-
-// -------------------------------------
-
-class Texture2D final : public Texture {
-public:
-	virtual ~Texture2D() = default;
-
-	// Factory function
-	static std::shared_ptr<Texture> create(const std::string& path);
-
-	virtual void bind(uint32_t unit = 0) const override;
-	virtual void unbind() const override;
-
-private:
-	Texture2D() {}
-
-	virtual bool is2D() const override { return true; }
-
-private:
 	void create(unsigned char* data);
-};
-
-// -------------------------------------
-
-class TextureCubemap final : public Texture {
-public:
-	virtual ~TextureCubemap() = default;
-
-	// Factory function
-	static std::shared_ptr<Texture> create(const std::string& path);
-
-	virtual void bind(uint32_t unit = 0) const override;
-	virtual void unbind() const override;
 
 private:
-	TextureCubemap() {};
+	std::string m_path;
-
+	uint32_t m_width;
-	virtual bool isCubeMap() const override { return true; }
+	uint32_t m_height;
-
+	uint32_t m_id;
-private:
+	uint32_t m_internalFormat;
-	void create();
+	uint32_t m_dataFormat;
 };
 
 // -------------------------------------
@@ -107,7 +52,7 @@ public:
 	~TextureManager();
 
 	void add(const std::string& path, std::shared_ptr<Texture> texture);
-	std::shared_ptr<Texture> load(const std::string& path, Texture::Type type = Texture::Type::TwoDimensional);
+	std::shared_ptr<Texture> load(const std::string& path);
 	std::shared_ptr<Texture> get(const std::string& path);
 	bool exists(const std::string& path);
 

src/inferno/scene/scene.cpp

@@ -1,23 +1,18 @@
 /*
- * Copyright (C) 2022-2024 Riyyi
+ * Copyright (C) 2022 Riyyi
  *
  * SPDX-License-Identifier: MIT
  */
 
-#include <cstddef> // size_t
 #include <cstdint> // uint32_t
 #include <limits>  // std::numeric_limits
-#include <utility> // std::pair
 
-#include "entt/entity/entity.hpp" // ent::entity
 #include "ruc/file.h"
 #include "ruc/format/log.h"
 #include "ruc/json/json.h"
 #include "ruc/meta/assert.h"
 
 #include "inferno/component/cameracomponent.h"
-#include "inferno/component/cubemap-component.h"
-#include "inferno/component/id-component.h"
 #include "inferno/component/luascriptcomponent.h"
 #include "inferno/component/nativescriptcomponent.h"
 #include "inferno/component/spritecomponent.h"
@@ -31,7 +26,6 @@
 #include "inferno/system/scriptsystem.h"
 #include "inferno/system/textareasystem.h"
 #include "inferno/system/transformsystem.h"
-#include "inferno/uid.h"
 
 namespace Inferno {
 
@@ -53,19 +47,54 @@ void Scene::initialize()
 
 	auto sceneJson = ruc::Json::parse(ruc::File("assets/scene/scene1.json").data());
 
-	if (sceneJson.exists("init")) {
+	// Camera
-		// TODO: load either NativeScript or LuaScript?
+
+	VERIFY(sceneJson.exists("camera"), "scene doesnt contain a camera");
+	auto& cameraJson = sceneJson.at("camera");
+	uint32_t camera = loadEntity(cameraJson);
+
+	auto& cameraComponent = addComponent<CameraComponent>(camera);
+	if (cameraJson.exists("type") && cameraJson.at("type").get<std::string>() == "orthographic") {
+		cameraComponent.type = CameraType::Orthographic;
+	}
+	if (cameraJson.exists("zoom-level") && cameraJson.at("zoom-level").type() == ruc::Json::Type::Number) {
+		cameraComponent.zoomLevel = cameraJson.at("zoom-level").asDouble();
 	}
 
-	// Entities
+	if (cameraJson.exists("script")) {
-	// -------------------------------------
+		auto& cameraScript = cameraJson.at("script");
+		if (cameraScript.exists("type") && cameraScript.exists("name")) {
+			auto name = cameraScript.at("name").get<std::string>();
+			if (cameraScript.at("type").get<std::string>() == "lua") {
+				addComponent<LuaScriptComponent>(camera, name);
+			}
+			else {
+				addComponent<NativeScriptComponent>(camera, name);
+			}
+		}
+	}
+
+	// Quads
 
-	if (sceneJson.exists("entities")) {
+	if (sceneJson.exists("quad") && sceneJson.at("quad").type() == ruc::Json::Type::Array) {
-		const auto& entityJson = sceneJson.at("entities");
+		auto& quads = sceneJson.at("quad").asArray().elements();
-		VERIFY(entityJson.type() == ruc::Json::Type::Array);
+		for (const auto& quad : quads) {
-		const auto& entities = entityJson.asArray();
+			uint32_t quadEntity = loadEntity(quad);
-		for (size_t i = 0; i < entities.size(); ++i) {
+			addComponent<SpriteComponent>(quadEntity);
-			loadEntity(entities.at(i));
+			auto& spriteComponent = getComponent<SpriteComponent>(quadEntity);
+			quad.getTo(spriteComponent);
+		}
+	}
+
+	// Text
+
+	if (sceneJson.exists("text") && sceneJson.at("text").type() == ruc::Json::Type::Array) {
+		auto& texts = sceneJson.at("text").asArray().elements();
+		for (const auto& text : texts) {
+			uint32_t textEntity = loadEntity(text);
+			addComponent<TextAreaComponent>(textEntity);
+			auto& textAreaComponent = getComponent<TextAreaComponent>(textEntity);
+			text.getTo(textAreaComponent);
 		}
 	}
 
@@ -94,85 +123,22 @@ void Scene::destroy()
 	TransformSystem::destroy();
 }
 
-// -----------------------------------------
-
 uint32_t Scene::createEntity(const std::string& name)
-{
-	return createEntityWithUID(UID(), name);
-}
-
-uint32_t Scene::createEntityWithUID(UID id, const std::string& name)
 {
 	uint32_t entity = static_cast<uint32_t>(m_registry->create());
-	addComponent<IDComponent>(entity, id);
 	addComponent<TagComponent>(entity, name.empty() ? "Unnamed Entity" : name);
 	addComponent<TransformComponent>(entity);
 
-	TransformSystem::the().add(entity);
-
 	return entity;
 }
 
-uint32_t Scene::loadEntity(ruc::Json components, uint32_t parentEntity)
+uint32_t Scene::loadEntity(ruc::Json json)
 {
-	VERIFY(components.type() == ruc::Json::Type::Object);
+	uint32_t entity = createEntity((json.exists("name"))
-
+	                                   ? json.at("name").get<std::string>()
-	uint32_t entity = createEntity();
+	                                   : "");
-
-	// At minimum, ID is required
-	VERIFY(components.exists("id"), "id not found");
-	auto& id = getComponent<IDComponent>(entity);
-	components.at("id").getTo(id);
-
-	if (components.exists("tag")) {
-		auto& tag = getComponent<TagComponent>(entity);
-		components.at("tag").getTo(tag);
-	}
-	if (components.exists("transform")) {
 	auto& transform = getComponent<TransformComponent>(entity);
-		components.at("transform").getTo(transform);
+	json.getTo(transform);
-		transform.parent = static_cast<entt::entity>(parentEntity);
-	}
-	if (components.exists("camera")) {
-		auto& camera = addComponent<CameraComponent>(entity);
-		components.at("camera").getTo(camera);
-	}
-	if (components.exists("lua-scripts")) {
-		VERIFY(components.at("lua-scripts").type() == ruc::Json::Type::Array);
-		const auto& scripts = components.at("lua-scripts").asArray();
-		for (size_t i = 0; i < scripts.size(); ++i) {
-			auto& script = addComponent<LuaScriptComponent>(entity);
-			scripts.at(i).getTo(script);
-		}
-	}
-	if (components.exists("native-scripts")) {
-		VERIFY(components.at("native-scripts").type() == ruc::Json::Type::Array);
-		const auto& scripts = components.at("native-scripts").asArray();
-		for (size_t i = 0; i < scripts.size(); ++i) {
-			auto& script = addComponent<NativeScriptComponent>(entity);
-			scripts.at(i).getTo(script);
-			script.bind();
-		}
-	}
-	if (components.exists("sprite")) {
-		auto& sprite = addComponent<SpriteComponent>(entity);
-		components.at("sprite").getTo(sprite);
-	}
-	if (components.exists("cubemap")) {
-		auto& cubemap = addComponent<CubemapComponent>(entity);
-		components.at("cubemap").getTo(cubemap);
-	}
-	if (components.exists("text")) {
-		auto& text = addComponent<TextAreaComponent>(entity);
-		components.at("text").getTo(text);
-	}
-	if (components.exists("children")) {
-		VERIFY(components.at("children").type() == ruc::Json::Type::Array);
-		const auto& children = components.at("children").asArray();
-		for (size_t i = 0; i < children.size(); ++i) {
-			loadEntity(components.at("children")[i], entity);
-		}
-	}
 
 	return entity;
 }
@@ -196,9 +162,7 @@ void Scene::destroyEntity(uint32_t entity)
 	m_registry->destroy(entt::entity { entity });
 }
 
-// -----------------------------------------
+glm::mat4 Scene::cameraProjectionView()
-
-std::pair<glm::mat4, glm::mat4> Scene::cameraProjectionView()
 {
 	return CameraSystem::the().projectionView();
 }

src/inferno/scene/scene.h

@@ -1,23 +1,19 @@
 /*
- * Copyright (C) 2022,2024 Riyyi
+ * Copyright (C) 2022 Riyyi
  *
  * SPDX-License-Identifier: MIT
  */
 
 #pragma once
 
-#include <cstddef> // size_t
 #include <cstdint> // uint32_t
 #include <memory>  // std::shared_ptr
-#include <utility> // std::pair
 
 #include "entt/entity/registry.hpp"    // entt::entity, entt::registry
 #include "glm/ext/matrix_float4x4.hpp" // glm::mat4
 #include "ruc/format/format.h"
 #include "ruc/json/json.h"
 
-#include "inferno/uid.h"
-
 namespace Inferno {
 
 class Camera;
@@ -31,15 +27,11 @@ public:
 	void destroy();
 
 	uint32_t createEntity(const std::string& name = "");
-	uint32_t createEntityWithUID(UID id, const std::string& name = "");
+	uint32_t loadEntity(ruc::Json json);
-	uint32_t loadEntity(ruc::Json components, uint32_t parentEntity = entt::null);
 	uint32_t findEntity(std::string_view name);
 	void destroyEntity(uint32_t entity);
 
-	/**
+	glm::mat4 cameraProjectionView();
-	 * @brief Return a pair from the camera component: { projection, view }
-	 */
-	std::pair<glm::mat4, glm::mat4> cameraProjectionView();
 
 	void validEntity(uint32_t entity) const;
 
@@ -57,8 +49,7 @@ public:
 		return m_registry->any<T...>(entt::entity { entity });
 	}
 
-	// TODO: Should replace be allowed? could trigger memory leaks with nativescript
+	// @Todo Should replace be allowed? could trigger memory leaks with nativescript
-	// TODO: Replace will make it so an entity cant have multiple scripts
 	template<typename T, typename... P>
 	T& addComponent(uint32_t entity, P&&... parameters) const
 	{
@@ -73,7 +64,7 @@ public:
 		return m_registry->remove_if_exists<T>(entt::entity { entity });
 	}
 
-	// TODO: Should replace be allowed? could trigger memory leaks with nativescript
+	// @Todo Should replace be allowed? could trigger memory leaks with nativescript
 	template<typename T, typename... P>
 	T& getComponent(uint32_t entity, P&&... parameters) const
 	{

src/inferno/script/nativescript.h

@@ -55,8 +55,8 @@ public:
 		m_detroyBindings.emplace(binding, destroy);
 	}
 
-	NativeScript::InitializeFunction initializeBinding(const std::string& name) { return m_initializeBindings[name]; }
+	NativeScript::InitializeFunction initializeBinding(const std::string& binding) { return m_initializeBindings[binding]; }
-	NativeScript::DestroyFunction destroyBinding(const std::string& name) { return m_detroyBindings[name]; }
+	NativeScript::DestroyFunction destroyBinding(const std::string& binding) { return m_detroyBindings[binding]; }
 
 private:
 	std::unordered_map<std::string, NativeScript::InitializeFunction> m_initializeBindings;

src/inferno/system/camerasystem.cpp

@@ -1,11 +1,9 @@
 /*
- * Copyright (C) 2022,2024 Riyyi
+ * Copyright (C) 2022 Riyyi
  *
  * SPDX-License-Identifier: MIT
  */
 
-#include <utility> // std::pair
-
 #include "glm/ext/matrix_clip_space.hpp" // glm::perspective, glm::ortho
 #include "glm/ext/matrix_transform.hpp"  // glm::radians, glm::lookAt
 #include "ruc/format/log.h"
@@ -44,17 +42,17 @@ void CameraSystem::update()
 	}
 }
 
-std::pair<glm::mat4, glm::mat4> CameraSystem::projectionView()
+glm::mat4 CameraSystem::projectionView()
 {
 	auto view = m_registry->view<TransformComponent, CameraComponent>();
 
 	for (auto [entity, transform, camera] : view.each()) {
-		return { camera.projection, transform.transform };
+		return camera.projection * transform.transform;
 	}
 
 	VERIFY_NOT_REACHED();
 
-	return {};
+	return glm::mat4 { 1.0f };
 }
 
 void CameraSystem::updateOrthographic(TransformComponent& transform, CameraComponent& camera)

src/inferno/system/camerasystem.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022,2024 Riyyi
+ * Copyright (C) 2022 Riyyi
  *
  * SPDX-License-Identifier: MIT
  */
@@ -7,7 +7,6 @@
 #pragma once
 
 #include <memory> //std::shared_ptr
-#include <utility> // std::pair
 
 #include "entt/entity/registry.hpp"    // entt::entity, entt::registry
 #include "glm/ext/matrix_float4x4.hpp" // glm::mat4
@@ -28,10 +27,7 @@ public:
 
 	void update();
 
-	/**
+	glm::mat4 projectionView();
-	 * @brief Return a pair from the camera component: { projection, view }
-	 */
-	std::pair<glm::mat4, glm::mat4> projectionView();
 
 	void setRegistry(std::shared_ptr<entt::registry> registry) { m_registry = registry; };
 

src/inferno/system/rendersystem.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022,2024 Riyyi
+ * Copyright (C) 2022 Riyyi
  *
  * SPDX-License-Identifier: MIT
  */
@@ -7,7 +7,6 @@
 #include "glm/ext/matrix_transform.hpp" // glm::translate, glm::rotate, glm::scale, glm::radians
 #include "ruc/format/log.h"
 
-#include "inferno/component/cubemap-component.h"
 #include "inferno/component/spritecomponent.h"
 #include "inferno/component/transformcomponent.h"
 #include "inferno/render/renderer.h"
@@ -26,17 +25,11 @@ RenderSystem::~RenderSystem()
 
 void RenderSystem::render()
 {
-	auto quadView = m_registry->view<TransformComponent, SpriteComponent>();
+	auto group = m_registry->group<TransformComponent, SpriteComponent>();
 
-	for (auto [entity, transform, sprite] : quadView.each()) {
+	for (auto [entity, transform, sprite] : group.each()) {
 		Renderer2D::the().drawQuad(transform, sprite.color, sprite.texture);
 	}
-
-	auto cubemapView = m_registry->view<TransformComponent, CubemapComponent>();
-
-	for (auto [entity, transform, cubemap] : cubemapView.each()) {
-		RendererCubemap::the().drawCubemap(transform, cubemap.color, cubemap.texture);
-	}
 }
 
 } // namespace Inferno

src/inferno/system/transformsystem.cpp

@@ -1,13 +1,9 @@
 /*
- * Copyright (C) 2022,2024 Riyyi
+ * Copyright (C) 2022 Riyyi
  *
  * SPDX-License-Identifier: MIT
  */
 
-#include <algorithm> // std::sort
-#include <cstdint>   // uint32_t
-
-#include "entt/entity/fwd.hpp"          // entt:entity
 #include "glm/ext/matrix_transform.hpp" // glm::translate, glm::rotate, glm::scale, glm::radians
 #include "ruc/format/log.h"
 
@@ -29,7 +25,7 @@ void TransformSystem::update()
 {
 	auto view = m_registry->view<TransformComponent>();
 
-	for (auto entity : m_hierarchy) {
+	for (auto entity : view) {
 
 		auto& component = view.get<TransformComponent>(entity);
 
@@ -46,29 +42,7 @@ void TransformSystem::update()
 
 		// Scale
 		component.transform = glm::scale(component.transform, component.scale);
-
-		// Apply the parent transform to the child transform
-		if (component.parent != entt::null) {
-			auto& parent = view.get<TransformComponent>(component.parent);
-			component.transform = parent.transform * component.transform;
-		}
 	}
 }
 
-void TransformSystem::add(uint32_t entity)
-{
-	m_hierarchy.push_back(static_cast<entt::entity>(entity));
-}
-
-void TransformSystem::sort()
-{
-	std::sort(m_hierarchy.begin(), m_hierarchy.end(),
-	          [](entt::entity a, entt::entity b) {
-				  return (a == entt::null && b == entt::null) ? false
-		                 : (a == entt::null)                  ? true
-		                 : (b == entt::null)                  ? false
-		                                                      : a < b;
-			  });
-}
-
 } // namespace Inferno

src/inferno/system/transformsystem.h

@@ -1,14 +1,12 @@
 /*
- * Copyright (C) 2022,2024 Riyyi
+ * Copyright (C) 2022 Riyyi
  *
  * SPDX-License-Identifier: MIT
  */
 
 #pragma once
 
-#include <cstdint> // uint32_t
 #include <memory> // std::shared_ptr
-#include <vector>
 
 #include "entt/entity/registry.hpp" // entt::entity, entt::registry
 #include "ruc/singleton.h"
@@ -22,14 +20,9 @@ public:
 
 	void update();
 
-	void add(uint32_t entity);
-	void sort();
-
 	void setRegistry(std::shared_ptr<entt::registry> registry) { m_registry = registry; };
 
 private:
-	std::vector<entt::entity> m_hierarchy;
-
 	std::shared_ptr<entt::registry> m_registry;
 };
 

src/inferno/uid.cpp

@@ -1,38 +0,0 @@
-/*
- * Copyright (C) 2023 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#include <cstdint>
-#include <random>
-
-#include "ruc/format/log.h"
-#include "ruc/json/json.h"
-
-#include "inferno/uid.h"
-
-namespace Inferno {
-
-static std::random_device s_seed;
-static std::mt19937_64 s_engine(s_seed());
-static std::uniform_int_distribution<uint64_t> s_distribution;
-
-UID::UID()
-	: m_uid(s_distribution(s_engine))
-{
-}
-
-UID::UID(uint64_t uid)
-	: m_uid(uid)
-{
-}
-
-void fromJson(const ruc::Json& json, UID& value)
-{
-	VERIFY(json.type() == ruc::Json::Type::Number);
-
-	value = UID((int64_t)json.asDouble());
-}
-
-} // namespace Inferno

src/inferno/uid.h

@@ -1,47 +0,0 @@
-/*
- * Copyright (C) 2023 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#pragma once
-
-#include <cstdint> // uint64_t
-
-#include "ruc/json/json.h"
-
-namespace Inferno {
-
-class UID {
-public:
-	UID();
-	UID(uint64_t uid);
-
-	// Comparison operator for std::map
-	bool operator<(const UID& other) const
-	{
-		return m_uid < other.m_uid;
-	}
-
-	operator uint64_t() const { return m_uid; }
-
-private:
-	uint64_t m_uid;
-};
-
-void fromJson(const ruc::Json& json, UID& value);
-
-} // namespace Inferno
-
-namespace std {
-
-// Hash function for std::unordered_map
-template<>
-struct hash<Inferno::UID> {
-	size_t operator()(const Inferno::UID& uid) const
-	{
-		return hash<uint64_t>()(static_cast<uint64_t>(uid));
-	}
-};
-
-} // namespace std