ParticleSystem

Engine/BuiltInShaders/shaders/fs_particle.sc

@@ -0,0 +1,13 @@
+$input v_color0, v_texcoord0
+#include "../common/common.sh"
+
+SAMPLER2D(s_texColor, 0);
+
+void main()
+{
+	vec4 rgba = texture2D(s_texColor, v_texcoord0.xy);
+
+	rgba.xyz = rgba.xyz * v_color0.xyz;
+	rgba.w   = rgba.w * v_color0.w;
+	gl_FragColor = rgba;
+}

Engine/BuiltInShaders/shaders/fs_particleEmitterShape.sc

@@ -0,0 +1,6 @@
+#include "../common/common.sh"
+
+void main()
+{
+	gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
+}

Engine/BuiltInShaders/shaders/fs_particleforcefield.sc

@@ -0,0 +1,6 @@
+#include "../common/common.sh"
+
+void main()
+{
+	gl_FragColor = vec4(0.0, 1.0, 1.0, 1.0);
+}

Engine/BuiltInShaders/shaders/fs_wo_billboardparticle.sc

@@ -0,0 +1,13 @@
+$input v_color0, v_texcoord0
+#include "../common/common.sh"
+
+SAMPLER2D(s_texColor, 0);
+
+void main()
+{
+	vec4 rgba = texture2D(s_texColor, v_texcoord0.xy);
+
+	rgba.xyz = rgba.xyz * v_color0.xyz;
+	rgba.w   = rgba.w * v_color0.w;
+	gl_FragColor = rgba;
+}

Engine/BuiltInShaders/shaders/varying.def.sc

@@ -18,4 +18,10 @@ vec2  a_texcoord0        : TEXCOORD0;
 vec4  a_color0           : COLOR0;
 vec4  a_color1           : COLOR1;
 ivec4 a_indices          : BLENDINDICES;
-vec4  a_weight           : BLENDWEIGHT;
+vec4  a_weight           : BLENDWEIGHT;
+
+vec4 i_data0     : TEXCOORD7;
+vec4 i_data1     : TEXCOORD6;
+vec4 i_data2     : TEXCOORD5;
+vec4 i_data3     : TEXCOORD4;
+vec4 i_data4     : TEXCOORD3;

Engine/BuiltInShaders/shaders/vs_particle.sc

@@ -0,0 +1,30 @@
+#if defined(PARTICLEINSTANCE)
+$input a_position, a_color0, a_texcoord0, i_data0, i_data1 ,i_data2 ,i_data3 ,i_data4
+$output v_color0, v_texcoord0
+
+#include "../common/common.sh"
+
+void main()
+{
+	mat4 model = mtxFromCols(i_data0, i_data1, i_data2, i_data3);
+
+	vec4 worldPos = mul(model,vec4(a_position,1.0));
+	gl_Position = mul(u_viewProj, worldPos);
+	v_color0    = a_color0*i_data4;
+	v_texcoord0 = a_texcoord0;
+}
+#else
+$input a_position, a_color0, a_texcoord0
+$output v_color0, v_texcoord0
+
+#include "../common/common.sh"
+
+uniform vec4 u_particleColor;
+
+void main()
+{
+	gl_Position = mul(u_modelViewProj, vec4(a_position,1.0));
+	v_color0    = a_color0 * u_particleColor;
+	v_texcoord0 = a_texcoord0;
+}
+#endif

Engine/BuiltInShaders/shaders/vs_particleEmitterShape.sc

@@ -0,0 +1,10 @@
+$input a_position//, a_color1
+
+#include "../common/common.sh"
+
+uniform vec4 u_shapeRange;
+
+void main()
+{
+	gl_Position = mul(u_modelViewProj, vec4(a_position*u_shapeRange.xyz, 1.0));
+}

Engine/BuiltInShaders/shaders/vs_particleforcefield.sc

@@ -0,0 +1,8 @@
+$input a_position//, a_color1
+
+#include "../common/common.sh"
+
+void main()
+{
+	gl_Position = mul(u_modelViewProj, vec4(a_position, 1.0));
+}

Engine/BuiltInShaders/shaders/vs_wo_billboardparticle.sc

