예제 #1
0
	public void Go(MeshExploder.MeshExplosionPreparation prep,
		float minSpeed, float maxSpeed, float minRotationSpeed, float maxRotationSpeed,
		bool useGravity, Vector3 scale) {
		
		preparation = prep;
		
		var frontTriangles = prep.totalFrontTriangles;
		triangleRotationAxes = new Vector3[frontTriangles];
		triangleSpeeds = new float[frontTriangles];
		triangleRotationSpeeds = new float[frontTriangles];
		
		var deltaSpeed = maxSpeed - minSpeed;
		var deltaRotationSpeed = maxRotationSpeed - minRotationSpeed;
		var fixedSpeed = minSpeed == maxSpeed;
		var fixedRotationSpeed = minRotationSpeed == maxRotationSpeed;
		
		this.useGravity = useGravity;
		explosionTime = 0;
		thisTransform = transform;
		
		for (var triangleNumber = 0; triangleNumber < frontTriangles; ++triangleNumber) {
			triangleRotationAxes[triangleNumber] = Random.onUnitSphere;
			triangleSpeeds[triangleNumber] = fixedSpeed ?
				minSpeed : minSpeed + Random.value * deltaSpeed;
			triangleRotationSpeeds[triangleNumber] = fixedRotationSpeed ?
				minRotationSpeed : minRotationSpeed + Random.value * deltaRotationSpeed;
		}
		
		GetComponent<MeshFilter>().mesh = mesh = (Mesh)Object.Instantiate(prep.startMesh);
		triangleCurrentCentroids = (Vector3[])prep.triangleCentroids.Clone();
		
		// It might seem like a waste of memory to keep a copy of these arrays, but actually
		// retrieving them allocates new garbage collected memory every time so it's much better to
		// just retrieve them once rather than retrieving them every frame and creating lots of
		// garbage.
		vertices = mesh.vertices;
		normals = mesh.normals;
		tangents = mesh.tangents;
		
		if (scale != Vector3.one) {
			{
				var n = vertices.Length;
				for (var i = 0; i < n; ++i) {
					vertices[i] = Vector3.Scale(vertices[i], scale);
				}
			}
			{
				var n = triangleCurrentCentroids.Length;
				for (var i = 0; i < n; ++i) {
					triangleCurrentCentroids[i] = Vector3.Scale(triangleCurrentCentroids[i], scale);
				}
			}
		}
		
		// Do one frame of explosion to start it off.
		Update();
	}
예제 #2
0
    public void Go(MeshExploder.MeshExplosionPreparation prep,
                   float minSpeed, float maxSpeed, float minRotationSpeed, float maxRotationSpeed,
                   bool useGravity)
    {
        preparation = prep;

        var frontTriangles = prep.totalFrontTriangles;

        triangleRotationAxes   = new Vector3[frontTriangles];
        triangleSpeeds         = new float[frontTriangles];
        triangleRotationSpeeds = new float[frontTriangles];

        var deltaSpeed         = maxSpeed - minSpeed;
        var deltaRotationSpeed = maxRotationSpeed - minRotationSpeed;
        var fixedSpeed         = minSpeed == maxSpeed;
        var fixedRotationSpeed = minRotationSpeed == maxRotationSpeed;

        this.useGravity = useGravity;
        explosionTime   = 0;
        thisTransform   = transform;

        for (var triangleNumber = 0; triangleNumber < frontTriangles; ++triangleNumber)
        {
            triangleRotationAxes[triangleNumber] = Random.onUnitSphere;
            triangleSpeeds[triangleNumber]       = fixedSpeed ?
                                                   minSpeed : minSpeed + Random.value * deltaSpeed;
            triangleRotationSpeeds[triangleNumber] = fixedRotationSpeed ?
                                                     minRotationSpeed : minRotationSpeed + Random.value * deltaRotationSpeed;
        }

        GetComponent <MeshFilter>().mesh = mesh = (Mesh)Object.Instantiate(prep.startMesh);
        triangleCurrentCentroids         = (Vector3[])prep.triangleCentroids.Clone();

        // It might seem like a waste of memory to keep a copy of these arrays, but actually
        // retrieving them allocates new garbage collected memory every time so it's much better to
        // just retrieve them once rather than retrieving them every frame and creating lots of
        // garbage.
        vertices = mesh.vertices;
        normals  = mesh.normals;
        tangents = mesh.tangents;

        // Do one frame of explosion to start it off.
        Update();
    }
