Got Animation Render Pipeline Working

Arcane/src/Arcane/ECS/Component.h

@@ -90,4 +90,12 @@ namespace Arcane
 		Kinetics::Shape* shape;
 		glm::vec3 center;
 	};
+
+	///////////////////////
+	/// Animation
+	//////////////////////
+	struct Animator
+	{
+		float stuff;
+	};
 }

Arcane/src/Arcane/Renderer/SceneRenderer.cpp

@@ -32,6 +32,12 @@ namespace Arcane
 		int texId;
 	};
 
+	struct AnimatedQuadVertex
+	{
+		glm::vec3 position;
+		glm::vec3 color;
+		glm::vec2 texCoord;
+	};
 
 	struct AnimData
 	{
@@ -126,7 +132,20 @@ namespace Arcane
 		////////////////////////////////////////////////////////////////////////////////
 		//// 2D Animated Rendering Info
 		////////////////////////////////////////////////////////////////////////////////
-
+		std::vector<VertexBuffer*> AnimatedQuadBuffers;
+		std::vector<IndexBuffer*> AnimatedQuadIndexBuffers;
+		std::vector<Texture*> AnimatedQuadTextures;
+		std::vector<AnimData> AnimatedQuadAnimationData;
+
+		Shader* SpriteAnimatedShader;
+		Pipeline* SpriteAnimatedPipeline;
+		DescriptorSet* SpriteAnimatedDescriptorSet;
+		UniformBuffer* AnimDataUniformBuffer;
+		VertexDescriptor* SpriteAnimatedVertexDescriptor;
+
+
+		int animatedQuadCount = 0;
+		int maxAnimatedQuads = 10;
 	};
 
 	static SceneRendererData s_Data;
@@ -366,6 +385,53 @@ namespace Arcane
 		quadPipelineSpecs.DescriptorSets = { s_Data.GlobalDescriptorSet, s_Data.QuadDescriptorSet };
 		quadPipelineSpecs.topolgy = PrimativeTopology::TRIANGLE_STRIP;
 		s_Data.QuadPipeline = Pipeline::Create(quadPipelineSpecs);
+
+
+		////////////////////////////////////////////////////////////////////////////////////
+		//// 2D Animation Render (needs to be seperate buffers (probably?))
+		////////////////////////////////////////////////////////////////////////////////////
+		s_Data.AnimatedQuadBuffers.resize(s_Data.maxAnimatedQuads);
+		s_Data.AnimatedQuadIndexBuffers.resize(s_Data.maxAnimatedQuads);
+		s_Data.AnimatedQuadTextures.resize(s_Data.maxAnimatedQuads);
+		s_Data.AnimatedQuadAnimationData.resize(s_Data.maxAnimatedQuads);
+
+		std::vector<uint32_t> animatedQuadIndices = {
+			0, 1, 3,
+			1, 2, 3
+		};
+
+		for (int i = 0; i < s_Data.maxAnimatedQuads; i++) {
+			s_Data.AnimatedQuadBuffers[i] = VertexBuffer::Create(sizeof(AnimatedQuadVertex) * 4);
+			s_Data.AnimatedQuadIndexBuffers[i] = IndexBuffer::Create(animatedQuadIndices.data(), 6);
+			s_Data.AnimatedQuadBuffers[i]->AddIndexBuffer(s_Data.AnimatedQuadIndexBuffers[i]);
+		}
+
+		s_Data.SpriteAnimatedVertexDescriptor = VertexDescriptor::Create({
+			VertexType::float3,
+			VertexType::float3,
+			VertexType::float2
+		});
+
+		s_Data.SpriteAnimatedShader = ShaderLibrary::GetShader("Sprite-Animated");
+
+		DescriptorSetSpecs spriteAnimatedDescriptorSpecs;
+		spriteAnimatedDescriptorSpecs.SetNumber = 1;
+
+		s_Data.SpriteAnimatedDescriptorSet = DescriptorSet::Create(spriteAnimatedDescriptorSpecs, {
+			{0, 1, DescriptorType::SAMPLER, "sprite", DescriptorLocation::FRAGMENT},
+			{1, 1, DescriptorType::UNIFORM_BUFFER, "animData", DescriptorLocation::FRAGMENT}
+		});
+
+		s_Data.AnimDataUniformBuffer = UniformBuffer::Create(sizeof(AnimData));
+		s_Data.SpriteAnimatedDescriptorSet->AddUniformBuffer(s_Data.AnimDataUniformBuffer, 1, 1);
+
+		PipelineSpecification animatedQuadPipelineSpecs;
+		animatedQuadPipelineSpecs.shader = s_Data.SpriteAnimatedShader;
+		animatedQuadPipelineSpecs.renderPass = s_Data.GeometryRenderPass;
+		animatedQuadPipelineSpecs.descriptor = s_Data.SpriteAnimatedVertexDescriptor;
+		animatedQuadPipelineSpecs.DescriptorSets = { s_Data.GlobalDescriptorSet, s_Data.SpriteAnimatedDescriptorSet };
+		animatedQuadPipelineSpecs.topolgy = PrimativeTopology::TRIANGLE_STRIP;
+		s_Data.SpriteAnimatedPipeline = Pipeline::Create(animatedQuadPipelineSpecs);
 	}
 
 	Framebuffer* SceneRenderer::GetFinalRenderFramebuffer()
