// 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; }
void Start() { if (StarsSpawnRate == 0) { StarsSpawnRate = 1; } spawnTime = (1 / StarsSpawnRate); ps = GetComponent <ParticleSystem>(); ParticleSystemRenderer psr = GetComponent <ParticleSystemRenderer>(); psr.material = StarsMaterial; ParticleSystem.MainModule psm = ps.main; psm.startLifetimeMultiplier = StarsLifetime; psm.startSizeMultiplier = StarsSize; psm.maxParticles = MaximumStarsNumber; psm.startSpeedMultiplier = 0; ParticleSystem.EmissionModule pse = ps.emission; pse.enabled = false; ParticleSystem.SizeOverLifetimeModule pss = ps.sizeOverLifetime; pss.enabled = true; pss.size = new ParticleSystem.MinMaxCurve(1f, new AnimationCurve( new Keyframe(0, 0), new Keyframe(0.5f, 1f), new Keyframe(1f, 0))); }
void Start() { if (Resources.Load("LaserMaterial/_laser") != null && laserMaterial == null) { laserMaterial = (Material)Resources.Load("LaserMaterial/_laser"); } _ps = GetComponent <ParticleSystem>(); _pr = (ParticleSystemRenderer)GetComponent <Renderer>(); Intensity = 1000; emmision = _ps.emission; emmision.enabled = true; shape = _ps.shape; sizeOverLifeTime = _ps.sizeOverLifetime; colorOverLifeTime = _ps.colorOverLifetime; collision = _ps.collision; _material = GetComponent <ParticleSystemRenderer>().sharedMaterial; _pr.material = laserMaterial; sizeOverLifeTimeCurve.mode = ParticleSystemCurveMode.Constant; generator = new Generator(this); tempColor = (Color.r == 0 && Color.g == 0 && Color.b == 0 && Color.a == 0) ? Color.white : Color; _ps.hideFlags = HideFlags.NotEditable; _ps.Play(); }
protected override void OnJam() { chargingObject.DisableLaserBeam(); ParticleSystem.Particle[] particles = new ParticleSystem.Particle[1]; int p = chargeBall.GetParticles(particles); chargeBall.Stop(true, ParticleSystemStopBehavior.StopEmittingAndClear); ParticleSystem.MainModule main = chargeBall.main; main.duration = timeToCancel; main.startLifetime = timeToCancel; main.startSize = particles[0].GetCurrentSize(chargeBall); // Have the color change. ParticleSystem.ColorOverLifetimeModule color = chargeBall.colorOverLifetime; color.enabled = true; AnimationCurve curve = new AnimationCurve(); curve.AddKey(0f, 1f); curve.AddKey(1f, 0f); ParticleSystem.SizeOverLifetimeModule mod = chargeBall.sizeOverLifetime; mod.enabled = true; mod.size = new ParticleSystem.MinMaxCurve(1f, curve); chargeBall.Play(false); }
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 SetupMainThruster() { mainThruster = GetComponent <ParticleSystem>(); #region Main Properties mainThruster.startLifetime = 0.25f; mainThruster.startSpeed = thrusterStrength; mainThruster.startSize = 2.5f; mainThruster.gravityModifier = 9.8f; mainThruster.simulationSpace = ParticleSystemSimulationSpace.World; mainThruster.scalingMode = ParticleSystemScalingMode.Shape; mainThruster.playOnAwake = false; mainThruster.maxParticles = 0; #endregion #region Emission Module ParticleSystem.EmissionModule emission = mainThruster.emission; emission.enabled = true; emission.rate = 0; #endregion #region Shape Module ParticleSystem.ShapeModule shape = mainThruster.shape; shape.enabled = true; shape.shapeType = ParticleSystemShapeType.Cone; shape.angle = 0; shape.radius = 0.01f; #endregion #region Color Over Lifetime Module ParticleSystem.ColorOverLifetimeModule colorOverLifetime = mainThruster.colorOverLifetime; colorOverLifetime.enabled = true; Gradient gradient = new Gradient(); gradient.SetKeys(new GradientColorKey[] { new GradientColorKey(mainColor, 0.3f), new GradientColorKey(Color.white, 1f) }, new GradientAlphaKey[] { new GradientAlphaKey(1, 0), new GradientAlphaKey(0, 1) }); colorOverLifetime.color = gradient; #endregion #region Size Over Lifetime Module ParticleSystem.SizeOverLifetimeModule sizeOverLifetime = mainThruster.sizeOverLifetime; sizeOverLifetime.enabled = true; sizeOverLifetime.separateAxes = false; AnimationCurve curve = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.3f, 1f), new Keyframe(1, 0)); sizeOverLifetime.size = new ParticleSystem.MinMaxCurve(1, curve); #endregion #region Collision Module ParticleSystem.CollisionModule collision = mainThruster.collision; collision.enabled = true; collision.type = ParticleSystemCollisionType.World; collision.mode = ParticleSystemCollisionMode.Collision2D; collision.bounce = 0; collision.radiusScale = 0.5f; collision.enableInteriorCollisions = false; collision.sendCollisionMessages = true; LayerMask layerMask = new LayerMask(); layerMask.value = (1 << LayerMask.NameToLayer("World")) | (1 << LayerMask.NameToLayer("Vehicle") | (1 << LayerMask.NameToLayer("Object"))); collision.collidesWith = layerMask; #endregion #region Renderer Module ParticleSystemRenderer renderer = GetComponent <ParticleSystemRenderer>(); renderer.material = new Material(Resources.Load <Material>("Materials/Particles/Thruster")); renderer.sortingFudge = 10; #endregion }
// Set size over life time. different axis. Increase almost instantly particles after birth public static void SetSizeOverLifeTime(ParticleSystem.SizeOverLifetimeModule sizeOverLifeTime, Vector3 size) { sizeOverLifeTime.enabled = true; sizeOverLifeTime.separateAxes = true; sizeOverLifeTime.x = GetCurveSizeOverLifeTime(size.x); sizeOverLifeTime.y = GetCurveSizeOverLifeTime(size.y); sizeOverLifeTime.z = GetCurveSizeOverLifeTime(size.z); }
// Use this for initialization void Start() { initialStartSize = GetComponent <ParticleSystem>().main.startSize; solm = GetComponent <ParticleSystem>().sizeOverLifetime; initialSizeOverLifeCurve = solm.size; solm.enabled = false; solm.size = initialStartSize; }
private static void SetupSmallTracerSizeOverLifetime(this ParticleSystem particles) { ParticleSystem.SizeOverLifetimeModule mainPsSol = particles.sizeOverLifetime; mainPsSol.enabled = true; mainPsSol.separateAxes = true; mainPsSol.x = 1f; mainPsSol.y = new ParticleSystem.MinMaxCurve(1f, AnimationCurve.EaseInOut(0f, 1f, 1f, 0f)); mainPsSol.z = 1f; }
private static void SetSizeOverLifetime( ParticleSystem.SizeOverLifetimeModule size, float startSize, float endSize) { AnimationCurve scaleCurve = new AnimationCurve(); scaleCurve.AddKey(0, startSize); scaleCurve.AddKey(1, endSize); size.size = new ParticleSystem.MinMaxCurve(1f, scaleCurve); }
void Start() { PS = this.GetComponent <ParticleSystem>(); myShape = PS.shape; myColor = PS.colorOverLifetime; grad = new Gradient(); mySize = PS.sizeOverLifetime; myRot = PS.rotationOverLifetime; }
protected override void OnFinishedCharge() { ParticleSystem.SizeOverLifetimeModule mod = chargeBall.sizeOverLifetime; mod.enabled = false; ParticleSystem.MainModule main = chargeBall.main; otherParticles[0].Stop(false, ParticleSystemStopBehavior.StopEmittingAndClear); chargeBall.Pause(); chargingObject.EnableLaserBeam(); }
public static void ParticleSizeOverLifetimeSettings(this ParticleSystem PS, bool enabled = true, float scalar = 0.0f, AnimationCurve animationCurve = null // Set Externally ) { ParticleSystem.SizeOverLifetimeModule sizeOverLifetimeModule = PS.sizeOverLifetime; // Size over Lifetime Settings ParticleSystem.MinMaxCurve Curve = new ParticleSystem.MinMaxCurve(scalar, animationCurve); sizeOverLifetimeModule.enabled = enabled; sizeOverLifetimeModule.size = Curve; }
void Start() { particleSystem = GetComponent <ParticleSystem>() ?? gameObject.AddComponent <ParticleSystem>(); particleSystem.playOnAwake = false; particleSystem.Stop(); particleSystem.startLifetime = LifeTime; particleSystem.loop = true; particleSystem.startColor = StartColor; particleSystem.simulationSpace = ParticleSystemSimulationSpace.World; particleSystem.maxParticles = 10240; particleSystem.gravityModifier = -0.02f; particleSystem.scalingMode = ParticleSystemScalingMode.Shape; ParticleSystem.ShapeModule sm = particleSystem.shape; sm.shapeType = ParticleSystemShapeType.ConeShell; sm.radius = Radius; sm.angle = Angle; sm.length = 1; sm.randomDirection = true; sm.enabled = true; ParticleSystem.SizeOverLifetimeModule sl = particleSystem.sizeOverLifetime; sl.size = new ParticleSystem.MinMaxCurve(Size, AnimationCurve.Linear(0f, StartSize, LifeTime, EndSize)); sl.enabled = true; ParticleSystem.RotationOverLifetimeModule rolm = particleSystem.rotationOverLifetime; rolm.enabled = true; rolm.x = new ParticleSystem.MinMaxCurve(0, 360); ParticleSystem.ColorOverLifetimeModule colm = particleSystem.colorOverLifetime; colm.color = new Gradient() { alphaKeys = new GradientAlphaKey[] { new GradientAlphaKey(StartAlpha, StartAlphaTime), new GradientAlphaKey(EndAlpha, EndAlphaTime) }, colorKeys = new GradientColorKey[] { new GradientColorKey(StartColor, StartColorTime), new GradientColorKey(EndColor, EndColorTime) } }; colm.enabled = true; ParticleSystem seb = particleSystem.subEmitters.birth0; seb = GetComponent <ParticleSystem>(); ParticleSystemRenderer particleSystemRenderer = particleSystem.GetComponent <ParticleSystemRenderer>(); particleSystemRenderer.sortMode = ParticleSystemSortMode.Distance; particleSystemRenderer.sortingFudge = 80; particleSystemRenderer.receiveShadows = true; particleSystemRenderer.sharedMaterial = new Material(Shader.Find("Particles/Alpha Blended")); particleSystemRenderer.sharedMaterial.mainTexture = (ModResource.GetTexture("Rocket Smoke Texture")); }
public static void DebugSizeOverLifeTime(this ParticleSystem.SizeOverLifetimeModule sizeOverLifetimeModule) { DLog.Log("\n[SizeOverLifetimeModule]"); DLog.Log($"enabled: {sizeOverLifetimeModule.enabled}"); DLog.Log($"separateAxes: {sizeOverLifetimeModule.separateAxes}"); sizeOverLifetimeModule.size.DebugMinMaxCurve("size"); DLog.Log($"sizeMultiplier: {sizeOverLifetimeModule.sizeMultiplier}"); sizeOverLifetimeModule.x.DebugMinMaxCurve("x"); DLog.Log($"xMultiplier: {sizeOverLifetimeModule.xMultiplier}"); sizeOverLifetimeModule.y.DebugMinMaxCurve("y"); DLog.Log($"yMultiplier: {sizeOverLifetimeModule.yMultiplier}"); sizeOverLifetimeModule.z.DebugMinMaxCurve("z"); DLog.Log($"zMultiplier: {sizeOverLifetimeModule.zMultiplier}"); }
public void Configure(SplatterSettings settings) { system = GetComponent <ParticleSystem>(); this.settings = settings; system.maxParticles = settings.maxParticles; if (settings.removeParticles) { #if UNITY_5_3_OR_NEWER ParticleSystem.SizeOverLifetimeModule solm = system.sizeOverLifetime; solm.enabled = true; #endif system.startLifetime = settings.particleLifetime; } ParticleSystemRenderer particleRenderer = (ParticleSystemRenderer)system.GetComponent <Renderer>(); if (particleRenderer != null) { if (settings.particleMode == ParticleMode.Circle) { particleRenderer.material = (Material)Resources.Load( settings.multiplyColor? "CircleParticleMultiply" : "CircleParticleAlphaBlend"); } else if (settings.particleMode == ParticleMode.Square) { particleRenderer.material = (Material)Resources.Load( settings.multiplyColor? "SquareParticleMultiply" : "SquareParticleAlphaBlend"); } else if (settings.particleMode == ParticleMode.CustomTexture) { particleRenderer.material = (Material)Resources.Load( settings.multiplyColor? "CustomParticleMultiply" : "CustomParticleAlphaBlend"); particleRenderer.material.SetTexture("_MainTex", settings.particleTexture); } else if (settings.particleMode == ParticleMode.CustomMaterial) { particleRenderer.material = settings.particleMaterial; } if (particleRenderer.material == null) { Debug.LogError("[SPLATTER SYSTEM] Can't find particle renderer material."); } particleRenderer.sortingLayerName = settings.sortingLayerName; particleRenderer.renderMode = settings.orientation == OrientationMode.Horizontal? ParticleSystemRenderMode.HorizontalBillboard : ParticleSystemRenderMode.VerticalBillboard; } }
protected override void PerformOperation(Flow flow) { module = Particle.sizeOverLifetime; module.separateAxes = SeparateAxes; if (!SeparateAxes) { module.size = flow.GetValue <ParticleSystem.MinMaxCurve>(Size); } else { module.x = flow.GetValue <ParticleSystem.MinMaxCurve>(SizeX); module.y = flow.GetValue <ParticleSystem.MinMaxCurve>(SizeY); module.z = flow.GetValue <ParticleSystem.MinMaxCurve>(SizeZ); } }
protected override void ReadFromImpl(object obj) { base.ReadFromImpl(obj); ParticleSystem.SizeOverLifetimeModule uo = (ParticleSystem.SizeOverLifetimeModule)obj; enabled = uo.enabled; size = uo.size; sizeMultiplier = uo.sizeMultiplier; x = uo.x; xMultiplier = uo.xMultiplier; y = uo.y; yMultiplier = uo.yMultiplier; z = uo.z; zMultiplier = uo.zMultiplier; separateAxes = uo.separateAxes; }
protected override object WriteToImpl(object obj) { obj = base.WriteToImpl(obj); ParticleSystem.SizeOverLifetimeModule uo = (ParticleSystem.SizeOverLifetimeModule)obj; uo.enabled = enabled; uo.size = size; uo.sizeMultiplier = sizeMultiplier; uo.x = x; uo.xMultiplier = xMultiplier; uo.y = y; uo.yMultiplier = yMultiplier; uo.z = z; uo.zMultiplier = zMultiplier; uo.separateAxes = separateAxes; return(uo); }
// Update is called once per frame void Update() { //only spawn shield after a small delay if (!alive) { startingTimer -= Time.deltaTime; if (startingTimer <= 0) { SpawnShield(); } } if (alive) { scaletimer += Time.deltaTime; //scale up whole transform if (scaletimer <= maxScale) { transform.localScale = new Vector3(transform.localScale.x + scaletimer * scaleSpeed, transform.localScale.y + scaletimer * scaleSpeed, transform.localScale.z + scaletimer * scaleSpeed); } else { //stay for a period of time them go pop //shimmer? if (scaletimer >= aliveTime) { particles.Play(); //turn on size over lifetime ParticleSystem.SizeOverLifetimeModule newSize = particles.sizeOverLifetime; newSize.enabled = true; //turn on coolour over lifetime ParticleSystem.ColorOverLifetimeModule newCol = particles.colorOverLifetime; newCol.enabled = true; //TURN OFF COLLIDER shieldCollider.enabled = false; Destroy(gameObject, destroyTime); } } } }
public void Initialize() { m_SizeOverLifeTimeModuleReference = m_ParticleSystemReference.sizeOverLifetime; //MainModule : StartLifeTime t_DefaultSizeOverLifeTime = m_SizeOverLifeTimeModuleReference.sizeMultiplier; t_DefaultMaxSizeOverLifeTime = t_DefaultSizeOverLifeTime * maxChangeOfSizeOverLifeTime; t_DefaultSizeOverLifeTimeOnX = m_SizeOverLifeTimeModuleReference.xMultiplier; t_DefaultMaxSizeOverLifeTimeOnX = t_DefaultSizeOverLifeTimeOnX * maxChangeOfSizeOverLifeTime; t_DefaultSizeOverLifeTimeOnY = m_SizeOverLifeTimeModuleReference.xMultiplier; t_DefaultMaxSizeOverLifeTimeOnY = t_DefaultSizeOverLifeTimeOnY * maxChangeOfSizeOverLifeTime; t_DefaultSizeOverLifeTimeOnZ = m_SizeOverLifeTimeModuleReference.xMultiplier; t_DefaultMaxSizeOverLifeTimeOnZ = t_DefaultSizeOverLifeTimeOnZ * maxChangeOfSizeOverLifeTime; }
private void UpdateCircles() { if (centerCircle != null) { centerCircle.transform.localScale = Vector2.one * radius * 2; } if (concentricCircles != null) { ParticleSystem.MainModule concentricCirclesMain = concentricCircles.main; ParticleSystem.SizeOverLifetimeModule concentricCirclesSizeOverLifeTime = concentricCircles.sizeOverLifetime; Keyframe[] keyframes = new Keyframe[2]; keyframes[0] = new Keyframe(0, 1); keyframes[1] = new Keyframe(1, radius * 2 / concentricCirclesMain.startSize.constant); concentricCirclesSizeOverLifeTime.size = new ParticleSystem.MinMaxCurve(1, new AnimationCurve(keyframes)); } }
private void MapSizeOverLifetimeParameters(ParticleSystem pSystem, int i) { ParticleSystem.SizeOverLifetimeModule sizeOverLifetimeModule = pSystem.sizeOverLifetime ; try { sizeOverLifetimeModule.enabled = GetBoolParam(i, "sizeOverLifetime_enabled"); } catch (NullReferenceException) { sizeOverLifetimeModule.enabled = false; return; } sizeOverLifetimeModule.separateAxes = GetBoolParam(i, "sizeOverLifetime_separateAxes"); sizeOverLifetimeModule.x = NodeFXUtilities.InterpretStringToCurve(GetStringParam(i, "sizeOverLifetime_size_x")); sizeOverLifetimeModule.y = NodeFXUtilities.InterpretStringToCurve(GetStringParam(i, "sizeOverLifetime_size_y")); sizeOverLifetimeModule.z = NodeFXUtilities.InterpretStringToCurve(GetStringParam(i, "sizeOverLifetime_size_z")); }
protected override void OnCharge() { ParticleSystem.MainModule main = chargeBall.main; main.duration = timeToCharge; main.startLifetime = timeToCharge; main.startSize = chargeBallSize; AnimationCurve curve = new AnimationCurve(); curve.AddKey(0f, 0f); curve.AddKey(1f, 1f); ParticleSystem.SizeOverLifetimeModule mod = chargeBall.sizeOverLifetime; mod.enabled = true; mod.size = new ParticleSystem.MinMaxCurve(1f, curve); chargeBall.gameObject.SetActive(true); chargeBall.Play(true); }
private static void HitparticlesystemAssign() { ParticleSystem ps = new GameObject().AddComponent <ParticleSystem>(); hitParticleSystem = ps; ParticleSystem.MainModule main = ps.main; ParticleSystem.EmissionModule emission = ps.emission; ParticleSystem.ShapeModule shape = ps.shape; ParticleSystem.RotationOverLifetimeModule rot = ps.rotationOverLifetime; ParticleSystem.SizeOverLifetimeModule size = ps.sizeOverLifetime; ParticleSystem.ColorOverLifetimeModule color = ps.colorOverLifetime; ParticleSystemRenderer rend = ps.GetComponent <ParticleSystemRenderer>(); main.startSize = 3f; main.startSpeed = 0f; main.startLifetime = 0.4f; main.startColor = new ParticleSystem.MinMaxGradient(new Color(0.4f, 0.5f, 0.51f, 1f), new Color(0.56f, 0.53f, 0.8679245f, 1)); main.startRotation = new ParticleSystem.MinMaxCurve(0, 360); main.simulationSpace = ParticleSystemSimulationSpace.World; main.loop = false; emission.enabled = false; shape.enabled = false; rot.enabled = true; rot.z = 360; size.enabled = true; size.size = new ParticleSystem.MinMaxCurve(1, new AnimationCurve(new Keyframe[] { new Keyframe(0, 0, 2, 2), new Keyframe(0.8007382f, 1, 0, 0), new Keyframe(1, 0, 0, 0), })); color.enabled = true; color.color = new ParticleSystem.MinMaxGradient(new Color(1, 1, 1, 1), new Color(1, 1, 1, 0)); Material mat1 = new Material(Shader.Find("Particles/Additive")) { mainTexture = Res.ResourceLoader.GetTexture(129) }; rend.material = mat1; }
// Update is called once per frame void Update() { if (pathParticleInst != null && pathParticleInst.activeSelf) { instanceActive = true; instPS = pathParticleInst.GetComponent <ParticleSystem>(); timer = instPS.sizeOverLifetime.sizeMultiplier; sizeOL = instPS.sizeOverLifetime; shapeOL = instPS.shape; if (defaultMultiplier == 0) { defaultMultiplier = instPS.sizeOverLifetime.sizeMultiplier; } } else { instanceActive = false; } if (pathPos >= 1.35f) { pathPos = 1.35f; } if (target != null) { startloc = target.transform.position; if (pathParticleInst != null) { pathParticleInst.SetActive(true); pathParticleInst.transform.LookAt(endLoc, Vector3.up); } if (!instPS.isPlaying) { instPS.Play(); } } else { Debug.Log("No Target!!!"); } }
static void WriteParticleSystemSizeOverLifetime(ParticleSystem.SizeOverLifetimeModule module) { m_writer.Write(module.enabled); if (!module.enabled) { return; } m_writer.Write(module.separateAxes); if (module.separateAxes) { WriteMinMaxCurve(module.x); WriteMinMaxCurve(module.y); WriteMinMaxCurve(module.z); } else { WriteMinMaxCurve(module.size); } }
void Setup() { ParticleSystem.MinMaxCurve minMax = new ParticleSystem.MinMaxCurve(startLifetime.x, startLifetime.y); // //MAIN MODULE ModuleMain = Particules.main; ModuleMain.startSpeed = startSpeed; ModuleMain.startLifetime = minMax; ModuleMain.maxParticles = LimitMax; //ModuleMain.maxParticles = countValidPoint; ParticleSystem.MinMaxGradient minMaxGradient = new ParticleSystem.MinMaxGradient(Couleur1, Couleur2); ModuleMain.startColor = minMaxGradient; ModuleMain.simulationSpace = ParticleSystemSimulationSpace.World; //ModuleMain.customSimulationSpace = transform; ModuleMain.startSize = startSize; // // EMISSION MODULE ModuleEmission = Particules.emission; ModuleEmission.enabled = true; ModuleEmission.rateOverTime = RateOverTIme; // // SIZE OVER LIFETIME MODULE ModuleSizeOverLifetime = Particules.sizeOverLifetime; ModuleSizeOverLifetime.enabled = true; Keyframe[] KeysMin = { new Keyframe(0, 0), new Keyframe(0.2f, 0.3f), new Keyframe(0.8f, 0.3f), new Keyframe(1, 0) }; Keyframe[] KeysMax = { new Keyframe(0, 0), new Keyframe(0.2f, 1), new Keyframe(0.8f, 1), new Keyframe(1, 0) }; AnimationCurve min = new AnimationCurve(KeysMin); AnimationCurve max = new AnimationCurve(KeysMax); ParticleSystem.MinMaxCurve minMaxCurve = new ParticleSystem.MinMaxCurve(1, min, max); ModuleSizeOverLifetime.size = minMaxCurve; // // RENDERER MODULE ParticleSystemRenderer.material = ParticuleMaterial; }
public void PlayEMPEffect(EMPEffectReadyEvent e, EMPEffectNode effect, [JoinByTank] TankNode tank, [JoinAll] SingleNode <MapInstanceComponent> map) { EMPWaveGraphicsBehaviour behaviour = Object.Instantiate <EMPWaveGraphicsBehaviour>(tank.empWaveGraphicsEffect.EMPWaveAsset, tank.tankVisualRoot.transform.position, tank.tankVisualRoot.transform.rotation, map.component.SceneRoot.transform); float num2 = effect.empEffect.Radius * 2f; ParticleSystem waveParticleSystem = behaviour.WaveParticleSystem; ParticleSystem.SizeOverLifetimeModule sizeOverLifetime = waveParticleSystem.sizeOverLifetime; ParticleSystem.MinMaxCurve size = sizeOverLifetime.size; AnimationCurve curve = size.curve; Keyframe key = curve.keys[0]; key.value = (num2 * 0.152f) / 50f; curve.MoveKey(0, key); size.curveMultiplier = num2; sizeOverLifetime.size = size; AudioSource waveSound = behaviour.WaveSound; waveSound.transform.parent = null; waveSound.Play(); waveParticleSystem.Play(); Object.Destroy(behaviour.gameObject, waveParticleSystem.startLifetime + 0.5f); Object.Destroy(waveSound.gameObject, waveSound.clip.length + 0.5f); }
void Start() { particleSystem = GetComponent <ParticleSystem>() ?? gameObject.AddComponent <ParticleSystem>(); particleSystem.playOnAwake = false; particleSystem.Stop(); particleSystem.startLifetime = LifeTime; particleSystem.scalingMode = ParticleSystemScalingMode.Hierarchy; ParticleSystem.ShapeModule sm = particleSystem.shape; sm.shapeType = ParticleSystemShapeType.Cone; sm.radius = Radius; sm.angle = Angle; sm.randomDirection = false; sm.enabled = true; ParticleSystem.SizeOverLifetimeModule sl = particleSystem.sizeOverLifetime; sl.size = new ParticleSystem.MinMaxCurve(Size, AnimationCurve.Linear(0f, StartSize, LifeTime, EndSize)); sl.enabled = true; ParticleSystem.ColorOverLifetimeModule colm = particleSystem.colorOverLifetime; colm.color = new Gradient() { alphaKeys = new GradientAlphaKey[] { new GradientAlphaKey(1, 0), new GradientAlphaKey(0, LifeTime) }, colorKeys = new GradientColorKey[] { new GradientColorKey(StartColor, ColorStartTime), new GradientColorKey(EndColor, ColorEndTime) } }; colm.enabled = true; ParticleSystemRenderer particleSystemRenderer = GetComponent <ParticleSystemRenderer>(); particleSystemRenderer.sharedMaterial = new Material(Shader.Find("Particles/Additive")); particleSystemRenderer.sharedMaterial.mainTexture = (ModResource.GetTexture("Rocket Fire Texture")); }