private void DebugField()
{
Vector3 debugPos;
Vector3 debugTurb;
Vector3 debugTarget;
for (float x = -fieldSize.x; x <= fieldSize.x; x += stepSize.x)
{
for (float y = -fieldSize.y; y <= fieldSize.y; y += stepSize.y)
{
for (float z = -fieldSize.z; z <= fieldSize.z; z += stepSize.z)
{
debugPos.x = transform.position.x + x;
debugPos.y = transform.position.y + y;
debugPos.z = transform.position.z + z;
debugTurb = HayateTurbulence.GetTurbulence(debugPos, this);
if (UseRelativeOrAbsoluteValues == HayateEnums.TurbulenceType.relative)
{
debugTarget = debugPos + Vector3.Scale(debugTurb, new Vector3(10f, 10f, 10f) * rayLength);
}
else
{
debugTarget = debugPos + Vector3.Scale(debugTurb, new Vector3(0.1f, 0.1f, 0.1f) * rayLength);
}
if (removeCurrentParticle)
{
removeCurrentParticle = false;
}
else
{
Debug.DrawLine(debugPos, debugTarget, debugColor);
}
}
}
}
}
private void HayateUpdate()
{
if (index.Count > 0)
{
_index = index[0];
_length = length[0];
index.RemoveAt(0);
length.RemoveAt(0);
}
else
{
Debug.LogError("Index empty! Thread can't execute.");
return;
}
/*
* Prototype
* if(accelerations.Count < particleCount)
* {
* for(int i = 0; i < particleCount - accelerations.Count; i++)
* {
* accelerations.Add( Vector3.zero );
* }
* }
*/
for (int i = _index; i < (_index + _length); i++)
{
if (AssignTurbulenceTo == HayateEnums.AssignTo.position)
{
if (UseRelativeOrAbsoluteValues == HayateEnums.TurbulenceType.absolute)
{
if (particles[i].velocity == Vector3.zero)
{
particles[i].velocity = particles[i].position;
}
particles[i].position = transform.position + HayateTurbulence.GetTurbulence(particles[i].velocity, this);
}
else
{
particles[i].position += HayateTurbulence.GetTurbulence(particles[i].position, this);
}
}
else if (AssignTurbulenceTo == HayateEnums.AssignTo.velocity)
{
if (UseRelativeOrAbsoluteValues == HayateEnums.TurbulenceType.absolute)
{
particles[i].velocity = HayateTurbulence.GetTurbulence(particles[i].position, this);
}
else
{
particles[i].velocity += HayateTurbulence.GetTurbulence(particles[i].position, this);
}
}
/*
* Prototype
* else if ( AssignTurbulenceTo == HayateEnums.AssignTo.acceleration )
* {
* accelerations[i] = HayateTurbulence.GetTurbulence(particles[i].position, this);
*
* if (UseRelativeOrAbsoluteValues == HayateEnums.TurbulenceType.absolute)
* {
* particles[i].velocity = HayateTurbulence.GetTurbulence(particles[i].position, this);
* }
* else
* {
* particles[i].velocity += HayateTurbulence.GetTurbulence(particles[i].position, this);
* }
* }
*/
if (useAttractor)
{
for (int a = 0; a < attractors.Count; a++)
{
desiredVelocity = attractorPositions[a] - particles[i].position;
particles[i].velocity += (desiredVelocity.normalized * attractorStrength[a] * deltaTime) * (1f - Mathf.Clamp01((Vector3.Distance(particles[i].position, attractorPositions[a]) / attractorAttenuation[a])));
}
}
if (useAlphaMask && removeCurrentParticle && particles[i].lifetime >= particles[i].startLifetime - threshold)
{
particles[i].lifetime = 0;
removeCurrentParticle = false;
}
}
if (useTransformParticle && transformParticle && Application.isPlaying)
{
particleList = new List <ParticleSystem.Particle> ();
for (int i = 0; i < particleCount; i++)
{
particleList.Add(particles[i]);
}
if (transformParticles.Count < particleList.Count)
{
int diff = particleList.Count - transformParticles.Count;
for (int i = 0; i < diff; i++)
{
GameObject g = Instantiate(transformParticle) as GameObject;
g.transform.parent = transform;
transformParticles.Add(g);
}
}
for (int i = 0; i < particleList.Count; i++)
{
transformParticles[i].transform.position = particleList[i].position;
if (transformParticleLookTowardsFlightDirection)
{
transformParticles[i].transform.LookAt(particles[i].position + particles[i].velocity);
}
if (particleList[i].lifetime < 1f)
{
particleList.RemoveAt(i);
if (detachTransformParticleAfterParticleDeath)
{
Destroy(transformParticles[i].gameObject, detachedObjectDestructionTimeAfter);
}
else
{
Destroy(transformParticles[i].gameObject);
}
transformParticles.RemoveAt(i);
particleCount--;
i--;
}
}
particles = particleList.ToArray();
}
else
{
for (int n = 0; n < transformParticles.Count; n++)
{
DestroyImmediate(transformParticles[n]);
transformParticles.RemoveAt(n);
}
}
if (lockOffsetToEmitterPosition)
{
float halfTextureWidth = turbulenceWidth / 2;
if (
UseCalculationMethodX == HayateEnums.CalculationMethod.precalculatedTexture ||
UseCalculationMethodY == HayateEnums.CalculationMethod.precalculatedTexture ||
UseCalculationMethodZ == HayateEnums.CalculationMethod.precalculatedTexture ||
UseCalculationMethodX == HayateEnums.CalculationMethod.Audio ||
UseCalculationMethodY == HayateEnums.CalculationMethod.Audio ||
UseCalculationMethodZ == HayateEnums.CalculationMethod.Audio)
{
Offset = new Vector3(currentPosition.x / Frequency.x, currentPosition.y / Frequency.y, currentPosition.z / Frequency.z) * 100f + new Vector3(halfTextureWidth, halfTextureWidth, halfTextureWidth);
}
else
{
Offset = new Vector3(currentPosition.x / Frequency.x, currentPosition.y / Frequency.y, currentPosition.z / Frequency.z);
}
}
else
{
if (particleSystem.isPlaying)
{
Offset += OffsetSpeed * deltaTime;
}
}
if (moveToMesh)
{
float meshSpeed = 0;
if (!useSkinnedMesh && meshTarget)
{
if (meshTarget.GetComponent <MeshFilter>())
{
targets = meshTarget.GetComponent <MeshFilter>().sharedMesh.vertices;
for (int z = _index; z < (_index + _length); z++)
{
if (useParticleSpeedCurve)
{
meshSpeed = particleSpeedToMeshAnimation.Evaluate(particles[z].startLifetime - particles[z].lifetime);
}
else
{
meshSpeed = particleSpeedToMesh;
}
if (meshSpeed < 0)
{
meshSpeed = 0;
}
safeIndex = z % targets.Length;
if (meshFollow == HayateEnums.MeshFollow.byDistance)
{
particles[z].position = Vector3.Lerp(particles[z].position, meshTarget.transform.TransformPoint(targets[safeIndex]), 1 / Mathf.Pow(Vector3.Distance(meshTarget.transform.TransformPoint(targets[safeIndex]), particles[z].position), 2) * meshSpeed);
}
else if (meshFollow == HayateEnums.MeshFollow.byTime)
{
particles[z].position = Vector3.Lerp(particles[z].position, meshTarget.transform.TransformPoint(targets[safeIndex]), meshSpeed * deltaTime);
}
else
{
_desiredVelocity = meshTarget.transform.TransformPoint(targets[safeIndex]) - particles[z].position;
particles[z].velocity += _desiredVelocity.normalized * meshSpeed * deltaTime;
}
}
}
else
{
Debug.LogWarning("No MeshFilter attached to this GameObject!");
meshTarget = null;
}
}
if (useSkinnedMesh && skinnedMeshTarget)
{
if (skinnedMeshTarget.GetComponent <SkinnedMeshRenderer>())
{
if (skinnedMeshBuffer == null)
{
skinnedMeshBuffer = new Mesh();
}
skinnedMeshTarget.GetComponent <SkinnedMeshRenderer>().BakeMesh(skinnedMeshBuffer);
skinnedMeshVertices = skinnedMeshBuffer.vertices;
targets = skinnedMeshBuffer.vertices;
for (int z = _index; z < (_index + _length); z++)
{
if (useParticleSpeedCurve)
{
meshSpeed = particleSpeedToMeshAnimation.Evaluate(particles[z].lifetime);
}
else
{
meshSpeed = particleSpeedToMesh;
}
if (meshSpeed < 0)
{
meshSpeed = 0;
}
safeIndex = z % targets.Length;
if (particles[z].startLifetime - particles[z].lifetime <= 0.05f)
{
particles[z].position = skinnedMeshTarget.transform.TransformPoint(skinnedMeshVertices[UnityEngine.Random.Range(0, skinnedMeshVertices.Length)]);
}
else
{
if (meshFollow == HayateEnums.MeshFollow.byDistance)
{
particles[z].position = Vector3.Lerp(
particles[z].position,
skinnedMeshTarget.transform.TransformPoint(targets[safeIndex]),
1 / Mathf.Pow(Vector3.Distance(skinnedMeshTarget.transform.TransformPoint(targets[safeIndex]), particles[z].position), 2) * meshSpeed);
}
else if (meshFollow == HayateEnums.MeshFollow.byTime)
{
particles[z].position = Vector3.Lerp(particles[z].position, skinnedMeshTarget.transform.TransformPoint(targets[safeIndex]), meshSpeed * deltaTime);
}
else
{
_desiredVelocity = skinnedMeshTarget.transform.TransformPoint(targets[safeIndex]) - particles[z].position;
particles[z].velocity += _desiredVelocity.normalized * meshSpeed * deltaTime;
}
}
}
}
else
{
Debug.LogWarning("No SkinnedMesh attached to this GameObject!");
skinnedMeshTarget = null;
}
}
}
}