@@ -431,13 +497,34 @@ namespace Arcane
 				Renderer::RenderQuad(s_Data.GridVertexBuffer, s_Data.GridPipleine, { s_Data.GlobalDescriptorSet });*/
 		}
 
-		// 2D Batch Render
+		// 2D Renderer
 		{
+			// Batch non animated quads
 			if (s_Data.quadCount > 0) {
 				s_Data.QuadDescriptorSet->AddImageSamplerArray(s_Data.SpriteTextures, 1, 0);
 				s_Data.QuadVertexBuffer->SetData(s_Data.quadVertices, s_Data.quadCount * 4 * sizeof(QuadVertex));
 				Renderer::RenderQuad(s_Data.QuadVertexBuffer, s_Data.QuadPipeline, {s_Data.GlobalDescriptorSet, s_Data.QuadDescriptorSet});
 			}
+
+			// Render Animated Quads Seperatly
+			if (s_Data.animatedQuadCount > 0)
+			{
+				for (int i = 0; i < s_Data.animatedQuadCount; i++)
+				{
+					// Set Uniforms
+					AnimData currentAnimData = s_Data.AnimatedQuadAnimationData[i];
+					Texture* currentTexture = s_Data.AnimatedQuadTextures[i];
+
+					s_Data.AnimDataUniformBuffer->WriteData((void*)&currentAnimData, sizeof(AnimData));
+					s_Data.SpriteAnimatedDescriptorSet->AddImageSampler(currentTexture, 1, 0);
+
+					// Render Quad
+					Renderer::RenderQuad(s_Data.AnimatedQuadBuffers[i], s_Data.SpriteAnimatedPipeline, {
+						s_Data.GlobalDescriptorSet,
+						s_Data.SpriteAnimatedDescriptorSet
+					});
+				}
+			}
 		}
 		Renderer::EndRenderPass(s_Data.GeometryRenderPass);
 	}
@@ -467,6 +554,7 @@ namespace Arcane
 		delete s_Data.quadVertices;
 		s_Data.quadVertices = new QuadVertex[s_Data.maxQuadVertices];
 		s_Data.quadCount = 0;
+		s_Data.animatedQuadCount = 0;
 	}
 
 	void SceneRenderer::SubmitMesh(Mesh* mesh, TransformComponent& transform, Material* material) 
@@ -539,6 +627,48 @@ namespace Arcane
 		s_Data.quadCount++;
 	}
 
+	void SceneRenderer::SubmitAnimatedQuad(TransformComponent& transformComponent, SpriteRendererComponent& spriteRendererComponent)
+	{
+		int quadSize = 4;
+
+		glm::mat4 translation = glm::translate(glm::mat4(1.0), transformComponent.pos);
+		glm::mat4 scale = glm::scale(glm::mat4(1.0), transformComponent.scale);
+		glm::mat4 rotation = glm::mat4(glm::quat(transformComponent.rotation));
+
+		glm::vec2 textureCoords[4] = {
+			{1.0f, 0.0f},
+			{0.0f, 0.0f},
+			{0.0f, 1.0f},
+			{1.0f, 1.0f}
+		};
+
+		std::vector<AnimatedQuadVertex> vertices;
+
+		for (int i = 0; i < quadSize; i++) {
+			AnimatedQuadVertex v;
+			v.position = translation * rotation * scale * s_Data.quadBase[i];
+			v.color = spriteRendererComponent.color;
+			v.texCoord = textureCoords[i];
+			vertices.push_back(v);
+		}
+
+		AnimData newData;
+		newData.currentFrameCountX = 0;
+		newData.currentFrameCountY = 0;
+
+		newData.totalFrameCountY = 1;
+		newData.totalFrameCountX = 6;
+
+		if (spriteRendererComponent.sprite == nullptr)
+			s_Data.AnimatedQuadTextures[s_Data.animatedQuadCount] = s_Data.QuadBaseTexture;
+		else
+			s_Data.AnimatedQuadTextures[s_Data.animatedQuadCount] = spriteRendererComponent.sprite;
+
+		s_Data.AnimatedQuadAnimationData[s_Data.animatedQuadCount] = newData;
+		s_Data.AnimatedQuadBuffers[s_Data.animatedQuadCount]->SetData(vertices.data(), vertices.size() * sizeof(AnimatedQuadVertex));
+		s_Data.animatedQuadCount++;
+	}
+
 	void SceneRenderer::SetCamera(Camera* camera)
 	{
 		s_Data.SceneCamera = camera;

Arcane/src/Arcane/Renderer/SceneRenderer.h

@@ -28,6 +28,7 @@ namespace Arcane
 		void SetCamera(Camera* camera);
 		void SubmitMesh(Mesh* mesh, TransformComponent& component, Material* material);
 		void SubmitQuad(TransformComponent& transformComponent, SpriteRendererComponent& spriteRendererComponent);
+		void SubmitAnimatedQuad(TransformComponent& transformComponent, SpriteRendererComponent& spriteRendererComponent);
 
 		// Lighting code
 		void SetDirectionalLight(LightComponent& light, TransformComponent& transform);

Arcane/src/Arcane/Renderer/Shader.cpp

@@ -94,7 +94,15 @@ namespace Arcane
 			dir + "\\src\\EditorAssets\\Shaders\\SkyboxFrag.spv"
 		);
 
