add more module

native/cocos/particle/Emitter.h

@@ -20,6 +20,7 @@ struct Emitter {
     uint32_t capacity{1000};
     uint32_t fixedRandomSeed{0};
     float duration{5.F};
+    float filpRotation{0.F};
     CurveRange delay{0};
 
 

native/cocos/particle/ParticleSystem.cpp

@@ -6,19 +6,19 @@
 #include <cmath>
 
 namespace cc {
-void ParticleSystem::updateEmitterState(float deltaTime) {
+void ParticleSystem::updateEmitterState(ModuleUpdateContext& context) {
     // in first frame, we should initialize some value; 
-    if (_emitter.age < deltaTime) {
+    if (_emitter.age < context.deltaTime) {
         _emitter.randomSeed = _emitter.autoRandomSeed ? _emitter.fixedRandomSeed : ParticleSystemManager::getInstance().getRandomSeed();
         _emitter.emissionRemainderOverTime = 0.F;
         _emitter.emissionRemainderOverDistance = 0.F;
         _emitter.tickCount = 0;
     }
     _emitter.tickCount++;
     float prevTime = _emitter.age;
-    _emitter.age += deltaTime;
+    _emitter.age += context.deltaTime;
     float currentTime = _emitter.age;
-    float currentDelay = _emitter.delay.evaluateSlow(1.F, Rand::rand1(_emitter.randomSeed, 0, 0));
+    float currentDelay = _emitter.delay.evaluateSlow(1.F, Rand::randomFloat(_emitter.randomSeed, 0, 0));
     float currentDuration = std::max((double)_emitter.duration, mathutils::EPSILON);
 
     prevTime -= currentDelay;
@@ -41,4 +41,21 @@ void ParticleSystem::updateEmitterState(float deltaTime) {
     _emitter.loopedAge = currentTime;
     _emitter.normalizedLoopAge = currentTime * invDuration;
 }
+
+void ParticleSystem::updateEmissionModules(ModuleUpdateContext& context) {
+    context.spawnInfos.clear();
+    if (_emissionOverTime && _emissionOverTime->isEnabled()) {
+        _emissionOverTime->update(context);
+    }
+    if (_emissionOverDistance && _emissionOverDistance->isEnabled()) {
+        _emissionOverDistance->update(context);
+    }
+    if (_emissionByBurst && _emissionByBurst->isEnabled()) {
+        _emissionByBurst->update(context);
+    }
+    if (_emissionByEvent && _emissionByEvent->isEnabled()) {
+        _emissionByEvent->update(context);
+    }
+}
+
 }

native/cocos/particle/ParticleSystem.h

@@ -41,25 +41,27 @@ class ParticleSystem {
     ParticleSystem() = default;
     ~ParticleSystem() = default;
 
-    inline uint32_t getParticleCount() const {
-        return _particles.size();
+    inline size_t getParticleCount() const {
+        return _particles.count();
     }
 
     void tick(float deltaTime);
-    void updateEmitterState(float deltaTime);
-    void updateEmissionModules();
-    void spawnParticles();
-    void initializeParticles();
-    void preUpdateIncrementalModules();
+    void updateEmitterState(ModuleUpdateContext& context);
+    void updateEmissionModules(ModuleUpdateContext& context);
+    void spawnParticles(ModuleUpdateContext& context);
+    void initializeParticles(ModuleUpdateContext& context);
+    void preUpdateIncrementalModules(ModuleUpdateContext& context);
     void updateParticleVelocity(ModuleUpdateContext& context);
-    void updateIncrementalModules();
-    void updateParticleState();
-    void updateNonIncrementalModules();
-    void updateRenderer();
+    void updateIncrementalModules(ModuleUpdateContext& context);
+    void updateParticleState(ModuleUpdateContext& context);
+    void updateNonIncrementalModules(ModuleUpdateContext& context);
+    void updateRenderer(ModuleUpdateContext& context);
 
 private:
     Emitter     _emitter{};
     Particles   _particles{};
+    std::vector<SpawnInfo> spawnInfos{};
+    std::unordered_map<std::string, std::vector<EventInfo>> eventInfos{};
     // Particle Emission modules
     std::unique_ptr<EmissionOverTime>               _emissionOverTime{nullptr};
     std::unique_ptr<EmissionOverDistance>           _emissionOverDistance{nullptr};
@@ -80,13 +82,13 @@ class ParticleSystem {
     std::unique_ptr<GravityOverLifetime>            _gravityOverLifetime{nullptr};
     std::unique_ptr<DragOverLifetime>               _dragOverLifetime{nullptr};
     std::unique_ptr<CurlNoiseForceOverLifetime>     _curlNoiseForceOverLifetime{nullptr};
+    std::unique_ptr<SpeedMultiplierOverLifetime>    _speedMultiplierOverLifetime{nullptr};
     std::unique_ptr<InheritVelocityOverLifetime>    _inheritVelocityOverLifetime{nullptr};
     std::unique_ptr<LinearVelocityOverLifetime>     _linearVelocityOverLifetime{nullptr};
     std::unique_ptr<OrbitalVelocityOverLifetime>    _orbitalVelocityOverLifetime{nullptr};
 
 
     std::unique_ptr<LimitVelocityOverLifetime>      _limitVelocityOverLifetime{nullptr};
-    std::unique_ptr<SpeedMultiplierOverLifetime>    _speedMultiplierOverLifetime{nullptr};
     std::unique_ptr<RotationBySpeed>                _rotationBySpeed{nullptr};
     std::unique_ptr<RotationOverLifetime>           _rotationOverLifetime{nullptr};
 

native/cocos/particle/ParticleSystemManager.h

@@ -14,7 +14,7 @@ class ParticleSystemManager {
     }
 
     inline uint32_t getRandomSeed() {
-        return Rand::randInt(seed++, (uint32_t)time(nullptr), 0);
+        return Rand::randomInt(seed++, (uint32_t)time(nullptr), 0);
     }
 
 private:

native/cocos/particle/ParticleSystemModule.h

@@ -3,32 +3,41 @@
 #include <string>
 #include "particle/Emitter.h"
 #include "particle/Particles.h"
+#include "math/Mat4.h"
 
 namespace cc {
 
-struct EmissionInfo {
-    EmissionInfo() = default;
-    inline EmissionInfo(uint32_t count, float intervalDt, float intervalNormalizedT, float interpStartDt, float interpStartNormalizedT):
+struct SpawnInfo {
+    SpawnInfo() = default;
+    inline SpawnInfo(uint32_t count, float intervalDt, float intervalNormalizedT, float interpStartDt, float interpStartNormalizedT, const Mat4& localToSimulation):
         count(count), intervalDt(intervalDt), intervalNormalizedT(intervalNormalizedT), interpStartDt(interpStartDt), interpStartNormalizedT(interpStartNormalizedT) {}
-    ~EmissionInfo() = default;
+    ~SpawnInfo() = default;
 
     float intervalDt{0.F};
     float intervalNormalizedT{0.F};
     float interpStartDt{0.F};
     float interpStartNormalizedT{0.F};
     uint32_t count{0};
+    Mat4 localToSimulation{};
+};
+
+struct EventInfo {
+
 };
 
 struct ModuleUpdateContext {
-    explicit ModuleUpdateContext(Particles& particles, Emitter& emitter, uint32_t fromIndex, uint32_t toIndex, float deltaTime) : particles(particles), emitter(emitter), fromIndex(fromIndex), toIndex(toIndex), deltaTime(deltaTime){};
+    explicit ModuleUpdateContext(Particles& particles, Emitter& emitter, std::vector<SpawnInfo>& spawnInfos, std::unordered_map<std::string, std::vector<EventInfo>>& eventInfos) : particles(particles),
+        emitter(emitter), spawnInfos(spawnInfos), eventInfos(eventInfos) {};
     ~ModuleUpdateContext() = default;
     Particles& particles;
     Emitter& emitter;
-    int32_t fromIndex{-1};
-    int32_t toIndex{-1};
-    int32_t emissionIndex{-1};
+    std::vector<SpawnInfo>& spawnInfos;
+    std::unordered_map<std::string, std::vector<EventInfo>>& eventInfos;
+    size_t fromIndex{0};
+    size_t toIndex{0};
+    int32_t spawnGroup{-1};
     float deltaTime{0};
-    std::vector<EmissionInfo> emissionInfos{};
+
 };
 
 class ParticleSystemModule {

native/cocos/particle/Particles.h

@@ -13,6 +13,14 @@ struct ParticleFloatArray {
     }
     ~ParticleFloatArray() = default;
 
+    inline size_t size() const {
+        return _data.size();
+    }
+
+    inline size_t capacity() const {
+        return _data.capacity();
+    }
+
     inline void operator=(const ParticleFloatArray& other) {
         _data = other._data;
     }
@@ -102,6 +110,14 @@ struct ParticleUInt32Array {
     ParticleUInt32Array() = default;
     ~ParticleUInt32Array() = default;
 
+    inline size_t size() const {
+        return _data.size();
+    }
+
+    inline size_t capacity() const {
+        return _data.capacity();
+    }
+
     inline uint32_t load(size_t index) const {
         return _data[index];
     }
@@ -119,6 +135,14 @@ struct ParticleColorArray {
     ParticleColorArray() = default;
     ~ParticleColorArray() = default;
 
+    inline size_t size() const {
+        return _data.size() << 2;
+    }
+
+    inline size_t capacity() const {
+        return _data.capacity() << 2;
+    }
+
     inline Color load(size_t index) const {
         index <<= 2;
         return Color(_data[index], _data[index + 1], _data[index + 2], _data[index + 3]);
@@ -140,6 +164,54 @@ struct Particles {
     Particles() = default;
     ~Particles() = default;
 
+    inline size_t count() const {
+        return id.size();
+    }
+
+    inline size_t capacity() const {
+        return id.capacity();
+    }
+
+    inline ParticleVec3Array& getVelocity() {
+        return velocity[_velocityIndex];
+    }
+
+    inline ParticleVec3Array& getPrevVelocity() {
+        return velocity[_prevVelocityIndex];
+    }
+
+    inline ParticleVec3Array& getSize() {
+        return size[_sizeIndex];
+    }
+
+    inline ParticleVec3Array& getPrevSize() {
+        return size[_prevSizeIndex];
+    }
+
+    inline ParticleVec3Array& getPosition() {
+        return position[_positionIndex];
+    }
+
+    inline ParticleVec3Array& getPrevSize() {
+        return position[_prevPositionIndex];
+    }
+
+    inline bool getUse3DSize() const {
+        return _use3DSize;
+    }
+
+    inline void setUse3DSize(bool val) {
+        _use3DSize = val;
+    }
+
+    inline bool getUseInitialDirection() const {
+        return _useInitialDirection;
+    }
+
+    inline void setUseInitialDirection(bool val) {
+        _useInitialDirection = val;
+    }
+
     ParticleUInt32Array id{};
     ParticleVec3Array   position[2]{};
     ParticleVec3Array   force{};
@@ -157,13 +229,15 @@ struct Particles {
     ParticleVec3Array   angularVelocity{};
     ParticleVec4Array   customData[2]{};
 
-    bool use3DSize{false};
-    uint8_t velocityIndex{0};
-    uint8_t prevVelocityIndex{1};
-    uint8_t sizeIndex{0};
-    uint8_t prevSizeIndex{1};
-    uint8_t positionIndex{0};
-    uint8_t prevPositionIndex{0};
+private:
+    bool _use3DSize{false};
+    bool _useInitialDirection{false};
+    uint8_t _velocityIndex{0};
+    uint8_t _prevVelocityIndex{1};
+    uint8_t _sizeIndex{0};
+    uint8_t _prevSizeIndex{1};
+    uint8_t _positionIndex{0};
+    uint8_t _prevPositionIndex{1};
 };
 }
 

native/cocos/particle/Rand.h

@@ -4,12 +4,19 @@
 #include "math/Vec3.h"
 
 namespace cc {
-class Rand {
-public:
-    static inline int32_t randInt(int32_t seed1, int32_t seed2, int32_t seed3) {
+struct Rand {
+
+    inline explicit Rand(int32_t seed1, int32_t seed2, int32_t seed3) : seed1(seed1), seed2(seed2), seed3(seed3), counter(0) {}
+
+    int32_t seed1;
+    int32_t seed2;
+    int32_t seed3;
+    uint32_t counter;
+
+    inline int32_t randomInt() {
         int32_t x = seed1 * 1664525 + 1013904223;
         int32_t y = seed2 * 1664525 + 1013904223;
-        int32_t z = seed3 * 1664525 + 1013904223;
+        int32_t z = (counter++ + seed3) * 1664525 + 1013904223;
         x += y * z;
         y += x * z;
         z += x * y;
@@ -18,14 +25,18 @@ class Rand {
         return x;
     }
 
-    static inline float rand1(int32_t seed1, int32_t seed2, int32_t seed3) {
-        return ((randInt(seed1, seed2, seed3) >> 8) & 0x00ffffff) / 16777216.0;
+    inline float randomFloat() {
+        return ((randomInt() >> 8) & 0x00ffffff) / 16777216.0;
     }
 
-    static inline Vec2 rand2(int32_t seed1, int32_t seed2, int32_t seed3) {
+    inline float randomRangedFloat(float min, float max) {
+        return min + (max - min) * randomFloat();
+    }
+
+    inline Vec2 randomVec2() {
         int32_t x = seed1 * 1664525 + 1013904223;
         int32_t y = seed2 * 1664525 + 1013904223;
-        int32_t z = seed3 * 1664525 + 1013904223;
+        int32_t z = (counter++ + seed3) * 1664525 + 1013904223;
         x += y * z;
         y += x * z;
         z += x * y;
@@ -35,10 +46,10 @@ class Rand {
         return Vec2((x >> 8) & 0x00ffffff, (y >> 8) & 0x00ffffff) / 16777216.0;
     }
 
-    static inline Vec3 rand3(int32_t seed1, int32_t seed2, int32_t seed3) {
+    inline Vec3 randomVec3() {
         int32_t x = seed1 * 1664525 + 1013904223;
         int32_t y = seed2 * 1664525 + 1013904223;
-        int32_t z = seed3 * 1664525 + 1013904223;
+        int32_t z = (counter++ + seed3) * 1664525 + 1013904223;
         x += y * z;
         y += x * z;
         z += x * y;
@@ -48,5 +59,14 @@ class Rand {
 
         return Vec3((x >> 8) & 0x00ffffff, (y >> 8) & 0x00ffffff, (z >> 8) & 0x00ffffff) / 16777216.0;
     }
+
+    inline Vec3 randomUnitVec3() {
+        float z = randomRangedFloat(-1.F, 1.F);
+        float theta = randomRangedFloat(0.F, math::PI_2);
+        float r = std::sqrt(1.F - z * z);
+        float x = r * std::cos(theta);
+        float y = r * std::sin(theta);
+        return Vec3(x, y, z);
+    }
 };
 }