1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
|
#include "UnityPrefix.h"
#include "RotationModule.h"
#include "Runtime/BaseClasses/ObjectDefines.h"
#include "Runtime/Serialize/TransferFunctions/SerializeTransfer.h"
#include "Runtime/Graphics/ParticleSystem/ParticleSystemUtils.h"
#include "Runtime/Math/Random/Random.h"
#include "Runtime/Math/Vector2.h"
struct DualMinMaxPolyCurves
{
MinMaxOptimizedPolyCurves optRot;
MinMaxPolyCurves rot;
};
template<ParticleSystemCurveEvalMode mode>
void UpdateTpl(const MinMaxCurve& curve, ParticleSystemParticles& ps, const size_t fromIndex, const size_t toIndex)
{
if ( !ps.usesRotationalSpeed ) return;
for (size_t q = fromIndex; q < toIndex; ++q)
{
const float time = NormalizedTime(ps, q);
const float random = GenerateRandom(ps.randomSeed[q] + kParticleSystemRotationCurveId);
ps.rotationalSpeed[q] += Evaluate<mode> (curve, time, random);
}
}
template<bool isOptimized>
void UpdateProceduralTpl(const DualMinMaxPolyCurves& curves, ParticleSystemParticles& ps)
{
const size_t count = ps.array_size ();
for (int q=0; q<count; q++)
{
float time = NormalizedTime(ps, q);
float random = GenerateRandom(ps.randomSeed[q] + kParticleSystemRotationCurveId);
float range = ps.startLifetime[q];
float value;
if(isOptimized)
value = EvaluateIntegrated (curves.optRot, time, random);
else
value = EvaluateIntegrated (curves.rot, time, random);
ps.rotation[q] += value * range;
}
}
RotationModule::RotationModule() : ParticleSystemModule(false)
{}
void RotationModule::Update (const ParticleSystemReadOnlyState& roState, const ParticleSystemState& state, ParticleSystemParticles& ps, const size_t fromIndex, const size_t toIndex)
{
if (m_Curve.minMaxState == kMMCScalar)
UpdateTpl<kEMScalar>(m_Curve, ps, fromIndex, toIndex);
else if(m_Curve.IsOptimized() && m_Curve.UsesMinMax())
UpdateTpl<kEMOptimizedMinMax>(m_Curve, ps, fromIndex, toIndex);
else if(m_Curve.IsOptimized())
UpdateTpl<kEMOptimized>(m_Curve, ps, fromIndex, toIndex);
else
UpdateTpl<kEMSlow>(m_Curve, ps, fromIndex, toIndex);
}
void RotationModule::UpdateProcedural (const ParticleSystemState& state, ParticleSystemParticles& ps)
{
DualMinMaxPolyCurves curves;
if(m_Curve.IsOptimized())
{
curves.optRot = m_Curve.polyCurves; curves.optRot.Integrate();
UpdateProceduralTpl<true>(curves, ps);
}
else
{
DebugAssert(CurvesSupportProcedural (m_Curve.editorCurves, m_Curve.minMaxState));
BuildCurves(curves.rot, m_Curve.editorCurves, m_Curve.GetScalar(), m_Curve.minMaxState); curves.rot.Integrate();
UpdateProceduralTpl<false>(curves, ps);
}
}
template<class TransferFunction>
void RotationModule::Transfer (TransferFunction& transfer)
{
ParticleSystemModule::Transfer (transfer);
transfer.Transfer (m_Curve, "curve");
}
INSTANTIATE_TEMPLATE_TRANSFER(RotationModule)
|
