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;
}
// Use this for initialization
void Start()
{
string[] bandNames =
{
"Sub Base",
"Bass",
"Low Midrange",
"Midrange",
"Upper Midrange",
"Low Presence",
"Presence",
"Brilliance"
};
_emissionModules = new ParticleSystem.EmissionModule[_numberOfParticleGenerators];
_shapeModules = new ParticleSystem.ShapeModule[_numberOfParticleGenerators];
_mainModules = new ParticleSystem.MainModule[_numberOfParticleGenerators];
_particleGenerators = new GameObject[_numberOfParticleGenerators];
_noiseModules = new ParticleSystem.NoiseModule[_numberOfParticleGenerators];
float offset = -14;
for (int i = 0; i < _numberOfParticleGenerators; i++)
{
GameObject go = new GameObject(bandNames[i]);
ParticleSystem particleGenerator = go.AddComponent <ParticleSystem>();
ParticleSystemRenderer particleRenderer =
(ParticleSystemRenderer)particleGenerator.GetComponent <Renderer>();
ExtractModules(i, particleGenerator);
ParticleSystem.LightsModule lm = particleGenerator.lights;
lm.enabled = true;
lm.light = ParticleLight;
lm.ratio = 1;
lm.useParticleColor = true;
ParticleSystem.TrailModule trm = particleGenerator.trails;
trm.enabled = true;
trm.lifetime = 0.1f;
ParticleSystem.ExternalForcesModule em = particleGenerator.externalForces;
em.enabled = true;
em.multiplier = 0.5f;
particleRenderer.renderMode = ParticleSystemRenderMode.Mesh;
particleRenderer.mesh = Resources.GetBuiltinResource <Mesh>("Sphere.fbx");
particleRenderer.material = ParticleMaterial;
particleRenderer.trailMaterial = TrailMaterial;
Vector3 pos = new Vector3(offset + 4 * i, 0, 0);
go.transform.position = transform.TransformPoint(transform.position + pos);
go.transform.parent = transform;
_particleGenerators[i] = go;
}
InitializeMainModules();
InitializeEmissionModules();
InitializeNoiseModules();
InitializeShapeModules();
}
private void Awake()
{
if (ForParticleSystem == null)
{
ForParticleSystem = GetComponent <ParticleSystem>();
}
lights = ForParticleSystem.lights;
}
// Use this for initialization
void Start()
{
_velocity = Vector3.zero;
LightLevel = 1.0f;
_spawnPoint = transform.position;
Cursor.lockState = CursorLockMode.Locked;
Cursor.visible = false;
_ps = transform.Find("PS_ElectricOrb").transform.Find("Circle").GetComponent <ParticleSystem>();
_lights = _ps.lights;
}
void SetVariables()
{
audioEfecto1.pitch = baseSpeed;
audioEfecto2.pitch = baseSpeed;
anim.speed = baseSpeed;
trailP = trailParticle.trails;
foreach (GameObject gO in gObject)
{
gO.transform.localScale = new Vector3(gO.transform.localScale.x * baseSize, gO.transform.localScale.y, gO.transform.localScale.z * baseSize);
}
foreach (ParticleSystem p in allParticles)
{
lightP = p.lights;
velP = p.velocityOverLifetime;
emissionP = p.emission;
shapeP = p.shape;
mainP = p.main;
colorP = p.colorOverLifetime;
colorP.color = gradient;
mainP.startSizeMultiplier *= baseSize;
shapeP.radius *= baseSize;
emissionP.rateOverTimeMultiplier *= baseSize;
velP.speedModifierMultiplier *= baseSize;
lightP.intensityMultiplier *= baseSize;
}
if (effect1Active)
{
for (int i = 0; i < lenght; i++)
{
mainP = effect2Particles[i].main;
mainP.startDelay = new ParticleSystem.MinMaxCurve(delays[i] + effect2Delay);
}
}
trailP.colorOverLifetime = gradient;
vCam1.SetActive(true);
vCam2.SetActive(false);
objectToTeleport.transform.position = posInitial.position;
teleported = false;
hasFinised = true;
}
public static void DebugLightsModule(this ParticleSystem.LightsModule lightsModule)
{
DLog.Log("\n[LightsModule]");
DLog.Log($"alphaAffectsIntensity: {lightsModule.alphaAffectsIntensity}");
DLog.Log($"enabled: {lightsModule.enabled}");
lightsModule.intensity.DebugMinMaxCurve("intensity");
DLog.Log($"intensityMultiplier: {lightsModule.intensityMultiplier}");
lightsModule.light.DebugLight("light");
DLog.Log($"maxLights: {lightsModule.maxLights}");
lightsModule.range.DebugMinMaxCurve("range");
DLog.Log($"rangeMultiplier: {lightsModule.rangeMultiplier}");
DLog.Log($"ratio: {lightsModule.ratio}");
DLog.Log($"sizeAffectsRange: {lightsModule.sizeAffectsRange}");
DLog.Log($"useParticleColor: {lightsModule.useParticleColor}");
DLog.Log($"useRandomDistribution: {lightsModule.useRandomDistribution}");
}
public override void OnStartServer()
{
entrances = new List <Entrance>();
#if UNITY_IOS
foreach (ParticleSystem p in particles)
{
if (p.lights.enabled)
{
ParticleSystem.LightsModule lights = p.lights;
lights.enabled = false;
}
}
spotLight.enabled = false;
#endif
}
protected override void ReadFromImpl(object obj)
{
base.ReadFromImpl(obj);
ParticleSystem.LightsModule uo = (ParticleSystem.LightsModule)obj;
enabled = uo.enabled;
ratio = uo.ratio;
useRandomDistribution = uo.useRandomDistribution;
light = ToID(uo.light);
useParticleColor = uo.useParticleColor;
sizeAffectsRange = uo.sizeAffectsRange;
alphaAffectsIntensity = uo.alphaAffectsIntensity;
range = uo.range;
rangeMultiplier = uo.rangeMultiplier;
intensity = uo.intensity;
intensityMultiplier = uo.intensityMultiplier;
maxLights = uo.maxLights;
}
protected override object WriteToImpl(object obj)
{
obj = base.WriteToImpl(obj);
ParticleSystem.LightsModule uo = (ParticleSystem.LightsModule)obj;
uo.enabled = enabled;
uo.ratio = ratio;
uo.useRandomDistribution = useRandomDistribution;
uo.light = FromID(light, uo.light);
uo.useParticleColor = useParticleColor;
uo.sizeAffectsRange = sizeAffectsRange;
uo.alphaAffectsIntensity = alphaAffectsIntensity;
uo.range = range;
uo.rangeMultiplier = rangeMultiplier;
uo.intensity = intensity;
uo.intensityMultiplier = intensityMultiplier;
uo.maxLights = maxLights;
return(uo);
}
private void TrailingFlamesHandheld(Vector2 velocity)
{
ParticleSystem.LightsModule systemLights = _particleSystem.lights;
if (velocity != Vector2.zero)
{
systemLights.enabled = true;
_particleSystem.Play();
}
else
{
_light.intensity = _intensity;
_light.color = _lightColor;
_particleSystem.Clear();
systemLights.enabled = false;
}
ParticleSystem.ShapeModule particleSystemShape = _particleSystem.shape;
particleSystemShape.rotation = new Vector2(_moveDirection.y * 90f, -_moveDirection.x * 90f);
}
public static void ParticleLightSettings(this ParticleSystem PS,
bool enabled = true,
float scalar = 0.0f,
AnimationCurve animationCurve = null, // Set outside
string LightPrefab = null
)
{
ParticleSystem.LightsModule lightsModule = PS.lights;
// Light Settings
lightsModule.enabled = enabled;
GameObject LightObject = (GameObject)LoadResource(LightPrefab);
Light light = LightObject.GetComponent <Light>();
lightsModule.light = light;
ParticleSystem.MinMaxCurve LightCurve = new ParticleSystem.MinMaxCurve(scalar, animationCurve);
lightsModule.intensity = LightCurve;
lightsModule.range = 100;
lightsModule.useRandomDistribution = false;
lightsModule.ratio = 1;
lightsModule.useParticleColor = false;
lightsModule.intensity = 1;
lightsModule.maxLights = 3;
}
// TODO: unity minmax curve script manual shows cool things
void Start()
{
_lightObj = new GameObject("cfx_light");
_meshObj = (GameObject)GameObject.Instantiate(UnityEngine.Resources.Load("Effects/fx_exhaustFlare_yellow"));
//_meshObj = (GameObject)GameObject.Instantiate(UnityEngine.Resources.Load(Path.Combine(typeof(CollisionFX).Assembly.Location, "spark.png")));
//_sparkSystem = _sparkObj.GetComponent<ParticleSystem>();
_sparkObj = new GameObject("sparks4u");
_sparkObj.transform.parent = this.transform.parent;
_sparkObj.transform.Rotate(-this.transform.parent.transform.forward);
// _rigidBody = _sparkObj.AddComponent<Rigidbody>();
var transformParent = this.transform.parent;
Part part = transform.parent.GetComponentInParent <Part>();
//_rigidBody = part.GetComponent<Rigidbody>();//.GetComponentInParent<Rigidbody>();
//if(_rigidBody = null)
// part.RigidBodyPart.ri
//_rigidBody.useGravity = true;
//_rigidBody.transform.parent = _sparkObj.transform.parent;
_sparkSystem = new ParticleSystem();
_sparkSystem = _sparkObj.AddComponent <ParticleSystem>();
//_sparkSystem.transform.parent = _rigidBody.transform;
if (_sparkSystem == null)
{
Debug.LogException(new NullReferenceException("CollisionFXUPdated: _sparkSystem could not find ParticleSystem component"));
}
else
{
try
{
var main = _sparkSystem.main;
// length of time particles are emitted, control this later
main.duration = 1.0f;
// replay at end of main.duration seconds
main.loop = false;
// time of particle, die when reach 0
main.startLifetime = 2f;
// starting size of particle
main.startSize = new ParticleSystem.MinMaxCurve(0.1f, 0.25f);
main.startSpeed = 1f;
main.startColor = (Color) new Color32(255, 192, 98, 255);
main.gravityModifier = 2;
// particles are released into the world
main.simulationSpace = ParticleSystemSimulationSpace.World;
// don't start on start
main.playOnAwake = false;
main.maxParticles = 10000;
main.scalingMode = ParticleSystemScalingMode.Local;
_emission = _sparkSystem.emission;
// how many per second / how much flow
_emission.rateOverTime = 500f;
_emission.enabled = false;
#region shape
var shape = _sparkSystem.shape;
shape.enabled = true;
shape.shapeType = ParticleSystemShapeType.Sphere;
shape.radius = 0.1f;
shape.scale = Vector3.one;
//_meshObj = new GameObject();
//var meshRenderer = _sparkObj.GetComponent<MeshRenderer>();
//shape.meshRenderer = meshRenderer;
//meshRenderer.enabled = true;
////meshRenderer.
//var meshFilter = _sparkObj.GetComponent<MeshFilter>();
//meshFilter.mesh = CreateSphere(null);
//shape.mesh = meshFilter.mesh;
//shape.shapeType = ParticleSystemShapeType.Cone;
//shape.angle = 20f;
//shape.radius = 0.01f;
//shape.radiusThickness = 1;
//shape.arc = 180f;
//shape.arcMode = ParticleSystemShapeMultiModeValue.Random;
//shape.arcSpread = 0;
#endregion
var inheritVelocity = _sparkSystem.inheritVelocity;
inheritVelocity.enabled = false;
inheritVelocity.mode = ParticleSystemInheritVelocityMode.Initial;
inheritVelocity.curveMultiplier = 0.75f;
var velOverLifetime = _sparkSystem.velocityOverLifetime;
velOverLifetime.enabled = false;
velOverLifetime.space = ParticleSystemSimulationSpace.World;
velOverLifetime.x = 5;
var colorOverLifetime = _sparkSystem.colorOverLifetime;
colorOverLifetime.enabled = true;
//colorOverLifetime.color = new ParticleSystem.MinMaxGradient((Color)new Color32(255, 255, 0, 255), (Color)new Color32(165, 153, 0, 0));
float alpha = 1.0f;
var grad = new Gradient();
grad.SetKeys(
new GradientColorKey[] { new GradientColorKey(new Color32(255, 244, 232, 255), 0.0f), new GradientColorKey(new Color32(255, 100, 100, 0), 0.3f), new GradientColorKey(new Color32(255, 23, 23, 0), 1.0f) },
new GradientAlphaKey[] { new GradientAlphaKey(1.0f, 0.0f), new GradientAlphaKey(1.0f, 0.5f), new GradientAlphaKey(alpha, 0.0f) }
);
colorOverLifetime.color = grad;
var animCurve = new AnimationCurve();
//animCurve.AddKey(0.0f, 0.5f);
//animCurve.AddKey(0.1f, 0.6f);
//animCurve.AddKey(0.2f, 0.7f);
//animCurve.AddKey(0.3f, 0.5f);
//animCurve.AddKey(0.5f, 0.4f);
//animCurve.AddKey(0.7f, 0.3f);
//animCurve.AddKey(0.9f, 0.2f);
//animCurve.AddKey(1.0f, 0.1f);
animCurve.AddKey(0.0f, 0.4f);
animCurve.AddKey(1.0f, 0.01f);
_sizeoverlifetime = _sparkSystem.sizeOverLifetime;
_sizeoverlifetime.enabled = true;
//_sizeoverlifetime.size = GenerateSizeGrowCurve(0.01f, 0f, 5f);
_sizeoverlifetime.size = new ParticleSystem.MinMaxCurve(1, animCurve);
#region collisions
var collisions = _sparkSystem.collision;
collisions.enabled = true;
collisions.mode = ParticleSystemCollisionMode.Collision3D;
collisions.type = ParticleSystemCollisionType.World;
collisions.dampen = 0.1f;
collisions.bounce = 0.7f;
collisions.minKillSpeed = 1;
collisions.maxKillSpeed = 1000;
collisions.radiusScale = .25f;
collisions.quality = ParticleSystemCollisionQuality.High;
collisions.collidesWith = 1;
collisions.maxCollisionShapes = 256;
collisions.enableDynamicColliders = true;
#endregion
var systemRender = _sparkSystem.GetComponent <ParticleSystemRenderer>();
systemRender.renderMode = ParticleSystemRenderMode.Stretch;
systemRender.velocityScale = .1f;
systemRender.lengthScale = 1f;
//string path = Path.Combine(typeof(CollisionFX).Assembly.Location, "spark.png");
//byte[] fileData = File.ReadAllBytes(path);
//Texture2D tex = new Texture2D(64, 64);
//tex.LoadImage(fileData); //..this will auto-resize the texture dimensions.
systemRender.material = _meshObj.GetComponent <Renderer>().material; // UnityEngine.Resources.Load("Effects/fx_exhaustSparks_flameout");
//systemRender.material.mainTexture = tex;
systemRender.trailMaterial = _meshObj.GetComponent <Renderer>().material;
//systemRender.minParticleSize;
//systemRender.maxParticleSize;
//systemRender.normalDirection = 0;
#region lights
//_lightObj.transform.parent = transform;
var light = _lightObj.AddComponent <Light>();
light.type = LightType.Point;
light.range = .1f;
light.intensity = 2f;
light.color = new Color32(255, 157, 82, 255);
light.enabled = true;
light.renderMode = LightRenderMode.ForcePixel;
_particleLights = _sparkSystem.lights;
_particleLights.light = light;
_particleLights.ratio = 1f;
_particleLights.rangeMultiplier = 1;
_particleLights.intensityMultiplier = 1;
_particleLights.useParticleColor = false;
_particleLights.maxLights = 10000;
_particleLights.enabled = true;
_contactPtLight = _sparkObj.AddComponent <Light>();
_contactPtLight.transform.parent = _sparkObj.transform;
_contactPtLight.type = LightType.Point;
_contactPtLight.range = 0.1f;
_contactPtLight.intensity = 2f;
_contactPtLight.color = new Color32(255, 153, 0, 255);
_contactPtLight.enabled = true;
#endregion
#region trails
_trails = _sparkSystem.trails;
_trails.enabled = false;
_trails.ratio = 0.1f;
_trails.lifetime = .25f;
_trails.textureMode = ParticleSystemTrailTextureMode.Stretch;
//trails.dieWithParticles = true;
_trails.sizeAffectsWidth = true;
_trails.minVertexDistance = 0.2f;
_trails.inheritParticleColor = true;
_trails.worldSpace = true;
_trails.sizeAffectsLifetime = false;
_trails.widthOverTrail = 0.2f;
//var grad2 = new Gradient();
//grad2.SetKeys(
// new GradientColorKey[] { new GradientColorKey(new Color32(255, 244, 232, 255), 0.0f), new GradientColorKey(new Color32(255, 23, 23, 0), 0.3f), new GradientColorKey(new Color32(255, 23, 23, 0), 1.0f) },
// new GradientAlphaKey[] { new GradientAlphaKey(1.0f, 0.0f), new GradientAlphaKey(1.0f, 0.5f), new GradientAlphaKey(alpha, 0.0f) }
//);
//colorOverLifetime.color = grad2;
//trails.colorOverLifetime = grad;
#endregion
#region gravity
var _externalforce = _sparkSystem.externalForces;
_externalforce.enabled = true;
var forceOverLifetime = _sparkSystem.forceOverLifetime;
forceOverLifetime.enabled = true;
forceOverLifetime.space = ParticleSystemSimulationSpace.World;
forceOverLifetime.x = Physics.gravity.x;
forceOverLifetime.y = Physics.gravity.y;
forceOverLifetime.z = Physics.gravity.z;
#endregion
_instantiated = true;
DoLights(false);
}
catch (Exception ex)
{
Debug.LogException(new Exception(String.Format("CollisionFXUPdated: Error in SparkLauncher Setup -- > {0}", ex), ex));
}
}
}
internal ParticleElementTemplate(ParticleElement element)
{
this.element = element;
this.partSys = element.partSys;
this.partRend = element.partRend;
this.main = this.partSys.main;
this.collision = this.partSys.collision;
this.collision.enabled = false;
this.colorBySpeed = this.partSys.colorBySpeed;
this.colorBySpeed.enabled = false;
this.colorOverLifetime = this.partSys.colorOverLifetime;
this.colorOverLifetime.enabled = false;
this.customData = this.partSys.customData;
this.customData.enabled = false;
this.emission = this.partSys.emission;
this.emission.enabled = false;
this.externalForces = this.partSys.externalForces;
this.externalForces.enabled = false;
this.forceOverLifetime = this.partSys.forceOverLifetime;
this.forceOverLifetime.enabled = false;
this.inheritVelocity = this.partSys.inheritVelocity;
this.inheritVelocity.enabled = false;
this.lights = this.partSys.lights;
this.lights.enabled = false;
this.limitVelocityOverLifetime = this.partSys.limitVelocityOverLifetime;
this.limitVelocityOverLifetime.enabled = false;
this.noise = this.partSys.noise;
this.noise.enabled = false;
this.rotationBySpeed = this.partSys.rotationBySpeed;
this.rotationBySpeed.enabled = false;
this.rotationOverLifetime = this.partSys.rotationOverLifetime;
this.rotationOverLifetime.enabled = false;
this.shape = this.partSys.shape;
this.shape.enabled = false;
this.sizeBySpeed = this.partSys.sizeBySpeed;
this.sizeBySpeed.enabled = false;
this.sizeOverLifetime = this.partSys.sizeOverLifetime;
this.sizeOverLifetime.enabled = false;
this.subEmitters = this.partSys.subEmitters;
this.subEmitters.enabled = false;
this.textureSheetAnimation = this.partSys.textureSheetAnimation;
this.textureSheetAnimation.enabled = false;
this.trails = this.partSys.trails;
this.trails.enabled = false;
this.trigger = this.partSys.trigger;
this.trigger.enabled = false;
this.velocityOverLifetime = this.partSys.velocityOverLifetime;
this.velocityOverLifetime.enabled = false;
}
protected void InitializeParticleSystem(ParticleSystem ps, ParticleSystemRenderer renderer, int max_particles)
{
ParticleSystem.MainModule main = ps.main;
main.loop = false;
main.playOnAwake = false;
main.maxParticles = max_particles;
main.startColor = new ParticleSystem.MinMaxGradient(new Color(1.0f, 1.0f, 1.0f, 0.0f));
renderer.sortMode = ParticleSystemSortMode.Distance;
renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
renderer.receiveShadows = false;
renderer.enableGPUInstancing = true;
Material particleMaterial = new Material(Shader.Find(shader));
renderer.material = particleMaterial;
PrepareMaterial(particleMaterial);
particleMaterial.SetColor("_Color", new Color(1.0f, 1.0f, 1.0f, 1.0f));
particleMaterial.SetColor("_EmissionColor", new Color(0.8f, 0.8f, 0.8f, 1.0f));
ParticleSystem.EmissionModule em = ps.emission;
em.enabled = false;
ParticleSystem.ShapeModule sh = ps.shape;
sh.enabled = false;
ParticleSystem.VelocityOverLifetimeModule vol = ps.velocityOverLifetime;
vol.enabled = false;
ParticleSystem.LimitVelocityOverLifetimeModule lvol = ps.limitVelocityOverLifetime;
lvol.enabled = false;
ParticleSystem.InheritVelocityModule ivm = ps.inheritVelocity;
ivm.enabled = false;
ParticleSystem.ForceOverLifetimeModule fol = ps.forceOverLifetime;
fol.enabled = false;
ParticleSystem.ColorOverLifetimeModule col = ps.colorOverLifetime;
col.enabled = false;
ParticleSystem.ColorBySpeedModule cbs = ps.colorBySpeed;
cbs.enabled = false;
ParticleSystem.SizeOverLifetimeModule sol = ps.sizeOverLifetime;
sol.enabled = false;
ParticleSystem.SizeBySpeedModule sbs = ps.sizeBySpeed;
sbs.enabled = false;
ParticleSystem.RotationOverLifetimeModule rol = ps.rotationOverLifetime;
rol.enabled = false;
ParticleSystem.RotationBySpeedModule rbs = ps.rotationBySpeed;
rbs.enabled = false;
ParticleSystem.ExternalForcesModule extf = ps.externalForces;
extf.enabled = false;
ParticleSystem.NoiseModule noise = ps.noise;
noise.enabled = false;
ParticleSystem.CollisionModule collision = ps.collision;
collision.enabled = false;
ParticleSystem.TriggerModule triggers = ps.trigger;
triggers.enabled = false;
ParticleSystem.SubEmittersModule subem = ps.subEmitters;
subem.enabled = false;
ParticleSystem.TextureSheetAnimationModule tsa = ps.textureSheetAnimation;
tsa.enabled = false;
ParticleSystem.LightsModule lights = ps.lights;
lights.enabled = false;
ParticleSystem.CustomDataModule cd = ps.customData;
cd.enabled = false;
}
protected override void GetDepsFromImpl(object obj, GetDepsFromContext context)
{
base.GetDepsFromImpl(obj, context);
ParticleSystem.LightsModule uo = (ParticleSystem.LightsModule)obj;
AddDep(uo.light, context);
}
internal static GameObject CreatePlasmaBurnPrefab()
{
var obj = PrefabsCore.CreatePrefab("PlasmaBurn", false);
var holder = new GameObject("Particles");
holder.transform.parent = obj.transform;
var mainPs = holder.AddComponent <ParticleSystem>();
var mainPsr = holder.AddOrGetComponent <ParticleSystemRenderer>();
mainPs
.BurnMain()
.BurnEmission()
.BurnShape()
.BurnCOL()
.BurnSOL();
mainPsr
.BurnRenderer();
ParticleSystem.VelocityOverLifetimeModule mainPsVol = mainPs.velocityOverLifetime;
mainPsVol.enabled = false;
ParticleSystem.LimitVelocityOverLifetimeModule mainPsLvol = mainPs.limitVelocityOverLifetime;
mainPsLvol.enabled = false;
ParticleSystem.InheritVelocityModule mainPsIvel = mainPs.inheritVelocity;
mainPsIvel.enabled = false;
ParticleSystem.ForceOverLifetimeModule mainPsFol = mainPs.forceOverLifetime;
mainPsFol.enabled = false;
ParticleSystem.ColorBySpeedModule mainPsCbs = mainPs.colorBySpeed;
mainPsCbs.enabled = false;
ParticleSystem.SizeBySpeedModule mainPsSbs = mainPs.sizeBySpeed;
mainPsSbs.enabled = false;
ParticleSystem.RotationOverLifetimeModule mainPsRol = mainPs.rotationOverLifetime;
mainPsRol.enabled = false;
ParticleSystem.RotationBySpeedModule mainPsRbs = mainPs.rotationBySpeed;
mainPsRbs.enabled = false;
ParticleSystem.ExternalForcesModule mainPsExt = mainPs.externalForces;
mainPsExt.enabled = false;
ParticleSystem.NoiseModule mainPsNoise = mainPs.noise;
mainPsNoise.enabled = false;
ParticleSystem.CollisionModule mainPsColl = mainPs.collision;
mainPsColl.enabled = false;
ParticleSystem.TriggerModule mainPsTrig = mainPs.trigger;
mainPsTrig.enabled = false;
ParticleSystem.SubEmittersModule mainPsSub = mainPs.subEmitters;
mainPsSub.enabled = false;
ParticleSystem.TextureSheetAnimationModule mainPsTex = mainPs.textureSheetAnimation;
mainPsTex.enabled = false;
ParticleSystem.LightsModule mainPsLigh = mainPs.lights;
mainPsLigh.enabled = false;
ParticleSystem.TrailModule mainPsTrail = mainPs.trails;
mainPsTrail.enabled = false;
ParticleSystem.CustomDataModule mainPsData = mainPs.customData;
mainPsData.enabled = false;
return(obj);
}
private void SetupFlameParticleSystem(ParticleSystem ps, Int32 skinIndex, FlamePSInfo psi)
{
ParticleSystem.MainModule main = ps.main;
main.duration = 1f;
main.loop = true;
main.prewarm = false;
main.startDelay = 0f;
main.startLifetime = new ParticleSystem.MinMaxCurve
{
mode = ParticleSystemCurveMode.Constant,
constant = 0.65f
};
main.startSpeed = new ParticleSystem.MinMaxCurve
{
mode = ParticleSystemCurveMode.Constant,
constant = psi.startSpeed
};
main.startSize3D = false;
main.startSize = new ParticleSystem.MinMaxCurve
{
mode = ParticleSystemCurveMode.Constant,
constant = psi.startSize * 0.75f
};
main.startRotation3D = false;
main.startRotation = new ParticleSystem.MinMaxCurve
{
mode = ParticleSystemCurveMode.TwoConstants,
constantMin = 0f,
constantMax = 360f
};
main.flipRotation = 0f;
main.startColor = new ParticleSystem.MinMaxGradient
{
mode = ParticleSystemGradientMode.Color,
color = new Color(1f, 1f, 1f, 1f)
};
main.gravityModifier = new ParticleSystem.MinMaxCurve
{
mode = ParticleSystemCurveMode.Constant,
constant = psi.gravity
};
main.simulationSpace = ParticleSystemSimulationSpace.Local;
main.simulationSpeed = 1f;
main.useUnscaledTime = false;
main.scalingMode = ParticleSystemScalingMode.Local;
main.playOnAwake = true;
main.emitterVelocityMode = ParticleSystemEmitterVelocityMode.Transform;
main.maxParticles = 1000;
main.stopAction = ParticleSystemStopAction.None;
main.cullingMode = ParticleSystemCullingMode.AlwaysSimulate;
main.ringBufferMode = ParticleSystemRingBufferMode.Disabled;
ParticleSystem.EmissionModule emission = ps.emission;
emission.enabled = true;
emission.rateOverTime = new ParticleSystem.MinMaxCurve
{
mode = ParticleSystemCurveMode.Constant,
constant = 10f
};
emission.rateOverDistance = new ParticleSystem.MinMaxCurve
{
mode = ParticleSystemCurveMode.Constant,
constant = 0f
};
emission.rateOverDistanceMultiplier = 0f;
emission.rateOverTimeMultiplier = psi.rate;
ParticleSystem.ShapeModule shape = ps.shape;
shape.enabled = true;
shape.shapeType = ParticleSystemShapeType.Cone;
shape.angle = 38.26f;
shape.radius = psi.radius * 0.75f;
shape.radiusThickness = 1f;
shape.arc = 360f;
shape.arcMode = ParticleSystemShapeMultiModeValue.Random;
shape.arcSpread = 0f;
shape.position = psi.position;
shape.rotation = psi.rotation;
shape.scale = psi.scale;
shape.alignToDirection = false;
ParticleSystem.VelocityOverLifetimeModule velOverLife = ps.velocityOverLifetime;
velOverLife.enabled = false;
ParticleSystem.LimitVelocityOverLifetimeModule limVelOverLife = ps.limitVelocityOverLifetime;
limVelOverLife.enabled = false;
ParticleSystem.InheritVelocityModule inheritVel = ps.inheritVelocity;
inheritVel.enabled = false;
ParticleSystem.ForceOverLifetimeModule forceOverLife = ps.forceOverLifetime;
forceOverLife.enabled = false;
ParticleSystem.ColorOverLifetimeModule colorOverLife = ps.colorOverLifetime;
colorOverLife.enabled = true;
colorOverLife.color = new ParticleSystem.MinMaxGradient
{
mode = ParticleSystemGradientMode.Gradient,
gradient = new Gradient
{
mode = GradientMode.Blend,
colorKeys = new GradientColorKey[1]
{
new GradientColorKey(new Color(1f, 1f, 1f), 0f)
},
alphaKeys = new GradientAlphaKey[4]
{
new GradientAlphaKey(0f, 0f),
new GradientAlphaKey(0.9f, 0.1f),
new GradientAlphaKey(0.6f, 0.6f),
new GradientAlphaKey(0f, 1f)
}
}
};
ParticleSystem.ColorBySpeedModule colorBySpeed = ps.colorBySpeed;
colorBySpeed.enabled = false;
ParticleSystem.SizeOverLifetimeModule sizeOverLife = ps.sizeOverLifetime;
sizeOverLife.enabled = true;
sizeOverLife.size = new ParticleSystem.MinMaxCurve
{
mode = ParticleSystemCurveMode.Curve,
curve = new AnimationCurve
{
postWrapMode = WrapMode.Clamp,
preWrapMode = WrapMode.Clamp,
keys = new Keyframe[3]
{
new Keyframe(0f, 0.2f),
new Keyframe(0.47f, 0.71f),
new Keyframe(1f, 0.025f)
}
}
};
sizeOverLife.sizeMultiplier = 1f;
ParticleSystem.SizeBySpeedModule sizeBySpeed = ps.sizeBySpeed;
sizeBySpeed.enabled = false;
ParticleSystem.RotationOverLifetimeModule rotOverLife = ps.rotationOverLifetime;
rotOverLife.enabled = true;
rotOverLife.separateAxes = false;
rotOverLife.z = new ParticleSystem.MinMaxCurve
{
mode = ParticleSystemCurveMode.Constant,
constant = 3f
};
ParticleSystem.RotationBySpeedModule rotBySpeed = ps.rotationBySpeed;
rotBySpeed.enabled = false;
ParticleSystem.ExternalForcesModule extForce = ps.externalForces;
extForce.enabled = false;
ParticleSystem.NoiseModule noise = ps.noise;
noise.enabled = false;
ParticleSystem.CollisionModule col = ps.collision;
col.enabled = false;
ParticleSystem.TriggerModule trig = ps.trigger;
trig.enabled = false;
ParticleSystem.SubEmittersModule subEmit = ps.subEmitters;
subEmit.enabled = false;
ParticleSystem.TextureSheetAnimationModule texSheet = ps.textureSheetAnimation;
texSheet.enabled = false;
ParticleSystem.LightsModule light = ps.lights;
light.enabled = false;
ParticleSystem.TrailModule trails = ps.trails;
trails.enabled = false;
ParticleSystem.CustomDataModule custData = ps.customData;
custData.enabled = false;
}
// Update is called once per frame
void Update()
{
if (!hasFinised)
{
t += Time.deltaTime / (9.25f + effect2Delay) * baseSpeed;
}
foreach (ParticleSystem p in allParticles)
{
lightP = p.lights;
mainP = p.main;
mainP.simulationSpeed = baseSpeed * (curveSpeed.Evaluate(t));
lightP.intensity = baseSize * (curveGeneral.Evaluate(t));
}
audioEfecto1.volume = baseSize * (curveGeneral.Evaluate(t));
audioEfecto2.volume = baseSize * (curveGeneral.Evaluate(t));
if (effect1Active && fireRing.isStopped && !hasFinised)
{
projector.Activate();
}
else if (hasFinised)
{
projector.Desactivate();
}
if (!animTriggerJump && t > ((effect2Delay + (5.2 * 0.85)) / (9.25f + effect2Delay)))
{
anim.SetTrigger("Jump");
animTriggerJump = true;
}
if (!changeAudio && t > (effect2Delay / (9.25f + effect2Delay)))
{
audioEfecto2.Play();
changeAudio = true;
}
if (!teleported && effect1Active && effect2Active)
{
if (!IsEffect1Playing)
{
vCam1.SetActive(false);
vCam2.SetActive(true);
objectToTeleport.transform.position = posFinish.position;
objectToTeleport.transform.rotation = posFinish.rotation;
teleported = true;
}
}
if (effect2Active)
{
if (!IsEffect2Playing && !hasFinised)
{
hasFinised = true;
OnEffectFinished?.Invoke();
anim.SetTrigger("Idle");
}
}
if (effect1Active && !effect2Active)
{
if (!IsEffect1Playing && !hasFinised)
{
hasFinised = true;
OnEffectFinished?.Invoke();
anim.SetTrigger("Idle");
}
}
// if (IsEffect2Playing && !hasFinised)
flashImage.color = new Color(flashImage.color.r, flashImage.color.g, flashImage.color.b, flashCurve.Evaluate(t));
if (!hasFinised)
{
foreach (var shaker in shakeControllers)
{
shaker.ShakeAmplitude = intensityCurve.Evaluate(t);
}
}
float y = minBloomEffect.Evaluate(t) * bloomMultiplier;
float y2 = intensityCurve.Evaluate(t) * bloomMultiplier;
bloom.intensity = Mathf.Max(y, y2);
playerMaterial.SetFloat("_SphereMultiplier", curvePlayer.Evaluate(t));
}
private static void BasicSetup(ParticleSystem ps)
{
ParticleSystem.EmissionModule ps1Emission = ps.emission;
ps1Emission.enabled = false;
ParticleSystem.ShapeModule ps1Shape = ps.shape;
ps1Shape.enabled = false;
ParticleSystem.VelocityOverLifetimeModule ps1VOL = ps.velocityOverLifetime;
ps1VOL.enabled = false;
ParticleSystem.LimitVelocityOverLifetimeModule ps1LimVOL = ps.limitVelocityOverLifetime;
ps1LimVOL.enabled = false;
ParticleSystem.InheritVelocityModule ps1InhVel = ps.inheritVelocity;
ps1InhVel.enabled = false;
ParticleSystem.ForceOverLifetimeModule ps1FOL = ps.forceOverLifetime;
ps1FOL.enabled = false;
ParticleSystem.ColorOverLifetimeModule ps1COL = ps.colorOverLifetime;
ps1COL.enabled = false;
ParticleSystem.ColorBySpeedModule ps1CBS = ps.colorBySpeed;
ps1CBS.enabled = false;
ParticleSystem.SizeOverLifetimeModule ps1SOL = ps.sizeOverLifetime;
ps1SOL.enabled = false;
ParticleSystem.SizeBySpeedModule ps1SBS = ps.sizeBySpeed;
ps1SBS.enabled = false;
ParticleSystem.RotationOverLifetimeModule ps1ROL = ps.rotationOverLifetime;
ps1ROL.enabled = false;
ParticleSystem.RotationBySpeedModule ps1RBS = ps.rotationBySpeed;
ps1RBS.enabled = false;
ParticleSystem.ExternalForcesModule ps1ExtFor = ps.externalForces;
ps1ExtFor.enabled = false;
ParticleSystem.NoiseModule ps1Noise = ps.noise;
ps1Noise.enabled = false;
ParticleSystem.CollisionModule ps1Collis = ps.collision;
ps1Collis.enabled = false;
ParticleSystem.TriggerModule ps1Trig = ps.trigger;
ps1Trig.enabled = false;
ParticleSystem.SubEmittersModule ps1SubEmit = ps.subEmitters;
ps1SubEmit.enabled = false;
ParticleSystem.TextureSheetAnimationModule ps1TexAnim = ps.textureSheetAnimation;
ps1TexAnim.enabled = false;
ParticleSystem.LightsModule ps1Light = ps.lights;
ps1Light.enabled = false;
ParticleSystem.TrailModule ps1Trails = ps.trails;
ps1Trails.enabled = false;
ParticleSystem.CustomDataModule ps1Cust = ps.customData;
ps1Cust.enabled = false;
}
private static void EnforceParticleLimits(GameObject avatar)
{
ParticleScanOptions options = Config.ParticleScanOptions;
ParticleSystem[] systems = avatar.GetComponentsInChildren <ParticleSystem>(true);
if (systems.Length == 0)
{
Log.Debug("Skipping particle limit check - no particles found on avatar.");
return;
}
if (systems.Length > options.MaxSystems)
{
UnityEngine.Object.Destroy(avatar);
Log.Debug($"Particle limit check - destroyed avatar {avatar.name} - too many particle systems");
return;
}
for (int i = 0; i < systems.Length; i++)
{
void DestroyMe()
{
Log.Debug($"Particle limit check - destroyed {systems[i].name}");
UnityEngine.Object.Destroy(systems[i].gameObject);
UnityEngine.Object.Destroy(systems[i]);
}
ParticleSystem.EmissionModule emission = systems[i].emission;
ParticleSystem.Burst[] bursts = new ParticleSystem.Burst[emission.burstCount];
ParticleSystem.CollisionModule collisionMod = systems[i].collision;
ParticleSystem.LightsModule lightsMod = systems[i].lights;
if (emission.rateOverTime.constantMax > options.Emission || emission.rateOverTime.constantMax < 0)
{
Log.Debug($"Particle limit check - destroying particle system for {emission.rateOverTime.constantMax} rateOverTime emission");
DestroyMe();
}
else if (emission.rateOverDistance.constantMax > options.Emission || emission.rateOverDistance.constantMax < 0)
{
Log.Debug($"Particle limit check - destroying particle system for {emission.rateOverDistance.constantMax} rateOverDistance emission");
DestroyMe();
}
else if (lightsMod.maxLights > options.MaxLights)
{
Log.Debug($"Particle limit check - destroying particle system for {lightsMod.maxLights} lights maxcount");
DestroyMe();
}
else if (emission.burstCount != 0)
{
emission.GetBursts(bursts);
for (int x = 0; x < bursts.Length; x++)
{
if (systems[i] == null)
{
continue;
}
short count = bursts[x].maxCount;
if (count > options.Bursts || count < 0)
{
Log.Debug($"Particle limit check - destroying particle system for {count} burst maxCount");
DestroyMe();
}
}
}
if (!options.Collision && collisionMod.collidesWith.value == 1024)
{
Log.Debug("Particle limit check - disabling PlayerLocal collision");
collisionMod.enabled = false;
}
if (collisionMod.maxKillSpeed > options.MaxKill || collisionMod.maxKillSpeed < options.MinKill)
{
Log.Debug($"Particle limit check - disabling collision for {collisionMod.maxKillSpeed} maxKillSpeed");
collisionMod.enabled = false;
}
if (options.LightSizeConstraint)
{
Log.Debug($"Particle limit check - lights on particle system have had their size constrained");
lightsMod.sizeAffectsRange = false;
}
if (collisionMod.maxCollisionShapes > 256)
{
Log.Debug($"Particle limit check - destroyed particle system for {collisionMod.maxCollisionShapes} maxCollisionShapes");
UnityEngine.Object.Destroy(systems[i]);
}
}
}
public void ChangeLighting()
{
ParticleSystem.LightsModule lighting = muzzleFlash.lights;
lighting.enabled = MuzzleFlashLighting;
}
internal static GameObject CreateSmallAmmoTracer(Material mainMat, Material trailMat)
{
GameObject obj = PrefabsCore.CreatePrefab("Standard Tracer", false);
Transform tracerHead = new GameObject("TracerHead").transform;
tracerHead.parent = obj.transform;
tracerHead.localPosition = Vector3.zero;
tracerHead.localRotation = Quaternion.identity;
//tracerHead.localEulerAngles = new Vector3( 0f, 90f, 0f );
tracerHead.localScale = Vector3.one;
Transform tracerTail = new GameObject("TracerTail").transform;
tracerTail.parent = obj.transform;
tracerTail.localPosition = Vector3.zero;
tracerTail.localRotation = Quaternion.identity;
tracerTail.localScale = Vector3.one;
Transform trail = new GameObject("trail").transform;
trail.parent = tracerTail;
trail.localPosition = Vector3.zero;
trail.localRotation = Quaternion.identity;
trail.localScale = Vector3.one;
Transform headBeam = new GameObject("HeadBeam").transform;
headBeam.parent = tracerTail;
headBeam.localPosition = Vector3.zero;
headBeam.localEulerAngles = new Vector3(0f, 90f, 0f);
headBeam.localScale = Vector3.one;
EffectComponent effectComp = obj.AddComponent <EffectComponent>();
Tracer tracer = obj.AddComponent <Tracer>();
VFXAttributes vfxAtrib = obj.AddComponent <VFXAttributes>();
Rigidbody headRb = tracerHead.AddComponent <Rigidbody>();
Rigidbody tailRb = tracerTail.AddComponent <Rigidbody>();
ParticleSystem mainPs = headBeam.AddComponent <ParticleSystem>();
ParticleSystemRenderer mainPsr = headBeam.AddOrGetComponent <ParticleSystemRenderer>();
ParticleSystem trailPs = trail.AddComponent <ParticleSystem>();
ParticleSystemRenderer trailPsr = trail.AddOrGetComponent <ParticleSystemRenderer>();
DestroyTracerOnDelay cleanup = obj.AddComponent <DestroyTracerOnDelay>();
cleanup.delay = 2f;
cleanup.tracer = tracer;
ZeroTracerLengthOverDuration zeroLength = obj.AddComponent <ZeroTracerLengthOverDuration>();
zeroLength.tracer = tracer;
DestroyOnTimer timer = obj.AddComponent <DestroyOnTimer>();
timer.duration = 10f;
effectComp.effectIndex = EffectIndex.Invalid;
effectComp.positionAtReferencedTransform = false;
effectComp.parentToReferencedTransform = false;
effectComp.applyScale = false;
effectComp.soundName = null;
effectComp.disregardZScale = false;
tracer.startTransform = null;
tracer.beamObject = null;
tracer.beamDensity = 0f;
tracer.speed = 600f;
tracer.headTransform = tracerHead;
tracer.tailTransform = tracerTail;
tracer.length = 20f;
tracer.reverse = false;
headRb.isKinematic = true;
headRb.useGravity = false;
tailRb.isKinematic = true;
tailRb.useGravity = false;
vfxAtrib.optionalLights = null;
vfxAtrib.secondaryParticleSystem = null;
vfxAtrib.vfxIntensity = VFXAttributes.VFXIntensity.Low;
vfxAtrib.vfxPriority = VFXAttributes.VFXPriority.Always;
mainPs.PlayOnStart();
mainPs.SetupSmallTracerMain();
mainPs.SetupSmallTracerEmission();
mainPs.SetupSmallTracerShape();
mainPs.SetupSmallTracerColorOverLifetime();
mainPs.SetupSmallTracerSizeOverLifetime();
mainPsr.SetupSmallTracerRenderer(mainMat);
ParticleSystem.VelocityOverLifetimeModule mainPsVol = mainPs.velocityOverLifetime;
mainPsVol.enabled = false;
ParticleSystem.LimitVelocityOverLifetimeModule mainPsLvol = mainPs.limitVelocityOverLifetime;
mainPsLvol.enabled = false;
ParticleSystem.InheritVelocityModule mainPsIvel = mainPs.inheritVelocity;
mainPsIvel.enabled = false;
ParticleSystem.ForceOverLifetimeModule mainPsFol = mainPs.forceOverLifetime;
mainPsFol.enabled = false;
ParticleSystem.ColorBySpeedModule mainPsCbs = mainPs.colorBySpeed;
mainPsCbs.enabled = false;
ParticleSystem.SizeBySpeedModule mainPsSbs = mainPs.sizeBySpeed;
mainPsSbs.enabled = false;
ParticleSystem.RotationOverLifetimeModule mainPsRol = mainPs.rotationOverLifetime;
mainPsRol.enabled = false;
ParticleSystem.RotationBySpeedModule mainPsRbs = mainPs.rotationBySpeed;
mainPsRbs.enabled = false;
ParticleSystem.ExternalForcesModule mainPsExt = mainPs.externalForces;
mainPsExt.enabled = false;
ParticleSystem.NoiseModule mainPsNoise = mainPs.noise;
mainPsNoise.enabled = false;
ParticleSystem.CollisionModule mainPsColl = mainPs.collision;
mainPsColl.enabled = false;
ParticleSystem.TriggerModule mainPsTrig = mainPs.trigger;
mainPsTrig.enabled = false;
ParticleSystem.SubEmittersModule mainPsSub = mainPs.subEmitters;
mainPsSub.enabled = false;
ParticleSystem.TextureSheetAnimationModule mainPsTex = mainPs.textureSheetAnimation;
mainPsTex.enabled = false;
ParticleSystem.LightsModule mainPsLight = mainPs.lights;
mainPsLight.enabled = false;
ParticleSystem.TrailModule mainPsTrail = mainPs.trails;
mainPsTrail.enabled = false;
ParticleSystem.CustomDataModule mainPsData = mainPs.customData;
mainPsData.enabled = false;
trailPs.PlayOnStart();
trailPs.SetupSmallTracerTrailMain();
trailPs.SetupSmallTracerTrailEmission();
trailPs.SetupSmallTracerTrailNoise();
trailPs.SetupSmallTracerTrailTrail();
trailPsr.SetupSmallTracerTrailRenderer(trailMat);
ParticleSystem.ShapeModule trailPsShape = trailPs.shape;
trailPsShape.enabled = false;
ParticleSystem.VelocityOverLifetimeModule trailPsVol = trailPs.velocityOverLifetime;
trailPsVol.enabled = false;
ParticleSystem.LimitVelocityOverLifetimeModule trailPsLvol = trailPs.limitVelocityOverLifetime;
trailPsLvol.enabled = false;
ParticleSystem.InheritVelocityModule trailPsIvel = trailPs.inheritVelocity;
trailPsIvel.enabled = false;
ParticleSystem.ForceOverLifetimeModule trailPsFol = trailPs.forceOverLifetime;
trailPsFol.enabled = false;
ParticleSystem.ColorOverLifetimeModule trailPsCol = trailPs.colorOverLifetime;
trailPsCol.enabled = false;
ParticleSystem.ColorBySpeedModule trailPsCbs = trailPs.colorBySpeed;
trailPsCbs.enabled = false;
ParticleSystem.SizeOverLifetimeModule trailPsSol = trailPs.sizeOverLifetime;
trailPsSol.enabled = false;
ParticleSystem.SizeBySpeedModule trailPsSbs = trailPs.sizeBySpeed;
trailPsSbs.enabled = false;
ParticleSystem.RotationOverLifetimeModule trailPsRol = trailPs.rotationOverLifetime;
trailPsRol.enabled = false;
ParticleSystem.RotationBySpeedModule trailPsRbs = trailPs.rotationBySpeed;
trailPsRbs.enabled = false;
ParticleSystem.ExternalForcesModule trailPsExt = trailPs.externalForces;
trailPsExt.enabled = false;
ParticleSystem.NoiseModule trailPsNoise = trailPs.noise;
trailPsNoise.enabled = true;
ParticleSystem.CollisionModule trailPsColl = trailPs.collision;
trailPsColl.enabled = false;
ParticleSystem.TriggerModule trailPsTrig = trailPs.trigger;
trailPsTrig.enabled = false;
ParticleSystem.SubEmittersModule trailPsSub = trailPs.subEmitters;
trailPsSub.enabled = false;
ParticleSystem.TextureSheetAnimationModule trailPsTex = trailPs.textureSheetAnimation;
trailPsTex.enabled = false;
ParticleSystem.LightsModule trailPsLigh = trailPs.lights;
trailPsLigh.enabled = false;
ParticleSystem.CustomDataModule trailPsData = trailPs.customData;
trailPsData.enabled = false;
return(obj);
}
protected void InitializeParticleSystem(ParticleSystem ps, ParticleSystemRenderer renderer, int max_particles)
{
ParticleSystem.MainModule main = ps.main;
main.loop = false;
main.playOnAwake = false;
main.maxParticles = max_particles;
main.startColor = new ParticleSystem.MinMaxGradient(new Color(1.0f, 1.0f, 1.0f, 0.0f));
renderer.sortMode = ParticleSystemSortMode.Distance;
renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
renderer.receiveShadows = false;
renderer.renderMode = ParticleSystemRenderMode.Billboard;
//GameObject gameObj = GameObject.CreatePrimitive(PrimitiveType.Sphere);
//renderer.mesh = gameObj.GetComponent<MeshFilter>().mesh;
//Destroy(gameObj);
renderer.enableGPUInstancing = true;
renderer.alignment = ParticleSystemRenderSpace.Facing;
ps_material = new Material(Shader.Find(shader));
renderer.material = ps_material;
PrepareMaterial(ps_material, m_Particle);
SetDefaultColor(new Color(1.0f, 1.0f, 1.0f, 1.0f));
SetDefaultEmission(new Color(1f, 1f, 1f, 1f));
ParticleSystem.EmissionModule em = ps.emission;
em.enabled = false;
ParticleSystem.ShapeModule sh = ps.shape;
sh.enabled = false;
ParticleSystem.VelocityOverLifetimeModule vol = ps.velocityOverLifetime;
vol.enabled = false;
ParticleSystem.LimitVelocityOverLifetimeModule lvol = ps.limitVelocityOverLifetime;
lvol.enabled = false;
ParticleSystem.InheritVelocityModule ivm = ps.inheritVelocity;
ivm.enabled = false;
ParticleSystem.ForceOverLifetimeModule fol = ps.forceOverLifetime;
fol.enabled = false;
ParticleSystem.ColorOverLifetimeModule col = ps.colorOverLifetime;
col.enabled = false;
ParticleSystem.ColorBySpeedModule cbs = ps.colorBySpeed;
cbs.enabled = false;
ParticleSystem.SizeOverLifetimeModule sol = ps.sizeOverLifetime;
sol.enabled = false;
ParticleSystem.SizeBySpeedModule sbs = ps.sizeBySpeed;
sbs.enabled = false;
ParticleSystem.RotationOverLifetimeModule rol = ps.rotationOverLifetime;
rol.enabled = false;
ParticleSystem.RotationBySpeedModule rbs = ps.rotationBySpeed;
rbs.enabled = false;
ParticleSystem.ExternalForcesModule extf = ps.externalForces;
extf.enabled = false;
ParticleSystem.NoiseModule noise = ps.noise;
noise.enabled = false;
ParticleSystem.CollisionModule collision = ps.collision;
collision.enabled = false;
ParticleSystem.TriggerModule triggers = ps.trigger;
triggers.enabled = false;
ParticleSystem.SubEmittersModule subem = ps.subEmitters;
subem.enabled = false;
ParticleSystem.TextureSheetAnimationModule tsa = ps.textureSheetAnimation;
tsa.enabled = false;
ParticleSystem.LightsModule lights = ps.lights;
lights.enabled = false;
ParticleSystem.CustomDataModule cd = ps.customData;
cd.enabled = false;
}
