private void Start() { if (particle == null) { particle = GetComponent <ParticleSystem>(); } mainm = particle.main; emitm = particle.emission; switch (mode) { case FireworkControlMode.Once: mainm.loop = false; emitm.SetBursts(new ParticleSystem.Burst[] { new ParticleSystem.Burst(0, 1) }); particle.Play(); break; case FireworkControlMode.Loop: mainm.loop = true; emitm.SetBursts(new ParticleSystem.Burst[] { new ParticleSystem.Burst(0, 1) }); mainm.duration = looplength; particle.Play(); break; case FireworkControlMode.Random: mainm.loop = true; emitm.SetBursts(new ParticleSystem.Burst[0]); particle.Play(); break; } }
public override object WriteTo(object obj) { obj = base.WriteTo(obj); if (obj == null) { return(null); } ParticleSystem.EmissionModule o = (ParticleSystem.EmissionModule)obj; if (m_bursts != null) { ParticleSystem.Burst[] bursts = new ParticleSystem.Burst[m_bursts.Length]; for (int i = 0; i < m_bursts.Length; ++i) { if (m_bursts[i] != null) { bursts[i] = (ParticleSystem.Burst)m_bursts[i].WriteTo(bursts[i]); } } o.SetBursts(bursts); } else { o.SetBursts(new ParticleSystem.Burst[0]); } return(obj); }
private void Start() { int currentParticleQuality = GraphicsSettings.INSTANCE.CurrentParticleQuality; float num2 = this.coefficient[currentParticleQuality]; ParticleSystem[] componentsInChildren = base.GetComponentsInChildren <ParticleSystem>(); int index = 0; while (index < componentsInChildren.Length) { ParticleSystem system = componentsInChildren[index]; ParticleSystem.MainModule main = system.main; main.maxParticles = Mathf.Max(Mathf.Min(main.maxParticles, 1), (int)(main.maxParticles * num2)); ParticleSystem.EmissionModule emission = system.emission; emission.rateOverTimeMultiplier = Mathf.Max(Mathf.Min(emission.rateOverTimeMultiplier, 1f), (float)((int)(emission.rateOverTimeMultiplier * num2))); emission.rateOverDistanceMultiplier = Mathf.Max(Mathf.Min(emission.rateOverDistanceMultiplier, 1f), (float)((int)(emission.rateOverDistanceMultiplier * num2))); ParticleSystem.Burst[] bursts = new ParticleSystem.Burst[emission.burstCount]; emission.GetBursts(bursts); int num4 = 0; while (true) { if (num4 >= emission.burstCount) { emission.SetBursts(bursts); index++; break; } bursts[num4].minCount = (short)Mathf.Max((float)Mathf.Min(bursts[num4].minCount, 1), bursts[num4].minCount * num2); bursts[num4].maxCount = (short)Mathf.Max((float)Mathf.Min(bursts[num4].maxCount, 1), bursts[num4].maxCount * num2); num4++; } } }
public static void ParticleEmissionSettings(this ParticleSystem PS, bool enabled = true, float scalar = 0.0f, bool RateOverTime = false, bool Burst = false, ParticleSystem.Burst[] BurstSettings = null, // Set Externally AnimationCurve animationCurve = null, // Set Externally ParticleSystemCurveMode CurveMode = ParticleSystemCurveMode.Constant, int rate = 0 ) { ParticleSystem.MinMaxCurve EmissionCurve; ParticleSystem.EmissionModule emissionModule = PS.emission; // Emission Settings emissionModule.enabled = enabled; if (RateOverTime) { EmissionCurve = new ParticleSystem.MinMaxCurve(scalar, animationCurve); EmissionCurve.mode = CurveMode; emissionModule.rateOverTime = EmissionCurve; } if (Burst) { emissionModule.SetBursts(BurstSettings); } emissionModule.rateOverTime = rate; }
// Token: 0x06000DB1 RID: 3505 RVA: 0x00043364 File Offset: 0x00041564 private void Start() { this.originalCoinCount = (int)base.GetComponent <EffectComponent>().effectData.genericFloat; int i = this.originalCoinCount; for (int j = 0; j < this.coinTiers.Length; j++) { CoinBehavior.CoinTier coinTier = this.coinTiers[j]; int num = 0; while (i >= coinTier.valuePerCoin) { i -= coinTier.valuePerCoin; num++; } if (num > 0) { ParticleSystem.EmissionModule emission = coinTier.particleSystem.emission; emission.enabled = true; emission.SetBursts(new ParticleSystem.Burst[] { new ParticleSystem.Burst(0f, (float)num) }); coinTier.particleSystem.gameObject.SetActive(true); } } }
private void SetCoinParticles() { ParticleSystem.EmissionModule coinFxEmission = coinFX.emission; float f = 0.75f / (coinRewardCount / 5); coinFxEmission.SetBursts(new ParticleSystem.Burst[] { new ParticleSystem.Burst(0, 1, coinRewardCount / 2, f) }); SceneActivationBehaviour <GameLogicActivator> .Instance.GameController.CoinsGrantedHandler(coinRewardCount, coinSourceType); }
private void setcount(ParticleSystem.EmissionModule emission, short[] counts, float scale) { ParticleSystem.Burst[] bursts = new ParticleSystem.Burst[emission.burstCount]; emission.GetBursts(bursts); for (int i = 0; i < bursts.Length; i++) { bursts[i].maxCount = (short)(counts[i] * scale); } emission.SetBursts(bursts); }
void SetLaserGunPositions(ParticleSystem ps, float distance) { ParticleSystem.ShapeModule sm = ps.shape; sm.length = distance - 0.6f; // 0.4 seconds lifetime, speed = 1. Slight extension ParticleSystem.EmissionModule em = ps.emission; em.SetBursts(new ParticleSystem.Burst[] { new ParticleSystem.Burst(0f, (short)(distance * 2)) }); ps.Play(); }
private void SetCoinParticles() { ParticleSystem.EmissionModule coinFxEmission = coinFX.emission; int cycles = (int)(coinRewardCount * 0.1f); float f = WaitTime / (float)cycles; //print($"PARTICLE CYCLES {cycles} frequency: {f}"); coinFxEmission.SetBursts(new ParticleSystem.Burst[] { new ParticleSystem.Burst(0, 1, 1, cycles, f) }); }
public override object WriteTo(object obj) { obj = base.WriteTo(obj); if (obj == null) { return(null); } ParticleSystem.EmissionModule o = (ParticleSystem.EmissionModule)obj; if (m_bursts != null) { o.SetBursts(m_bursts); } else { o.SetBursts(new ParticleSystem.Burst[0]); } return(obj); }
public void CreateWeatherEffect() { UniStormSystem UniStormSystemObject = FindObjectOfType <UniStormSystem>(); ParticleSystem Temp = Instantiate(WeatherEffect, Vector3.zero, Quaternion.AngleAxis(-90, Vector3.right)); Temp.transform.SetParent(GameObject.Find("UniStorm Effects").transform); Temp.name = Temp.name.Replace("(Clone)", " (UniStorm)"); ParticleSystem.EmissionModule CurrentEmission = Temp.emission; CurrentEmission.enabled = true; CurrentEmission.rateOverTime = new ParticleSystem.MinMaxCurve(0); CurrentEmission.SetBursts(new ParticleSystem.Burst[] { }); UniStormSystemObject.WeatherEffectsList.Add(Temp); }
/// ///////////////////////////////////////////////////////// /// Emission /// ///////////////////////////////////////////////////////// // Set emission public static void SetEmission(ParticleSystem.EmissionModule emissionModule, float distanceRate, int burstAmount) { emissionModule.enabled = true; emissionModule.rateOverTimeMultiplier = 0f; emissionModule.rateOverDistanceMultiplier = distanceRate; // Set burst if (burstAmount > 0) { ParticleSystem.Burst burst = new ParticleSystem.Burst(0.0f, (short)burstAmount, (short)burstAmount, 1, 999f); ParticleSystem.Burst[] bursts = new [] { burst }; emissionModule.SetBursts(bursts); } }
public void TriggerWave(int wave) { currentEnemy = 0; currentWave = wave; int particleCount = Waves[currentWave].Enemies.Length; ParticleSystem.Burst[] bursts = new ParticleSystem.Burst[1]; ParticleSystem.EmissionModule emissions = particlesystem.emission; emissions.GetBursts(bursts); bursts[0].minCount = (short)particleCount; bursts[0].maxCount = (short)particleCount; emissions.SetBursts(bursts); particlesystem.Play(); }
public virtual void Start() { ParticleSystem myParticleSystem = this.GetComponent <ParticleSystem>(); ParticleSystem.MainModule mainModule = myParticleSystem.main; ParticleSystem.MinMaxCurve origStartLifetime = mainModule.startLifetime; ParticleSystem.MinMaxCurve startLifetime = new ParticleSystem.MinMaxCurve(0); startLifetime.constantMin = 0; startLifetime.constantMax = origStartLifetime.constantMax; mainModule.startLifetime = startLifetime; ParticleSystem.EmissionModule emissionModule = myParticleSystem.emission; float burstSize = emissionModule.rateOverTime.constantMin * startLifetime.constantMax; ParticleSystem.Burst[] bursts = new ParticleSystem.Burst[1]; bursts[0] = new ParticleSystem.Burst(0f, (short)Mathf.RoundToInt(burstSize), (short)Mathf.RoundToInt(burstSize)); emissionModule.SetBursts(bursts); }
private void MapEmissionParameters(ParticleSystem pSystem, int i) { ParticleSystem.EmissionModule emissionModule = pSystem.emission; try { emissionModule.enabled = GetBoolParam(i, "emission_enabled"); } catch (NullReferenceException) { emissionModule.enabled = false; return; } emissionModule.rateOverTime = NodeFXUtilities.InterpretStringToCurve(GetStringParam(i, "emission_rateOverTime")); emissionModule.rateOverDistance = NodeFXUtilities.InterpretStringToCurve(GetStringParam(i, "emission_rateOverDistance")); emissionModule.SetBursts(NodeFXUtilities.InterpretStringToBurst(GetStringParam(i, "emission_bursts"))); return; }
private void AddSubEmitter(ref ParticleSystem subPS, ParticleSystemSubEmitterType type, System.Action <Vector3> callback) { // Create SubEmitter object GameObject go = new GameObject("subemitter-" + type.ToString()); go.transform.parent = transform; go.transform.localPosition = Vector3.zero; go.transform.localScale = Vector3.one; go.transform.localEulerAngles = Vector3.zero; // Configure SubEmitter particle system subPS = go.AddComponent <ParticleSystem>(); subPS.Stop(); // go.GetComponent<ParticleSystemRenderer>().material = new Material(Shader.Find("Particles/Additive")); ParticleSystem.MainModule main = subPS.main; main.duration = 10f; main.startLifetime = 10f; main.startSize = 0f; main.startSpeed = 0f; main.maxParticles = ps.main.maxParticles; main.loop = true; main.playOnAwake = true; ParticleSystem.EmissionModule emission = subPS.emission; emission.rateOverTime = 0f; emission.SetBursts(new ParticleSystem.Burst[] { new ParticleSystem.Burst(0f, 1, 1, 1, 0) }); ParticleSystem.ShapeModule shape = subPS.shape; shape.shapeType = ParticleSystemShapeType.Box; shape.scale = Vector3.zero; subPS.Play(); // Add SubEmitter callback SubEmitterHandler handler = go.AddComponent <SubEmitterHandler>(); handler.callback = callback; // Attach subemitter to to main emitter ParticleSystem.SubEmittersModule subEmitters = ps.subEmitters; subEmitters.AddSubEmitter(subPS, type, ParticleSystemSubEmitterProperties.InheritNothing); subEmitters.enabled = true; }
void setupEmission(ParticleSystem ps, SystemScrambler ss) { ParticleSystem.EmissionModule em = ps.emission; if (!ss.Enabled [3]) { return; //Need emission always enabled } em.rateOverTime = ss.Floats[32]; //Bursts ParticleSystem.Burst[] bArray = new ParticleSystem.Burst[ss.Bursts [0]]; for (int i = 0; i < ss.Bursts [0]; i++) { short v1 = Convert.ToInt16(ss.Bursts [(i * 3) + 2]); short v2 = Convert.ToInt16(ss.Bursts [(i * 3) + 3]); ParticleSystem.Burst b = new ParticleSystem.Burst( ss.Bursts [(i * 3) + 1], v1, v2); bArray [i] = b; } em.SetBursts(bArray); }
public void Initialize(int ID) { ParticleSystem.EmissionModule emit = ps.emission; //Material and emission is determined by color, indicated by the ID number mod4 int i = ID % 4; rend.material = materials[i]; emit.SetBursts(new ParticleSystem.Burst[] { new ParticleSystem.Burst(0.0f, (short)(15 + (i * 5)), (short)(15 + (i * 5))) }); ps.Play(); if (AudioManager.RequestKillSound()) { int c = Random.Range(0, clips.Length); float p = Random.Range(0.95f, 1.05f); aud.clip = clips[c]; aud.pitch = p; aud.Play(); Invoke("RetireSound", 0.8f); } }
public void ParticleSelect(AI.Elements SpellType, ParticleSystem SpellPS) { ParticleSystem.MainModule Main = SpellPS.main; ParticleSystem.EmissionModule EM = SpellPS.emission; ParticleSystem.ColorOverLifetimeModule CLT = SpellPS.colorOverLifetime; switch (SpellType) { case AI.Elements.Fire: Main.startColor = Color.red; EM.enabled = true; EM.SetBursts(new ParticleSystem.Burst[] { new ParticleSystem.Burst(2.0f, 1), new ParticleSystem.Burst(4.0f, 1) }); Gradient Grad = new Gradient(); CLT.enabled = true; Grad.SetKeys(new GradientColorKey[] { new GradientColorKey(Color.blue, 0.0f), new GradientColorKey(Color.red, 1.0f) }, new GradientAlphaKey[] { new GradientAlphaKey(1.0f, 0.0f), new GradientAlphaKey(0.0f, 1.0f) }); CLT.color = Grad; break; case AI.Elements.Water: break; case AI.Elements.Electric: break; case AI.Elements.Nature: break; case AI.Elements.Rock: break; default: // Shouldn't hit this case break; } }
public void UpdateParticleSystem() { ParticleSystem refSystem = referenceLine.GetComponent <ParticleSystem>(); ParticleSystem.MainModule refSetting = refSystem.main; ParticleSystem.EmissionModule refEmission = refSystem.emission; ParticleSystem.RotationOverLifetimeModule refRotationLifeTime = refSystem.rotationOverLifetime; ParticleSystem.SizeOverLifetimeModule refSizeLifetime = refSystem.sizeOverLifetime; ParticleSystemRenderer refRenderer = refSystem.GetComponent <ParticleSystemRenderer>(); ParticleSystem.Burst refBurst = refEmission.GetBurst(0); foreach (Line line in triangleComplex.lines) { ParticleSystem particleSystem = line.GetComponent <ParticleSystem>(); ParticleSystem.MainModule particleSettings = particleSystem.main; ParticleSystem.EmissionModule particleEmission = particleSystem.emission; ParticleSystem.RotationOverLifetimeModule particleRotationLifeTime = particleSystem.rotationOverLifetime; ParticleSystem.SizeOverLifetimeModule particleSizeLifetime = particleSystem.sizeOverLifetime; ParticleSystemRenderer particleRenderer = particleSystem.GetComponent <ParticleSystemRenderer>(); particleSettings.customSimulationSpace = refSetting.customSimulationSpace; particleSettings.duration = refSetting.duration; particleSettings.emitterVelocityMode = refSetting.emitterVelocityMode; particleSettings.flipRotation = refSetting.flipRotation; particleSettings.gravityModifier = refSetting.gravityModifier; particleSettings.gravityModifierMultiplier = refSetting.gravityModifierMultiplier; particleSettings.loop = refSetting.loop; particleSettings.maxParticles = refSetting.maxParticles; particleSettings.playOnAwake = refSetting.playOnAwake; particleSettings.prewarm = refSetting.prewarm; particleSettings.scalingMode = refSetting.scalingMode; particleSettings.simulationSpace = refSetting.simulationSpace; particleSettings.simulationSpeed = refSetting.simulationSpeed; particleSettings.startColor = refSetting.startColor; particleSettings.startDelay = refSetting.startDelay; particleSettings.startDelayMultiplier = refSetting.startDelayMultiplier; particleSettings.startLifetime = refSetting.startLifetime; particleSettings.startLifetimeMultiplier = refSetting.startLifetimeMultiplier; particleSettings.startRotation = refSetting.startRotation; particleSettings.startRotation3D = refSetting.startRotation3D; particleSettings.startRotationMultiplier = refSetting.startRotationMultiplier; particleSettings.startRotationX = refSetting.startRotationX; particleSettings.startRotationXMultiplier = refSetting.startRotationXMultiplier; particleSettings.startRotationY = refSetting.startRotationY; particleSettings.startRotationYMultiplier = refSetting.startRotationYMultiplier; particleSettings.startRotationZ = refSetting.startRotationZ; particleSettings.startRotationZMultiplier = refSetting.startRotationZMultiplier; particleSettings.startSize = refSetting.startSize; particleSettings.startSize3D = refSetting.startSize3D; particleSettings.startSizeMultiplier = refSetting.startSizeMultiplier; particleSettings.startSizeX = refSetting.startSizeX; particleSettings.startSizeXMultiplier = refSetting.startSizeXMultiplier; particleSettings.startSizeY = refSetting.startSizeY; particleSettings.startSizeYMultiplier = refSetting.startSizeYMultiplier; particleSettings.startSizeZ = refSetting.startSizeZ; particleSettings.startSizeZMultiplier = refSetting.startSizeZMultiplier; particleSettings.startSpeed = refSetting.startSpeed; particleSettings.startSpeedMultiplier = refSetting.startSpeedMultiplier; particleSettings.stopAction = refSetting.stopAction; particleSettings.useUnscaledTime = refSetting.useUnscaledTime; particleEmission.burstCount = refEmission.burstCount; particleEmission.enabled = refEmission.enabled; particleEmission.rateOverDistance = refEmission.rateOverDistance; particleEmission.rateOverDistanceMultiplier = refEmission.rateOverDistanceMultiplier; particleEmission.rateOverTime = refEmission.rateOverTime; particleEmission.rateOverTimeMultiplier = refEmission.rateOverTimeMultiplier; particleRotationLifeTime.enabled = refRotationLifeTime.enabled; particleRotationLifeTime.separateAxes = refRotationLifeTime.separateAxes; particleRotationLifeTime.x = refRotationLifeTime.x; particleRotationLifeTime.xMultiplier = refRotationLifeTime.xMultiplier; particleRotationLifeTime.y = refRotationLifeTime.y; particleRotationLifeTime.yMultiplier = refRotationLifeTime.yMultiplier; particleRotationLifeTime.z = refRotationLifeTime.z; particleRotationLifeTime.zMultiplier = refRotationLifeTime.zMultiplier; particleSizeLifetime.enabled = refSizeLifetime.enabled; particleSizeLifetime.separateAxes = refSizeLifetime.separateAxes; particleSizeLifetime.size = refSizeLifetime.size; particleSizeLifetime.sizeMultiplier = refSizeLifetime.sizeMultiplier; particleSizeLifetime.x = refSizeLifetime.x; particleSizeLifetime.xMultiplier = refSizeLifetime.xMultiplier; particleSizeLifetime.y = refSizeLifetime.y; particleSizeLifetime.yMultiplier = refSizeLifetime.yMultiplier; particleSizeLifetime.z = refSizeLifetime.z; particleSizeLifetime.zMultiplier = refSizeLifetime.zMultiplier; particleRenderer.minParticleSize = refRenderer.minParticleSize; particleEmission.SetBursts(new ParticleSystem.Burst[] { refBurst }); } }
/// <summary>Awake message.</summary> /// <author>Liam Ireland</author> void Awake() { if (constantDampening < 0) { constantDampening *= -1.0F; } if (!medium) { medium = ScriptableObject.CreateInstance <ShockwaveMedium>(); } particleEmitter = gameObject.AddComponent <ParticleSystem>() as ParticleSystem; particleEmitter.name = "Particle Emitter"; particleEmitter.playOnAwake = true; particleEmitter.loop = false; particleEmitter.startLifetime = startLifetime; particleEmitter.startSpeed = startSpeed; particleEmitter.startSize = 0.1F; particleEmitter.maxParticles = 1000000; particleEmitter.simulationSpace = ParticleSystemSimulationSpace.World; //setup the curve something module //tom did this ParticleSystem.LimitVelocityOverLifetimeModule limitVelocityModule = particleEmitter.limitVelocityOverLifetime; limitVelocityModule.enabled = true; limitVelocityModule.limit = 0F; limitVelocityModule.dampen = constantDampening; //setup the shape module ParticleSystem.ShapeModule shapeModule = particleEmitter.shape; shapeModule.enabled = true; shapeModule.shapeType = ParticleSystemShapeType.Sphere; shapeModule.radius = 0.01F; shapeModule.randomDirection = true; //setup the Emission module ParticleSystem.EmissionModule emissionModule = particleEmitter.emission; emissionModule.rate = 0; // if the number of particles is bigger than the number of particles in each burst, split them up into seperate bursts // (the reason for this is the maximum number of particles in one burst can only be a short (16 bits), using multiple bursts we can get around this (although unity does only limit us to 4 bursts)) if (NumberOfParticles > NoOfParticlesInEachBurst) { int numberOfBursts = 0; if (NumberOfParticles % NoOfParticlesInEachBurst == 0) { numberOfBursts = NumberOfParticles / NoOfParticlesInEachBurst; } else { numberOfBursts = (NumberOfParticles / NoOfParticlesInEachBurst) + 1; } ParticleSystem.Burst[] bursts = new ParticleSystem.Burst[numberOfBursts]; for (int i = 0; i < numberOfBursts; i++) { bursts[i] = new ParticleSystem.Burst(0, NoOfParticlesInEachBurst); } emissionModule.SetBursts(bursts); } else { emissionModule.SetBursts(new ParticleSystem.Burst[] { new ParticleSystem.Burst(0, NoOfParticlesInEachBurst) }); // make the bursts array and create the initiale burst of particles } // setup the collision module ParticleSystem.CollisionModule collisionModule = particleEmitter.collision; collisionModule.enabled = true; collisionModule.type = ParticleSystemCollisionType.World; collisionModule.mode = ParticleSystemCollisionMode.Collision3D; collisionModule.enableDynamicColliders = true; collisionModule.enableInteriorCollisions = true; collisionModule.quality = ParticleSystemCollisionQuality.High; // could perhaps change to help performance collisionModule.sendCollisionMessages = true; collisionModule.maxCollisionShapes = 256; // default value // get the static objects in the scene and set the particle triggers for diffraction - this is no longer used /* * Collider[] allColldiers = FindObjectsOfType<Collider>(); * staticColliders = new Collider[allColldiers.Length - FindObjectsOfType<Rigidbody>().Length]; // initialise the staticColliders array to the size of the number of static colliders in the scene * int counter = 0; * foreach (Collider collider in allColldiers) // loop through every collider in the scene * { * if (!collider.GetComponent<Rigidbody>()) // if the collider does not have a rigidbody * { * staticColliders[counter++] = collider; // set the collider to the counter element on the staticColliders array and increment the counter * } * } */ // set up the triggers for diffraction - this is no longer used /* * ParticleSystem.TriggerModule triggers = particleEmitter.trigger; // initialise the same amount of triggers as static colliders * triggers.enabled = true; * triggers.exit = ParticleSystemOverlapAction.Callback; // when a particle exits the trigger, call OnParticleTrigger() * triggers.inside = ParticleSystemOverlapAction.Ignore; * for (int i=0; i<counter; i++) * { * GameObject trigger = new GameObject(); * trigger.name = "Particle Trigger"; * trigger.transform.position = staticColliders[i].transform.position; * trigger.transform.localScale = new Vector3(staticColliders[i].transform.localScale.x + 0.5F, staticColliders[i].transform.localScale.y + 0.5F, staticColliders[i].transform.localScale.z + 0.5F); * trigger.AddComponent<BoxCollider>(); // I'm assuming the static colliders have box colliders - they may not - need to fix * trigger.GetComponent<BoxCollider>().isTrigger = true; * triggers.SetCollider(i, trigger.GetComponent<BoxCollider>()); * } */ }
public void DisableBursts() { emissionModule.SetBursts(null, 0); }
public void Awake() { _particleSystem = (gameObject.AddComponent <ParticleSystem>()) as ParticleSystem; if (gameObject.GetComponent <ParticleSystemRenderer>()) { _psRenderer = gameObject.GetComponent <ParticleSystemRenderer>(); } else { _psRenderer = (gameObject.AddComponent <ParticleSystemRenderer>()) as ParticleSystemRenderer; } _psEmitParams = new ParticleSystem.EmitParams(); _psEmission = _particleSystem.emission; _psMain = _particleSystem.main; _psVelocityOverLifetime = _particleSystem.limitVelocityOverLifetime; _psSizeOverLifetime = _particleSystem.sizeOverLifetime; _psColorOverLifetime = _particleSystem.colorOverLifetime; _psShape = _particleSystem.shape; _psMain.loop = false; _psMain.startSpeed = 0f; _psMain.flipRotation = .5f; _psEmission.rateOverTime = 0; _psEmission.SetBursts(new ParticleSystem.Burst[] { new ParticleSystem.Burst(0.0f, 1, 1) }); _psVelocityOverLifetime.enabled = true; _psVelocityOverLifetime.separateAxes = true; _psVelocityOverLifetime.limitX = .1f; _psVelocityOverLifetime.limitY = .1f; _psVelocityOverLifetime.limitZ = .1f; _psVelocityOverLifetime.space = ParticleSystemSimulationSpace.World; _psShape.enabled = true; _psShape.shapeType = ParticleSystemShapeType.Sphere; _psShape.radius = 0.1f; _psRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On; _psRenderer.receiveShadows = true; //Just to start and make sure there is no interference _psEmission.enabled = false; _particleSystem.hideFlags = HideFlags.HideAndDontSave; _psVelocityOverLifetime.dampen = _baseDamping; _psRenderer.maxParticleSize = maxScreenSize; _psRenderer.material = material; _psRenderer.material.color = Color.white; //Defaulting to a linear curve if (!useExplicitSizeCurve) { SizeOverLifetimeCurve.AddKey(0.0f, 0.1f); SizeOverLifetimeCurve.AddKey(1.0f, 1.0f); } _psSoLMMCurve = new ParticleSystem.MinMaxCurve(2, SizeOverLifetimeCurve); _psSizeOverLifetime.size = _psSoLMMCurve; if (explodeOnAwake) { Explode(); } }
public override void OnLoad() { base.OnLoad(); equipmentDef.name = "MysticsItems_GateChalice"; ConfigManager.Balance.CreateEquipmentCooldownOption(equipmentDef, "Equipment: Gate Chalice", 60f); equipmentDef.canDrop = true; ConfigManager.Balance.CreateEquipmentEnigmaCompatibleOption(equipmentDef, "Equipment: Gate Chalice", false); ConfigManager.Balance.CreateEquipmentCanBeRandomlyTriggeredOption(equipmentDef, "Equipment: Gate Chalice", false); equipmentDef.isLunar = true; equipmentDef.colorIndex = ColorCatalog.ColorIndex.LunarItem; equipmentDef.pickupModelPrefab = PrepareModel(Main.AssetBundle.LoadAsset <GameObject>("Assets/Equipment/Gate Chalice/Model.prefab")); equipmentDef.pickupIconSprite = Main.AssetBundle.LoadAsset <Sprite>("Assets/Equipment/Gate Chalice/Icon.png"); Material mat = equipmentDef.pickupModelPrefab.transform.Find("mdlGateChalice").gameObject.GetComponent <MeshRenderer>().sharedMaterial; HopooShaderToMaterial.Standard.Apply(mat); HopooShaderToMaterial.Standard.Gloss(mat, 0.5f); HopooShaderToMaterial.Standard.Emission(mat, 0.02f, new Color(48f / 255f, 127f / 255f, 255f / 255f)); foreach (Transform lightTransform in equipmentDef.pickupModelPrefab.transform.Find("mdlGateChalice").Find("Lights")) { SetScalableChildEffect(equipmentDef.pickupModelPrefab, lightTransform.gameObject); FlickerLight flickerLight = lightTransform.gameObject.AddComponent <FlickerLight>(); flickerLight.light = lightTransform.gameObject.GetComponent <Light>(); flickerLight.sinWaves = new Wave[] { new Wave { amplitude = 0.3f, frequency = 4f }, new Wave { amplitude = 0.6f, frequency = 2f }, new Wave { amplitude = 0.9f, frequency = 1f } }; } itemDisplayPrefab = PrepareItemDisplayModel(PrefabAPI.InstantiateClone(equipmentDef.pickupModelPrefab, equipmentDef.pickupModelPrefab.name + "Display", false)); onSetupIDRS += () => { AddDisplayRule("CommandoBody", "Stomach", new Vector3(-0.09F, 0.1F, -0.102F), new Vector3(5.862F, 140.357F, 1.915F), new Vector3(0.059F, 0.059F, 0.059F)); AddDisplayRule("HuntressBody", "Pelvis", new Vector3(-0.082F, -0.111F, 0.085F), new Vector3(0.679F, 36.762F, 188.148F), new Vector3(0.047F, 0.047F, 0.048F)); AddDisplayRule("Bandit2Body", "Stomach", new Vector3(-0.096F, 0.027F, -0.151F), new Vector3(337.162F, 337.663F, 11.532F), new Vector3(0.04F, 0.04F, 0.04F)); AddDisplayRule("ToolbotBody", "Hip", new Vector3(-1.239F, 0.577F, -1.044F), new Vector3(0F, 180F, 180F), new Vector3(0.349F, 0.349F, 0.349F)); AddDisplayRule("EngiBody", "Pelvis", new Vector3(-0.178F, 0.078F, 0.157F), new Vector3(11.745F, 186.295F, 185.936F), new Vector3(0.047F, 0.047F, 0.047F)); AddDisplayRule("MageBody", "Pelvis", new Vector3(-0.128F, -0.131F, 0.024F), new Vector3(6.286F, 3.408F, 167.572F), new Vector3(0.044F, 0.044F, 0.044F)); AddDisplayRule("MercBody", "Chest", new Vector3(0F, 0.193F, -0.286F), new Vector3(71.925F, 180F, 0F), new Vector3(0.027F, 0.027F, 0.027F)); AddDisplayRule("TreebotBody", "FlowerBase", new Vector3(-0.485F, 0.701F, -0.803F), new Vector3(26.173F, 24.306F, 86.838F), new Vector3(0.061F, 0.061F, 0.061F)); AddDisplayRule("LoaderBody", "Pelvis", new Vector3(-0.216F, -0.016F, -0.022F), new Vector3(342.363F, 183.205F, 159.555F), new Vector3(0.045F, 0.045F, 0.045F)); AddDisplayRule("CrocoBody", "SpineStomach1", new Vector3(0.845F, 0.495F, 1.289F), new Vector3(74.633F, 327.618F, 247.859F), new Vector3(0.361F, 0.361F, 0.361F)); AddDisplayRule("CaptainBody", "Stomach", new Vector3(-0.195F, 0.128F, 0.126F), new Vector3(336.504F, 156.734F, 358.159F), new Vector3(0.041F, 0.041F, 0.041F)); AddDisplayRule("ScavBody", "MuzzleEnergyCannon", new Vector3(0F, 0F, -1.503F), new Vector3(90F, 0F, 0F), new Vector3(2.281F, 2.281F, 2.281F)); AddDisplayRule("EquipmentDroneBody", "GunBarrelBase", new Vector3(0F, 0F, 1.069F), new Vector3(0F, 0F, 0F), new Vector3(0.267F, 0.267F, 0.267F)); if (SoftDependencies.SoftDependenciesCore.itemDisplaysSniper) { AddDisplayRule("SniperClassicBody", "Pelvis", new Vector3(0.19432F, 0.18834F, -0.17385F), new Vector3(343.5044F, 339.549F, 357.2065F), new Vector3(0.05181F, 0.05181F, 0.05181F)); } AddDisplayRule("RailgunnerBody", "Pelvis", new Vector3(0.14878F, -0.03065F, 0.10522F), new Vector3(354.5591F, 180F, 180F), new Vector3(0.05639F, 0.05639F, 0.05639F)); AddDisplayRule("VoidSurvivorBody", "Hand", new Vector3(-0.03581F, 0.28639F, -0.00539F), new Vector3(0F, 0F, 4.98446F), new Vector3(0.09781F, 0.09781F, 0.09781F)); }; visualEffectOnUse = PrefabAPI.InstantiateClone(new GameObject(), "MysticsItems_GateChaliceOnUseEffect", false); EffectComponent effectComponent = visualEffectOnUse.AddComponent <EffectComponent>(); effectComponent.soundName = "Play_env_teleporter_active_button"; effectComponent.positionAtReferencedTransform = true; effectComponent.applyScale = true; effectComponent.disregardZScale = true; VFXAttributes vfxAttributes = visualEffectOnUse.AddComponent <VFXAttributes>(); vfxAttributes.vfxPriority = VFXAttributes.VFXPriority.Low; vfxAttributes.vfxIntensity = VFXAttributes.VFXIntensity.Low; visualEffectOnUse.AddComponent <DestroyOnTimer>().duration = 2f; GameObject massSparks = PrefabAPI.InstantiateClone(new GameObject(), "MassSparks", false); ParticleSystem particleSystem = massSparks.AddComponent <ParticleSystem>(); massSparks.GetComponent <ParticleSystemRenderer>().material = Object.Instantiate(LegacyResourcesAPI.Load <GameObject>("Prefabs/Effects/ActivateRadarTowerEffect").transform.Find("MassSparks").gameObject.GetComponent <ParticleSystemRenderer>().material); particleSystem.useAutoRandomSeed = true; ParticleSystem.MainModule mainModule = particleSystem.main; mainModule.simulationSpace = ParticleSystemSimulationSpace.World; mainModule.scalingMode = ParticleSystemScalingMode.Local; mainModule.startLifetime = 5f; mainModule.duration = 1f; mainModule.playOnAwake = true; ParticleSystem.MinMaxCurve particleSpeed = mainModule.startSpeed; particleSpeed.mode = ParticleSystemCurveMode.TwoConstants; particleSpeed.constantMin = 10f; particleSpeed.constantMax = 1000f; mainModule.startSize = 0.1f; mainModule.startColor = new Color(48f / 255f, 127f / 255f, 255f / 255f); mainModule.gravityModifier = 0.3f; mainModule.maxParticles = 20; ParticleSystem.EmissionModule emissionModule = particleSystem.emission; emissionModule.enabled = true; emissionModule.rateOverTime = 10; emissionModule.rateOverDistance = 0; emissionModule.SetBursts(new ParticleSystem.Burst[] { new ParticleSystem.Burst { time = 0f, count = 20f, cycleCount = 1, repeatInterval = 0.01f, probability = 1f } }); ParticleSystem.ShapeModule shapeModule = particleSystem.shape; shapeModule.shapeType = ParticleSystemShapeType.Sphere; massSparks.transform.SetParent(visualEffectOnUse.transform); MysticsItemsContent.Resources.effectPrefabs.Add(visualEffectOnUse); visualEffectTeleportOut = PrefabAPI.InstantiateClone(new GameObject(), "MysticsItems_GateChaliceTeleportOutEffect", false); effectComponent = visualEffectTeleportOut.AddComponent <EffectComponent>(); vfxAttributes = visualEffectTeleportOut.AddComponent <VFXAttributes>(); vfxAttributes.vfxPriority = VFXAttributes.VFXPriority.Always; vfxAttributes.vfxIntensity = VFXAttributes.VFXIntensity.Medium; visualEffectTeleportOut.AddComponent <DestroyOnTimer>().duration = 4f; GameObject ppHolder = PrefabAPI.InstantiateClone(new GameObject(), "PP", false); ppHolder.layer = LayerIndex.postProcess.intVal; ppHolder.AddComponent <MysticsItemsGateChalicePPController>().time = 3f; PostProcessVolume pp = ppHolder.AddComponent <PostProcessVolume>(); pp.isGlobal = true; pp.weight = 0f; pp.priority = 50; PostProcessProfile ppProfile = ScriptableObject.CreateInstance <PostProcessProfile>(); ppProfile.name = "ppGateChalice"; LensDistortion lensDistortion = ppProfile.AddSettings <LensDistortion>(); lensDistortion.SetAllOverridesTo(true); lensDistortion.intensity.value = -100f; lensDistortion.scale.value = 1f; ColorGrading colorGrading = ppProfile.AddSettings <ColorGrading>(); colorGrading.colorFilter.value = new Color(97f / 255f, 163f / 255f, 239f / 255f); colorGrading.colorFilter.overrideState = true; pp.sharedProfile = ppProfile; ppHolder.transform.SetParent(visualEffectTeleportOut.transform); MysticsItemsContent.Resources.effectPrefabs.Add(visualEffectTeleportOut); SceneExitController sceneExitController = sceneExitControllerObject.AddComponent <SceneExitController>(); sceneExitController.useRunNextStageScene = true; sceneExitControllerObject.AddComponent <MysticsItemsGateChaliceSceneExit>(); itemDestroyEffectPrefab = PrefabAPI.InstantiateClone(new GameObject(), "MysticsItems_GateChaliceItemDestroyEffect", false); EntityStateMachine entityStateMachine = itemDestroyEffectPrefab.AddComponent <EntityStateMachine>(); entityStateMachine.initialStateType = entityStateMachine.mainStateType = new EntityStates.SerializableEntityStateType(typeof(MysticsItemsGateChaliceItemDestroyEffect)); PickupDisplay pickupDisplay = itemDestroyEffectPrefab.AddComponent <PickupDisplay>(); Rigidbody rigidbody = itemDestroyEffectPrefab.AddComponent <Rigidbody>(); rigidbody.useGravity = false; rigidbody.drag = 2f; effectComponent = itemDestroyEffectPrefab.AddComponent <EffectComponent>(); effectComponent.applyScale = true; effectComponent.soundName = "Play_moonBrother_phase4_itemSuck_returnSingle"; vfxAttributes = itemDestroyEffectPrefab.AddComponent <VFXAttributes>(); vfxAttributes.vfxIntensity = VFXAttributes.VFXIntensity.High; vfxAttributes.vfxPriority = VFXAttributes.VFXPriority.Always; Highlight highlight = itemDestroyEffectPrefab.AddComponent <Highlight>(); pickupDisplay.highlight = highlight; highlight.highlightColor = Highlight.HighlightColor.pickup; MysticsItemsContent.Resources.effectPrefabs.Add(itemDestroyEffectPrefab); }
private void SetParticleSystemProps(ParticleEffectContent content, GameObject go, bool stream) { ParticleSystem particleSystem = go.GetComponent <ParticleSystem>(); ParticleSystem.MainModule main = particleSystem.main; main.simulationSpace = content.isLocal ? ParticleSystemSimulationSpace.Local : ParticleSystemSimulationSpace.World; main.duration = content.duration; main.startLifetime = content.duration; main.gravityModifier = content.gravityModifier; ParticleSystem.ShapeModule shape = particleSystem.shape; switch (content.shapeType) { case ParticleEffectContent.ShapeType.Cone: shape.shapeType = ParticleSystemShapeType.Cone; break; case ParticleEffectContent.ShapeType.Sphere: shape.shapeType = ParticleSystemShapeType.Sphere; break; case ParticleEffectContent.ShapeType.Box: shape.shapeType = ParticleSystemShapeType.Box; break; case ParticleEffectContent.ShapeType.Circle: shape.shapeType = ParticleSystemShapeType.Circle; break; case ParticleEffectContent.ShapeType.Rectangle: shape.shapeType = ParticleSystemShapeType.Rectangle; break; } shape.scale = Vector3.one * content.shapeSize; ParticleSystem.EmissionModule emission = particleSystem.emission; emission.enabled = true; if (stream) { emission.rateOverTime = content.burstCount; } else { emission.rateOverTime = 0; emission.SetBursts( new ParticleSystem.Burst[] { new ParticleSystem.Burst(0.0f, content.burstCount) }); } ParticleSystem.VelocityOverLifetimeModule velocityOverLifetime = particleSystem.velocityOverLifetime; velocityOverLifetime.enabled = true; velocityOverLifetime.speedModifier = content.speed; ParticleSystem.RotationOverLifetimeModule rotationOverLifetime = particleSystem.rotationOverLifetime; rotationOverLifetime.enabled = true; SetRotationOverLifetime(rotationOverLifetime, content.rotationOverLifetime); ParticleSystem.SizeOverLifetimeModule sizeOverLifetime = particleSystem.sizeOverLifetime; sizeOverLifetime.enabled = true; SetSizeOverLifetime(sizeOverLifetime, content.startSize, content.endSize); ParticleSystem.ColorOverLifetimeModule colorOverLifetime = particleSystem.colorOverLifetime; colorOverLifetime.enabled = true; colorOverLifetime.color = ColorTuplesToGradient(content.colorOverLifetime); ParticleSystemRenderer renderer = go.GetComponent <ParticleSystemRenderer>(); renderer.material = particleMaterial; }