Beispiel #1
0
    private static float CalculateAudioNoiseZ(float _positionY, float _positionX, Hayate hayate)
    {
        positionRemapedY = (int)(_positionY % hayate.amountOfSamples);
        positionRemapedX = (int)(_positionX % hayate.amountOfSamples);

        indexTurb = ((positionRemapedX) * hayate.amountOfSamples + (positionRemapedY));
        indexTurb = Mathf.Abs(indexTurb);

        turbulenceValue = hayate.hayateSamples[indexTurb] * hayate.Amplitude.z * hayate.deltaTime;
        return(turbulenceValue);
    }
Beispiel #2
0
    public static void CalculateAudioTurbulence( Hayate hayate )
    {
        if (!hayate.audioClip)
        {
            return;
        }

        hayate.hayateSamples = new float[hayate.amountOfSamples * hayate.amountOfSamples];

        float[] audioTurbX = new float[hayate.amountOfSamples * 2];
        float[] audioTurbY = new float[hayate.amountOfSamples * 2];
        hayate.audioClip.GetData(audioTurbX, hayate.atSample);
        hayate.audioClip.GetData(audioTurbY, hayate.atSample + hayate.amountOfSamples * 2);

        for (int x = 0; x < hayate.amountOfSamples; x++)
        {
            for (int y = 0; y < hayate.amountOfSamples; y++)
            {
                hayate.hayateSamples[y * hayate.amountOfSamples + x] = audioTurbY[x * 2] + audioTurbX[y * 2] / 2f;
            }
        }
    }
Beispiel #3
0
    public static void CalculateAudioTurbulence(Hayate hayate)
    {
        if (!hayate.audioClip)
        {
            return;
        }

        hayate.hayateSamples = new float[hayate.amountOfSamples * hayate.amountOfSamples];

        float[] audioTurbX = new float[hayate.amountOfSamples * 2];
        float[] audioTurbY = new float[hayate.amountOfSamples * 2];
        hayate.audioClip.GetData(audioTurbX, hayate.atSample);
        hayate.audioClip.GetData(audioTurbY, hayate.atSample + hayate.amountOfSamples * 2);

        for (int x = 0; x < hayate.amountOfSamples; x++)
        {
            for (int y = 0; y < hayate.amountOfSamples; y++)
            {
                hayate.hayateSamples[y * hayate.amountOfSamples + x] = audioTurbY[x * 2] + audioTurbX[y * 2] / 2f;
            }
        }
    }
