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;
}
