Add many triangles to test rendering

CMakeLists.txt

@@ -12,6 +12,8 @@ set(SRC_FILES
 	"src/ecs_system.cpp"
 	"src/application.cpp"
 
+	"src/systems/render.cpp"
+
 	"src/resources/material.cpp"
 	"src/resources/texture.cpp"
 

include/components/renderable.hpp

@@ -1,12 +1,17 @@
 #pragma once
 
-#include <glm/vec3.hpp>
-#include <glm/gtc/quaternion.hpp>
-#include <glm/mat4x4.hpp>
+#include <memory>
 
 namespace engine {
 
+	namespace resources {
+		class Mesh;
+		class Material;
+	}
+
 	struct RenderableComponent {
+		std::shared_ptr<resources::Mesh> mesh;
+		std::shared_ptr<resources::Material> material;
 	};
 
 }

include/systems/render.hpp

@@ -17,17 +17,7 @@ namespace engine {
 		{
 		}
 
-		void onUpdate(float ts) override
-		{
-			for (uint32_t entity : m_entities) {
-
-				auto t = m_scene->getComponent<TransformComponent>(entity);
-
-				TRACE("rendering {}", t->tag);
-
-			}
-
-		}
+		void onUpdate(float ts) override;
 
 	};
 

include/systems/transform.hpp

@@ -28,7 +28,7 @@ namespace engine {
 
 				auto t = m_scene->getComponent<TransformComponent>(entity);
 
-				TRACE("tag is {}", t->tag);
+//				TRACE("tag is {}", t->tag);
 
 				glm::mat4 transform;
 				

src/application.cpp

@@ -80,7 +80,8 @@ namespace engine {
 			m_sceneManager->updateActiveScene(m_window->dt());
 
 			if(m_window->getKeyPress(inputs::Key::K_L)) {
-				m_enableFrameLimiter = !m_enableFrameLimiter;
+//				m_enableFrameLimiter = !m_enableFrameLimiter;
+				m_window->infoBox("fps", std::to_string(m_window->getFPS()) + " fps " + std::to_string(m_window->dt() * 1000.0f) + " ms");
 			}
 
 			/* draw */

src/scene.cpp

@@ -25,6 +25,11 @@ namespace engine {
 		m_signatures.emplace(id, std::bitset<MAX_COMPONENTS>{});
 
 		auto t = addComponent<TransformComponent>(id);
+
+		t->position = {0.0f, 0.0f, 0.0f};
+		t->rotation = {};
+		t->scale = {1.0f, 1.0f, 1.0f};
+
 		t->tag = tag;
 		t->parent = parent;
 

src/systems/render.cpp

@@ -0,0 +1,61 @@
+#include "systems/render.hpp"
+
+#include "application.hpp"
+#include "gfx_device.hpp"
+
+#include "resources/material.hpp"
+#include "resources/shader.hpp"
+#include "resources/texture.hpp"
+
+#include "resources/mesh.hpp"
+
+#include <glm/mat4x4.hpp>
+
+namespace engine {
+
+	void RenderSystem::onUpdate(float ts)
+	{
+		GFXDevice* const gfx = m_scene->app()->gfx();
+
+		constexpr float FOV_H = 75.0f;
+		constexpr float CLIP_NEAR = 0.1f;
+		constexpr float CLIP_FAR = 100.0f;
+
+		uint32_t w, h;
+		gfx->getViewportSize(&w, &h);
+		float aspect = w / h;
+		float verticalFOV = FOV_H / aspect;
+		glm::mat4 projMatrix = glm::perspectiveZO(verticalFOV, aspect, CLIP_NEAR, CLIP_FAR);
+
+		for (uint32_t entity : m_entities) {
+
+			auto t = m_scene->getComponent<TransformComponent>(entity);
+			auto r = m_scene->getComponent<RenderableComponent>(entity);
+
+//			TRACE("rendering {}", t->tag);
+
+			gfx->updateUniformBuffer(r->material->getShader()->getPipeline(), &projMatrix, sizeof(projMatrix), 0);
+
+			struct {
+				glm::mat4 model;
+				glm::mat4 view;
+			} pushConsts{};
+
+			pushConsts.model = t->worldMatrix;
+			pushConsts.view = glm::mat4{ 1.0f };
+
+			gfx->draw(
+				r->material->getShader()->getPipeline(),
+				r->mesh->getVB(),
+				r->mesh->getIB(),
+				r->mesh->getCount(),
+				&pushConsts,
+				sizeof(pushConsts),
+				r->material->m_texture->getHandle()
+			);
+		}
+
+	}
+
+}
+

test/src/game.cpp

@@ -4,10 +4,17 @@
 #include "window.hpp"
 #include "scene_manager.hpp"
 #include "scene.hpp"
+
 #include "components/transform.hpp"
 #include "components/renderable.hpp"
+
 #include "systems/transform.hpp"
 
+#include "resources/mesh.hpp"
+#include "resources/material.hpp"
+#include "resources/shader.hpp"
+#include "resources/texture.hpp"
+
 void playGame()
 {
 	engine::Application app(PROJECT_NAME, PROJECT_VERSION);
@@ -17,13 +24,54 @@ void playGame()
 
 	auto myScene = app.sceneManager()->createEmptyScene();
 
-	myScene->createEntity("entity1");
+	std::shared_ptr<engine::resources::Material> myMaterial;
+	{
+		engine::resources::Shader::VertexParams vertParams{};
+		vertParams.hasNormal = true;
+		vertParams.hasUV0 = true;
+		auto myShader = std::make_unique<engine::resources::Shader>(
+			app.gfx(),
+			app.getResourcePath("engine/shaders/texture.vert").c_str(),
+			app.getResourcePath("engine/shaders/texture.frag").c_str(),
+			vertParams,
+			false,
+			true
+		);
+		myMaterial = std::make_shared<engine::resources::Material>(std::move(myShader));
+		myMaterial->m_texture = std::make_shared<engine::resources::Texture>(
+			app.gfx(),
+			app.getResourcePath("engine/textures/white.png")
+		);
+	}
 
-	auto entity1 = myScene->getEntity("entity1");
+	auto myMesh = std::make_shared<engine::resources::Mesh>(
+		app.gfx(),
+		std::vector<engine::Vertex>{
+			{ {  0.5f,  0.5f, 0.0f }, { 0.0f, 0.0f, 1.0f }, { 1.0f, 0.0f } },
+			{ { -0.5f, -0.5f, 0.0f }, { 0.0f, 0.0f, 1.0f }, { 0.0f, 1.0f } },
+			{ {  0.5f, -0.5f, 0.0f }, { 0.0f, 0.0f, 1.0f }, { 1.0f, 1.0f } },
+		}
+	);
 
-	myScene->getComponent<engine::TransformComponent>(entity1)->tag = "HELLO WORLD";
+	constexpr int N = 100;
 
-	myScene->addComponent<engine::RenderableComponent>(entity1);
+	for (int i = 0; i < N; i++) {
+		for (int j = 0; j < N; j++) {
+
+			auto entity = myScene->createEntity(std::to_string(i * 10 + j));
+
+			auto t = myScene->getComponent<engine::TransformComponent>(entity);
+			float x = ((float)(i) * 10.0f / (float)(N) ) - 5.0f;
+			float y = ((float)(j) * 10.0f / (float)(N) ) - 5.0f;
+			t->position = {x, y, -35.0f};
+			t->scale /= (float)(N) / 4.0f;
+
+			auto r = myScene->addComponent<engine::RenderableComponent>(entity);
+			r->material = myMaterial;
+			r->mesh = myMesh;
+
+		}
+	}
 
 	app.gameLoop();
 }