Beispiel #4
0
    void functionKeys(int windowID)
    {
        GUILayout.Space(5f);
        GUILayout.BeginHorizontal();

        GUILayout.Label("Emitter: ", GUILayout.MaxWidth(80));

        if (GUILayout.Button("Plane", GUILayout.MaxWidth(80)))
        {
            HayateHolder.SetActive(true);
            HayateHolder3.SetActive(false);
            HayateHolder2.SetActive(false);
            hayate = HayateHolder.GetComponent <Hayate>();
        }

        if (GUILayout.Button("Sphere", GUILayout.MaxWidth(80)))
        {
            HayateHolder.SetActive(false);
            HayateHolder3.SetActive(false);
            HayateHolder2.SetActive(true);
            hayate = HayateHolder2.GetComponent <Hayate>();
        }
        if (GUILayout.Button("Line", GUILayout.MaxWidth(80)))
        {
            HayateHolder.SetActive(false);
            HayateHolder3.SetActive(true);
            HayateHolder2.SetActive(false);
            hayate = HayateHolder3.GetComponent <Hayate>();
        }

        if (GUILayout.Button("Velocity relative", GUILayout.MaxWidth(120)))
        {
            hayate.UseRelativeOrAbsoluteValues = Hayate.TurbulenceType.relative;
            hayate.AssignTurbulenceTo          = Hayate.AssignTo.velocity;
        }

        if (GUILayout.Button("Velocity absolute", GUILayout.MaxWidth(120)))
        {
            hayate.UseRelativeOrAbsoluteValues = Hayate.TurbulenceType.absolute;
            hayate.AssignTurbulenceTo          = Hayate.AssignTo.velocity;
        }

        if (GUILayout.Button("Position relative", GUILayout.MaxWidth(120)))
        {
            hayate.UseRelativeOrAbsoluteValues = Hayate.TurbulenceType.relative;
            hayate.AssignTurbulenceTo          = Hayate.AssignTo.position;
        }
        GUILayout.EndHorizontal();

        GUILayout.Space(5f);
        GUILayout.BeginHorizontal();

        GUILayout.Label("X-Axis: ", GUILayout.MaxWidth(80));

        if (GUILayout.Button("None", GUILayout.MaxWidth(80)))
        {
            hayate.UseCalculationMethodX = Hayate.CalculationMethod.none;
        }

        if (GUILayout.Button("Sine", GUILayout.MaxWidth(80)))
        {
            hayate.UseCalculationMethodX = Hayate.CalculationMethod.sine;
        }

        if (GUILayout.Button("Cosine", GUILayout.MaxWidth(80)))
        {
            hayate.UseCalculationMethodX = Hayate.CalculationMethod.cosine;
        }

        if (GUILayout.Button("Perlin", GUILayout.MaxWidth(80)))
        {
            hayate.UseCalculationMethodX = Hayate.CalculationMethod.perlin;
        }

        if (GUILayout.Button("Texture", GUILayout.MaxWidth(80)))
        {
            hayate.UseCalculationMethodX = Hayate.CalculationMethod.precalculatedTexture;
        }

        if (GUILayout.Button("Audio", GUILayout.MaxWidth(80)))
        {
            hayate.UseCalculationMethodX = Hayate.CalculationMethod.Audio;
        }

        GUILayout.Label("Amplitude: ", GUILayout.MaxWidth(80));
        hayate.Amplitude.x = float.Parse(GUILayout.TextField(hayate.Amplitude.x.ToString(), GUILayout.MaxWidth(50)));
        GUILayout.Label("Frequency: ", GUILayout.MaxWidth(80));
        hayate.Frequency.x = float.Parse(GUILayout.TextField(hayate.Frequency.x.ToString(), GUILayout.MaxWidth(50)));
        GUILayout.Label("Offset: ", GUILayout.MaxWidth(80));
        hayate.Offset.x = float.Parse(GUILayout.TextField(hayate.Offset.x.ToString(), GUILayout.MaxWidth(50)));
        GUILayout.Label("OffsetSpeed: ", GUILayout.MaxWidth(80));
        hayate.OffsetSpeed.x = float.Parse(GUILayout.TextField(hayate.OffsetSpeed.x.ToString(), GUILayout.MaxWidth(50)));

        GUILayout.EndHorizontal();

        GUILayout.Space(5f);
        GUILayout.BeginHorizontal();

        GUILayout.Label("Y-Axis: ", GUILayout.MaxWidth(80));

        if (GUILayout.Button("None", GUILayout.MaxWidth(80)))
        {
            hayate.UseCalculationMethodY = Hayate.CalculationMethod.none;
        }

        if (GUILayout.Button("Sine", GUILayout.MaxWidth(80)))
        {
            hayate.UseCalculationMethodY = Hayate.CalculationMethod.sine;
        }

        if (GUILayout.Button("Cosine", GUILayout.MaxWidth(80)))
        {
            hayate.UseCalculationMethodY = Hayate.CalculationMethod.cosine;
        }

        if (GUILayout.Button("Perlin", GUILayout.MaxWidth(80)))
        {
            hayate.UseCalculationMethodY = Hayate.CalculationMethod.perlin;
        }

        if (GUILayout.Button("Texture", GUILayout.MaxWidth(80)))
        {
            hayate.UseCalculationMethodY = Hayate.CalculationMethod.precalculatedTexture;
        }

        if (GUILayout.Button("Audio", GUILayout.MaxWidth(80)))
        {
            hayate.UseCalculationMethodY = Hayate.CalculationMethod.Audio;
        }

        GUILayout.Label("Amplitude: ", GUILayout.MaxWidth(80));
        hayate.Amplitude.y = float.Parse(GUILayout.TextField(hayate.Amplitude.y.ToString(), GUILayout.MaxWidth(50)));
        GUILayout.Label("Frequency: ", GUILayout.MaxWidth(80));
        hayate.Frequency.y = float.Parse(GUILayout.TextField(hayate.Frequency.y.ToString(), GUILayout.MaxWidth(50)));
        GUILayout.Label("Offset: ", GUILayout.MaxWidth(80));
        hayate.Offset.y = float.Parse(GUILayout.TextField(hayate.Offset.y.ToString(), GUILayout.MaxWidth(50)));
        GUILayout.Label("OffsetSpeed: ", GUILayout.MaxWidth(80));
        hayate.OffsetSpeed.y = float.Parse(GUILayout.TextField(hayate.OffsetSpeed.y.ToString(), GUILayout.MaxWidth(50)));

        GUILayout.EndHorizontal();
        GUILayout.Space(5f);
        GUILayout.BeginHorizontal();

        GUILayout.Label("Z-Axis: ", GUILayout.MaxWidth(80));

        if (GUILayout.Button("None", GUILayout.MaxWidth(80)))
        {
            hayate.UseCalculationMethodZ = Hayate.CalculationMethod.none;
        }

        if (GUILayout.Button("Sine", GUILayout.MaxWidth(80)))
        {
            hayate.UseCalculationMethodZ = Hayate.CalculationMethod.sine;
        }

        if (GUILayout.Button("Cosine", GUILayout.MaxWidth(80)))
        {
            hayate.UseCalculationMethodZ = Hayate.CalculationMethod.cosine;
        }

        if (GUILayout.Button("Perlin", GUILayout.MaxWidth(80)))
        {
            hayate.UseCalculationMethodZ = Hayate.CalculationMethod.perlin;
        }

        if (GUILayout.Button("Texture", GUILayout.MaxWidth(80)))
        {
            hayate.UseCalculationMethodZ = Hayate.CalculationMethod.precalculatedTexture;
        }

        if (GUILayout.Button("Audio", GUILayout.MaxWidth(80)))
        {
            hayate.UseCalculationMethodZ = Hayate.CalculationMethod.Audio;
        }

        GUILayout.Label("Amplitude: ", GUILayout.MaxWidth(80));
        hayate.Amplitude.z = float.Parse(GUILayout.TextField(hayate.Amplitude.z.ToString(), GUILayout.MaxWidth(50)));
        GUILayout.Label("Frequency: ", GUILayout.MaxWidth(80));
        hayate.Frequency.z = float.Parse(GUILayout.TextField(hayate.Frequency.z.ToString(), GUILayout.MaxWidth(50)));
        GUILayout.Label("Offset: ", GUILayout.MaxWidth(80));
        hayate.Offset.z = float.Parse(GUILayout.TextField(hayate.Offset.z.ToString(), GUILayout.MaxWidth(50)));
        GUILayout.Label("OffsetSpeed: ", GUILayout.MaxWidth(80));
        hayate.OffsetSpeed.z = float.Parse(GUILayout.TextField(hayate.OffsetSpeed.z.ToString(), GUILayout.MaxWidth(50)));

        GUILayout.EndHorizontal();


        //hayate.Amplitude.y = GUILayout.HorizontalSlider(hayate.Amplitude.y, -500f, 500f);
        //hayate.Amplitude.z = GUILayout.HorizontalSlider(hayate.Amplitude.z, -500f, 500f);
    }