-		m_Shaders["Sprite-Default"] = Shader::Create(dir + "\\src\\EditorAssets\\Shaders\\Sprite.arcaneshader");
+		m_Shaders["Sprite-Default"] = Shader::Create(
+			dir + "\\src\\EditorAssets\\Shaders\\SpriteVert.spv",
+			dir + "\\src\\EditorAssets\\Shaders\\SpriteFrag.spv"
+		);
+
+		m_Shaders["Sprite-Animated"] = Shader::Create(
+			dir + "\\src\\EditorAssets\\Shaders\\SpriteAnimVert.spv",
+			dir + "\\src\\EditorAssets\\Shaders\\SpriteAnimFrag.spv"
+		);
 	}
 
 	ShaderLibrary* ShaderLibrary::GetInstance()

Arcane/src/Arcane/Scene/Scene.cpp

@@ -160,7 +160,13 @@ namespace Arcane
 			{
 				auto& spriteRendererComponent = view.get<SpriteRendererComponent>(entity);
 				auto& transformComponent = view.get<TransformComponent>(entity);
-				m_SceneRenderer->SubmitQuad(transformComponent, spriteRendererComponent);
+
+				Entity entityHandle = Entity(entity, this);
+
+				if (entityHandle.HasComponent<Animator>())
+					m_SceneRenderer->SubmitAnimatedQuad(transformComponent, spriteRendererComponent);
+				else
+					m_SceneRenderer->SubmitQuad(transformComponent, spriteRendererComponent);
 			}
 		}
 

Arcane/src/Arcane/Scripting/Script.cpp

@@ -294,9 +294,6 @@ namespace Arcane
 			{
 				newProperty.type = "Entity";
 				newProperty.value = nullptr;
-
-				// Add functions to this to load it up
-
 			}
 
 			if (lua_isuserdata(ScriptingEngine::GetLuaState(), -1)) 

EnchantingTable/src/EditorAssets/Shaders/Sprite.frag

@@ -0,0 +1,15 @@
+#version 450
+
+layout (location = 0) in vec3 fragColor;
+layout (location = 1) in vec2 fragTexCoord;
+layout (location = 2) in flat int fragTexId; 
+
+layout(location = 0) out vec4 Color;
+layout(location = 1) out int EntityIds;
+
+layout(set = 1, binding = 0) uniform sampler2D sprites[32];
+
+void main() {
+	EntityIds = 1;
+	Color = texture(sprites[fragTexId], fragTexCoord) * vec4(fragColor, 1.0);
+}

EnchantingTable/src/EditorAssets/Shaders/Sprite.vert

@@ -0,0 +1,24 @@
+#version 450
+
+layout (location = 0) in vec3 aPos;
+layout (location = 1) in vec3 aColor;
+layout (location = 2) in vec2 aTexCoord;
+layout (location = 3) in int  aTexId;
+
+layout (location = 0) out vec3 fragColor;
+layout (location = 1) out vec2 fragTexCoord;
+layout (location = 2) out flat int fragTexId;
+
+// Global Frame data
+layout (set = 0, binding = 0) uniform Camera {
+	mat4 proj;
+	mat4 view;
+	vec3 cameraPosition;
+} camera;
+
+void main() {
+	gl_Position = camera.proj * camera.view * vec4(aPos, 1.0);
+	fragColor = aColor;
+	fragTexCoord = aTexCoord;
+	fragTexId = aTexId;
+}