@@ -0,0 +1,62 @@
+#if defined(PARTICLEINSTANCE)
+$input a_position, a_color0, a_texcoord0, i_data0, i_data1 ,i_data2 ,i_data3 ,i_data4
+$output v_color0, v_texcoord0
+
+#include "../common/common.sh"
+
+uniform vec4 u_particlePos;
+uniform vec4 u_particleScale;
+
+void main()
+{
+	mat4 model = mtxFromCols(i_data0, i_data1, i_data2, i_data3);
+
+    mat4 billboardMatrix;
+    billboardMatrix[0] = vec4(
+        u_view[0][0]*u_particleScale.x,
+        u_view[1][0]*u_particleScale.x,
+        u_view[2][0]*u_particleScale.x,
+        0.0
+    );
+    billboardMatrix[1] = vec4(
+        u_view[0][1]*u_particleScale.y,
+        u_view[1][1]*u_particleScale.y,
+        u_view[2][1]*u_particleScale.y,
+        0.0
+    );
+    billboardMatrix[2] = vec4(
+        u_view[0][2]*u_particleScale.z,
+        u_view[1][2]*u_particleScale.z,
+        u_view[2][2]*u_particleScale.z,
+        0.0
+    );
+    billboardMatrix[3] = vec4(
+        u_particlePos.x,
+        u_particlePos.y,
+        u_particlePos.z,
+        1.0
+    );
+
+    model = mul(model,billboardMatrix);
+
+	vec4 worldPos = mul(model,vec4(a_position,1.0));
+	gl_Position = mul(u_viewProj, worldPos);
+	v_color0    = a_color0*i_data4;
+	v_texcoord0 = a_texcoord0;
+}
+#else
+$input a_position, a_color0, a_texcoord0
+$output v_color0, v_texcoord0
+
+#include "../common/common.sh"
+
+uniform vec4 u_particleColor;
+
+void main()
+{
+
+	gl_Position = mul(u_modelViewProj, vec4(a_position,1.0));
+	v_color0    = a_color0 * u_particleColor;
+	v_texcoord0 = a_texcoord0;
+}
+#endif

Engine/Source/Editor/ECWorld/ECWorldConsumer.cpp

@@ -74,21 +74,41 @@ void ECWorldConsumer::Execute(const cd::SceneDatabase* pSceneDatabase)
 		}
 	};
 
+	auto ParseMeshWithParticles= [&](cd::MeshID meshID,  const cd::ParticleEmitter& emitter)
+	{
+		engine::Entity meshEntity = m_pSceneWorld->GetWorld()->CreateEntity();
+
+		engine::MaterialType* pMaterialType = m_pSceneWorld->GetParticleMaterialType();
+
+		const auto& mesh = pSceneDatabase->GetMesh(meshID.Data());
+		AddParticleEmitter(meshEntity, mesh, pMaterialType->GetRequiredVertexFormat(),emitter);
+	};
+
 	// There are multiple kinds of cases in the SceneDatabase:
 	// 1. No nodes but have meshes in the SceneDatabase.
 	// 2. Only a root node with multiple meshes.
 	// 3. Node hierarchy.
 	// Another case is that we want to skip Node/Mesh which alreay parsed previously.
 	std::set<uint32_t> parsedMeshIDs;
+	m_particleMinID = 0;
 	for (const auto& mesh : pSceneDatabase->GetMeshes())
 	{
 		if (m_meshMinID > mesh.GetID().Data())
 		{
 			continue;
 		}
-
-		ParseMesh(mesh.GetID(), cd::Transform::Identity());
-		parsedMeshIDs.insert(mesh.GetID().Data());
+
+		if (pSceneDatabase->GetParticleEmitterCount())
+		{
+			ParseMeshWithParticles(mesh.GetID(), pSceneDatabase->GetParticleEmitter(m_particleMinID));
+			parsedMeshIDs.insert(mesh.GetID().Data());
+			++m_particleMinID;
+		}
+		else
+		{
+			ParseMesh(mesh.GetID(), cd::Transform::Identity());
+			parsedMeshIDs.insert(mesh.GetID().Data());
+		}
 	}
 
 	for (const auto& node : pSceneDatabase->GetNodes())
@@ -398,4 +418,43 @@ void ECWorldConsumer::AddBlendShape(engine::Entity entity, const cd::Mesh* pMesh
 	blendShapeComponent.Build();
 }
 
