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,14 @@
+$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;
+}

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,54 @@
+$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_cameraPos;
+uniform vec4 u_particleUp;
+
+void main()
+{
+	mat4 model = mtxFromCols(i_data0, i_data1, i_data2, i_data3);
+
+    vec4 forward = u_cameraPos - model[3];
+    forward = mul(model,forward);
+
+    vec4 right = vec4(
+    u_particleUp.y * forward.z - u_particleUp.z * forward.y,
+    u_particleUp.z * forward.x - u_particleUp.x * forward.z,
+    u_particleUp.x * forward.y - u_particleUp.y * forward.x,
+    1.0
+    );
+
+    float pitch = -atan2(forward.y, sqrt(forward.x * forward.x + forward.z * forward.z)); 
+    float yaw = -atan2(right.z, right.x);
+    float roll = atan2(right.x, -right.y);
+
+    mat4 pitchMatrix = mat4(
+        1.0, 0.0, 0.0, 0.0,
+        0.0, cos(pitch), -sin(pitch), 0.0,
+        0.0, sin(pitch), cos(pitch), 0.0,
+        0.0, 0.0, 0.0, 1.0
+    );
+
+    mat4 yawMatrix = mat4(
+        cos(yaw), 0.0, sin(yaw), 0.0,
+        0.0, 1.0, 0.0, 0.0,
+        -sin(yaw), 0.0, cos(yaw), 0.0,
+        0.0, 0.0, 0.0, 1.0
+    );
+
+    mat4 rollMatrix = mat4(
+        cos(roll), -sin(roll), 0.0, 0.0,
+        sin(roll), cos(roll), 0.0, 0.0,
+        0.0, 0.0, 1.0, 0.0,
+        0.0, 0.0, 0.0, 1.0
+    );
+    mat4 rotationMatrix = mul(pitchMatrix,mul(yawMatrix,rollMatrix));
+    model = mul(model,rotationMatrix);
+
+	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;
+}

Engine/Source/Editor/ECWorld/ECWorldConsumer.cpp

@@ -89,12 +89,23 @@ 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())
@@ -107,6 +118,14 @@ void ECWorldConsumer::Execute(const cd::SceneDatabase* pSceneDatabase)
 			ParseMeshWithMorphs(mesh.GetID(), cd::Transform::Identity(), pSceneDatabase->GetMorphs());
 			parsedMeshIDs.insert(mesh.GetID().Data());
 		}
+		//TODO: Change to " have a generic function to judge what is the purpose of mesh usage."
+		// The first case is your particle mesh. But in the future, there maybe lod meshes, imposter meshes, collision meshes... So pre-sort meshes by purpose is better.
+		else if (pSceneDatabase->GetParticleEmitterCount())
+		{
+			ParseMeshWithParticles(mesh.GetID(), pSceneDatabase->GetParticleEmitter(m_particleMinID));
+			parsedMeshIDs.insert(mesh.GetID().Data());
+			++m_particleMinID;
+		}
 		else 
 		{
 			ParseMesh(mesh.GetID(), cd::Transform::Identity());
@@ -345,4 +364,40 @@ void ECWorldConsumer::AddMorphs(engine::Entity entity, const std::vector<cd::Mor
 	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::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.Build();
+}
+
 }

Engine/Source/Editor/ECWorld/ECWorldConsumer.h

@@ -24,6 +24,7 @@ class Material;
 class Mesh;
 class Morph;
 class Node;
+class ParticleEmitter;
 class SceneDatabase;
 class Texture;
 class VertexFormat;
@@ -67,6 +68,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 AddMorphs(engine::Entity entity, const std::vector<cd::Morph>& morphs, const cd::Mesh* pMesh);
+	void AddParticleEmitter(engine::Entity entity, const cd::Mesh& mesh, const cd::VertexFormat& vertexFormat, const cd::ParticleEmitter& emitter);
 
 private:
 	engine::MaterialType* m_pDefaultMaterialType = nullptr;
@@ -75,6 +77,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

@@ -31,6 +31,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"
@@ -257,19 +258,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()
@@ -541,6 +546,14 @@ void EditorApp::InitEngineRenderers()
 	pParticlerenderer->SetSceneWorld(m_pSceneWorld.get());
 	AddEngineRenderer(cd::MoveTemp(pParticlerenderer));
 
+	//auto pParticleShapeRenderer = std::make_unique<engine::ParticleEmitterShapeRenderer>(m_pRenderContext->CreateView(), pSceneRenderTarget);
+	//pParticleShapeRenderer->SetSceneWorld(m_pSceneWorld.get());
+	//AddEngineRenderer(cd::MoveTemp(pParticleShapeRenderer));
+
+	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());

