Conserve memory allocations & Improve animation system.

Use memory when we need it 😠

core/2d/CCParticleSystem.cpp

@@ -138,9 +138,7 @@ bool ParticleData::init(int count)
     deltaColorG        = (float*)malloc(count * sizeof(float));
     deltaColorB        = (float*)malloc(count * sizeof(float));
     deltaColorA        = (float*)malloc(count * sizeof(float));
-    hue                = (float*)malloc(count * sizeof(float));
+
-    sat                = (float*)malloc(count * sizeof(float));
-    val                = (float*)malloc(count * sizeof(float));
     size               = (float*)malloc(count * sizeof(float));
     deltaSize          = (float*)malloc(count * sizeof(float));
     rotation           = (float*)malloc(count * sizeof(float));
@@ -148,10 +146,6 @@ bool ParticleData::init(int count)
     deltaRotation      = (float*)malloc(count * sizeof(float));
     totalTimeToLive    = (float*)malloc(count * sizeof(float));
     timeToLive         = (float*)malloc(count * sizeof(float));
-    animTimeLength     = (float*)malloc(count * sizeof(float));
-    animTimeDelta      = (float*)malloc(count * sizeof(float));
-    animIndex          = (unsigned short*)malloc(count * sizeof(unsigned short));
-    animCellIndex      = (unsigned short*)malloc(count * sizeof(unsigned short));
     atlasIndex         = (unsigned int*)malloc(count * sizeof(unsigned int));
 
     modeA.dirX            = (float*)malloc(count * sizeof(float));
@@ -165,10 +159,10 @@ bool ParticleData::init(int count)
     modeB.radius           = (float*)malloc(count * sizeof(float));
 
     return posx && posy && startPosX && startPosY && colorR && colorG && colorB && colorA && deltaColorR &&
-           deltaColorG && deltaColorB && deltaColorA && hue && sat && val && size && deltaSize && rotation &&
+           deltaColorG && deltaColorB && deltaColorA && size && deltaSize && rotation && staticRotation &&
-           staticRotation && deltaRotation && totalTimeToLive && timeToLive && animTimeLength && animTimeDelta &&
+           deltaRotation && totalTimeToLive && timeToLive && atlasIndex && modeA.dirX && modeA.dirY &&
-           animIndex && animCellIndex && atlasIndex && modeA.dirX && modeA.dirY && modeA.radialAccel &&
+           modeA.radialAccel && modeA.tangentialAccel && modeB.angle && modeB.degreesPerSecond && modeB.deltaRadius &&
-           modeA.tangentialAccel && modeB.angle && modeB.degreesPerSecond && modeB.deltaRadius && modeB.radius;
+           modeB.radius;
 }
 
 void ParticleData::release()
@@ -226,6 +220,8 @@ ParticleSystem::ParticleSystem()
     , _atlasIndex(0)
     , _transformSystemDirty(false)
     , _allocatedParticles(0)
+    , _isAnimAllocated(false)
+    , _isHSVAllocated(false)
     , _isActive(true)
     , _particleCount(0)
     , _duration(0)
@@ -244,6 +240,7 @@ ParticleSystem::ParticleSystem()
     , _endSpinVar(0)
     , _spawnAngle(0)
     , _spawnAngleVar(0)
+    , _isHsv(false)
     , _hsv(0, 1, 1)
     , _hsvVar(0, 0, 0)
     , _emissionRate(0)
@@ -314,6 +311,51 @@ Vector<ParticleSystem*>& ParticleSystem::getAllParticleSystems()
     return __allInstances;
 }
 