+void ECWorldConsumer::AddParticleEmitter(engine::Entity entity, const cd::Mesh& mesh, const cd::VertexFormat& vertexFormat, const cd::ParticleEmitter& emitter)
+{
+	engine::World* pWorld = m_pSceneWorld->GetWorld();
+	engine::MaterialType* pMaterialType = m_pSceneWorld->GetParticleMaterialType();
+	engine::NameComponent& nameComponent = pWorld->CreateComponent<engine::NameComponent>(entity);
+	nameComponent.SetName(emitter.GetName());
+	auto& particleEmitterComponent = pWorld->CreateComponent<engine::ParticleEmitterComponent>(entity);
+	// TODO : Some initialization here.
+	auto& transformComponent = pWorld->CreateComponent<engine::TransformComponent>(entity);
+	cd::Vec3f pos = emitter.GetPosition();
+	cd::Vec3f rotation = emitter.GetFixedRotation();
+	cd::Vec3f scale = emitter.GetFixedScale();
+	auto fixedrotation = cd::Math::RadianToDegree(rotation);
+	cd::Quaternion rotationQuat = cd::Quaternion::FromPitchYawRoll(fixedrotation.x(), fixedrotation.y(), fixedrotation.z());
+	transformComponent.GetTransform().SetTranslation(pos);
+	transformComponent.GetTransform().SetRotation(rotationQuat);
+	transformComponent.GetTransform().SetScale(scale);
+	transformComponent.Build();
+
+	particleEmitterComponent.SetRequiredVertexFormat(&vertexFormat);
+	////const cd::VertexFormat *requriredVertexFormat = emitter.GetVertexFormat();
+	////particleEmitterComponent.SetRequiredVertexFormat(requriredVertexFormat);
+	////particleEmitterComponent.GetParticleSystem().Init();
+	if (nameof::nameof_enum(emitter.GetType()) == "Sprite") { particleEmitterComponent.SetEmitterParticleType(engine::ParticleType::Sprite); }
+	else if (nameof::nameof_enum(emitter.GetType()) == "Ribbon") { particleEmitterComponent.SetEmitterParticleType(engine::ParticleType::Ribbon); }
+	else if (nameof::nameof_enum(emitter.GetType()) == "Ring") { particleEmitterComponent.SetEmitterParticleType(engine::ParticleType::Ring); }
+	else if (nameof::nameof_enum(emitter.GetType()) == "Model") { particleEmitterComponent.SetEmitterParticleType(engine::ParticleType::Model); }
+	else if (nameof::nameof_enum(emitter.GetType()) == "Track") { particleEmitterComponent.SetEmitterParticleType(engine::ParticleType::Track); }
+
+	particleEmitterComponent.SetSpawnCount(emitter.GetMaxCount());
+	particleEmitterComponent.SetEmitterColor(emitter.GetColor()/255.0f);
+	particleEmitterComponent.SetEmitterVelocity(emitter.GetVelocity());
+	particleEmitterComponent.SetEmitterAcceleration(emitter.GetAccelerate());
+	particleEmitterComponent.SetMeshData(&mesh); 
+	particleEmitterComponent.SetMaterialType(pMaterialType);
+	particleEmitterComponent.ActivateShaderFeature(engine::ShaderFeature::PARTICLE_INSTANCE);
+	particleEmitterComponent.Build();
+}
+
 }

Engine/Source/Editor/ECWorld/ECWorldConsumer.h

@@ -25,6 +25,7 @@ class Material;
 class Mesh;
 class Morph;
 class Node;
+class ParticleEmitter;
 class SceneDatabase;
 class Texture;
 class VertexFormat;
@@ -69,7 +70,7 @@ class ECWorldConsumer final : public cdtools::IConsumer
 	void AddAnimation(engine::Entity entity, const cd::Animation& animation, const cd::SceneDatabase* pSceneDatabase);
 	void AddMaterial(engine::Entity entity, const cd::Material* pMaterial, engine::MaterialType* pMaterialType, const cd::SceneDatabase* pSceneDatabase);
 	void AddBlendShape(engine::Entity entity, const cd::Mesh* pMesh, const cd::BlendShape& blendShape, const cd::SceneDatabase* pSceneDatabase);
-
+	void AddParticleEmitter(engine::Entity entity, const cd::Mesh& mesh, const cd::VertexFormat& vertexFormat, const cd::ParticleEmitter& emitter);
 private:
 	engine::MaterialType* m_pDefaultMaterialType = nullptr;
 	engine::SceneWorld* m_pSceneWorld = nullptr;
@@ -78,6 +79,7 @@ class ECWorldConsumer final : public cdtools::IConsumer
 
 	uint32_t m_nodeMinID;
 	uint32_t m_meshMinID;
+	uint32_t m_particleMinID = 0;
 };
 
 }

Engine/Source/Editor/EditorApp.cpp

@@ -34,6 +34,7 @@
 #include "Rendering/TerrainRenderer.h"
 #include "Rendering/WorldRenderer.h"
 #include "Rendering/ParticleRenderer.h"
+#include "Rendering/ParticleForceFieldRenderer.h"
 #include "Resources/FileWatcher.h"
 #include "Resources/ResourceBuilder.h"
 #include "Resources/ShaderBuilder.h"
