protected virtual void GetParticleSystem()
{
_particleSystem = GetComponentInChildren <ParticleSystem>();
particleRenderer = GetComponentInChildren <ParticleSystemRenderer>();
// Modules - for ease of access
mainModule = _particleSystem.main;
collisionModule = _particleSystem.collision;
colorBySpeedModule = _particleSystem.colorBySpeed;
colorOverTimeModule = _particleSystem.colorOverLifetime;
customDataModule = _particleSystem.customData;
emissionModule = _particleSystem.emission;
externalForcesModule = _particleSystem.externalForces;
forceOverTimeModule = _particleSystem.forceOverLifetime;
inheritVelocityModule = _particleSystem.inheritVelocity;
lightsModule = _particleSystem.lights;
limitVelocityOverTimeModule = _particleSystem.limitVelocityOverLifetime;
noiseModule = _particleSystem.noise;
rotationBySpeedModule = _particleSystem.rotationBySpeed;
sizeBySpeedModule = _particleSystem.sizeBySpeed;
sizeOverTimeModule = _particleSystem.sizeOverLifetime;
trailModule = _particleSystem.trails;
triggerModule = _particleSystem.trigger;
shapeModule = _particleSystem.shape;
velOverTimeModule = _particleSystem.velocityOverLifetime;
}
private void Awake()
{
if (!_isReady)
{
DebugLog.ToConsole($"Warning - Awake() ran when _isReady is false!", OWML.Common.MessageType.Warning);
return;
}
_particleSystem = GetComponent <ParticleSystem>();
if (_particleSystem == null)
{
DebugLog.ToConsole($"Error - _particleSystem is null.", OWML.Common.MessageType.Error);
_isReady = false;
return;
}
_rotation = transform.rotation;
_mainModule = _particleSystem.main;
_mainModule.simulationSpace = ParticleSystemSimulationSpace.Custom;
_mainModule.customSimulationSpace = _simulationSpace;
_velocityOverLifetimeModule = _particleSystem.velocityOverLifetime;
_velocityOverLifetimeVector = new RelativisticParticleSystem.ModuleVector(_velocityOverLifetimeModule.x, _velocityOverLifetimeModule.y, _velocityOverLifetimeModule.z);
_limitVelocityOverLifetimeModule = _particleSystem.limitVelocityOverLifetime;
_limitVelocityOverLifetimeVector = new RelativisticParticleSystem.ModuleVector(_limitVelocityOverLifetimeModule.limitX, _limitVelocityOverLifetimeModule.limitY, _limitVelocityOverLifetimeModule.limitZ);
_forceOverLifetimeModule = _particleSystem.forceOverLifetime;
_forceOverLifetimeVector = new RelativisticParticleSystem.ModuleVector(_forceOverLifetimeModule.x, _forceOverLifetimeModule.y, _forceOverLifetimeModule.z);
}
public void UpdateGravity()
{
// Debug.Log("UpdateGravity");
ParticleSystem.ForceOverLifetimeModule fol = _ps.forceOverLifetime;
fol.x = new ParticleSystem.MinMaxCurve(Physics2D.gravity.x * .1f);
fol.y = new ParticleSystem.MinMaxCurve(Physics2D.gravity.y * .1f);
}
//
// public AnimationCurve x;
//
// // Use this for initialization
// void Start () {
// par = GetComponent<ParticleSystem> ();
// rig = transform.parent.gameObject.GetComponent<Rigidbody> ();
// x = AnimationCurve.Constant (0, 1f, 0f);
// }
//
// // Update is called once per frame
// void Update () {
// //x = AnimationCurve.Constant (0, 1f, rig.velocity.x * i);
// //par.forceOverLifetime.x.constant = rig.velocity.x * i;
// var temp = par.forceOverLifetime.x;
// par.forceOverLifetime.x = temp;
// }
void Start()
{
rig = transform.parent.gameObject.GetComponent <Rigidbody> ();
ps = GetComponent <ParticleSystem>();
fo = ps.forceOverLifetime;
fo.enabled = true;
}
// Update is called once per frame
void Update()
{
int randNum = Random.Range(0, 100);
if (randNum > 96)
{
foreach (ParticleSystem system in systems)
{
ParticleSystem.ForceOverLifetimeModule forceOverLifetime = system.forceOverLifetime;
if (forceOverLifetime.x.constant < 5f)
{
forceOverLifetime.x = forceOverLifetime.x.constant + 1f;
}
}
}
else if (randNum < 3)
{
foreach (ParticleSystem system in systems)
{
ParticleSystem.ForceOverLifetimeModule forceOverLifetime = system.forceOverLifetime;
if (forceOverLifetime.x.constant > -5f)
{
forceOverLifetime.x = forceOverLifetime.x.constant - 1f;
}
}
}
}
// load the needed properties for fireflies particle system
void Start()
{
this.fireFliesEmission = this.firefliesSystem.emission;
this.fireFliesForceOverTime = this.firefliesSystem.forceOverLifetime;
this.fireFliesSizeOverTime = this.firefliesSystem.sizeOverLifetime;
this.fireFliesMain = this.firefliesSystem.main;
this.fireFliesSizeOverTime.enabled = true;
this.fireFliesEmission.enabled = true;
this.fireFliesForceOverTime.enabled = true;
this.fireFliesMain.startLifetime = this.fireFilesLifetimeSeconds;
this.fireFliesEmission.rateOverTime = 0;
this.fireFliesSizeOverTime.separateAxes = false;
this.fireFliesSizeOverTime.x = new ParticleSystem.MinMaxCurve(sizeCurveMultiplier, sizeCurve);
this.fireFliesForceOverTime.x = new ParticleSystem.MinMaxCurve(forceCurveMultiplier, xForceCurve);
this.fireFliesForceOverTime.y = new ParticleSystem.MinMaxCurve(forceCurveMultiplier, yForceCurve);
this.fireFliesForceOverTime.z = new ParticleSystem.MinMaxCurve(forceCurveMultiplier, zForceCurve);
this.fireFliesForceOverTime.randomized = true;
this.fireFliesMain.playOnAwake = false;
this.fireFliesMain.loop = false;
}
// Update is called once per frame
void Update()
{
InputValues inputs = InputHandler.GetInputs();
//TODO: check that the panID is in range of pan count once we have a Static Game Class
if (hobID < 0 || hobID >= 3) //i know there 3 but still.
{
Debug.LogError("Pan Id Out of range (obj name: " + name + ")");
return;
}
// Update the particleSystem
float hobPercent = (inputs.hobs[hobID] / 1023f);
ParticleSystem.MainModule mainMod = particleSystem.main;
mainMod.startLifetime = lifetime.GetValue(hobPercent);
ParticleSystem.ForceOverLifetimeModule forceMod = particleSystem.forceOverLifetime;
forceMod.y = yForce.GetValue(hobPercent);
ParticleSystem.EmissionModule emissionMod = particleSystem.emission;
emissionMod.rateOverTime = emissions.GetValue(hobPercent);
// send temp to pan.
float temperureDif = maxTemperture - minTemperture;
float temp = minTemperture + (temperureDif * hobPercent);
fryingPan.AddTempture(temp);
}
float Fire_z = 0f;//火焰角度
// Use this for initialization
void Start()
{
particleSystem = GetComponent <ParticleSystem>();
forceMode = particleSystem.forceOverLifetime;
//记录初始参数值，方便还原
ParticleSystem.MinMaxCurve origin_x = forceMode.x;
ParticleSystem.MinMaxCurve origin_y = forceMode.y;
origin_stratSize = particleSystem.startSize;
origin_startLifetime = particleSystem.startLifetime;
/*
* Debug.Log(forceMode.x.constantMax);
* Debug.Log(forceMode.y.constantMax);
* Debug.Log(particleSystem.startSize);
* Debug.Log(particleSystem.startLifetime);
* Debug.Log(origin_stratSize);
* Debug.Log(origin_startLifetime);
*/
//激活陀螺仪
Input.gyro.enabled = true;
//因安卓设备的陀螺仪四元数水平值为[0,0,0,0]水平向下，所以将相机初始位置修改与其对齐
transform.eulerAngles = new Vector3(90, 90, 0);
}
void Awake()
{
smokeMax = smoke.startSpeed;
dragMax = smoke.forceOverLifetime.z.constant;
drag = smoke.forceOverLifetime;
rb = GetComponent <Rigidbody2D>();
}
private void FixedUpdate()
{
if (!inited)
{
Start();
inited = true;
}
if (process)
{
float b = 0f;
if (frame == frameSkip)
{
frame = 0;
b = ((!Physics.Raycast(base.transform.position + new Vector3(0f, 2f, 0f), Vector3.up, out RaycastHit _, float.PositiveInfinity)) ? maxEmit : minEmit);
}
else
{
frame++;
}
pFX.emissionRate = Mathf.Lerp(pFX.emission.rateOverTime.constantMax, b, speed * Time.deltaTime);
ParticleSystem.NoiseModule noiseModule = pFX.noise;
float num2 = noiseModule.strengthMultiplier = Mathf.Lerp(pFX.noise.strengthMultiplier, noise, speed * Time.deltaTime);
ParticleSystem.ForceOverLifetimeModule forceOverLifetime = pFX.forceOverLifetime;
Vector3 vector = Vector3.Normalize(windDirection) * windStrength;
forceOverLifetime.x = vector.x;
forceOverLifetime.y = vector.y;
forceOverLifetime.z = vector.z;
base.transform.rotation = Quaternion.identity;
}
}
public PersistentKSPShurikenEmitter(
GameObject go,
ParticleSystem pe,
ParticleSystemRenderer pr,
KSPParticleEmitter templateKspParticleEmitter)
{
this.go = go;
this.pe = pe;
this.pr = pr;
// TODO That s what we need to also save to emit manually with proper values
// float emitterVelocityScale
// Vector3 rndVelocity
// bool rndRotation
// float angularVelocity
// float rndAngularVelocity
//templateKspParticleEmitter.ve
shape = templateKspParticleEmitter.shape;
scale1DBase = shape1D = templateKspParticleEmitter.shape1D;
scale2DBase = shape2D = templateKspParticleEmitter.shape2D;
scale3DBase = shape3D = templateKspParticleEmitter.shape3D;
minEmissionBase = minEmission = templateKspParticleEmitter.minEmission;
maxEmissionBase = maxEmission = templateKspParticleEmitter.maxEmission;
minEnergyBase = minEnergy = templateKspParticleEmitter.minEnergy;
maxEnergyBase = maxEnergy = templateKspParticleEmitter.maxEnergy;
minSizeBase = minSize = templateKspParticleEmitter.minSize;
maxSizeBase = maxSize = templateKspParticleEmitter.maxSize;
localVelocityBase = localVelocity = templateKspParticleEmitter.localVelocity;
worldVelocityBase = worldVelocity = templateKspParticleEmitter.worldVelocity;
forceBase = force = templateKspParticleEmitter.force;
rndForce = templateKspParticleEmitter.rndForce;
rndVelocity = templateKspParticleEmitter.rndVelocity;
rndRotation = templateKspParticleEmitter.rndRotation;
angularVelocity = templateKspParticleEmitter.angularVelocity;
rndAngularVelocity = templateKspParticleEmitter.rndAngularVelocity;
// Unity sure love its strange way of using struct (this actually works because each properties of the struct does magic)
ParticleSystem.ForceOverLifetimeModule fol = pe.forceOverLifetime;
fol.enabled = force.sqrMagnitude > 0 || rndForce.sqrMagnitude > 0;
fol.x = new ParticleSystem.MinMaxCurve(forceBase.x, forceBase.x + rndForce.x);
fol.y = new ParticleSystem.MinMaxCurve(forceBase.y, forceBase.y + rndForce.y);
fol.z = new ParticleSystem.MinMaxCurve(forceBase.z, forceBase.z + rndForce.z);
color = templateKspParticleEmitter.color;
saturationMult = 1;
brightnessMult = 1;
alphaMult = 1;
PersistentEmitterManager.Add(this);
}
// - Awake -
void Awake()
{
transform = gameObject.transform;
Character.CharacterInit(gameObject, GameObject.Find("CharacterHUD"));
UrineFoltModule = UrinePS.forceOverLifetime;
UrinePSTransform = UrinePS.transform;
camerasT = Character.Cameras.transform;
}
void Start()
{
ps = GetComponent <ParticleSystem>();
forceOverLifetime = ps.forceOverLifetime;
forceOverLifetime.enabled = true;
forceOverLifetime.space = ParticleSystemSimulationSpace.World;
forceOverLifetime.randomized = false;
}
void Start()
{
MoveSpeed = 2.0f;
particleSystem = GetComponent <ParticleSystem>();
forceMode = particleSystem.forceOverLifetime;
fireX = transform.position.x; //获取火焰的场景X坐标
fireZ = transform.position.z; //获取火焰的场景Z坐标
}
// Start is called before the first frame update
void Start()
{
ps = GetComponent <ParticleSystem>();
ParticleSystem.ForceOverLifetimeModule force = ps.forceOverLifetime;
force.xMultiplier = 5;
force.zMultiplier = 5;
force.yMultiplier = 50;
}
void Start()
{
main = particleSystem.main;
playerRb = GetComponent <Rigidbody2D>();
em = particleSystem.emission;
em.enabled = false;
noiseModule = particleSystem.noise;
fom = particleSystem.forceOverLifetime;
defaultForce = new Vector2(fom.x.constant, fom.y.constant);
}
void Awake()
{
rainEmission = rainPart.emission;
rainForce = rainPart.forceOverLifetime;
windEmission = windPart.emission;
windMain = windPart.main;
lightningEmission = lightningPart.emission;
lightningMain = lightningPart.main;
fogEmission = fogPart.emission;
UpdateAll();
}
void Awake()
{
snowTransform = snowPart.transform;
snowEmission = snowPart.emission;
snowShape = snowPart.shape;
snowForce = snowPart.forceOverLifetime;
windEmission = windPart.emission;
windMain = windPart.main;
fogEmission = fogPart.emission;
UpdateAll();
}
private void UpdateParticleSystem()
{
ParticleSystem.MainModule mainMod = particleSys.main;
mainMod.startLifetime = lifetime.GetValue(inputValue.Precent);
ParticleSystem.ForceOverLifetimeModule forceMod = particleSys.forceOverLifetime;
forceMod.y = yForce.GetValue(inputValue.Precent);
ParticleSystem.EmissionModule emissionMod = particleSys.emission;
emissionMod.rateOverTime = emissions.GetValue(inputValue.Precent);
}
private void Awake()
{
myForceOverLifetime = GetComponent <ParticleSystem>().forceOverLifetime;
myEmission = GetComponent <ParticleSystem>().emission;
render = GetComponent <SpriteRenderer>();
if (breakableTilemap == null)
{
breakableTilemap = FindObjectOfType <BreakableTilemap>();
}
}
private void Awake()
{
_particleSystem = GetComponent <ParticleSystem>();
_rotation = transform.rotation;
_mainModule = _particleSystem.main;
_mainModule.simulationSpace = ParticleSystemSimulationSpace.Custom;
_mainModule.customSimulationSpace = _simulationSpace;
_velocityOverLifetimeModule = _particleSystem.velocityOverLifetime;
_velocityOverLifetimeVector = new ModuleVector(_velocityOverLifetimeModule.x, _velocityOverLifetimeModule.y, _velocityOverLifetimeModule.z);
_limitVelocityOverLifetimeModule = _particleSystem.limitVelocityOverLifetime;
_limitVelocityOverLifetimeVector = new ModuleVector(_limitVelocityOverLifetimeModule.limitX, _limitVelocityOverLifetimeModule.limitY, _limitVelocityOverLifetimeModule.limitZ);
_forceOverLifetimeModule = _particleSystem.forceOverLifetime;
_forceOverLifetimeVector = new ModuleVector(_forceOverLifetimeModule.x, _forceOverLifetimeModule.y, _forceOverLifetimeModule.z);
}
static void WriteParticleSystemForceOverLifetime(ParticleSystem.ForceOverLifetimeModule module)
{
m_writer.Write(module.enabled);
if (!module.enabled)
{
return;
}
WriteMinMaxCurve(module.x);
WriteMinMaxCurve(module.y);
WriteMinMaxCurve(module.z);
m_writer.Write((int)module.space);
m_writer.Write(module.randomized);
}
protected override void ReadFromImpl(object obj)
{
base.ReadFromImpl(obj);
ParticleSystem.ForceOverLifetimeModule uo = (ParticleSystem.ForceOverLifetimeModule)obj;
enabled = uo.enabled;
x = uo.x;
y = uo.y;
z = uo.z;
xMultiplier = uo.xMultiplier;
yMultiplier = uo.yMultiplier;
zMultiplier = uo.zMultiplier;
space = uo.space;
randomized = uo.randomized;
}
protected override object WriteToImpl(object obj)
{
obj = base.WriteToImpl(obj);
ParticleSystem.ForceOverLifetimeModule uo = (ParticleSystem.ForceOverLifetimeModule)obj;
uo.enabled = enabled;
uo.x = x;
uo.y = y;
uo.z = z;
uo.xMultiplier = xMultiplier;
uo.yMultiplier = yMultiplier;
uo.zMultiplier = zMultiplier;
uo.space = space;
uo.randomized = randomized;
return(uo);
}
// Start is called before the first frame update
void Start()
{
ps = gameObject.GetComponent <ParticleSystem>();
var main = ps.main;
main.startColor = new Color(Random.Range(0.3f, 1.0f), Random.Range(0.3f, 1.0f), Random.Range(0.3f, 1.0f), Random.Range(0.3f, 1.0f));
fo = ps.forceOverLifetime;
fo.enabled = true;
// Destroy(gameObject, 1.0f);
//speed = 0.1f;
// AnimationCurve curve = new AnimationCurve();
// curve.AddKey(0.0f, 0.1f);
// curve.AddKey(0.75f, 1.0f);
// fo.y = 5.0f; //= new ParticleSystem.MinMaxCurve(1.5f, curve);
}
private void OnCollisionEnter(Collision collision)
{
if (collision.collider.gameObject.layer == LayerMask.NameToLayer("Player") && collid.Equals(false))
{
EventManager.OnDamage(dmg);
EventManager.OnCollisionTrash();
ParticleSystem ps = Instantiate(EffectsManager.em.Boom, rb.position, Quaternion.identity).GetComponent <ParticleSystem>();
ParticleSystem.ShapeModule shape = ps.shape;
ParticleSystem.ForceOverLifetimeModule force = ps.forceOverLifetime;
shape.rotation = rb.rotation.eulerAngles;
shape.mesh = GetComponent <MeshFilter>().mesh;
force.x = rb.velocity.x;
force.y = rb.velocity.y;
force.z = rb.velocity.z;
Destroy(gameObject);
collid = true;
}
}
// Token: 0x06000431 RID: 1073 RVA: 0x00021EB0 File Offset: 0x000200B0
private void UpdateWind()
{
if (this.m_alignToWindDirection)
{
Vector3 windDir = EnvMan.instance.GetWindDir();
base.transform.rotation = Quaternion.LookRotation(windDir, Vector3.up);
}
if (this.m_ps)
{
if (!this.m_ps.emission.enabled)
{
return;
}
Vector3 windForce = EnvMan.instance.GetWindForce();
if (this.m_particleVelocity)
{
ParticleSystem.VelocityOverLifetimeModule velocityOverLifetime = this.m_ps.velocityOverLifetime;
velocityOverLifetime.space = ParticleSystemSimulationSpace.World;
velocityOverLifetime.x = windForce.x * this.m_multiplier;
velocityOverLifetime.z = windForce.z * this.m_multiplier;
}
if (this.m_particleForce)
{
ParticleSystem.ForceOverLifetimeModule forceOverLifetime = this.m_ps.forceOverLifetime;
forceOverLifetime.space = ParticleSystemSimulationSpace.World;
forceOverLifetime.x = windForce.x * this.m_multiplier;
forceOverLifetime.z = windForce.z * this.m_multiplier;
}
if (this.m_particleEmission)
{
this.m_ps.emission.rateOverTimeMultiplier = Mathf.Lerp((float)this.m_particleEmissionMin, (float)this.m_particleEmissionMax, EnvMan.instance.GetWindIntensity());
}
}
if (this.m_cloth)
{
Vector3 a = EnvMan.instance.GetWindForce();
if (this.m_checkPlayerShelter && this.m_player != null && this.m_player.InShelter())
{
a = Vector3.zero;
}
this.m_cloth.externalAcceleration = a * this.m_multiplier;
this.m_cloth.randomAcceleration = a * this.m_multiplier * this.m_clothRandomAccelerationFactor;
}
}
private void MapForceOverLifetimeParameters(ParticleSystem pSystem, int i)
{
ParticleSystem.ForceOverLifetimeModule forceOverLifetimeModule = pSystem.forceOverLifetime;
try {
forceOverLifetimeModule.enabled = GetBoolParam(i, "forceOverLifetime_enabled");
}
catch (NullReferenceException) {
forceOverLifetimeModule.enabled = false;
return;
}
forceOverLifetimeModule.space = (ParticleSystemSimulationSpace)GetIntParam(i, "forceOverLifetime_space");
forceOverLifetimeModule.randomized = GetBoolParam(i, "forceOverLifetime_randomized");
forceOverLifetimeModule.x = NodeFXUtilities.InterpretStringToCurve(GetStringParam(i, "forceOverLifetime_force_x"));
forceOverLifetimeModule.y = NodeFXUtilities.InterpretStringToCurve(GetStringParam(i, "forceOverLifetime_force_y"));
forceOverLifetimeModule.z = NodeFXUtilities.InterpretStringToCurve(GetStringParam(i, "forceOverLifetime_force_z"));
}
void ChangeSetting(ParticleSystem particle)
{
var mainModle = particle.main;
mainModle.scalingMode = ParticleSystemScalingMode.Hierarchy;
if (particle.velocityOverLifetime.enabled)
{
ParticleSystem.VelocityOverLifetimeModule velocityOverLifetime = particle.velocityOverLifetime;
velocityOverLifetime.space = ParticleSystemSimulationSpace.Local;
}
if (particle.forceOverLifetime.enabled)
{
ParticleSystem.ForceOverLifetimeModule forceOverLifetime = particle.forceOverLifetime;
forceOverLifetime.space = ParticleSystemSimulationSpace.Local;
}
if (ChangeGravity)
{
float defaultGravity;
if (!defaultGravities.TryGetValue(particle, out defaultGravity))
{
defaultGravity = mainModle.gravityModifier.constant;
defaultGravities.Add(particle, defaultGravity);
}
mainModle.gravityModifier = defaultGravity * this.transform.lossyScale.y;
}
if (ChangeRenderMode)
{
ParticleSystemRenderer renderer = particle.GetComponent <ParticleSystemRenderer>();
if (renderer != null)
{
if (renderer.renderMode == ParticleSystemRenderMode.Stretch)
{
renderer.renderMode = ParticleSystemRenderMode.Billboard;
}
}
}
}
// =================================
// Nested classes and structures.
// =================================
// ...
// =================================
// Variables.
// =================================
// ...
// =================================
// Functions.
// =================================
// Scales against self.
public static void scale(this ParticleSystem particleSystem, float scale, bool scaleTransformLocalPosition)
{
// Transform.
if (scaleTransformLocalPosition)
{
particleSystem.transform.localPosition *= scale;
}
// Particle system.
ParticleSystem.MainModule main = particleSystem.main;
ParticleSystem.ShapeModule shape = particleSystem.shape;
ParticleSystem.VelocityOverLifetimeModule velocityOverLifetime = particleSystem.velocityOverLifetime;
ParticleSystem.LimitVelocityOverLifetimeModule limitVelocityOverLifetime = particleSystem.limitVelocityOverLifetime;
ParticleSystem.ForceOverLifetimeModule forceOverLifetime = particleSystem.forceOverLifetime;
ParticleSystem.MinMaxCurve mmCurve;
// Main.
mmCurve = main.startSpeed;
mmCurve.constantMin *= scale;
mmCurve.constantMax *= scale;
main.startSpeed = mmCurve;
mmCurve = main.startSize;
mmCurve.constantMin *= scale;
mmCurve.constantMax *= scale;
main.startSize = mmCurve;
// Shape.
shape.radius *= scale;
shape.scale *= scale;
shape.angle *= scale;
shape.randomDirectionAmount *= scale;
shape.sphericalDirectionAmount *= scale;
shape.scale *= scale;
shape.normalOffset *= scale;
// Velocity over lifetime.
mmCurve = velocityOverLifetime.x;
mmCurve.constantMin *= scale;
mmCurve.constantMax *= scale;
velocityOverLifetime.x = mmCurve;
mmCurve = velocityOverLifetime.y;
mmCurve.constantMin *= scale;
mmCurve.constantMax *= scale;
velocityOverLifetime.y = mmCurve;
mmCurve = velocityOverLifetime.z;
mmCurve.constantMin *= scale;
mmCurve.constantMax *= scale;
velocityOverLifetime.z = mmCurve;
// Force over lifetime.
mmCurve = forceOverLifetime.x;
mmCurve.constantMin *= scale;
mmCurve.constantMax *= scale;
forceOverLifetime.x = mmCurve;
mmCurve = forceOverLifetime.y;
mmCurve.constantMin *= scale;
mmCurve.constantMax *= scale;
forceOverLifetime.y = mmCurve;
mmCurve = forceOverLifetime.z;
mmCurve.constantMin *= scale;
mmCurve.constantMax *= scale;
forceOverLifetime.z = mmCurve;
}
