Beispiel #1
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 #2
0
	public void CreateParticles( Vector3 _Position, float _Width, float _Height, float _Depth, float TargetParticleSize, float _UiScale, HayateEnums.BuildOrder _buildOrder)
	{
		GetComponent<ParticleSystem>().Stop ();
		ParticleSystem.Particle[] p = new ParticleSystem.Particle[maxParticles];
		
		p = HayateHelper.CreateParticlesDynamically( this, _Position, _Width, _Height, _Depth, TargetParticleSize, _UiScale, _buildOrder);
		GetComponent<ParticleSystem>().SetParticles( p, maxParticles );
		GetComponent<ParticleSystem>().Play();
	}
Beispiel #3
0
    public static Mesh SubDivide( GameObject meshTarget, HayateEnums.DivisionType divisionType, float smallestTriangle)
    {
        List<Vector3> Vertices = new List<Vector3>();
        List<int> Triangles = new List<int>();
        List<Vector2> Uvs = new List<Vector2>();
        List<Vector3> Normals = new List<Vector3>();

        if (meshTarget)
        {
            for (int i = 0; i < meshTarget.GetComponent<MeshFilter>().sharedMesh.vertices.Length; i++)
            {
                Vertices.Add(meshTarget.GetComponent<MeshFilter>().sharedMesh.vertices[i]);
            }

            for (int i = 0; i < meshTarget.GetComponent<MeshFilter>().sharedMesh.triangles.Length; i++)
            {
                Triangles.Add(meshTarget.GetComponent<MeshFilter>().sharedMesh.triangles[i]);
            }

            for (int i = 0; i < meshTarget.GetComponent<MeshFilter>().sharedMesh.uv.Length; i++)
            {
                Uvs.Add(meshTarget.GetComponent<MeshFilter>().sharedMesh.uv[i]);
            }

            for (int i = 0; i < meshTarget.GetComponent<MeshFilter>().sharedMesh.normals.Length; i++)
            {
                Normals.Add(meshTarget.GetComponent<MeshFilter>().sharedMesh.normals[i]);
            }

            List<Vector3> newVertices = new List<Vector3>(Vertices);
            List<int> newTriangles = new List<int>(Triangles);
            List<Vector2> newUvs = new List<Vector2>(Uvs);
            List<Vector3> newNormals = new List<Vector3>(Normals);

            if (divisionType == HayateEnums.DivisionType.center)
            {
                for (int i = 0; i < newTriangles.Count; i += 3)
                {
                    if (SignedVolumeOfTriangle(newVertices[newTriangles[i]], newVertices[newTriangles[i + 1]], newVertices[newTriangles[i + 2]]) > smallestTriangle)
                    {
                        if (newVertices.Count > 60000)
                        {
                            Debug.Log("Stoped! Too many vertices");
                            break;
                        }

                        int p0 = newTriangles[i];
                        int p1 = newTriangles[i + 1];
                        int p2 = newTriangles[i + 2];

                        int pI0 = i;
                        int pI1 = i + 1;
                        int pI2 = i + 2;

                        Vector3 v0 = newVertices[p0];
                        Vector3 v1 = newVertices[p1];
                        Vector3 v2 = newVertices[p2];

                        Vector3 n0 = newNormals[p0];
                        Vector3 n1 = newNormals[p1];
                        Vector3 n2 = newNormals[p2];

                        Vector2 uv0 = newUvs[p0];
                        Vector2 uv1 = newUvs[p1];
                        Vector2 uv2 = newUvs[p2];

                        Vector3 nV = (v0 + v1 + v2) / 3;
                        Vector3 nN = ((n0 + n1 + n2) / 3).normalized;
                        Vector2 nU = (uv0 + uv1 + uv2) / 3;

                        int l = newVertices.Count;

                        newVertices.Add(nV);
                        newNormals.Add(nN);
                        newUvs.Add(nU);

                        newTriangles[pI0] = p0;
                        newTriangles[pI1] = p1;
                        newTriangles[pI2] = l;

                        newTriangles.Add(l);
                        newTriangles.Add(p1);
                        newTriangles.Add(p2);

                        newTriangles.Add(p0);
                        newTriangles.Add(l);
                        newTriangles.Add(p2);

                        if (SignedVolumeOfTriangle(newVertices[p0], newVertices[p1], newVertices[l]) > smallestTriangle)
                        {
                            i -= 3;
                        }
                    }
                }
            }
            else
            {
                for (int i = 0; i < newTriangles.Count; i += 3)
                {
                    if (SignedVolumeOfTriangle(newVertices[newTriangles[i]], newVertices[newTriangles[i + 1]], newVertices[newTriangles[i + 2]]) > smallestTriangle)
                    {
                        if (newVertices.Count > 40000)
                        {
                            Debug.Log("Stoped! Too many vertices");
                            break;
                        }

                        int p0 = newTriangles[i];
                        int p1 = newTriangles[i + 1];
                        int p2 = newTriangles[i + 2];

                        int pI0 = i;
                        int pI1 = i + 1;
                        int pI2 = i + 2;

                        Vector3 v0 = newVertices[p0];
                        Vector3 v1 = newVertices[p1];
                        Vector3 v2 = newVertices[p2];

                        Vector3 n0 = newNormals[p0];
                        Vector3 n1 = newNormals[p1];
                        Vector3 n2 = newNormals[p2];

                        Vector2 uv0 = newUvs[p0];
                        Vector2 uv1 = newUvs[p1];
                        Vector2 uv2 = newUvs[p2];

                        Vector3 v0_m = (v0 + v1) / 2;
                        Vector3 v1_m = (v1 + v2) / 2;
                        Vector3 v2_m = (v2 + v0) / 2;

                        Vector3 n0_m = ((n0 + n1) / 2).normalized;
                        Vector3 n1_m = ((n1 + n2) / 2).normalized;
                        Vector3 n2_m = ((n2 + n0) / 2).normalized;

                        Vector2 uv0_m = (uv0 + uv1) / 2;
                        Vector2 uv1_m = (uv1 + uv2) / 2;
                        Vector2 uv2_m = (uv2 + uv0) / 2;

                        int l0 = newVertices.Count;
                        int l1 = newVertices.Count + 1;
                        int l2 = newVertices.Count + 2;

                        newVertices.Add(v0_m);
                        newVertices.Add(v1_m);
                        newVertices.Add(v2_m);

                        newNormals.Add(n0_m);
                        newNormals.Add(n1_m);
                        newNormals.Add(n2_m);

                        newUvs.Add(uv0_m);
                        newUvs.Add(uv1_m);
                        newUvs.Add(uv2_m);

                        newTriangles[pI0] = p0;
                        newTriangles[pI1] = l0;
                        newTriangles[pI2] = l2;

                        newTriangles.Add(l0);
                        newTriangles.Add(l1);
                        newTriangles.Add(l2);

                        newTriangles.Add(l0);
                        newTriangles.Add(p1);
                        newTriangles.Add(l1);

                        newTriangles.Add(l2);
                        newTriangles.Add(l1);
                        newTriangles.Add(p2);

                        if (SignedVolumeOfTriangle(newVertices[p0], newVertices[l0], newVertices[l2]) > smallestTriangle)
                        {
                            i -= 3;
                        }
                    }
                }
            }

            Vector3[] ver = new Vector3[newVertices.Count];
            Vector3[] norms = new Vector3[newNormals.Count];
            Vector2[] uvs = new Vector2[newVertices.Count];
            int[] tri = new int[newTriangles.Count];

            for (int w = 0; w < newUvs.Count; w++)
            {
                uvs[w] = newUvs[w];
            }

            for (int w = 0; w < newNormals.Count; w++)
            {
                norms[w] = newNormals[w];
            }

            for (int x = 0; x < newVertices.Count; x++)
            {
                ver[x] = newVertices[x];
            }

            for (int y = 0; y < newTriangles.Count; y++)
            {
                tri[y] = newTriangles[y];
            }

            /*-------------ALLOCTION-------------*/
            Mesh subdivided = new Mesh();
            subdivided.vertices = ver;
            subdivided.triangles = tri;
            subdivided.uv = uvs;
            subdivided.normals = norms;
            subdivided.RecalculateBounds();

            Debug.Log((newVertices.Count - Vertices.Count) + " New Vertices created.");
            Debug.Log((newTriangles.Count - Triangles.Count) + " New Triangles created.");
            Debug.Log("Mesh target ready to work with " + newVertices.Count + " particles.");

            return subdivided;
        }
        else
        {
            Debug.LogWarning("No mesh target assigned!");
        }

        return null;
    }