+bool ParticleSystem::allocAnimationMem()
+{
+    if (!_isAnimAllocated)
+    {
+        _particleData.animTimeLength = (float*)malloc(_totalParticles * sizeof(float));
+        _particleData.animTimeDelta  = (float*)malloc(_totalParticles * sizeof(float));
+        _particleData.animIndex      = (unsigned short*)malloc(_totalParticles * sizeof(unsigned short));
+        _particleData.animCellIndex  = (unsigned short*)malloc(_totalParticles * sizeof(unsigned short));
+    }
+    return _isAnimAllocated = _particleData.animTimeLength && _particleData.animTimeDelta &&
+                              _particleData.animIndex && _particleData.animCellIndex;
+}
+
+void ParticleSystem::deallocAnimationMem()
+{
+    if (!_isAnimAllocated)
+    {
+        CC_SAFE_FREE(_particleData.animTimeLength);
+        CC_SAFE_FREE(_particleData.animTimeDelta);
+        CC_SAFE_FREE(_particleData.animIndex);
+        CC_SAFE_FREE(_particleData.animCellIndex);
+    }
+}
+
+bool ParticleSystem::allocHSVMem()
+{
+    if (!_isHSVAllocated)
+    {
+        _particleData.hue = (float*)malloc(_totalParticles * sizeof(float));
+        _particleData.sat = (float*)malloc(_totalParticles * sizeof(float));
+        _particleData.val = (float*)malloc(_totalParticles * sizeof(float));
+    }
+    return _isHSVAllocated = _particleData.hue && _particleData.sat && _particleData.val;
+}
+
+void ParticleSystem::deallocHSVMem()
+{
+    if (!_isHSVAllocated)
+    {
+        CC_SAFE_FREE(_particleData.hue);
+        CC_SAFE_FREE(_particleData.sat);
+        CC_SAFE_FREE(_particleData.val);
+    }
+}
+
 void ParticleSystem::setTotalParticleCountFactor(float factor)
 {
     __totalParticleCountFactor = factor;
@@ -647,7 +689,7 @@ ParticleSystem::~ParticleSystem()
     CC_SAFE_RELEASE(_texture);
 }
 