예제 #3
0
    // Token: 0x06002F6E RID: 12142 RVA: 0x000E6714 File Offset: 0x000E4B14
    public void Go(MeshExploder.MeshExplosionPreparation prep, float minSpeed, float maxSpeed, float minRotationSpeed, float maxRotationSpeed, bool useGravity, Vector3 scale)
    {
        this.preparation = prep;
        int totalFrontTriangles = prep.totalFrontTriangles;

        this.triangleRotationAxes   = new Vector3[totalFrontTriangles];
        this.triangleSpeeds         = new float[totalFrontTriangles];
        this.triangleRotationSpeeds = new float[totalFrontTriangles];
        float num   = maxSpeed - minSpeed;
        float num2  = maxRotationSpeed - minRotationSpeed;
        bool  flag  = minSpeed == maxSpeed;
        bool  flag2 = minRotationSpeed == maxRotationSpeed;

        this.useGravity    = useGravity;
        this.explosionTime = 0f;
        this.thisTransform = base.transform;
        for (int i = 0; i < totalFrontTriangles; i++)
        {
            this.triangleRotationAxes[i]   = UnityEngine.Random.onUnitSphere;
            this.triangleSpeeds[i]         = ((!flag) ? (minSpeed + UnityEngine.Random.value * num) : minSpeed);
            this.triangleRotationSpeeds[i] = ((!flag2) ? (minRotationSpeed + UnityEngine.Random.value * num2) : minRotationSpeed);
        }
        base.GetComponent <MeshFilter>().mesh = (this.mesh = UnityEngine.Object.Instantiate <Mesh>(prep.startMesh));
        this.triangleCurrentCentroids         = (Vector3[])prep.triangleCentroids.Clone();
        this.vertices = this.mesh.vertices;
        this.normals  = this.mesh.normals;
        this.tangents = this.mesh.tangents;
        if (scale != Vector3.one)
        {
            int num3 = this.vertices.Length;
            for (int j = 0; j < num3; j++)
            {
                this.vertices[j] = Vector3.Scale(this.vertices[j], scale);
            }
            int num4 = this.triangleCurrentCentroids.Length;
            for (int k = 0; k < num4; k++)
            {
                this.triangleCurrentCentroids[k] = Vector3.Scale(this.triangleCurrentCentroids[k], scale);
            }
        }
        this.Update();
    }