@@ -260,19 +261,23 @@ void EditorApp::InitMaterialType()
 	constexpr const char* WorldProgram = "WorldProgram";
 	constexpr const char* AnimationProgram = "AnimationProgram";
 	constexpr const char* TerrainProgram = "TerrainProgram";
+	constexpr const char* ParticleProgram = "ParticleProgram";
 
 	constexpr engine::StringCrc WorldProgramCrc{ WorldProgram };
 	constexpr engine::StringCrc AnimationProgramCrc{ AnimationProgram };
 	constexpr engine::StringCrc TerrainProgramCrc{ TerrainProgram };
+	constexpr engine::StringCrc ParticleProgramCrc{ ParticleProgram};
 
 	m_pRenderContext->RegisterShaderProgram(WorldProgramCrc, { "vs_PBR", "fs_PBR" });
 	m_pRenderContext->RegisterShaderProgram(AnimationProgramCrc, { "vs_animation", "fs_animation" });
 	m_pRenderContext->RegisterShaderProgram(TerrainProgramCrc, { "vs_terrain", "fs_terrain" });
+	m_pRenderContext->RegisterShaderProgram(ParticleProgramCrc, { "vs_particle","fs_particle" });
 
 	m_pSceneWorld = std::make_unique<engine::SceneWorld>();
 	m_pSceneWorld->CreatePBRMaterialType(WorldProgram, IsAtmosphericScatteringEnable());
 	m_pSceneWorld->CreateAnimationMaterialType(AnimationProgram);
 	m_pSceneWorld->CreateTerrainMaterialType(TerrainProgram);
+	m_pSceneWorld->CreateParticleMaterialType(ParticleProgram);
 }
 
 void EditorApp::InitEditorCameraEntity()
@@ -416,6 +421,30 @@ void EditorApp::UpdateMaterials()
 	}
 }
 
+void EditorApp::UpdatePatricleInstanceState()
+{
+	for (engine::Entity entity : m_pSceneWorld->GetParticleEmitterEntities())
+	{
+		engine::ParticleEmitterComponent* pParticleEmitterComponent = m_pSceneWorld->GetParticleEmitterComponent(entity);
+		const std::string& programName = pParticleEmitterComponent->GetShaderProgramName();
+		const std::string& featuresCombine = pParticleEmitterComponent->GetFeaturesCombine();
+
+		// New shader feature added, need to compile new variants.
+		m_pRenderContext->CheckShaderProgram(entity, programName, featuresCombine);
+
+		// Shader source files have been modified, need to re-compile existing variants.
+		if (m_crtInputFocus && !m_preInputFocus)
+		{
+			m_pRenderContext->OnShaderHotModified(entity, programName, featuresCombine);
+		}
+	}
+
+	if (m_crtInputFocus && !m_preInputFocus)
+	{
+		m_pRenderContext->ClearModifiedProgramNameCrcs();
+	}
+}
+
 void EditorApp::CompileAndLoadShaders()
 {
 	// 1. Compile
@@ -554,6 +583,10 @@ void EditorApp::InitEngineRenderers()
 	pParticleRenderer->SetSceneWorld(m_pSceneWorld.get());
 	AddEngineRenderer(cd::MoveTemp(pParticleRenderer));
 
+	auto pParticleForceFieldRenderer = std::make_unique<engine::ParticleForceFieldRenderer>(m_pRenderContext->CreateView(), pSceneRenderTarget);
+	pParticleForceFieldRenderer->SetSceneWorld(m_pSceneWorld.get());
+	AddEngineRenderer(cd::MoveTemp(pParticleForceFieldRenderer));
+
 #ifdef ENABLE_DDGI
 	auto pDDGIRenderer = std::make_unique<engine::DDGIRenderer>(m_pRenderContext->CreateView(), pSceneRenderTarget);
 	pDDGIRenderer->SetSceneWorld(m_pSceneWorld.get());
@@ -742,6 +775,7 @@ bool EditorApp::Update(float deltaTime)
 		m_pEngineImGuiContext->Update(deltaTime);
 
 		UpdateMaterials();
+		UpdatePatricleInstanceState();
 		CompileAndLoadShaders();
 
 		for (std::unique_ptr<engine::Renderer>& pRenderer : m_pEngineRenderers)

Engine/Source/Editor/EditorApp.h

@@ -89,6 +89,7 @@ class EditorApp final : public engine::IApplication
 	void OnShaderHotModifiedCallback(const char* rootDir, const char* filePath);
 
 	void UpdateMaterials();
+	void UpdatePatricleInstanceState();
 	void CompileAndLoadShaders();
 	void OnShaderCompileFailed(uint32_t handle, std::span<const char> str);