-void ParticleSystem::addParticles(int count, int animationCellIndex, int animationIndex)
+void ParticleSystem::addParticles(int count, int animationIndex, int animationCellIndex)
 {
     if (_paused)
         return;
@@ -681,6 +723,30 @@ void ParticleSystem::addParticles(int count, int animationCellIndex, int animati
         _particleData.posy[i] = _sourcePosition.y + _posVar.y * RANDOM_KISS();
     }
 
+    if (animationCellIndex != -1 || animationIndex != -1)
+        allocAnimationMem();
+
+    if (_isAnimAllocated)
+    {
+        if (animationCellIndex != -1)
+            std::fill_n(_particleData.animCellIndex + start, _particleCount - start, animationCellIndex);
+        else
+            std::fill_n(_particleData.animCellIndex + start, _particleCount - start, 0xFFFF);
+
+        if (animationIndex != -1)
+        {
+            for (int i = start; i < _particleCount; ++i)
+            {
+                _particleData.animIndex[i] = animationIndex;
+                auto& descriptor           = _animations.at(animationIndex);
+                _particleData.animTimeLength[i] =
+                    descriptor.animationSpeed + descriptor.animationSpeedVariance * RANDOM_KISS();
+            }
+        }
+    }
+
+    if (_isLifeAnimated || _isEmitterAnimated || _isLoopAnimated)
+    {
         if (animationCellIndex == -1 && _isEmitterAnimated)
         {
             for (int i = start; i < _particleCount; ++i)
@@ -690,9 +756,6 @@ void ParticleSystem::addParticles(int count, int animationCellIndex, int animati
             }
         }
 
-    if (animationCellIndex != -1)
-        std::fill_n(_particleData.animCellIndex + start, _particleCount - start, animationCellIndex);
-
         if (animationIndex == -1 && !_animations.empty())
         {
             if (_randomAnimations.empty())
@@ -711,16 +774,6 @@ void ParticleSystem::addParticles(int count, int animationCellIndex, int animati
 
         if (_isEmitterAnimated || _isLoopAnimated)
             std::fill_n(_particleData.animTimeDelta + start, _particleCount - start, 0);
-
-    if (animationIndex != -1)
-    {
-        for (int i = start; i < _particleCount; ++i)
-        {
-            _particleData.animIndex[i] = animationIndex;
-            auto& descriptor           = _animations.at(animationIndex);
-            _particleData.animTimeLength[i] =
-                descriptor.animationSpeed + descriptor.animationSpeedVariance * RANDOM_KISS();
-        }
     }
 
     // color
@@ -752,6 +805,7 @@ void ParticleSystem::addParticles(int count, int animationCellIndex, int animati
     SET_DELTA_COLOR(_particleData.colorA, _particleData.deltaColorA);
 
     // hue saturation value color
+    if (_isHSVAllocated)
     {
         for (int i = start; i < _particleCount; ++i)
         {
@@ -915,6 +969,45 @@ void ParticleSystem::setAnimationDescriptor(unsigned short indexOfDescriptor,
     desc.reverseIndices         = reverse;
 }
 
+void ParticleSystem::setLifeAnimation(bool enabled)
+{
+    if (enabled && !allocAnimationMem())
+        return;
+
+    if (!enabled)
+        deallocAnimationMem();
+
+    _isLifeAnimated    = enabled;
+    _isEmitterAnimated = false;
+    _isLoopAnimated    = false;
+}
+
+void ParticleSystem::setEmitterAnimation(bool enabled)
+{
+    if (enabled && !allocAnimationMem())
+        return;
+
+    if (!enabled)
+        deallocAnimationMem();
+
+    _isEmitterAnimated = enabled;
+    _isLifeAnimated    = false;
+    _isLoopAnimated    = false;
+}
+
+void ParticleSystem::setLoopAnimation(bool enabled)
+{
+    if (enabled && !allocAnimationMem())
+        return;
+
+    if (!enabled)
+        deallocAnimationMem();
+
+    _isLoopAnimated    = enabled;
+    _isEmitterAnimated = false;
+    _isLifeAnimated    = false;
+}
+
 void ParticleSystem::resetAnimationIndices()
 {
     _animIndexCount = 0;
@@ -1175,6 +1268,12 @@ void ParticleSystem::update(float dt)
         for (int i = 0; i < _particleCount; ++i)
         {
             _particleData.timeToLive[i] -= dt;
+        }
+
+        if (_isLifeAnimated || _isEmitterAnimated || _isLoopAnimated)
+        {
+            for (int i = 0; i < _particleCount; ++i)
+            {
                 if (_isEmitterAnimated && !_animations.empty())
                 {
                     _particleData.animTimeDelta[i] += (_animationTimescaleInd ? pureDt : dt);
@@ -1191,16 +1290,18 @@ void ParticleSystem::update(float dt)
                 }
                 if (_isLifeAnimated && _animations.empty())
                 {
-                float percent = (_particleData.totalTimeToLive[i] - _particleData.timeToLive[i]) / _particleData.totalTimeToLive[i];
+                    float percent = (_particleData.totalTimeToLive[i] - _particleData.timeToLive[i]) /
+                                    _particleData.totalTimeToLive[i];
                     percent = _isAnimationReversed ? 1.0F - percent : percent;
-                _particleData.animCellIndex[i] = (unsigned short)MIN(percent * _animIndexCount, _animIndexCount - 1);
+                    _particleData.animCellIndex[i] =
+                        (unsigned short)MIN(percent * _animIndexCount, _animIndexCount - 1);
                 }
                 if (_isLifeAnimated && !_animations.empty())
                 {
                     auto& anim = _animations.at(_particleData.animIndex[i]);
 
-                float percent =
+                    float percent = (_particleData.totalTimeToLive[i] - _particleData.timeToLive[i]) /
-                    (_particleData.totalTimeToLive[i] - _particleData.timeToLive[i]) / _particleData.totalTimeToLive[i];
+                                    _particleData.totalTimeToLive[i];
                     percent = (!!_isAnimationReversed != !!anim.reverseIndices) ? 1.0F - percent : percent;
                     percent = MAX(0.0F, percent);
 
@@ -1225,6 +1326,7 @@ void ParticleSystem::update(float dt)
                 if (_isLoopAnimated && _animations.empty())
                     std::fill_n(_particleData.animTimeDelta, _particleCount, 0);
             }
+        }
 
         for (int i = 0; i < _particleCount; ++i)
         {
@@ -1614,6 +1716,17 @@ bool ParticleSystem::isActive() const
     return _isActive;
 }
 
+void ParticleSystem::useHSV(bool hsv)
+{
+    if (hsv && !allocHSVMem())
+        return;
+
+    if (!hsv)
+        deallocHSVMem();
+
+    _isHsv = hsv;
+};
+
 int ParticleSystem::getTotalParticles() const
 {
     return _totalParticles;

core/2d/CCParticleSystem.h

@@ -150,9 +150,12 @@ public:
         deltaColorB[p1] = deltaColorB[p2];
         deltaColorA[p1] = deltaColorA[p2];
 
+        if (hue && sat && val)
+        {
             hue[p1] = hue[p2];
             sat[p1] = sat[p2];
             val[p1] = val[p2];
+        }
 
         size[p1]           = size[p2];
         deltaSize[p1]      = deltaSize[p2];
@@ -162,11 +165,15 @@ public:
 
         totalTimeToLive[p1] = totalTimeToLive[p2];
         timeToLive[p1]      = timeToLive[p2];
+
+        if (animTimeDelta && animTimeLength && animIndex && animCellIndex)
+        {
             animTimeDelta[p1]  = animTimeDelta[p2];
             animTimeLength[p1] = animTimeLength[p2];
-
             animIndex[p1]      = animIndex[p2];
             animCellIndex[p1]  = animCellIndex[p2];
+        }
+
         atlasIndex[p1]    = atlasIndex[p2];
 
         modeA.dirX[p1]            = modeA.dirX[p2];
@@ -309,8 +316,17 @@ public:
      */
     static Vector<ParticleSystem*>& getAllParticleSystems();
 
+protected:
+    bool allocAnimationMem();
+    void deallocAnimationMem();
+    bool _isAnimAllocated;
+
+    bool allocHSVMem();
+    void deallocHSVMem();
+    bool _isHSVAllocated;
+
 public:
-    void addParticles(int count, int animationCellIndex = -1, int animationIndex = -1);
+    void addParticles(int count, int animationIndex = -1, int animationCellIndex = -1);
 
     void stopSystem();
     /** Kill all living particles.
@@ -721,7 +737,7 @@ public:
      *
      * @param hsv Use HSV color system.
      */
-    void useHSV(bool hsv) { _isHsv = hsv; };
+    void useHSV(bool hsv);
     bool isHSV() { return _isHsv; };
 
     /** Gets the hue of each particle.
@@ -861,28 +877,13 @@ public:
     bool isOpacityModifyRGB() const override { return _opacityModifyRGB; }
 
     /** Enables or disables tex coord animations that are set based on particle life. */
-    void setLifeAnimation(bool enabled)
+    void setLifeAnimation(bool enabled);
-    {
-        _isLifeAnimated = enabled;
-        _isEmitterAnimated = false;
-        _isLoopAnimated = false;
-    }
 
     /** Enables or disables tex coord animations that are set by the emitter randomly when a particle is emitted. */
-    void setEmitterAnimation(bool enabled)
+    void setEmitterAnimation(bool enabled);
-    {
-        _isEmitterAnimated = enabled;
-        _isLifeAnimated = false;
-        _isLoopAnimated = false;
-    }
 
     /** Enables or disables tex coord animations that are used to make particles play a sequence forever until they die */
-    void setLoopAnimation(bool enabled)
+    void setLoopAnimation(bool enabled);
-    {
-        _isLoopAnimated = enabled;
-        _isEmitterAnimated = false;
-        _isLifeAnimated = false;
-    }
 
     bool isLifeAnimated() { return _isLifeAnimated; }
     bool isEmitterAnimated() { return _isEmitterAnimated; }

core/2d/CCParticleSystemQuad.cpp

@@ -507,7 +507,7 @@ void ParticleSystemQuad::updateParticleQuads()
     // And wether if every property's memory of the particle system is continuous,
     // for the purpose of improving cache hit rate, we should process only one property in one for-loop.
     // It was proved to be effective especially for low-end devices.
-    if (_isLifeAnimated || _isEmitterAnimated || _isLoopAnimated)
+    if (_isLifeAnimated || _isEmitterAnimated || _isLoopAnimated || _isAnimAllocated)
     {
         V3F_C4B_T2F_Quad* quad    = startQuad;
         unsigned short* cellIndex = _particleData.animCellIndex;
@@ -521,7 +521,7 @@ void ParticleSystemQuad::updateParticleQuads()
 
             auto iter = _animationIndices.find(*cellIndex);
             if (iter == _animationIndices.end())
-                index.rect = _undefinedIndexRect;
+                index.rect = {0, 0, float(_texture->getPixelsWide()), float(_texture->getPixelsHigh())};
             else
                 index = iter->second;