//
//  SizeModule.cpp
//  cocos2d_libs
//
//  Created by 徐俊杰 on 2020/4/24.
//

#include "rparticle/Modules/SizeModule.h"

//#include "UnityPrefix.h"
//#include "rparticle/Modules/SizeModule.h"
//#include "Runtime/BaseClasses/ObjectDefines.h"
#include "rparticle/Serialize/TransferFunctions/SerializeTransfer.h"

#include "rparticle/Math/Random/Random.h"
#include "rparticle/ParticleSystemUtils.h"

NS_RRP_BEGIN

template<ParticleSystemCurveEvalMode mode>
void UpdateTpl(const MinMaxCurve& curve, const ParticleSystemParticles& ps, float* tempSize, size_t fromIndex, size_t toIndex)
{
    for (size_t q = fromIndex; q < toIndex; ++q)
    {
        const float time = NormalizedTime(ps, q);
        const float random = GenerateRandom(ps.randomSeed[q] + kParticleSystemSizeCurveId);
        tempSize[q] *= MAX(0.0f, Evaluate<mode> (curve, time, random));
    }
}

template<ParticleSystemCurveEvalMode mode>
void UpdateTplSingle(const MinMaxCurve& curve, const ParticleSystemParticle& particle, float& tempSize)
{
    const float time = NormalizedTime(particle);
    const float random = GenerateRandom(particle.randomSeed + kParticleSystemSizeCurveId);
    tempSize *= std::max<float>(0.0f, Evaluate<mode>(curve, time, random));
}

SizeModule::SizeModule() : ParticleSystemModule(false)
{}

void SizeModule::Update (const ParticleSystemParticles& ps, float* tempSize, size_t fromIndex, size_t toIndex)
{
    DebugAssert(toIndex <= ps.array_size ());
    if(m_Curve.minMaxState == kMMCScalar)
        UpdateTpl<kEMScalar>(m_Curve, ps, tempSize, fromIndex, toIndex);
    else if (m_Curve.IsOptimized() && m_Curve.UsesMinMax ())
        UpdateTpl<kEMOptimizedMinMax>(m_Curve, ps, tempSize, fromIndex, toIndex);
    else if(m_Curve.IsOptimized())
        UpdateTpl<kEMOptimized>(m_Curve, ps, tempSize, fromIndex, toIndex);
    else
        UpdateTpl<kEMSlow>(m_Curve, ps, tempSize, fromIndex, toIndex);
}

void SizeModule::UpdateSingle(const ParticleSystemParticle& particle, bool uses3DSize, float& tempSize) const
{
    if(m_Curve.minMaxState == kMMCScalar)
        UpdateTplSingle<kEMScalar>(m_Curve, particle, tempSize);
    else if (m_Curve.IsOptimized() && m_Curve.UsesMinMax ())
        UpdateTplSingle<kEMOptimizedMinMax>(m_Curve, particle, tempSize);
    else if(m_Curve.IsOptimized())
        UpdateTplSingle<kEMOptimized>(m_Curve, particle, tempSize);
    else
        UpdateTplSingle<kEMSlow>(m_Curve, particle, tempSize);
}

template<class TransferFunction>
void SizeModule::Transfer (TransferFunction& transfer)
{
    ParticleSystemModule::Transfer (transfer);
    transfer.Transfer (m_Curve, "curve");
}
INSTANTIATE_TEMPLATE_TRANSFER(SizeModule)

NS_RRP_END