Beispiel #5
0
    void Start()
    {
        window = new Rect(0, Screen.height - 150, Screen.width, 150);

        hayate = HayateHolder.GetComponent <Hayate>();
    }
	public static Vector3 GetTurbulence(Vector3 _position, Hayate hayate)
	{
		float turbX = 0f;
		float turbY = 0f;
		float turbZ = 0f;
		
		if (hayate.UseCalculationMethodX == HayateEnums.CalculationMethod.sine)
		{
			turbX = (Mathf.Sin(_position.z / hayate.Frequency.x - hayate.Offset.x) * hayate.Amplitude.x + hayate.GlobalForce.x) * hayate.deltaTime;
			
		}
		else if (hayate.UseCalculationMethodX == HayateEnums.CalculationMethod.cosine)
		{
			turbX = (Mathf.Cos(_position.z / hayate.Frequency.x - hayate.Offset.x) * hayate.Amplitude.x + hayate.GlobalForce.x) * hayate.deltaTime;
			
		}
		else if(hayate.UseCalculationMethodX == HayateEnums.CalculationMethod.animationCurve)
		{
			turbX = (hayate.turbulenceCurveX.Evaluate( _position.y / hayate.Frequency.x - hayate.Offset.x ) * hayate.Amplitude.x + hayate.GlobalForce.x) * hayate.deltaTime;
		}
		else if (hayate.UseCalculationMethodX == HayateEnums.CalculationMethod.perlin)
		{
			turbX = ((Mathf.PerlinNoise(_position.z / hayate.Frequency.z - hayate.Offset.z, _position.y / hayate.Frequency.y - hayate.Offset.y) * 2 - 1) * hayate.Amplitude.x + hayate.GlobalForce.x) * hayate.deltaTime;
			
		}
		else if (hayate.UseCalculationMethodX == HayateEnums.CalculationMethod.precalculatedTexture)
		{
			if (hayate.turbulence != null && hayate.turbulence.Length != 0)
				turbX = (CalculateTextureNoiseOnXAxis(_position.z / hayate.Frequency.z * 100f - hayate.Offset.z, _position.y / hayate.Frequency.y * 100f - hayate.Offset.y, hayate) + hayate.GlobalForce.x) * hayate.deltaTime;
			
		}
		else if (hayate.UseCalculationMethodX == HayateEnums.CalculationMethod.Audio)
		{
			if (hayate.hayateSamples != null && hayate.hayateSamples.Length != 0)
				turbX = (CalculateAudioNoiseX(_position.z / hayate.Frequency.z * 100f - hayate.Offset.z, _position.y / hayate.Frequency.y * 100f - hayate.Offset.y, hayate) + hayate.GlobalForce.x) * hayate.deltaTime;
		}
		
		
		if (hayate.UseCalculationMethodY == HayateEnums.CalculationMethod.sine)
		{
			turbY = (Mathf.Sin(_position.z / hayate.Frequency.y - hayate.Offset.y) * hayate.Amplitude.y + hayate.GlobalForce.y) * hayate.deltaTime;
			
		}
		else if (hayate.UseCalculationMethodY == HayateEnums.CalculationMethod.cosine)
		{
			turbY = (Mathf.Cos(_position.z / hayate.Frequency.y - hayate.Offset.y) * hayate.Amplitude.y + hayate.GlobalForce.y) * hayate.deltaTime;
			
		}
		else if(hayate.UseCalculationMethodY == HayateEnums.CalculationMethod.animationCurve)
		{
			turbY = (hayate.turbulenceCurveY.Evaluate( _position.x / hayate.Frequency.y - hayate.Offset.y ) * hayate.Amplitude.y + hayate.GlobalForce.y) * hayate.deltaTime;
		}
		else if (hayate.UseCalculationMethodY == HayateEnums.CalculationMethod.perlin)
		{
			turbY = ((Mathf.PerlinNoise(_position.x / hayate.Frequency.x - hayate.Offset.x, _position.z / hayate.Frequency.z - hayate.Offset.z) * 2 - 1) * hayate.Amplitude.y + hayate.GlobalForce.y) * hayate.deltaTime;
			
		}
		else if (hayate.UseCalculationMethodY == HayateEnums.CalculationMethod.precalculatedTexture)
		{
			if (hayate.turbulence != null && hayate.turbulence.Length != 0)
				turbY = (CalculateTextureNoiseOnYAxis(_position.x / hayate.Frequency.x * 100f - hayate.Offset.x, _position.z / hayate.Frequency.z * 100f - hayate.Offset.z, hayate) + hayate.GlobalForce.y) * hayate.deltaTime;
			
		}
		else if (hayate.UseCalculationMethodY == HayateEnums.CalculationMethod.Audio)
		{
			if (hayate.hayateSamples != null && hayate.hayateSamples.Length != 0)
				turbY = (CalculateAudioNoiseY(_position.x / hayate.Frequency.x * 100f - hayate.Offset.x, _position.z / hayate.Frequency.z * 100f - hayate.Offset.z, hayate) + hayate.GlobalForce.y) * hayate.deltaTime;
		}
		
		
		if (hayate.UseCalculationMethodZ == HayateEnums.CalculationMethod.sine)
		{
			turbZ = (Mathf.Sin(_position.x / hayate.Frequency.z - hayate.Offset.z) * hayate.Amplitude.z + hayate.GlobalForce.z) * hayate.deltaTime;
			
		}
		else if (hayate.UseCalculationMethodZ == HayateEnums.CalculationMethod.cosine)
		{
			turbZ = (Mathf.Cos(_position.x / hayate.Frequency.z - hayate.Offset.z) * hayate.Amplitude.z + hayate.GlobalForce.z) * hayate.deltaTime;
			
		}
		else if(hayate.UseCalculationMethodZ == HayateEnums.CalculationMethod.animationCurve)
		{
			turbZ = (hayate.turbulenceCurveZ.Evaluate( _position.y / hayate.Frequency.z - hayate.Offset.z ) * hayate.Amplitude.z + hayate.GlobalForce.z) * hayate.deltaTime;
		}
		else if (hayate.UseCalculationMethodZ == HayateEnums.CalculationMethod.perlin)
		{
			turbZ = ((Mathf.PerlinNoise(_position.y / hayate.Frequency.y - hayate.Offset.y, _position.x / hayate.Frequency.x - hayate.Offset.x) * 2 - 1) * hayate.Amplitude.z + hayate.GlobalForce.z) * hayate.deltaTime;
			
		}
		else if (hayate.UseCalculationMethodZ == HayateEnums.CalculationMethod.precalculatedTexture)
		{
			if (hayate.turbulence != null && hayate.turbulence.Length != 0)
				turbZ = (CalculateTextureNoiseOnZAxis(_position.y / hayate.Frequency.y * 100f - hayate.Offset.y, _position.x / hayate.Frequency.x * 100f - hayate.Offset.x, hayate) + hayate.GlobalForce.z) * hayate.deltaTime;
			
		}
		else if (hayate.UseCalculationMethodZ == HayateEnums.CalculationMethod.Audio)
		{
			if (hayate.hayateSamples != null && hayate.hayateSamples.Length != 0)
				turbZ = (CalculateAudioNoiseZ(_position.y / hayate.Frequency.y * 100f - hayate.Offset.y, _position.x / hayate.Frequency.x * 100f - hayate.Offset.x, hayate) + hayate.GlobalForce.z) * hayate.deltaTime;
		}
		
		calculatedTurbulence = new Vector3(turbX, turbY, turbZ);
		return calculatedTurbulence;
	}
	private static float CalculateTextureNoiseOnZAxis(float _positionY, float _positionX, Hayate hayate)
	{
		
		positionRemapedY = (int)(_positionY % hayate.Turbulence.width);
		positionRemapedX = (int)(_positionX % hayate.Turbulence.height);
		
		indexTurb = ((positionRemapedX) * hayate.Turbulence.width + (positionRemapedY));
		indexTurb = Mathf.Abs(indexTurb);
		
		if (hayate.useAlphaMask && hayate.turbulence[indexTurb].a == 0)
			hayate.removeCurrentParticle = true;
		
		turbulenceValue = ((hayate.turbulence[indexTurb].b / 256f) * 2 - 1) * hayate.Amplitude.z * hayate.deltaTime;
		return (turbulenceValue);
	}
	private static float CalculateAudioNoiseZ(float _positionY, float _positionX, Hayate hayate)
	{
		
		positionRemapedY = (int)(_positionY % hayate.amountOfSamples);
		positionRemapedX = (int)(_positionX % hayate.amountOfSamples);
		
		indexTurb = ((positionRemapedX) * hayate.amountOfSamples + (positionRemapedY));
		indexTurb = Mathf.Abs(indexTurb);
		
		turbulenceValue = hayate.hayateSamples[indexTurb] * hayate.Amplitude.z * hayate.deltaTime;
		return (turbulenceValue);
	}