예제 #4
0
 private void Prepare(Mesh oldMesh, bool cachePreparation = true)
 {
     if (!oldMesh.isReadable)
     {
         Debug.LogError((object)"The mesh is not readable. Switch on the \"Read/Write Enabled\" option on the mesh's import settings.");
     }
     else
     {
         bool flag1 = this.type == MeshExploder.ExplosionType.Physics;
         MeshExploder.MeshExplosionPreparation explosionPreparation;
         if (MeshExploder.cache.TryGetValue(oldMesh, out explosionPreparation) && (flag1 && explosionPreparation.physicsMeshes != null || !flag1 && (Object)explosionPreparation.startMesh != (Object)null))
         {
             this.preparation = explosionPreparation;
         }
         else
         {
             Vector3[] vertices1    = oldMesh.vertices;
             Vector3[] normals1     = oldMesh.normals;
             Vector4[] tangents1    = oldMesh.tangents;
             Vector2[] uv           = oldMesh.uv;
             Vector2[] uv2          = oldMesh.uv2;
             Color[]   colors       = oldMesh.colors;
             int       subMeshCount = oldMesh.subMeshCount;
             int[][]   numArray1    = new int[subMeshCount][];
             int[]     numArray2    = !flag1 ? (int[])null : (explosionPreparation.frontMeshTrianglesPerSubMesh = new int[subMeshCount]);
             int       length1      = 0;
             for (int submesh = 0; submesh < subMeshCount; ++submesh)
             {
                 int num = (numArray1[submesh] = oldMesh.GetTriangles(submesh)).Length / 3;
                 if (flag1)
                 {
                     numArray2[submesh] = num;
                 }
                 length1 += num;
             }
             explosionPreparation.totalFrontTriangles = length1;
             int num1    = length1 * 2;
             int length2 = !flag1 ? num1 * 3 : 6;
             if (length2 > 65534)
             {
                 Debug.LogError((object)("The mesh has too many triangles to explode. It must have " + (object)10922 + " or fewer triangles."));
             }
             else
             {
                 Vector3[]    vertices2       = new Vector3[length2];
                 Vector3[]    normals2        = normals1 == null || normals1.Length == 0 ? (Vector3[])null : new Vector3[length2];
                 Vector4[]    tangents2       = tangents1 == null || tangents1.Length == 0 ? (Vector4[])null : new Vector4[length2];
                 Vector2[]    vector2Array1   = uv == null || uv.Length == 0 ? (Vector2[])null : new Vector2[length2];
                 Vector2[]    vector2Array2   = uv2 == null || uv2.Length == 0 ? (Vector2[])null : new Vector2[length2];
                 Color[]      colorArray      = colors == null || colors.Length == 0 ? (Color[])null : new Color[length2];
                 Vector3[]    vector3Array1   = explosionPreparation.triangleCentroids = new Vector3[length1];
                 Mesh[]       meshArray       = explosionPreparation.physicsMeshes = !flag1 ? (Mesh[])null : new Mesh[length1];
                 Quaternion[] quaternionArray = explosionPreparation.rotations = !flag1 ? (Quaternion[])null : new Quaternion[length1];
                 int[]        numArray3;
                 if (flag1)
                 {
                     numArray3 = new int[6] {
                         0, 1, 2, 3, 4, 5
                     }
                 }
                 ;
                 else
                 {
                     numArray3 = (int[])null;
                 }
                 int[]      numArray4  = numArray3;
                 int        index1     = 0;
                 int        index2     = 0;
                 Quaternion quaternion = Quaternion.identity;
                 for (int index3 = 0; index3 < subMeshCount; ++index3)
                 {
                     int[] numArray5 = numArray1[index3];
                     int   length3   = numArray5.Length;
                     int   num2      = 0;
                     while (num2 < length3)
                     {
                         int     num3      = num2;
                         Vector3 vector3_1 = Vector3.zero;
                         for (int index4 = 0; index4 < 2; ++index4)
                         {
                             num2 = num3;
                             bool flag2 = index4 == 1;
                             while (num2 < length3)
                             {
                                 int index5 = numArray5[!flag2 ? num2 : num3 + (2 - (num2 - num3))];
                                 if (flag1 && index1 % 6 == 0)
                                 {
                                     Vector3 vector3_2 = vertices1[index5];
                                     Vector3 vector3_3 = vertices1[numArray5[num2 + 1]];
                                     Vector3 vector3_4 = vertices1[numArray5[num2 + 2]];
                                     Vector3 vector3_5 = Vector3.Cross(vector3_3 - vector3_2, vector3_4 - vector3_2);
                                     quaternionArray[index2] = Quaternion.FromToRotation(Vector3.up, vector3_5);
                                     quaternion            = Quaternion.FromToRotation(vector3_5, Vector3.up);
                                     vector3Array1[index2] = vector3_1 = (vector3_2 + vector3_3 + vector3_4) / 3f;
                                 }
                                 if (!flag2)
                                 {
                                     vertices2[index1] = quaternion * (vertices1[index5] - vector3_1);
                                     if (normals2 != null)
                                     {
                                         normals2[index1] = quaternion * normals1[index5];
                                     }
                                     if (tangents2 != null)
                                     {
                                         tangents2[index1] = (Vector4)(quaternion * (Vector3)tangents1[index5]);
                                     }
                                 }
                                 if (vector2Array1 != null)
                                 {
                                     vector2Array1[index1] = uv[index5];
                                 }
                                 if (vector2Array2 != null)
                                 {
                                     vector2Array2[index1] = uv2[index5];
                                 }
                                 if (colorArray != null)
                                 {
                                     colorArray[index1] = colors[index5];
                                 }
                                 ++num2;
                                 ++index1;
                                 if (index1 % 6 == 0)
                                 {
                                     if (flag1)
                                     {
                                         MeshExplosion.SetBackTriangleVertices(vertices2, normals2, tangents2, 1);
                                         Mesh mesh = new Mesh();
                                         mesh.vertices = vertices2;
                                         if (normals2 != null)
                                         {
                                             mesh.normals = normals2;
                                         }
                                         if (tangents2 != null)
                                         {
                                             mesh.tangents = tangents2;
                                         }
                                         if (vector2Array1 != null)
                                         {
                                             mesh.uv = vector2Array1;
                                         }
                                         if (vector2Array2 != null)
                                         {
                                             mesh.uv2 = vector2Array2;
                                         }
                                         if (colorArray != null)
                                         {
                                             mesh.colors = colorArray;
                                         }
                                         mesh.triangles    = numArray4;
                                         meshArray[index2] = mesh;
                                         index1            = 0;
                                         break;
                                     }
                                     break;
                                 }
                                 if (index1 % 3 == 0 && !flag2)
                                 {
                                     break;
                                 }
                             }
                         }
                         ++index2;
                     }
                 }
                 Vector3 vector3_6 = Vector3.zero;
                 if (!flag1)
                 {
                     Mesh mesh = explosionPreparation.startMesh = new Mesh();
                     mesh.MarkDynamic();
                     mesh.vertices = vertices2;
                     if (normals2 != null)
                     {
                         mesh.normals = normals2;
                     }
                     if (tangents2 != null)
                     {
                         mesh.tangents = tangents2;
                     }
                     if (vector2Array1 != null)
                     {
                         mesh.uv = vector2Array1;
                     }
                     if (vector2Array2 != null)
                     {
                         mesh.uv2 = vector2Array2;
                     }
                     if (colorArray != null)
                     {
                         mesh.colors = colorArray;
                     }
                     mesh.subMeshCount = subMeshCount;
                     int num2 = 0;
                     for (int submesh = 0; submesh < subMeshCount; ++submesh)
                     {
                         int   length3   = numArray1[submesh].Length * 2;
                         int[] triangles = new int[length3];
                         int   index3    = 0;
                         while (index3 < length3)
                         {
                             triangles[index3] = num2;
                             ++index3;
                             ++num2;
                         }
                         mesh.SetTriangles(triangles, submesh);
                     }
                     if (this.useMeshBoundsCenter)
                     {
                         vector3_6 = mesh.bounds.center;
                     }
                 }
                 Vector3[] vector3Array2 = explosionPreparation.triangleNormals = new Vector3[length1];
                 int       index6        = 0;
                 int       index7        = 0;
                 while (index7 < length1)
                 {
                     Vector3 vector3_1;
                     if (flag1)
                     {
                         vector3_1 = vector3Array1[index7];
                     }
                     else
                     {
                         vector3_1             = (vertices2[index6] + vertices2[index6 + 1] + vertices2[index6 + 2]) / 3f;
                         vector3Array1[index7] = vector3_1;
                     }
                     Vector3 vector3_2;
                     if (this.useNormals && normals2 != null)
                     {
                         if (flag1)
                         {
                             normals2 = meshArray[index7].normals;
                             index6   = 0;
                         }
                         vector3_2 = ((normals2[index6] + normals2[index6 + 1] + normals2[index6 + 2]) / 3f).normalized;
                     }
                     else
                     {
                         vector3_2 = vector3_1;
                         if (this.useMeshBoundsCenter)
                         {
                             vector3_2 -= vector3_6;
                         }
                         vector3_2.Normalize();
                     }
                     vector3Array2[index7] = vector3_2;
                     ++index7;
                     index6 += 6;
                 }
                 this.preparation = explosionPreparation;
                 if (cachePreparation)
                 {
                     MeshExploder.cache[oldMesh] = explosionPreparation;
                 }
                 if ((double)this.fadeTime == 0.0 || this.shadersAlreadyHandleTransparency)
                 {
                     return;
                 }
                 foreach (Material sharedMaterial in this.GetComponent <Renderer>().sharedMaterials)
                 {
                     Shader shader         = sharedMaterial.shader;
                     Shader replacementFor = Fade.GetReplacementFor(shader);
                     if ((Object)replacementFor == (Object)null || !replacementFor.name.StartsWith("Transparent/"))
                     {
                         Debug.LogWarning((object)("Couldn't find an explicitly transparent version of shader '" + shader.name + "' so fading may not work. If the shader does support transparency then this warning can be avoided by enabling the 'Shaders Already Handle Transparency' option."));
                     }
                 }
             }
         }
     }
 }