Engine/Source/Editor/UILayers/AssetBrowser.cpp

@@ -13,6 +13,7 @@
 #include "Log/Log.h"
 #include "Material/MaterialType.h"
 #include "Producers/CDProducer/CDProducer.h"
+#include "Producers/EffekseerProducer/EffekseerProducer.h"
 #include "Rendering/WorldRenderer.h"
 #include "Rendering/RenderContext.h"
 #include "Resources/ResourceBuilder.h"
@@ -98,6 +99,21 @@ bool IsLightInputFile(const char* pFileExtension)
 	return false;
 }
 
+bool IsParticleInputFile(const char* pFileExtension)
+{
+	constexpr const char* pFileExtensions[] = { ".efkefc"};
+	constexpr const int fileExtensionsSize = sizeof(pFileExtensions) / sizeof(pFileExtensions[0]);
+	for (int extensionIndex = 0; extensionIndex < fileExtensionsSize; ++extensionIndex)
+	{
+		if (0 == strcmp(pFileExtensions[extensionIndex], pFileExtension))
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
 std::string GetFilePathExtension(const std::string& FileName)
 {
 	auto pos = FileName.find_last_of('.');
@@ -780,6 +796,10 @@ void AssetBrowser::ImportAssetFile(const char* pFilePath)
 		{
 			m_importOptions.AssetType = IOAssetType::Light;
 		}
+		else if (IsParticleInputFile(pFileExtension.c_str()))
+		{
+			m_importOptions.AssetType = IOAssetType::Particle;
+		}
 		else
 		{
 			// Still unknown, exit.
@@ -852,6 +872,10 @@ void AssetBrowser::ImportAssetFile(const char* pFilePath)
 	{
 		ImportJson(pFilePath);
 	}
+	else if (IOAssetType::Particle == m_importOptions.AssetType)
+	{
+		ImportParticleEffect(pFilePath);
+	}
 }
 
 void AssetBrowser::ProcessSceneDatabase(cd::SceneDatabase* pSceneDatabase, bool keepMesh, bool keepMaterial, bool keepTexture, bool keepCamera, bool keepLight)
@@ -1085,6 +1109,36 @@ void AssetBrowser::ImportJson(const char* pFilePath)
 	}
 }
 
+void AssetBrowser::ImportParticleEffect(const char* pFilePath)
+{
+	////engine::RenderContext* pCurrentRenderContext = GetRenderContext();
+	//engine::SceneWorld* pSceneWorld = GetImGuiContextInstance()->GetSceneWorld();
+
+	//cd::SceneDatabase* pSceneDatabase = pSceneWorld->GetSceneDatabase();
+	////uint32_t oldNodeCount = pSceneDatabase->GetNodeCount();
+	////uint32_t oldMeshCount = pSceneDatabase->GetMeshCount();
+	//uint32_t oldParticleEmitterCount = pSceneDatabase->GetParticleEmitterCount();
+
+	//// Step 1 : Convert model file to cd::SceneDatabase
+	//std::filesystem::path inputFilePath(pFilePath);
+	//std::filesystem::path inputFileExtension = inputFilePath.extension();
+	//if (0 == inputFileExtension.compare(".efkefc"))
+	//{
+	///*	cdtools::CDProducer cdProducer(pFilePath);
+	//	cd::SceneDatabase newSceneDatabase;
+	//	cdtools::Processor processor(&cdProducer, nullptr, &newSceneDatabase);
+	//	proce qssor.Run();
+	//	pSceneDatabase->Merge(cd::MoveTemp(newSceneDatabase));*/
+	//	std::string filePath = pFilePath;
+	//	int size = MultiByteToWideChar(CP_UTF8, 0, filePath.c_str(), -1, nullptr, 0);
+	//	std::wstring wstr(size, 0);
+	//	MultiByteToWideChar(CP_UTF8, 0, filePath.c_str(), -1, &wstr[0], size);
+	//	std::wstring wFilePath = wstr;
+	//	const char16_t* u16_cstr = reinterpret_cast<const char16_t*>(wFilePath.c_str());
+	//	cdtools::EffekseerProducer efkProducer(u16_cstr);
+	//}
+}
+
 void AssetBrowser::ExportAssetFile(const char* pFilePath)
 {
 	engine::SceneWorld* pSceneWorld = GetImGuiContextInstance()->GetSceneWorld();