EnchantingTable/src/EditorAssets/Shaders/SpriteAnim.frag

@@ -0,0 +1,23 @@
+#version 450
+
+layout (location = 0) in vec3 fragColor;
+layout (location = 1) in vec2 fragTexCoord;
+
+layout (set = 1, binding = 0) uniform sampler2D sprite;
+
+layout (set = 1, binding = 1) uniform AnimData {
+	float currentFrameCountX;
+	float currentFrameCountY;
+	float totalFrameCountX;
+	float totalFrameCountY;
+} animData;
+
+layout(location = 0) out vec4 Color;
+
+void main() {
+	float animTexCoordX = (fragTexCoord.x + animData.currentFrameCountX) * (1.0 / animData.totalFrameCountX);
+	float animTexCoordY = (fragTexCoord.y + animData.currentFrameCountY) * (1.0 / animData.totalFrameCountY);
+
+	vec2 animTexCoords = vec2(animTexCoordX, animTexCoordY);
+	Color = texture(sprite, animTexCoords) * vec4(fragColor, 1.0);
+}

EnchantingTable/src/EditorAssets/Shaders/SpriteAnim.vert

@@ -0,0 +1,21 @@
+#version 450
+
+layout (location = 0) in vec3 aPos;
+layout (location = 1) in vec3 aColor;
+layout (location = 2) in vec2 aTexCoord;
+
+layout (location = 0) out vec3 fragColor;
+layout (location = 1) out vec2 fragTexCoord;
+
+// Global Frame data
+layout (set = 0, binding = 0) uniform Camera {
+	mat4 proj;
+	mat4 view;
+	vec3 cameraPosition;
+} camera;
+
+void main() {
+	gl_Position = camera.proj * camera.view * vec4(aPos, 1.0);
+	fragColor = aColor;
+	fragTexCoord = aTexCoord;
+}

EnchantingTable/src/EditorLayer.cpp

@@ -16,10 +16,11 @@ EditorLayer::EditorLayer()
 void EditorLayer::OnAttach()
 {
 	m_EditorScene = new Arcane::Scene(true);
+	m_ActiveScene = m_EditorScene;
 
 	m_SceneRenderer = new Arcane::SceneRenderer();
 
-	m_EditorScene->SetSceneRenderer(m_SceneRenderer);
+	m_ActiveScene->SetSceneRenderer(m_SceneRenderer);
 
 	Arcane::DimensionType dimensionType = Arcane::Application::Get().GetProject()->GetDimensionType();
 
@@ -29,7 +30,7 @@ void EditorLayer::OnAttach()
 
 	// Create Panels
 	m_ScenePanel = new ScenePanel();
-	m_ScenePanel->SetContext(m_EditorScene);
+	m_ScenePanel->SetContext(m_ActiveScene);
 
 	m_EntityPanel = new EntityPanel();
 	m_FileBrowserPanel = new FileBrowserPanel();
@@ -57,8 +58,6 @@ void EditorLayer::OnAttach()
 		m_EditorCameraController = new PerspectiveController();
 
 	m_EditorCameraController->SetCamera(m_EditorCamera);
-
-	m_ActiveScene = m_EditorScene;
 }
 
 void EditorLayer::OnDetach()
@@ -201,7 +200,6 @@ void EditorLayer::OnImGuiRender()
 			}
 
 			if (Arcane::InputManager::GetKeyReleased(32)) {
-				//m_SceneRenderer->ReadGeometryFramebufferPixel(1);
 				if (m_State == SceneState::EDIT) {
 					OnScenePlay();
 				}
@@ -274,7 +272,9 @@ void EditorLayer::OnScenePlay()
 {
 	m_State = SceneState::PLAY;
 
-	m_ActiveScene = Arcane::Scene::Copy(m_EditorScene);
+	m_RuntimeScene = Arcane::Scene::Copy(m_EditorScene);
+	m_ActiveScene = m_RuntimeScene; 
+
 	m_ActiveScene->SetSceneRenderer(m_SceneRenderer);
 
 	m_ActiveScene->OnRuntimeStart();
@@ -286,5 +286,9 @@ void EditorLayer::OnSceneStop()
 {
 	m_State = SceneState::EDIT;
 	m_ActiveScene = m_EditorScene;
+
+	delete m_RuntimeScene;
+	m_RuntimeScene = nullptr;
+
 	m_ScenePanel->SetContext(m_ActiveScene);
 }