/// <summary>
/// Create VGO_PS_VelocityOverLifetimeModule from VelocityOverLifetimeModule.
/// </summary>
/// <param name="module"></param>
/// <returns></returns>
protected virtual VGO_PS_VelocityOverLifetimeModule CreateVgoModule(VelocityOverLifetimeModule module)
{
return(new VGO_PS_VelocityOverLifetimeModule()
{
enabled = module.enabled,
x = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.x),
y = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.y),
z = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.z),
xMultiplier = module.xMultiplier,
yMultiplier = module.yMultiplier,
zMultiplier = module.zMultiplier,
space = module.space,
orbitalX = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.orbitalX),
orbitalY = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.orbitalY),
orbitalZ = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.orbitalZ),
orbitalXMultiplier = module.orbitalXMultiplier,
orbitalYMultiplier = module.orbitalYMultiplier,
orbitalZMultiplier = module.orbitalZMultiplier,
orbitalOffsetX = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.orbitalOffsetX),
orbitalOffsetY = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.orbitalOffsetY),
orbitalOffsetZ = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.orbitalOffsetZ),
orbitalOffsetXMultiplier = module.orbitalOffsetXMultiplier,
orbitalOffsetYMultiplier = module.orbitalOffsetYMultiplier,
orbitalOffsetZMultiplier = module.orbitalOffsetZMultiplier,
radial = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.radial),
radialMultiplier = module.radialMultiplier,
speedModifier = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.speedModifier),
speedModifierMultiplier = module.speedModifierMultiplier,
});
}
/// <summary>
/// Set ParticleSystem rotationBySpeed field value.
/// </summary>
/// <param name="particleSystem"></param>
/// <param name="vgoModule"></param>
protected virtual void SetModuleValue(ParticleSystem particleSystem, VGO_PS_RotationBySpeedModule vgoModule)
{
if (vgoModule == null)
{
return;
}
RotationBySpeedModule module = particleSystem.rotationBySpeed;
module.enabled = vgoModule.enabled;
module.separateAxes = vgoModule.separateAxes;
if (vgoModule.separateAxes)
{
module.x = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.x);
module.y = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.y);
module.z = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.z);
module.xMultiplier = vgoModule.xMultiplier;
module.yMultiplier = vgoModule.yMultiplier;
module.zMultiplier = vgoModule.zMultiplier;
}
else
{
module.x = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.x);
module.xMultiplier = vgoModule.xMultiplier;
}
module.range = ArrayConverter.ToVector2(vgoModule.range);
}
/// <summary>
/// Create VGO_PS_VelocityOverLifetimeModule from VelocityOverLifetimeModule.
/// </summary>
/// <param name="module"></param>
/// <returns></returns>
protected virtual VGO_PS_LimitVelocityOverLifetimeModule CreateVgoModule(LimitVelocityOverLifetimeModule module)
{
var vgoModule = new VGO_PS_LimitVelocityOverLifetimeModule()
{
enabled = module.enabled,
separateAxes = module.separateAxes,
space = module.space,
dampen = module.dampen,
drag = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.drag),
dragMultiplier = module.dragMultiplier,
multiplyDragByParticleSize = module.multiplyDragByParticleSize,
multiplyDragByParticleVelocity = module.multiplyDragByParticleVelocity,
};
if (module.separateAxes)
{
vgoModule.limitX = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.limitX);
vgoModule.limitY = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.limitY);
vgoModule.limitZ = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.limitZ);
vgoModule.limitXMultiplier = module.limitXMultiplier;
vgoModule.limitYMultiplier = module.limitYMultiplier;
vgoModule.limitZMultiplier = module.limitZMultiplier;
}
else
{
vgoModule.limitX = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.limit);
vgoModule.limitXMultiplier = module.limitMultiplier;
}
return(vgoModule);
}
/// <summary>
/// Create VGO_PS_SizeOverLifetimeModule from SizeOverLifetimeModule.
/// </summary>
/// <param name="module"></param>
/// <returns></returns>
protected virtual VGO_PS_SizeOverLifetimeModule CreateVgoModule(SizeOverLifetimeModule module)
{
if (module.separateAxes)
{
return(new VGO_PS_SizeOverLifetimeModule()
{
enabled = module.enabled,
separateAxes = module.separateAxes,
x = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.x),
y = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.y),
z = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.z),
xMultiplier = module.xMultiplier,
yMultiplier = module.yMultiplier,
zMultiplier = module.zMultiplier,
});
}
else
{
return(new VGO_PS_SizeOverLifetimeModule()
{
enabled = module.enabled,
separateAxes = module.separateAxes,
x = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.size),
xMultiplier = module.sizeMultiplier,
});
}
}
/// <summary>
/// Set ParticleSystem sizeOverLifetime field value.
/// </summary>
/// <param name="particleSystem"></param>
/// <param name="vgoModule"></param>
protected virtual void SetModuleValue(ParticleSystem particleSystem, VGO_PS_SizeOverLifetimeModule vgoModule)
{
if (vgoModule == null)
{
return;
}
SizeOverLifetimeModule module = particleSystem.sizeOverLifetime;
module.enabled = vgoModule.enabled;
module.separateAxes = vgoModule.separateAxes;
if (vgoModule.separateAxes)
{
module.x = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.x);
module.y = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.y);
module.z = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.z);
module.xMultiplier = vgoModule.xMultiplier;
module.yMultiplier = vgoModule.yMultiplier;
module.zMultiplier = vgoModule.zMultiplier;
}
else
{
module.size = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.x);
module.sizeMultiplier = vgoModule.xMultiplier;
}
}
/// <summary>
/// Create VGO_PS_RotationBySpeedModule from RotationBySpeedModule.
/// </summary>
/// <param name="module"></param>
/// <returns></returns>
protected virtual VGO_PS_RotationBySpeedModule CreateVgoModule(RotationBySpeedModule module)
{
if (module.separateAxes)
{
return(new VGO_PS_RotationBySpeedModule()
{
enabled = module.enabled,
separateAxes = module.separateAxes,
x = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.x),
y = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.y),
z = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.z),
xMultiplier = module.xMultiplier,
yMultiplier = module.yMultiplier,
zMultiplier = module.zMultiplier,
range = module.range.ToArray(),
});
}
else
{
return(new VGO_PS_RotationBySpeedModule()
{
enabled = module.enabled,
separateAxes = module.separateAxes,
x = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.x),
xMultiplier = module.xMultiplier,
range = module.range.ToArray(),
});
}
}
/// <summary>
/// Set ParticleSystem limitVelocityOverLifetime field value.
/// </summary>
/// <param name="particleSystem"></param>
/// <param name="vgoModule"></param>
protected virtual void SetModuleValue(ParticleSystem particleSystem, VGO_PS_LimitVelocityOverLifetimeModule vgoModule)
{
if (vgoModule == null)
{
return;
}
LimitVelocityOverLifetimeModule module = particleSystem.limitVelocityOverLifetime;
module.enabled = vgoModule.enabled;
module.separateAxes = vgoModule.separateAxes;
if (vgoModule.separateAxes)
{
module.limitX = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.limitX);
module.limitY = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.limitY);
module.limitZ = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.limitZ);
module.limitXMultiplier = vgoModule.limitXMultiplier;
module.limitYMultiplier = vgoModule.limitYMultiplier;
module.limitZMultiplier = vgoModule.limitZMultiplier;
}
else
{
module.limit = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.limitX);
module.limitMultiplier = vgoModule.limitXMultiplier;
}
module.space = vgoModule.space;
module.dampen = vgoModule.dampen;
module.drag = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.drag);
module.dragMultiplier = vgoModule.dragMultiplier;
module.multiplyDragByParticleSize = vgoModule.multiplyDragByParticleSize;
module.multiplyDragByParticleVelocity = vgoModule.multiplyDragByParticleVelocity;
}
/// <summary>
/// Create VGO_PS_TrailModule from TrailModule.
/// </summary>
/// <param name="module"></param>
/// <returns></returns>
protected virtual VGO_PS_TrailModule CreateVgoModule(TrailModule module)
{
return(new VGO_PS_TrailModule()
{
enabled = module.enabled,
mode = module.mode,
ratio = module.ratio,
lifetime = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.lifetime),
lifetimeMultiplier = module.lifetimeMultiplier,
minVertexDistance = module.minVertexDistance,
worldSpace = module.worldSpace,
dieWithParticles = module.dieWithParticles,
ribbonCount = module.ribbonCount,
splitSubEmitterRibbons = module.splitSubEmitterRibbons,
attachRibbonsToTransform = module.attachRibbonsToTransform,
textureMode = module.textureMode,
sizeAffectsWidth = module.sizeAffectsWidth,
sizeAffectsLifetime = module.sizeAffectsLifetime,
inheritParticleColor = module.inheritParticleColor,
colorOverLifetime = VgoParticleSystemMinMaxGradientConverter.CreateFrom(module.colorOverLifetime),
widthOverTrail = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.widthOverTrail),
widthOverTrailMultiplier = module.widthOverTrailMultiplier,
colorOverTrail = VgoParticleSystemMinMaxGradientConverter.CreateFrom(module.colorOverTrail),
generateLightingData = module.generateLightingData,
shadowBias = module.shadowBias,
});
}
/// <summary>
/// Create VGO_PS_EmissionModule from EmissionModule.
/// </summary>
/// <param name="module"></param>
/// <returns></returns>
protected virtual VGO_PS_EmissionModule CreateVgoModule(EmissionModule module)
{
var vgoModule = new VGO_PS_EmissionModule()
{
enabled = module.enabled,
rateOverTime = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.rateOverTime),
rateOverTimeMultiplier = module.rateOverTimeMultiplier,
rateOverDistance = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.rateOverDistance),
rateOverDistanceMultiplier = module.rateOverDistanceMultiplier,
//BurstCount = module.burstCount,
};
if (module.burstCount > 0)
{
Burst[] bursts = new Burst[module.burstCount];
module.GetBursts(bursts);
if ((bursts != null) && bursts.Any())
{
vgoModule.bursts = new VGO_PS_Burst[bursts.Length];
for (int idx = 0; idx < bursts.Length; idx++)
{
vgoModule.bursts[idx] = VgoParticleSystemBurstConverter.CreateFrom(bursts[idx]);
}
}
}
return(vgoModule);
}
/// <summary>
/// Set ParticleSystem emission field value.
/// </summary>
/// <param name="particleSystem"></param>
/// <param name="vgoModule"></param>
protected virtual void SetModuleValue(ParticleSystem particleSystem, VGO_PS_EmissionModule vgoModule)
{
if (vgoModule == null)
{
return;
}
EmissionModule module = particleSystem.emission;
module.enabled = vgoModule.enabled;
module.rateOverTime = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.rateOverTime);
module.rateOverTimeMultiplier = vgoModule.rateOverTimeMultiplier;
module.rateOverDistance = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.rateOverDistance);
module.rateOverDistanceMultiplier = vgoModule.rateOverDistanceMultiplier;
//module.burstCount = vgoModule.BurstCount;
if ((vgoModule.bursts != null) && vgoModule.bursts.Any())
{
module.burstCount = vgoModule.bursts.Length;
for (int idx = 0; idx < vgoModule.bursts.Length; idx++)
{
module.SetBurst(idx, VgoParticleSystemBurstConverter.CreateBurst(vgoModule.bursts[idx]));
}
}
}
/// <summary>
/// Set ParticleSystem noiseModule field value.
/// </summary>
/// <param name="particleSystem"></param>
/// <param name="vgoModule"></param>
protected virtual void SetModuleValue(ParticleSystem particleSystem, VGO_PS_NoiseModule vgoModule)
{
if (vgoModule == null)
{
return;
}
NoiseModule module = particleSystem.noise;
module.enabled = vgoModule.enabled;
module.separateAxes = vgoModule.separateAxes;
if (vgoModule.separateAxes)
{
module.strengthX = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.strengthX);
module.strengthY = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.strengthY);
module.strengthZ = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.strengthZ);
module.strengthXMultiplier = vgoModule.strengthXMultiplier;
module.strengthYMultiplier = vgoModule.strengthYMultiplier;
module.strengthZMultiplier = vgoModule.strengthZMultiplier;
}
else
{
module.strength = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.strengthX);
module.strengthMultiplier = vgoModule.strengthXMultiplier;
}
module.frequency = vgoModule.frequency;
module.scrollSpeed = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.scrollSpeed);
module.scrollSpeedMultiplier = vgoModule.scrollSpeedMultiplier;
module.damping = vgoModule.damping;
module.octaveCount = vgoModule.octaveCount;
module.octaveMultiplier = vgoModule.octaveMultiplier;
module.octaveScale = vgoModule.octaveScale;
module.quality = vgoModule.quality;
module.remapEnabled = vgoModule.remapEnabled;
if (vgoModule.remapEnabled)
{
if (vgoModule.separateAxes)
{
module.remapX = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.remapX);
module.remapY = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.remapY);
module.remapZ = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.remapZ);
module.remapXMultiplier = vgoModule.remapXMultiplier;
module.remapYMultiplier = vgoModule.remapYMultiplier;
module.remapZMultiplier = vgoModule.remapZMultiplier;
}
else
{
module.remap = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.remapX);
module.remapMultiplier = vgoModule.remapXMultiplier;
}
}
module.positionAmount = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.positionAmount);
module.rotationAmount = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.rotationAmount);
module.sizeAmount = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.sizeAmount);
}
/// <summary>
/// Set ParticleSystem shape field value.
/// </summary>
/// <param name="particleSystem"></param>
/// <param name="vgoModule"></param>
/// <param name="textureItemList"></param>
protected virtual void SetModuleValue(ParticleSystem particleSystem, VGO_PS_ShapeModule vgoModule, IList <TextureItem> textureItemList)
{
if (vgoModule == null)
{
return;
}
ShapeModule module = particleSystem.shape;
module.enabled = vgoModule.enabled;
module.shapeType = vgoModule.shapeType;
module.angle = vgoModule.angle;
module.radius = vgoModule.radius;
module.donutRadius = vgoModule.donutRadius;
module.radiusMode = vgoModule.radiusMode;
module.radiusSpread = vgoModule.radiusSpread;
module.radiusSpeed = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.radiusSpeed);
module.radiusSpeedMultiplier = vgoModule.radiusSpeedMultiplier;
module.radiusThickness = vgoModule.radiusThickness;
module.boxThickness = ArrayConverter.ToVector3(vgoModule.boxThickness, reverseZ: true);
module.arc = vgoModule.arc;
module.arcMode = vgoModule.arcMode;
module.arcSpread = vgoModule.arcSpread;
module.arcSpeed = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.arcSpeed);
module.arcSpeedMultiplier = vgoModule.arcSpeedMultiplier;
module.length = vgoModule.length;
module.meshShapeType = vgoModule.meshShapeType;
module.meshSpawnMode = vgoModule.meshSpawnMode;
module.meshSpawnSpread = vgoModule.meshSpawnSpread;
module.meshSpawnSpeed = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.meshSpawnSpeed);
module.meshSpawnSpeedMultiplier = vgoModule.meshSpawnSpeedMultiplier;
//module.mesh;
//module.meshRenderer;
//module.skinnedMeshRenderer;
module.useMeshMaterialIndex = vgoModule.useMeshMaterialIndex;
module.meshMaterialIndex = vgoModule.meshMaterialIndex;
module.useMeshColors = vgoModule.useMeshColors;
//module.sprite;
//module.spriteRenderer;
module.normalOffset = vgoModule.normalOffset;
if ((textureItemList != null) && (-1 < vgoModule.textureIndex) && (vgoModule.textureIndex < textureItemList.Count))
{
module.texture = textureItemList[vgoModule.textureIndex].Texture;
}
module.textureClipChannel = vgoModule.textureClipChannel;
module.textureClipThreshold = vgoModule.textureClipThreshold;
module.textureColorAffectsParticles = vgoModule.textureColorAffectsParticles;
module.textureAlphaAffectsParticles = vgoModule.textureAlphaAffectsParticles;
module.textureBilinearFiltering = vgoModule.textureBilinearFiltering;
module.textureUVChannel = vgoModule.textureUVChannel;
module.position = ArrayConverter.ToVector3(vgoModule.position, reverseZ: true);
module.rotation = ArrayConverter.ToVector3(vgoModule.rotation, reverseZ: true);
module.scale = ArrayConverter.ToVector3(vgoModule.scale);
module.alignToDirection = vgoModule.alignToDirection;
module.randomPositionAmount = vgoModule.randomPositionAmount;
module.sphericalDirectionAmount = vgoModule.sphericalDirectionAmount;
module.randomDirectionAmount = vgoModule.randomDirectionAmount;
}
/// <summary>
/// Create VGO_PS_ShapeModule from ShapeModule.
/// </summary>
/// <param name="module"></param>
/// <param name="gltf"></param>
/// <returns></returns>
/// <remarks>
/// @notice TextureIO.ExportTexture() may export the same texture multiple times.
/// </remarks>
protected virtual VGO_PS_ShapeModule CreateVgoModule(ShapeModule module, glTF gltf)
{
var vgoShapeModule = new VGO_PS_ShapeModule()
{
enabled = module.enabled,
shapeType = module.shapeType,
angle = module.angle,
radius = module.radius,
donutRadius = module.donutRadius,
radiusMode = module.radiusMode,
radiusSpread = module.radiusSpread,
radiusSpeed = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.radiusSpeed),
radiusSpeedMultiplier = module.radiusSpeedMultiplier,
radiusThickness = module.radiusThickness,
boxThickness = module.boxThickness.ReverseZ().ToArray(),
arc = module.arc,
arcMode = module.arcMode,
arcSpread = module.arcSpread,
arcSpeed = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.arcSpeed),
arcSpeedMultiplier = module.arcSpeedMultiplier,
length = module.length,
meshShapeType = module.meshShapeType,
meshSpawnMode = module.meshSpawnMode,
meshSpawnSpread = module.meshSpawnSpread,
meshSpawnSpeed = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.meshSpawnSpread),
meshSpawnSpeedMultiplier = module.meshSpawnSpeedMultiplier,
//mesh
//meshRenderer
//skinnedMeshRenderer
useMeshMaterialIndex = module.useMeshMaterialIndex,
meshMaterialIndex = module.meshMaterialIndex,
useMeshColors = module.useMeshColors,
//sprite
//spriteRenderer
normalOffset = module.normalOffset,
textureIndex = -1,
textureClipChannel = module.textureClipChannel,
textureClipThreshold = module.textureClipThreshold,
textureColorAffectsParticles = module.textureColorAffectsParticles,
textureAlphaAffectsParticles = module.textureAlphaAffectsParticles,
textureBilinearFiltering = module.textureBilinearFiltering,
textureUVChannel = module.textureUVChannel,
position = module.position.ReverseZ().ToArray(),
rotation = module.rotation.ReverseZ().ToArray(),
scale = module.scale.ToArray(),
alignToDirection = module.alignToDirection,
randomPositionAmount = module.randomPositionAmount,
sphericalDirectionAmount = module.sphericalDirectionAmount,
randomDirectionAmount = module.randomDirectionAmount,
};
if (module.texture != null)
{
vgoShapeModule.textureIndex = TextureIO.ExportTexture(gltf, gltf.buffers.Count - 1, module.texture, glTFTextureTypes.Unknown);
}
return(vgoShapeModule);
}
/// <summary>
/// Create VGO_PS_InheritVelocityModule from InheritVelocityModule.
/// </summary>
/// <param name="module"></param>
/// <returns></returns>
protected virtual VGO_PS_InheritVelocityModule CreateVgoModule(InheritVelocityModule module)
{
return(new VGO_PS_InheritVelocityModule()
{
enabled = module.enabled,
mode = module.mode,
curve = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.curve),
curveMultiplier = module.curveMultiplier,
});
}
/// <summary>
/// Create VGO_PS_Burst from Burst.
/// </summary>
/// <param name="minMaxCurve"></param>
/// <returns></returns>
public static VGO_PS_Burst CreateFrom(Burst burst)
{
return(new VGO_PS_Burst()
{
time = burst.time,
count = VgoParticleSystemMinMaxCurveConverter.CreateFrom(burst.count),
cycleCount = burst.cycleCount,
repeatInterval = burst.repeatInterval,
probability = burst.probability,
});
}
/// <summary>
/// Create VGO_PS_ExternalForcesModule from ExternalForcesModule.
/// </summary>
/// <param name="module"></param>
/// <returns></returns>
protected virtual VGO_PS_ExternalForcesModule CreateVgoModule(ExternalForcesModule module)
{
return(new VGO_PS_ExternalForcesModule()
{
enabled = module.enabled,
multiplierCurve = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.multiplierCurve),
multiplier = module.multiplier,
influenceFilter = module.influenceFilter,
influenceMask = module.influenceMask.value,
});
}
/// <summary>
/// Create VGO_PS_NoiseModule from NoiseModule.
/// </summary>
/// <param name="module"></param>
/// <returns></returns>
protected virtual VGO_PS_NoiseModule CreateVgoModule(NoiseModule module)
{
var vgoModule = new VGO_PS_NoiseModule()
{
enabled = module.enabled,
separateAxes = module.separateAxes,
frequency = module.frequency,
scrollSpeed = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.scrollSpeed),
scrollSpeedMultiplier = module.scrollSpeedMultiplier,
damping = module.damping,
octaveCount = module.octaveCount,
octaveMultiplier = module.octaveMultiplier,
octaveScale = module.octaveScale,
quality = module.quality,
remapEnabled = module.remapEnabled,
positionAmount = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.positionAmount),
rotationAmount = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.rotationAmount),
sizeAmount = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.sizeAmount),
};
if (module.separateAxes)
{
vgoModule.strengthX = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.strengthX);
vgoModule.strengthY = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.strengthY);
vgoModule.strengthZ = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.strengthZ);
vgoModule.strengthXMultiplier = module.strengthXMultiplier;
vgoModule.strengthYMultiplier = module.strengthYMultiplier;
vgoModule.strengthZMultiplier = module.strengthZMultiplier;
if (module.remapEnabled)
{
vgoModule.remapX = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.remapX);
vgoModule.remapY = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.remapY);
vgoModule.remapZ = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.remapZ);
vgoModule.remapXMultiplier = module.remapXMultiplier;
vgoModule.remapYMultiplier = module.remapYMultiplier;
vgoModule.remapZMultiplier = module.remapZMultiplier;
}
}
else
{
vgoModule.strengthX = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.strengthX);
vgoModule.strengthXMultiplier = module.strengthXMultiplier;
if (module.remapEnabled)
{
vgoModule.remapX = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.remapX);
vgoModule.remapXMultiplier = module.remapXMultiplier;
}
}
return(vgoModule);
}
/// <summary>
/// Set ParticleSystem inhelitVelocity field value.
/// </summary>
/// <param name="particleSystem"></param>
/// <param name="vgoForceOverLifetimeModule"></param>
protected virtual void SetModuleValue(ParticleSystem particleSystem, VGO_PS_InheritVelocityModule vgoModule)
{
if (vgoModule == null)
{
return;
}
InheritVelocityModule module = particleSystem.inheritVelocity;
module.enabled = vgoModule.enabled;
module.mode = vgoModule.mode;
module.curve = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.curve);
module.curveMultiplier = vgoModule.curveMultiplier;
}
/// <summary>
/// Create VGO_PS_ForceOverLifetimeModule from ForceOverLifetimeModule.
/// </summary>
/// <param name="module"></param>
/// <returns></returns>
protected virtual VGO_PS_ForceOverLifetimeModule CreateVgoModule(ForceOverLifetimeModule module)
{
return(new VGO_PS_ForceOverLifetimeModule()
{
enabled = module.enabled,
x = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.x),
y = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.y),
z = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.z),
xMultiplier = module.xMultiplier,
yMultiplier = module.yMultiplier,
zMultiplier = module.zMultiplier,
space = module.space,
randomized = module.randomized,
});
}
/// <summary>
/// Create VGO_PS_LightsModule from LightsModule.
/// </summary>
/// <param name="module"></param>
/// <returns></returns>
protected virtual VGO_PS_LightsModule CreateVgoModule(LightsModule module)
{
return(new VGO_PS_LightsModule()
{
enabled = module.enabled,
ratio = module.ratio,
useRandomDistribution = module.useRandomDistribution,
light = VgoLightConverter.CreateFrom(module.light),
useParticleColor = module.useParticleColor,
sizeAffectsRange = module.sizeAffectsRange,
alphaAffectsIntensity = module.alphaAffectsIntensity,
range = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.range),
rangeMultiplier = module.rangeMultiplier,
intensity = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.intensity),
intensityMultiplier = module.intensityMultiplier,
maxLights = module.maxLights,
});
}
/// <summary>
/// Set ParticleSystem externalForcesModule field value.
/// </summary>
/// <param name="particleSystem"></param>
/// <param name="vgoModule"></param>
protected virtual void SetModuleValue(ParticleSystem particleSystem, VGO_PS_ExternalForcesModule vgoModule)
{
if (vgoModule == null)
{
return;
}
ExternalForcesModule module = particleSystem.externalForces;
module.enabled = vgoModule.enabled;
module.multiplierCurve = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.multiplierCurve);
module.multiplier = vgoModule.multiplier;
module.influenceFilter = vgoModule.influenceFilter;
module.influenceMask = new LayerMask()
{
value = vgoModule.influenceMask
};
}
/// <summary>
/// Set ParticleSystem forceOverLifetime field value.
/// </summary>
/// <param name="particleSystem"></param>
/// <param name="vgoModule"></param>
protected virtual void SetModuleValue(ParticleSystem particleSystem, VGO_PS_ForceOverLifetimeModule vgoModule)
{
if (vgoModule == null)
{
return;
}
ForceOverLifetimeModule module = particleSystem.forceOverLifetime;
module.enabled = vgoModule.enabled;
module.x = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.x);
module.y = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.y);
module.z = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.z);
module.xMultiplier = vgoModule.xMultiplier;
module.yMultiplier = vgoModule.yMultiplier;
module.zMultiplier = vgoModule.zMultiplier;
module.space = vgoModule.space;
module.randomized = vgoModule.randomized;
}
/// <summary>
/// Set ParticleSystem lightsModule field value.
/// </summary>
/// <param name="particleSystem"></param>
/// <param name="vgoModule"></param>
protected virtual void SetModuleValue(ParticleSystem particleSystem, VGO_PS_LightsModule vgoModule)
{
if (vgoModule == null)
{
return;
}
LightsModule module = particleSystem.lights;
module.enabled = vgoModule.enabled;
module.ratio = vgoModule.ratio;
module.useRandomDistribution = vgoModule.useRandomDistribution;
module.useParticleColor = vgoModule.useParticleColor;
module.sizeAffectsRange = vgoModule.sizeAffectsRange;
module.alphaAffectsIntensity = vgoModule.alphaAffectsIntensity;
module.range = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.range);
module.rangeMultiplier = vgoModule.rangeMultiplier;
module.intensity = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.intensity);
module.intensityMultiplier = vgoModule.intensityMultiplier;
module.maxLights = vgoModule.maxLights;
if (vgoModule.light != null)
{
// @notice
Light goLight = particleSystem.gameObject.GetComponent <Light>();
if (goLight == null)
{
goLight = particleSystem.gameObject.AddComponent <Light>();
}
VgoLightConverter.SetComponentValue(goLight, vgoModule.light);
goLight.enabled = false;
module.light = goLight;
if (Application.isEditor)
{
// @todo
}
}
}
/// <summary>
/// Set ParticleSystem velocityOverLifetime field value.
/// </summary>
/// <param name="particleSystem"></param>
/// <param name="vgoModule"></param>
protected virtual void SetModuleValue(ParticleSystem particleSystem, VGO_PS_VelocityOverLifetimeModule vgoModule)
{
if (vgoModule == null)
{
return;
}
VelocityOverLifetimeModule module = particleSystem.velocityOverLifetime;
module.enabled = vgoModule.enabled;
module.xMultiplier = vgoModule.xMultiplier;
module.yMultiplier = vgoModule.yMultiplier;
module.zMultiplier = vgoModule.zMultiplier;
module.x = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.x);
module.y = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.y);
module.z = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.z);
module.space = vgoModule.space;
module.orbitalX = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.orbitalX);
module.orbitalY = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.orbitalY);
module.orbitalZ = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.orbitalZ);
module.orbitalXMultiplier = vgoModule.orbitalXMultiplier;
module.orbitalYMultiplier = vgoModule.orbitalYMultiplier;
module.orbitalZMultiplier = vgoModule.orbitalZMultiplier;
module.orbitalOffsetX = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.orbitalOffsetX);
module.orbitalOffsetY = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.orbitalOffsetY);
module.orbitalOffsetZ = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.orbitalOffsetZ);
module.orbitalOffsetXMultiplier = vgoModule.orbitalOffsetXMultiplier;
module.orbitalOffsetYMultiplier = vgoModule.orbitalOffsetYMultiplier;
module.orbitalOffsetZMultiplier = vgoModule.orbitalOffsetZMultiplier;
module.radial = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.radial);
module.radialMultiplier = vgoModule.radialMultiplier;
module.speedModifier = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.speedModifier);
module.speedModifierMultiplier = vgoModule.speedModifierMultiplier;
}
/// <summary>
/// Set ParticleSystem noiseModule field value.
/// </summary>
/// <param name="particleSystem"></param>
/// <param name="vgoModule"></param>
protected virtual void SetModuleValue(ParticleSystem particleSystem, VGO_PS_TrailModule vgoModule)
{
if (vgoModule == null)
{
return;
}
TrailModule module = particleSystem.trails;
module.enabled = vgoModule.enabled;
module.mode = vgoModule.mode;
// PerParticle
module.ratio = vgoModule.ratio;
module.lifetime = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.lifetime);
module.lifetimeMultiplier = vgoModule.lifetimeMultiplier;
module.minVertexDistance = vgoModule.minVertexDistance;
module.worldSpace = vgoModule.worldSpace;
module.dieWithParticles = vgoModule.dieWithParticles;
// Ribbon
module.ribbonCount = vgoModule.ribbonCount;
module.splitSubEmitterRibbons = vgoModule.splitSubEmitterRibbons;
module.attachRibbonsToTransform = vgoModule.attachRibbonsToTransform;
module.textureMode = vgoModule.textureMode;
module.sizeAffectsWidth = vgoModule.sizeAffectsWidth;
module.sizeAffectsLifetime = vgoModule.sizeAffectsLifetime;
module.inheritParticleColor = vgoModule.inheritParticleColor;
module.colorOverLifetime = VgoParticleSystemMinMaxGradientConverter.CreateMinMaxGradient(vgoModule.colorOverLifetime);
module.widthOverTrail = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.widthOverTrail);
module.widthOverTrailMultiplier = vgoModule.widthOverTrailMultiplier;
module.colorOverTrail = VgoParticleSystemMinMaxGradientConverter.CreateMinMaxGradient(vgoModule.colorOverTrail);
module.generateLightingData = vgoModule.generateLightingData;
module.shadowBias = vgoModule.shadowBias;
}
/// <summary>
/// Create VGO_PS_MainModule from MainModule.
/// </summary>
/// <param name="module"></param>
/// <returns></returns>
protected virtual VGO_PS_MainModule CreateVgoModule(MainModule module)
{
var vgoModule = new VGO_PS_MainModule()
{
duration = module.duration,
loop = module.loop,
prewarm = module.prewarm,
startDelay = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.startDelay),
startDelayMultiplier = module.startDelayMultiplier,
startLifetime = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.startLifetime),
startLifetimeMultiplier = module.startLifetimeMultiplier,
startSpeed = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.startSpeed),
startSpeedMultiplier = module.startSpeedMultiplier,
startSize3D = module.startSize3D,
startRotation3D = module.startRotation3D,
flipRotation = module.flipRotation,
startColor = VgoParticleSystemMinMaxGradientConverter.CreateFrom(module.startColor),
gravityModifier = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.gravityModifier),
gravityModifierMultiplier = module.gravityModifierMultiplier,
simulationSpace = module.simulationSpace,
simulationSpeed = module.simulationSpeed,
customSimulationSpace = VgoTransformConverter.CreateFrom(module.customSimulationSpace),
useUnscaledTime = module.useUnscaledTime,
scalingMode = module.scalingMode,
playOnAwake = module.playOnAwake,
emitterVelocityMode = module.emitterVelocityMode,
maxParticles = module.maxParticles,
stopAction = module.stopAction,
cullingMode = module.cullingMode,
ringBufferMode = module.ringBufferMode,
};
if (module.startSize3D)
{
vgoModule.startSizeX = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.startSizeX);
vgoModule.startSizeY = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.startSizeY);
vgoModule.startSizeZ = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.startSizeZ);
vgoModule.startSizeXMultiplier = module.startSizeXMultiplier;
vgoModule.startSizeYMultiplier = module.startSizeYMultiplier;
vgoModule.startSizeZMultiplier = module.startSizeZMultiplier;
}
else
{
vgoModule.startSize = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.startSize);
vgoModule.startSizeMultiplier = module.startSizeMultiplier;
}
if (module.startRotation3D)
{
vgoModule.startRotationX = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.startRotationX);
vgoModule.startRotationY = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.startRotationY);
vgoModule.startRotationZ = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.startRotationZ);
vgoModule.StartRotationXMultiplier = module.startRotationXMultiplier;
vgoModule.StartRotationYMultiplier = module.startRotationYMultiplier;
vgoModule.StartRotationZMultiplier = module.startRotationZMultiplier;
}
else
{
vgoModule.startRotation = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.startRotation);
vgoModule.StartRotationMultiplier = module.startRotationMultiplier;
}
if (module.ringBufferMode == ParticleSystemRingBufferMode.LoopUntilReplaced)
{
vgoModule.ringBufferLoopRange = module.ringBufferLoopRange.ToArray();
}
return(vgoModule);
}
/// <summary>
/// Set ParticleSystem main field value.
/// </summary>
/// <param name="particleSystem"></param>
/// <param name="vgoModule"></param>
protected virtual void SetModuleValue(ParticleSystem particleSystem, VGO_PS_MainModule vgoModule)
{
if (vgoModule == null)
{
return;
}
MainModule module = particleSystem.main;
// @notice
if (Application.isPlaying == false)
{
module.duration = vgoModule.duration;
}
module.loop = vgoModule.loop;
module.prewarm = vgoModule.prewarm;
module.startDelay = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.startDelay);
module.startDelayMultiplier = vgoModule.startDelayMultiplier;
module.startLifetime = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.startLifetime);
module.startLifetimeMultiplier = vgoModule.startLifetimeMultiplier;
module.startSpeed = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.startSpeed);
module.startSpeedMultiplier = vgoModule.startSpeedMultiplier;
module.startSize3D = vgoModule.startSize3D;
if (vgoModule.startSize3D)
{
module.startSizeX = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.startSizeX);
module.startSizeY = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.startSizeY);
module.startSizeZ = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.startSizeZ);
module.startSizeXMultiplier = vgoModule.startSizeXMultiplier;
module.startSizeYMultiplier = vgoModule.startSizeYMultiplier;
module.startSizeZMultiplier = vgoModule.startSizeZMultiplier;
}
else
{
module.startSize = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.startSize);
module.startSizeMultiplier = vgoModule.startSizeMultiplier;
}
module.startRotation3D = vgoModule.startRotation3D;
if (vgoModule.startRotation3D)
{
module.startRotationX = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.startRotationX);
module.startRotationY = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.startRotationY);
module.startRotationZ = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.startRotationZ);
module.startRotationXMultiplier = vgoModule.StartRotationXMultiplier;
module.startRotationYMultiplier = vgoModule.StartRotationYMultiplier;
module.startRotationZMultiplier = vgoModule.StartRotationZMultiplier;
}
else
{
module.startRotation = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.startRotation);
module.startRotationMultiplier = vgoModule.StartRotationMultiplier;
}
module.flipRotation = vgoModule.flipRotation;
module.startColor = VgoParticleSystemMinMaxGradientConverter.CreateMinMaxGradient(vgoModule.startColor);
module.gravityModifier = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.gravityModifier);
module.gravityModifierMultiplier = vgoModule.gravityModifierMultiplier;
module.simulationSpace = vgoModule.simulationSpace;
module.simulationSpeed = vgoModule.simulationSpeed;
VgoTransformConverter.SetComponentValue(module.customSimulationSpace, vgoModule.customSimulationSpace);
module.useUnscaledTime = vgoModule.useUnscaledTime;
module.scalingMode = vgoModule.scalingMode;
module.playOnAwake = vgoModule.playOnAwake;
module.emitterVelocityMode = vgoModule.emitterVelocityMode;
module.maxParticles = vgoModule.maxParticles;
module.stopAction = vgoModule.stopAction;
module.cullingMode = vgoModule.cullingMode;
module.ringBufferMode = vgoModule.ringBufferMode;
if (vgoModule.ringBufferMode == ParticleSystemRingBufferMode.LoopUntilReplaced)
{
module.ringBufferLoopRange = ArrayConverter.ToVector2(vgoModule.ringBufferLoopRange);
}
}