Beispiel #9
0
    public static ParticleSystem.Particle[] CreateParticlesDynamically( Hayate hayate, Vector3 _Position, float _Width, float _Height, float _Depth, float _TargetParticleSize, float _UiScale, HayateEnums.BuildOrder _buildOrder)
    {
        int NumX = Mathf.CeilToInt (_Width / _TargetParticleSize );
        int NumY = Mathf.CeilToInt (_Height / _TargetParticleSize );
        int NumZ = Mathf.CeilToInt (_Depth / _TargetParticleSize );
        int MaxParticles = NumX * NumY * NumZ;
        hayate.GetComponent<ParticleSystem>().startSize = _TargetParticleSize * _UiScale;
        hayate.GetComponent<ParticleSystem>().emissionRate = 0f;
        #if UNITY_4_5 || UNITY_4_6 || UNITY_5_0
        hayate.particleSystem.maxParticles = MaxParticles;
        #endif
        hayate.GetComponent<ParticleSystem>().Emit( MaxParticles );

        ParticleSystem.Particle[] Particles = new ParticleSystem.Particle[MaxParticles];
        hayate.GetComponent<ParticleSystem>().GetParticles(Particles);

        int index = 0;
        int zIndex = 1;

        switch (_buildOrder)
        {
            case HayateEnums.BuildOrder.TopBottom:
                for(int z = 0; z < NumZ; z++)
                {
                    int yIndex = 1;
                    for(int y = NumY; y > 0; y--)
                    {
                        int xIndex = 1;
                        for(int x = 0; x < NumX; x++)
                        {

                            Particles[index].position = new Vector3(
                                ((_Position.x - ( _Width * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (x * _TargetParticleSize * _UiScale )),
                                ((_Position.y - ( _Height * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) - (_TargetParticleSize * _UiScale) + (y * _TargetParticleSize * _UiScale )),
                                ((_Position.z - ( _Depth * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (z * _TargetParticleSize * _UiScale ))
                            );

                            Particles[index].lifetime += (Particles[index].startLifetime / MaxParticles) * ((NumX/2f) * yIndex * zIndex);
                            Particles[index].startLifetime = Particles[index].lifetime;

                            index++;
                            xIndex++;
                        }
                        yIndex++;
                    }
                    zIndex++;
                }
            break;

            case HayateEnums.BuildOrder.TopRightBottomLeft:
                for(int z = 0; z < NumZ; z++)
                {
                    int yIndex = 1;
                    for(int y = NumY; y > 0; y--)
                    {
                        int xIndex = 1;
                        for(int x = NumX; x > 0 ; x--)
                        {
                            Particles[index].position = new Vector3(
                                ((_Position.x - ( _Width * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) - (_TargetParticleSize * _UiScale) + (x * _TargetParticleSize * _UiScale )),
                                ((_Position.y - ( _Height * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) - (_TargetParticleSize * _UiScale) + (y * _TargetParticleSize * _UiScale )),
                                ((_Position.z - ( _Depth * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (z * _TargetParticleSize * _UiScale ))
                            );

                            Particles[index].lifetime += (Particles[index].startLifetime / MaxParticles) * (xIndex * yIndex * zIndex);
                            Particles[index].startLifetime = Particles[index].lifetime;

                            index++;
                            xIndex++;
                        }
                        yIndex++;
                    }
                    zIndex++;
                }
            break;

            case HayateEnums.BuildOrder.RightLeft:
                for(int z = 0; z < NumZ; z++)
                {
                    int xIndex = 1;
                    for(int x = NumX; x > 0; x--)
                    {
                        int yIndex = 1;
                        for(int y = 0; y < NumY; y++)
                        {
                            Particles[index].position = new Vector3(
                                ((_Position.x - ( _Width * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) - (_TargetParticleSize * _UiScale) + (x * _TargetParticleSize * _UiScale )),
                                ((_Position.y - ( _Height * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (y * _TargetParticleSize * _UiScale )),
                                ((_Position.z - ( _Depth * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (z * _TargetParticleSize * _UiScale ))
                                );

                            Particles[index].lifetime += (Particles[index].startLifetime / MaxParticles) * (xIndex * yIndex * zIndex);
                            Particles[index].startLifetime = Particles[index].lifetime;

                            index++;
                            xIndex++;
                        }
                        yIndex++;
                    }
                    zIndex++;
                }
            break;

            case HayateEnums.BuildOrder.BottomRightTopLeft:
                for(int z = 0; z < NumZ; z++)
                {
                    int yIndex = 1;
                    for(int y = 0; y < NumY; y++)
                    {
                        int xIndex = 1;
                        for(int x = NumX; x > 0 ; x--)
                        {

                            Particles[index].position = new Vector3(
                                ((_Position.x - ( _Width * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) - (_TargetParticleSize * _UiScale) + (x * _TargetParticleSize * _UiScale )),
                                ((_Position.y - ( _Height * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (y * _TargetParticleSize * _UiScale )),
                                ((_Position.z - ( _Depth * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (z * _TargetParticleSize * _UiScale ))
                            );

                            Particles[index].lifetime += (Particles[index].startLifetime / MaxParticles) * (xIndex * yIndex * zIndex);
                            Particles[index].startLifetime = Particles[index].lifetime;

                            index++;
                            xIndex++;
                        }
                        yIndex++;
                    }
                    zIndex++;
                }
            break;

            case HayateEnums.BuildOrder.BottomTop:
            for(int z = 0; z < NumZ; z++)
            {
                int yIndex = 1;
                for(int y = 0; y < NumY; y++)
                {
                    int xIndex = 1;
                    for(int x = 0; x < NumX; x++)
                    {

                        Particles[index].position = new Vector3(
                            ((_Position.x - ( _Width * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (x * _TargetParticleSize * _UiScale )),
                            ((_Position.y - ( _Height * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (y * _TargetParticleSize * _UiScale )),
                            ((_Position.z - ( _Depth * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (z * _TargetParticleSize * _UiScale ))
                            );

                        Particles[index].lifetime += (Particles[index].startLifetime / MaxParticles) * ((NumX/2f) * yIndex * zIndex);
                        Particles[index].startLifetime = Particles[index].lifetime;

                        index++;
                        xIndex++;
                    }
                    yIndex++;
                }
                zIndex++;
            }
            break;

            case HayateEnums.BuildOrder.BottomLeftTopRight:
                for(int z = 0; z < NumZ; z++)
                {
                    int yIndex = 1;
                    for(int y = 0; y < NumY; y++)
                    {
                        int xIndex = 1;
                        for(int x = 0; x < NumX; x++)
                        {

                            Particles[index].position = new Vector3(
                                ((_Position.x - ( _Width * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (x * _TargetParticleSize * _UiScale )),
                                ((_Position.y - ( _Height * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (y * _TargetParticleSize * _UiScale )),
                                ((_Position.z - ( _Depth * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (z * _TargetParticleSize * _UiScale )));

                            Particles[index].lifetime += (Particles[index].startLifetime / MaxParticles) * (xIndex * yIndex * zIndex);
                            Particles[index].startLifetime = Particles[index].lifetime;

                            index++;
                            xIndex++;
                        }
                        yIndex++;
                    }
                    zIndex++;
                }
            break;

            case HayateEnums.BuildOrder.LeftRight:
                for(int z = 0; z < NumZ; z++)
                {

                    int xIndex = 1;
                    for(int x = 0; x < NumX; x++)
                    {
                        int yIndex = 1;
                        for(int y = 0; y < NumY; y++)
                        {
                            Particles[index].position = new Vector3(
                                ((_Position.x - ( _Width * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (x * _TargetParticleSize * _UiScale )),
                                ((_Position.y - ( _Height * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (y * _TargetParticleSize * _UiScale )),
                                ((_Position.z - ( _Depth * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (z * _TargetParticleSize * _UiScale ))
                            );

                            Particles[index].lifetime += (Particles[index].startLifetime / MaxParticles) * (xIndex * yIndex * zIndex);
                            Particles[index].startLifetime = Particles[index].lifetime;

                            index++;
                            xIndex++;
                        }
                        yIndex++;
                    }
                    zIndex++;
                }
            break;

            case HayateEnums.BuildOrder.TopLeftBottomRight:
                for(int z = 0; z < NumZ; z++)
                {
                    int yIndex = 1;
                    for(int y = NumY; y > 0; y--)
                    {
                        int xIndex = 1;
                        for(int x = 0; x < NumX; x++)
                        {
                            Particles[index].position = new Vector3(
                                ((_Position.x - ( _Width * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (x * _TargetParticleSize * _UiScale )),
                                ((_Position.y - ( _Height * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) - (_TargetParticleSize * _UiScale) + (y * _TargetParticleSize * _UiScale )),
                                ((_Position.z - ( _Depth * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (z * _TargetParticleSize * _UiScale ))
                            );

                            Particles[index].lifetime += (Particles[index].startLifetime / MaxParticles) * (xIndex * yIndex * zIndex);
                            Particles[index].startLifetime = Particles[index].lifetime;

                            index++;
                            xIndex++;
                        }
                        yIndex++;
                    }
                    zIndex++;
                }
            break;
        }

        return Particles;
    }
Beispiel #10
0
    public static ParticleSystem.Particle[] CreateParticlesDynamically(Hayate hayate, Vector3 _Position, float _Width, float _Height, float _Depth, float _TargetParticleSize, float _UiScale, HayateEnums.BuildOrder _buildOrder)
    {
        int NumX         = Mathf.CeilToInt(_Width / _TargetParticleSize);
        int NumY         = Mathf.CeilToInt(_Height / _TargetParticleSize);
        int NumZ         = Mathf.CeilToInt(_Depth / _TargetParticleSize);
        int MaxParticles = NumX * NumY * NumZ;

        hayate.particleSystem.startSize    = _TargetParticleSize * _UiScale;
        hayate.particleSystem.emissionRate = 0f;
#if UNITY_4_5 || UNITY_4_6 || UNITY_5_0
        hayate.particleSystem.maxParticles = MaxParticles;
#endif
        hayate.particleSystem.Emit(MaxParticles);

        ParticleSystem.Particle[] Particles = new ParticleSystem.Particle[MaxParticles];
        hayate.particleSystem.GetParticles(Particles);

        int index  = 0;
        int zIndex = 1;

        switch (_buildOrder)
        {
        case HayateEnums.BuildOrder.TopBottom:
            for (int z = 0; z < NumZ; z++)
            {
                int yIndex = 1;
                for (int y = NumY; y > 0; y--)
                {
                    int xIndex = 1;
                    for (int x = 0; x < NumX; x++)
                    {
                        Particles[index].position = new Vector3(
                            ((_Position.x - (_Width * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (x * _TargetParticleSize * _UiScale)),
                            ((_Position.y - (_Height * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) - (_TargetParticleSize * _UiScale) + (y * _TargetParticleSize * _UiScale)),
                            ((_Position.z - (_Depth * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (z * _TargetParticleSize * _UiScale))
                            );

                        Particles[index].lifetime     += (Particles[index].startLifetime / MaxParticles) * ((NumX / 2f) * yIndex * zIndex);
                        Particles[index].startLifetime = Particles[index].lifetime;

                        index++;
                        xIndex++;
                    }
                    yIndex++;
                }
                zIndex++;
            }
            break;

        case HayateEnums.BuildOrder.TopRightBottomLeft:
            for (int z = 0; z < NumZ; z++)
            {
                int yIndex = 1;
                for (int y = NumY; y > 0; y--)
                {
                    int xIndex = 1;
                    for (int x = NumX; x > 0; x--)
                    {
                        Particles[index].position = new Vector3(
                            ((_Position.x - (_Width * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) - (_TargetParticleSize * _UiScale) + (x * _TargetParticleSize * _UiScale)),
                            ((_Position.y - (_Height * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) - (_TargetParticleSize * _UiScale) + (y * _TargetParticleSize * _UiScale)),
                            ((_Position.z - (_Depth * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (z * _TargetParticleSize * _UiScale))
                            );

                        Particles[index].lifetime     += (Particles[index].startLifetime / MaxParticles) * (xIndex * yIndex * zIndex);
                        Particles[index].startLifetime = Particles[index].lifetime;

                        index++;
                        xIndex++;
                    }
                    yIndex++;
                }
                zIndex++;
            }
            break;

        case HayateEnums.BuildOrder.RightLeft:
            for (int z = 0; z < NumZ; z++)
            {
                int xIndex = 1;
                for (int x = NumX; x > 0; x--)
                {
                    int yIndex = 1;
                    for (int y = 0; y < NumY; y++)
                    {
                        Particles[index].position = new Vector3(
                            ((_Position.x - (_Width * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) - (_TargetParticleSize * _UiScale) + (x * _TargetParticleSize * _UiScale)),
                            ((_Position.y - (_Height * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (y * _TargetParticleSize * _UiScale)),
                            ((_Position.z - (_Depth * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (z * _TargetParticleSize * _UiScale))
                            );

                        Particles[index].lifetime     += (Particles[index].startLifetime / MaxParticles) * (xIndex * yIndex * zIndex);
                        Particles[index].startLifetime = Particles[index].lifetime;

                        index++;
                        xIndex++;
                    }
                    yIndex++;
                }
                zIndex++;
            }
            break;

        case HayateEnums.BuildOrder.BottomRightTopLeft:
            for (int z = 0; z < NumZ; z++)
            {
                int yIndex = 1;
                for (int y = 0; y < NumY; y++)
                {
                    int xIndex = 1;
                    for (int x = NumX; x > 0; x--)
                    {
                        Particles[index].position = new Vector3(
                            ((_Position.x - (_Width * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) - (_TargetParticleSize * _UiScale) + (x * _TargetParticleSize * _UiScale)),
                            ((_Position.y - (_Height * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (y * _TargetParticleSize * _UiScale)),
                            ((_Position.z - (_Depth * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (z * _TargetParticleSize * _UiScale))
                            );

                        Particles[index].lifetime     += (Particles[index].startLifetime / MaxParticles) * (xIndex * yIndex * zIndex);
                        Particles[index].startLifetime = Particles[index].lifetime;

                        index++;
                        xIndex++;
                    }
                    yIndex++;
                }
                zIndex++;
            }
            break;

        case HayateEnums.BuildOrder.BottomTop:
            for (int z = 0; z < NumZ; z++)
            {
                int yIndex = 1;
                for (int y = 0; y < NumY; y++)
                {
                    int xIndex = 1;
                    for (int x = 0; x < NumX; x++)
                    {
                        Particles[index].position = new Vector3(
                            ((_Position.x - (_Width * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (x * _TargetParticleSize * _UiScale)),
                            ((_Position.y - (_Height * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (y * _TargetParticleSize * _UiScale)),
                            ((_Position.z - (_Depth * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (z * _TargetParticleSize * _UiScale))
                            );

                        Particles[index].lifetime     += (Particles[index].startLifetime / MaxParticles) * ((NumX / 2f) * yIndex * zIndex);
                        Particles[index].startLifetime = Particles[index].lifetime;

                        index++;
                        xIndex++;
                    }
                    yIndex++;
                }
                zIndex++;
            }
            break;

        case HayateEnums.BuildOrder.BottomLeftTopRight:
            for (int z = 0; z < NumZ; z++)
            {
                int yIndex = 1;
                for (int y = 0; y < NumY; y++)
                {
                    int xIndex = 1;
                    for (int x = 0; x < NumX; x++)
                    {
                        Particles[index].position = new Vector3(
                            ((_Position.x - (_Width * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (x * _TargetParticleSize * _UiScale)),
                            ((_Position.y - (_Height * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (y * _TargetParticleSize * _UiScale)),
                            ((_Position.z - (_Depth * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (z * _TargetParticleSize * _UiScale)));

                        Particles[index].lifetime     += (Particles[index].startLifetime / MaxParticles) * (xIndex * yIndex * zIndex);
                        Particles[index].startLifetime = Particles[index].lifetime;

                        index++;
                        xIndex++;
                    }
                    yIndex++;
                }
                zIndex++;
            }
            break;

        case HayateEnums.BuildOrder.LeftRight:
            for (int z = 0; z < NumZ; z++)
            {
                int xIndex = 1;
                for (int x = 0; x < NumX; x++)
                {
                    int yIndex = 1;
                    for (int y = 0; y < NumY; y++)
                    {
                        Particles[index].position = new Vector3(
                            ((_Position.x - (_Width * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (x * _TargetParticleSize * _UiScale)),
                            ((_Position.y - (_Height * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (y * _TargetParticleSize * _UiScale)),
                            ((_Position.z - (_Depth * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (z * _TargetParticleSize * _UiScale))
                            );

                        Particles[index].lifetime     += (Particles[index].startLifetime / MaxParticles) * (xIndex * yIndex * zIndex);
                        Particles[index].startLifetime = Particles[index].lifetime;

                        index++;
                        xIndex++;
                    }
                    yIndex++;
                }
                zIndex++;
            }
            break;

        case HayateEnums.BuildOrder.TopLeftBottomRight:
            for (int z = 0; z < NumZ; z++)
            {
                int yIndex = 1;
                for (int y = NumY; y > 0; y--)
                {
                    int xIndex = 1;
                    for (int x = 0; x < NumX; x++)
                    {
                        Particles[index].position = new Vector3(
                            ((_Position.x - (_Width * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (x * _TargetParticleSize * _UiScale)),
                            ((_Position.y - (_Height * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) - (_TargetParticleSize * _UiScale) + (y * _TargetParticleSize * _UiScale)),
                            ((_Position.z - (_Depth * _UiScale / 2f) + _TargetParticleSize * _UiScale / 2f) + (z * _TargetParticleSize * _UiScale))
                            );

                        Particles[index].lifetime     += (Particles[index].startLifetime / MaxParticles) * (xIndex * yIndex * zIndex);
                        Particles[index].startLifetime = Particles[index].lifetime;

                        index++;
                        xIndex++;
                    }
                    yIndex++;
                }
                zIndex++;
            }
            break;
        }

        return(Particles);
    }
Beispiel #11
0
    private static float CalculateTextureNoiseOnZAxis(float _positionY, float _positionX, Hayate hayate)
    {
        positionRemapedY = (int)(_positionY % hayate.Turbulence.width);
        positionRemapedX = (int)(_positionX % hayate.Turbulence.height);

        indexTurb = ((positionRemapedX) * hayate.Turbulence.width + (positionRemapedY));
        indexTurb = Mathf.Abs(indexTurb);

        if (hayate.useAlphaMask && hayate.turbulence[indexTurb].a == 0)
        {
            hayate.removeCurrentParticle = true;
        }

        turbulenceValue = ((hayate.turbulence[indexTurb].b / 256f) * 2 - 1) * hayate.Amplitude.z * hayate.deltaTime;
        return(turbulenceValue);
    }
Beispiel #12
0
    public static Vector3 GetTurbulence(Vector3 _position, Hayate hayate)
    {
        float turbX = 0f;
        float turbY = 0f;
        float turbZ = 0f;

        if (hayate.UseCalculationMethodX == HayateEnums.CalculationMethod.sine)
        {
            turbX = (Mathf.Sin(_position.z / hayate.Frequency.x - hayate.Offset.x) * hayate.Amplitude.x + hayate.GlobalForce.x) * hayate.deltaTime;
        }
        else if (hayate.UseCalculationMethodX == HayateEnums.CalculationMethod.cosine)
        {
            turbX = (Mathf.Cos(_position.z / hayate.Frequency.x - hayate.Offset.x) * hayate.Amplitude.x + hayate.GlobalForce.x) * hayate.deltaTime;
        }
        else if (hayate.UseCalculationMethodX == HayateEnums.CalculationMethod.animationCurve)
        {
            turbX = (hayate.turbulenceCurveX.Evaluate(_position.y / hayate.Frequency.x - hayate.Offset.x) * hayate.Amplitude.x + hayate.GlobalForce.x) * hayate.deltaTime;
        }
        else if (hayate.UseCalculationMethodX == HayateEnums.CalculationMethod.perlin)
        {
            turbX = ((Mathf.PerlinNoise(_position.z / hayate.Frequency.z - hayate.Offset.z, _position.y / hayate.Frequency.y - hayate.Offset.y) * 2 - 1) * hayate.Amplitude.x + hayate.GlobalForce.x) * hayate.deltaTime;
        }
        else if (hayate.UseCalculationMethodX == HayateEnums.CalculationMethod.precalculatedTexture)
        {
            if (hayate.turbulence != null && hayate.turbulence.Length != 0)
            {
                turbX = (CalculateTextureNoiseOnXAxis(_position.z / hayate.Frequency.z * 100f - hayate.Offset.z, _position.y / hayate.Frequency.y * 100f - hayate.Offset.y, hayate) + hayate.GlobalForce.x) * hayate.deltaTime;
            }
        }
        else if (hayate.UseCalculationMethodX == HayateEnums.CalculationMethod.Audio)
        {
            if (hayate.hayateSamples != null && hayate.hayateSamples.Length != 0)
            {
                turbX = (CalculateAudioNoiseX(_position.z / hayate.Frequency.z * 100f - hayate.Offset.z, _position.y / hayate.Frequency.y * 100f - hayate.Offset.y, hayate) + hayate.GlobalForce.x) * hayate.deltaTime;
            }
        }


        if (hayate.UseCalculationMethodY == HayateEnums.CalculationMethod.sine)
        {
            turbY = (Mathf.Sin(_position.z / hayate.Frequency.y - hayate.Offset.y) * hayate.Amplitude.y + hayate.GlobalForce.y) * hayate.deltaTime;
        }
        else if (hayate.UseCalculationMethodY == HayateEnums.CalculationMethod.cosine)
        {
            turbY = (Mathf.Cos(_position.z / hayate.Frequency.y - hayate.Offset.y) * hayate.Amplitude.y + hayate.GlobalForce.y) * hayate.deltaTime;
        }
        else if (hayate.UseCalculationMethodY == HayateEnums.CalculationMethod.animationCurve)
        {
            turbY = (hayate.turbulenceCurveY.Evaluate(_position.x / hayate.Frequency.y - hayate.Offset.y) * hayate.Amplitude.y + hayate.GlobalForce.y) * hayate.deltaTime;
        }
        else if (hayate.UseCalculationMethodY == HayateEnums.CalculationMethod.perlin)
        {
            turbY = ((Mathf.PerlinNoise(_position.x / hayate.Frequency.x - hayate.Offset.x, _position.z / hayate.Frequency.z - hayate.Offset.z) * 2 - 1) * hayate.Amplitude.y + hayate.GlobalForce.y) * hayate.deltaTime;
        }
        else if (hayate.UseCalculationMethodY == HayateEnums.CalculationMethod.precalculatedTexture)
        {
            if (hayate.turbulence != null && hayate.turbulence.Length != 0)
            {
                turbY = (CalculateTextureNoiseOnYAxis(_position.x / hayate.Frequency.x * 100f - hayate.Offset.x, _position.z / hayate.Frequency.z * 100f - hayate.Offset.z, hayate) + hayate.GlobalForce.y) * hayate.deltaTime;
            }
        }
        else if (hayate.UseCalculationMethodY == HayateEnums.CalculationMethod.Audio)
        {
            if (hayate.hayateSamples != null && hayate.hayateSamples.Length != 0)
            {
                turbY = (CalculateAudioNoiseY(_position.x / hayate.Frequency.x * 100f - hayate.Offset.x, _position.z / hayate.Frequency.z * 100f - hayate.Offset.z, hayate) + hayate.GlobalForce.y) * hayate.deltaTime;
            }
        }


        if (hayate.UseCalculationMethodZ == HayateEnums.CalculationMethod.sine)
        {
            turbZ = (Mathf.Sin(_position.x / hayate.Frequency.z - hayate.Offset.z) * hayate.Amplitude.z + hayate.GlobalForce.z) * hayate.deltaTime;
        }
        else if (hayate.UseCalculationMethodZ == HayateEnums.CalculationMethod.cosine)
        {
            turbZ = (Mathf.Cos(_position.x / hayate.Frequency.z - hayate.Offset.z) * hayate.Amplitude.z + hayate.GlobalForce.z) * hayate.deltaTime;
        }
        else if (hayate.UseCalculationMethodZ == HayateEnums.CalculationMethod.animationCurve)
        {
            turbZ = (hayate.turbulenceCurveZ.Evaluate(_position.y / hayate.Frequency.z - hayate.Offset.z) * hayate.Amplitude.z + hayate.GlobalForce.z) * hayate.deltaTime;
        }
        else if (hayate.UseCalculationMethodZ == HayateEnums.CalculationMethod.perlin)
        {
            turbZ = ((Mathf.PerlinNoise(_position.y / hayate.Frequency.y - hayate.Offset.y, _position.x / hayate.Frequency.x - hayate.Offset.x) * 2 - 1) * hayate.Amplitude.z + hayate.GlobalForce.z) * hayate.deltaTime;
        }
        else if (hayate.UseCalculationMethodZ == HayateEnums.CalculationMethod.precalculatedTexture)
        {
            if (hayate.turbulence != null && hayate.turbulence.Length != 0)
            {
                turbZ = (CalculateTextureNoiseOnZAxis(_position.y / hayate.Frequency.y * 100f - hayate.Offset.y, _position.x / hayate.Frequency.x * 100f - hayate.Offset.x, hayate) + hayate.GlobalForce.z) * hayate.deltaTime;
            }
        }
        else if (hayate.UseCalculationMethodZ == HayateEnums.CalculationMethod.Audio)
        {
            if (hayate.hayateSamples != null && hayate.hayateSamples.Length != 0)
            {
                turbZ = (CalculateAudioNoiseZ(_position.y / hayate.Frequency.y * 100f - hayate.Offset.y, _position.x / hayate.Frequency.x * 100f - hayate.Offset.x, hayate) + hayate.GlobalForce.z) * hayate.deltaTime;
            }
        }

        calculatedTurbulence = new Vector3(turbX, turbY, turbZ);
        return(calculatedTurbulence);
    }