public MBEvent(MBEventType type, MBParticle PT, object data) { Type = type; Source = PT.Parent; Context = PT; Data = data; }
public override bool OnLifetime(MBParticle PT) { MBLineEmitter emtype=PT.Parent.EmitterType as MBLineEmitter; if (emtype) { emtype.EvenlySpread = true; emtype.SetDistribution(PT.Parent.ParticleCount - 1, emtype.DistributeOverTotal); if (mPerlin == null) mPerlin = new Perlin(); float timex = PT.ParticleSystem.GlobalTime * Speed * 0.1365143f; float timey = PT.ParticleSystem.GlobalTime * Speed * 1.21688f; float timez = PT.ParticleSystem.GlobalTime * Speed * 2.5564f; float step = (1.0f / (float)Mathf.Max(1, PT.Parent.ParticleCount - 1)); // As we set absolute position here, we need to transform the particles from emitter space into particlesystem space PT.Position = ParticleSystem.Transform.InverseTransformPoint(emtype.Transform.TransformPoint(emtype.GetDistributionPoint(mPtIdx, emtype.DistributeOverTotal))); Vector3 offset = new Vector3(mPerlin.Noise(timex + PT.Position.x, timex + PT.Position.y, timex + PT.Position.z), mPerlin.Noise(timey + PT.Position.x, timey + PT.Position.y, timey + PT.Position.z), mPerlin.Noise(timez + PT.Position.x, timez + PT.Position.y, timez + PT.Position.z)); PT.Position += (offset * Amplitude * (float)mPtIdx * step); if (++mPtIdx >= PT.Parent.ParticleCount) mPtIdx = 0; } return true; }
public override bool OnLifetime(MBParticle PT) { float mag = PT.Velocity.magnitude; if (mag == 0) return true; float radius = PT.Scale.x * 0.5f; float d = Mathf.Max(mag * PT.DeltaTime, radius); if (Physics.Raycast(PT.WorldPosition, PT.Velocity, out mHitInfo, d, -1)) { Vector3 refl = Vector3.Reflect(PT.Velocity, mHitInfo.normal); float colbounce = mHitInfo.collider.material.bounciness; switch (BounceCombine) { case PhysicMaterialCombine.Average: colbounce = (colbounce + Bounce) / 2.0f; break; case PhysicMaterialCombine.Maximum: colbounce = Mathf.Max(colbounce, Bounce); break; case PhysicMaterialCombine.Minimum: colbounce = Mathf.Min(colbounce, Bounce); break; case PhysicMaterialCombine.Multiply: colbounce = colbounce * Bounce; break; } PT.Velocity = refl * colbounce; if (mag < d) { if (mag >= RestBelowVelocity) PT.WorldPosition = mHitInfo.point + refl.normalized * d; else PT.Velocity = Vector3.zero; } OnParticleInsideZone(PT); } return true; }
public override bool OnLifetime(MBParticle PT) { // PT.mbColor store's the origional color! PT.mbColor = GetGradientColor(PT.AgePercent,false); return base.OnLifetime(PT); }
public override bool OnLifetime(MBParticle PT) { PT.Position -= ParentEmitter.Position; PT.Position = Quaternion.Euler(PT.Rotation * PT.DeltaTime) * PT.Position; PT.Position += ParentEmitter.Position; return true; }
public override bool OnLifetime(MBParticle PT) { if (PT.HasUserDataValue(mGameObjectSlotID)) { Transform ptobj = PT.UserData[mGameObjectSlotID] as Transform; if (ptobj) { if (SyncPosition) ptobj.position = ParticleSystem.Transform.TransformPoint(PT.Position); if (SyncSize) ptobj.localScale = PT.Scale; switch (SyncRotation) { case MBParticleTransformConnectorRotationMode.None: break; case MBParticleTransformConnectorRotationMode.ByVelocity: if (PT.Velocity != Vector3.zero) ptobj.rotation = Quaternion.LookRotation(PT.Velocity); break; case MBParticleTransformConnectorRotationMode.ByHeading: if (PT.Heading != Vector3.zero) ptobj.rotation = Quaternion.LookRotation(PT.Heading); break; } } } return true; }
public override void OnBirth(MBParticle PT) { base.OnBirth(PT); DeathReason = MBDeathReason.Color; PT.Color = Colors[0].Color; PT.mbColor = PT.Color; }
public override bool OnLifetime(MBParticle PT) { if (Relative) PT.Velocity = PT.Velocity.magnitude*(1+CurveLife.Evaluate(PT.AgePercent)*PT.DeltaTime) * PT.Heading; else PT.Velocity = CurveLife.Evaluate(PT.AgePercent) * PT.Heading; return true; }
public override void OnBirth(MBParticle PT) { PT.Orientation = Offset + Base + Random.Range(-ArcRange, ArcRange); if (Mode==MBOrientationMode.Turn){ float sign=(FixedRandomSign) ? MBUtility.RandomSign() : 1; PT.AngularRotation = (FixedTurnSpeed + Random.Range(-FixedTurnSpeed, FixedTurnSpeed) * FixedRandomPercent ) * sign; } }
public override Vector3 GetHeading(MBParticle PT) { if (Heading == MBEmitterTypeHeading.MeshNormal) { int dir = InverseHeading ? -1 : 1; return Triangles[mLastTriID].Normal*dir; } else return base.GetHeading(PT); }
public override void OnBirth(MBParticle PT) { float r = Random.Range(-1f, 1f) * RandomPercent; if (AnimatedBirth) PT.Mass = CurveBirth.Evaluate(PT.Parent.AgePercent); else PT.Mass = Base; PT.Mass+=PT.Mass*r; }
public override void OnBirth(MBParticle PT) { float init; float r = Random.Range(-1f, 1f) * RandomPercent; if (AnimatedBirth) init = CurveBase.Evaluate(PT.Parent.AgePercent); else init = Base; PT.Velocity = (init+init*r)*PT.Heading; }
public override Vector3 GetHeading(MBParticle PT) { if (Heading == MBEmitterTypeHeading.MeshNormal) { if (Normals.Length > 0) { int dir = InverseHeading ? -1 : 1; return Normals[mLastVertexID] * dir; } else return Vector3.zero; } else return base.GetHeading(PT); }
public override Vector3 GetPosition(MBParticle PT) { if (Points.Length == 0) return Vector3.zero; if (Ordered) { if (++mLastVertexID >= Points.Length) mLastVertexID = 0; } else mLastVertexID = Random.Range(0, Points.Length - 1); return Points[mLastVertexID]; }
public override void OnBirth(MBParticle PT) { base.OnBirth(PT); float init; float r = Random.Range(-1f, 1f) * RandomPercent; if (AnimatedBirth) init = CurveBase.Evaluate(PT.Parent.AgePercent); else init = Base; PT.Friction = (init + init * r); }
public override Vector3 GetPosition(MBParticle PT) { if (Triangles.Length == 0) return Vector3.zero; if (Ordered) { if (++mLastTriID >= Triangles.Length) mLastTriID = 0; } else mLastTriID = Random.Range(0, Triangles.Length - 1); return (UseCenter) ? Triangles[mLastTriID].Center : Triangles[mLastTriID].RandomInside(); }
public override bool OnLifetime(MBParticle PT) { if (Relative) { PT.Heading = Quaternion.Euler(new Vector3(CurveLifeX.Evaluate(PT.AgePercent) * PT.DeltaTime, CurveLifeY.Evaluate(PT.AgePercent) * PT.DeltaTime, CurveLifeZ.Evaluate(PT.AgePercent) * PT.DeltaTime)) *PT.Heading; } else PT.Heading = new Vector3(CurveLifeX.Evaluate(PT.AgePercent), CurveLifeY.Evaluate(PT.AgePercent), CurveLifeZ.Evaluate(PT.AgePercent)).normalized; return true; }
public override Vector3 GetPosition(MBParticle PT) { float r = Random.Range(Hollow, 1); float l = -Random.Range(0, Mathf.PI * 2); float h = Random.Range(-Mathf.PI/2+Arc*Mathf.PI/2, Mathf.PI / 2); float ch = Mathf.Cos(h); Vector3 v = new Vector3(r * Mathf.Cos(l) * ch, r * Mathf.Sin(h), r * Mathf.Sin(l) * ch); v.Scale(Scale); return v; }
public override Vector3 GetPosition(MBParticle PT) { int runs = 0; Rect r = new Rect(-Scale.x * .5f, -Scale.y * .5f, Scale.x, Scale.y); Rect hr = new Rect(r.xMin * Hollow.x, r.yMin * Hollow.y, r.width * Hollow.x, r.height * Hollow.y); Vector3 v = Vector3.zero; while (runs++ < 100) { v.x = Random.Range(r.xMin, r.xMax); v.y = Random.Range(r.yMin, r.yMax); if (!hr.Contains(v)) return v; } return new Vector3(r.xMin, r.yMin, 0); }
public override void OnBirth(MBParticle PT) { if (PT.HasUserData(mGameObjectSlotID)) { if (Source) { Transform ptobj = SpawnObject(); ptobj.parent = Source.parent; #if UNITY_4_0 ptobj.gameObject.SetActive(true); #else ptobj.gameObject.active = true; #endif PT.UserData[mGameObjectSlotID] = ptobj; } } }
public override Vector3 GetPosition(MBParticle PT) { int runs = 0; Bounds r = new Bounds(Vector3.zero,Scale); Vector3 hrs=Scale; hrs.Scale(Hollow); Bounds hr = new Bounds(Vector3.zero, hrs); Vector3 v = Vector3.zero; while (runs++ < 100) { v.x = Random.Range(r.min.x, r.max.x); v.y = Random.Range(r.min.y, r.max.y); v.z = Random.Range(r.min.z, r.max.z); if (!hr.Contains(v)) return v; } return new Vector3(r.min.x, r.min.y, r.min.z); }
public override Vector3 GetPosition(MBParticle PT) { Rect r = new Rect(-Scale.x * .5f, -Scale.y * .5f, Scale.x, Scale.y); if (!EvenlySpread) return new Vector3(Random.Range(r.xMin, r.xMax), Random.Range(r.yMin, r.yMax), 0); else{ Vector3 v = new Vector3(r.xMin + mDistributionStep.x * mDistributionX, r.yMax - mDistributionStep.y * mDistributionY, 0); if (++mDistributionX >= DistributionPointsX) { mDistributionX = 0; mDistributionY++; } if (mDistributionY >= DistributionPointsY) mDistributionY = 0; return v; } }
public override Vector3 GetPosition(MBParticle PT) { Vector3 v = Vector3.zero; if (Points.Length>0) { int idx = 0; if (!EvenlySpread) { idx = Mathf.Max(0, Random.Range(0, Points.Length / 2)) * 2; v = Vector3.Lerp(Points[idx], Points[idx+1], Random.value); } else if (DistributionPoints > 0) { v = GetDistributionPoint(mDistribution, DistributeOverTotal); mDistribution++; if (mDistribution >= DistributionPoints) mDistribution = 0; } } return v; }
public override void OnBirth(MBParticle PT) { DeathReason = MBDeathReason.Size; float x, y; float r = Random.Range(-1f, 1f) * RandomPercent; if (AnimatedBirth) { x = CurveBirthX.Evaluate(PT.Parent.AgePercent); y = (ConstrainAxis) ? x : CurveBirthY.Evaluate(PT.Parent.AgePercent); } else { x = Base.x; y = (ConstrainAxis) ? x : Base.y; } x += x * r; y += y * r; PT.Scale = new Vector2(x, y); }
public override Vector3 GetPosition(MBParticle PT) { float theta=0;//=PT.Parent.Transform.rotation.eulerAngles.z*Mathf.Deg2Rad; if (!EvenlySpread) theta = Random.Range(-Arc, Arc); else if (DistributionPoints > 0) { theta = -Arc + mDistributionStep * mDistribution++; if (mDistribution >= DistributionPoints) mDistribution = 0; } float d = Random.Range(Hollow, 1); Vector3 v = new Vector3(d * -Mathf.Sin(theta), d * Mathf.Cos(theta),0); v.Scale(Scale); return v; }
public override bool OnLifetime(MBParticle PT) { Vector3 ptOriginPos = (WorldSpace) ? PT.WorldPosition : Transform.InverseTransformPoint(PT.WorldPosition); if (WorldSpace) { Matrix4x4 mMove = Matrix4x4.TRS(-Transform.localPosition, Quaternion.identity, Vector3.one); Matrix4x4 mRot = Matrix4x4.TRS(Vector3.zero, Quaternion.Inverse(Transform.localRotation), Vector3.one); ptOriginPos = (mRot * mMove).MultiplyPoint3x4(ptOriginPos); } if (mZoneRect.Contains(ptOriginPos)) { if (PT.AffectedByZones == null || !PT.AffectedByZones.Contains(this)) OnParticleEnteringZone(PT); switch (Mode) { case MBParticleZoneMode.Attract: if (Attraction != 0) PT.Force += Transform.up * -Attraction; OnParticleInsideZone(PT); break; case MBParticleZoneMode.Freeze: PT.Velocity = Vector3.zero; OnParticleInsideZone(PT); break; case MBParticleZoneMode.Kill: OnParticleInsideZone(PT); return false; case MBParticleZoneMode.Reflect: PT.Velocity *= -1; PT.Heading *= -1; OnParticleInsideZone(PT); break; case MBParticleZoneMode.EventsOnly: OnParticleInsideZone(PT); break; } } else { if (PT.AffectedByZones != null && PT.AffectedByZones.Contains(this)) OnParticleLeavingZone(PT); } return true; }
public override Vector3 GetPosition(MBParticle PT) { if (Image) { int x, y; int trials = 100; while (trials-- > 0) { x=Random.Range(0, Image.width - 1); y=Random.Range(0, Image.height - 1); Color col = Image.GetPixel(x,y); if (col.a > MinAlpha) { PT.Color = col; x -= Image.width / 2; y -= Image.height / 2; return new Vector3(x*(Scale.x/Image.width),y*(Scale.y/Image.height),0); } } } return Vector3.zero; }
public override void OnBirth(MBParticle PT) { DeathReason = MBDeathReason.Color; switch (ColorMode){ case MBFixedColorMode.Fixed: PT.Color = Colors[0].Color; break; case MBFixedColorMode.GradientKeyRandom: PT.Color = Colors[Random.Range(0, Colors.Count)].Color; break; case MBFixedColorMode.GradientRandom: PT.Color = GetGradientColor(Random.Range(0f, 1f),false); break; case MBFixedColorMode.Timeline: PT.Color = GetGradientColor(PT.Parent.AgePercent,false); break; case MBFixedColorMode.TimelineKeys: PT.Color = GetGradientColor(PT.Parent.AgePercent, true); break; } PT.mbColor = PT.Color; }
public override Vector3 GetPosition(MBParticle PT) { Bounds b = new Bounds(Vector3.zero, Scale); if (!EvenlySpread) { return new Vector3(Random.Range(b.min.x, b.max.x), Random.Range(b.min.y, b.max.y), Random.Range(b.min.z, b.max.z)); } else { Vector3 v = new Vector3(b.min.x + mDistributionStep.x * mDistributionX, b.max.y - mDistributionStep.y * mDistributionY, b.max.z - mDistributionStep.z * mDistributionZ); if (++mDistributionX >= DistributionPointsX) { mDistributionX = 0; mDistributionY++; } if (mDistributionY >= DistributionPointsY) { mDistributionY = 0; mDistributionZ++; } if (mDistributionZ >= DistributionPointsZ) mDistributionZ = 0; return v; } }
public override bool OnLifetime(MBParticle PT) { float x = CurveLifeX.Evaluate(PT.AgePercent); float y = (ConstrainAxis) ? x : CurveLifeY.Evaluate(PT.AgePercent); float z = (ConstrainAxis) ? x : CurveLifeZ.Evaluate(PT.AgePercent); if (Relative) PT.Scale.Scale(new Vector3(1 + x * PT.DeltaTime, 1 + y * PT.DeltaTime, 1+z*PT.DeltaTime)); else PT.Scale = new Vector3(x, y, z); if (DieOnZero && (PT.Scale.x <= 0 || PT.Scale.y <= 0 || PT.Scale.z<=0)) { return false; } return true; }