private MeshCollider collide;      // quick pointer to the mesh collider that we're updating
                                       // Function:    Start
                                       //      This basically translates the information about the skinned mesh into
                                       // data that we can internally use to quickly update the collision mesh.
    void Start()
    {
        SkinnedMeshRenderer rend = GetComponent(typeof(SkinnedMeshRenderer)) as SkinnedMeshRenderer;

        collide = GetComponent(typeof(MeshCollider)) as MeshCollider;
        if (collide != null && rend != null)
        {
            Mesh baseMesh = rend.sharedMesh;
            mesh           = new Mesh();
            mesh.vertices  = baseMesh.vertices;
            mesh.uv        = baseMesh.uv;
            mesh.triangles = baseMesh.triangles;
            newVert        = new Vector3[baseMesh.vertices.Length];
            short i;
            // Make a CWeightList for each bone in the skinned mesh
            nodeWeights = new CWeightList[rend.bones.Length];
            for (i = 0; i < rend.bones.Length; i++)
            {
                nodeWeights[i]           = new CWeightList();
                nodeWeights[i].transform = rend.bones[i];
            }

            // Create a bone weight list for each bone, ready for quick calculation during an update...
            Vector3 localPt;
            for (i = 0; i < baseMesh.vertices.Length; i++)
            {
                BoneWeight bw = baseMesh.boneWeights[i];
                if (bw.weight0 != 0.0f)
                {
                    localPt = baseMesh.bindposes[bw.boneIndex0].MultiplyPoint3x4(baseMesh.vertices[i]);
                    nodeWeights[bw.boneIndex0].weights.Add(new CVertexWeight(i, localPt, bw.weight0));
                }

                if (bw.weight1 != 0.0f)
                {
                    localPt = baseMesh.bindposes[bw.boneIndex1].MultiplyPoint3x4(baseMesh.vertices[i]);
                    nodeWeights[bw.boneIndex1].weights.Add(new CVertexWeight(i, localPt, bw.weight1));
                }

                if (bw.weight2 != 0.0f)
                {
                    localPt = baseMesh.bindposes[bw.boneIndex2].MultiplyPoint3x4(baseMesh.vertices[i]);
                    nodeWeights[bw.boneIndex2].weights.Add(new CVertexWeight(i, localPt, bw.weight2));
                }

                if (bw.weight3 != 0.0f)
                {
                    localPt = baseMesh.bindposes[bw.boneIndex3].MultiplyPoint3x4(baseMesh.vertices[i]);
                    nodeWeights[bw.boneIndex3].weights.Add(new CVertexWeight(i, localPt, bw.weight3));
                }
            }

            UpdateCollisionMesh();
        }
        else
        {
            Debug.LogError(gameObject.name + ": SkinnedCollisionHelper: this object either has no SkinnedMeshRenderer or has no MeshCollider!");
        }
    }
    private CWeightList[] nodeWeights; // array of node weights (one per node)

    #endregion Fields

    #region Methods

    // Function:    Start
    //      This basically translates the information about the skinned mesh into
    // data that we can internally use to quickly update the collision mesh.
    void Start()
    {
        SkinnedMeshRenderer rend = GetComponent(typeof(SkinnedMeshRenderer)) as SkinnedMeshRenderer;
        collide = GetComponent(typeof(MeshCollider)) as MeshCollider;

        if (collide!=null && rend!=null)
        {
            Mesh baseMesh = rend.sharedMesh;
            mesh = new Mesh();
            mesh.vertices = baseMesh.vertices;
            mesh.uv = baseMesh.uv;
            mesh.triangles = baseMesh.triangles;
            newVert = new Vector3[baseMesh.vertices.Length];

            short i;
            // Make a CWeightList for each bone in the skinned mesh
            nodeWeights = new CWeightList[rend.bones.Length];
            for ( i=0 ; i<rend.bones.Length ; i++ )
            {
                nodeWeights[i] = new CWeightList();
                nodeWeights[i].transform = rend.bones[i];
            }

            // Create a bone weight list for each bone, ready for quick calculation during an update...
            Vector3 localPt;
            for ( i=0 ; i<baseMesh.vertices.Length ; i++ )
            {
                BoneWeight bw = baseMesh.boneWeights[i];
                if (bw.weight0!=0.0f)
                {
                    localPt = baseMesh.bindposes[bw.boneIndex0].MultiplyPoint3x4( baseMesh.vertices[i] );
                    nodeWeights[bw.boneIndex0].weights.Add( new CVertexWeight( i, localPt, bw.weight0 ) );
                }
                if (bw.weight1!=0.0f)
                {
                    localPt = baseMesh.bindposes[bw.boneIndex1].MultiplyPoint3x4( baseMesh.vertices[i] );
                    nodeWeights[bw.boneIndex1].weights.Add( new CVertexWeight( i, localPt, bw.weight1 ) );
                }
                if (bw.weight2!=0.0f)
                {
                    localPt = baseMesh.bindposes[bw.boneIndex2].MultiplyPoint3x4( baseMesh.vertices[i] );
                    nodeWeights[bw.boneIndex2].weights.Add( new CVertexWeight( i, localPt, bw.weight2 ) );
                }
                if (bw.weight3!=0.0f)
                {
                    localPt = baseMesh.bindposes[bw.boneIndex3].MultiplyPoint3x4( baseMesh.vertices[i] );
                    nodeWeights[bw.boneIndex3].weights.Add( new CVertexWeight( i, localPt, bw.weight3 ) );
                }
            }

            UpdateCollisionMesh();
        }
        else
        {
            Debug.LogError(gameObject.name + ": SkinnedCollisionHelper: this object either has no SkinnedMeshRenderer or has no MeshCollider!");
        }
    }
    /// <summary>
    ///  This basically translates the information about the skinned mesh into
    /// data that we can internally use to quickly update the collision mesh.
    /// </summary>
    void Start()
    {
        skinnedMeshRenderer = GetComponent <SkinnedMeshRenderer>();
        meshCollider        = GetComponent <MeshCollider>();

        if (meshCollider != null && skinnedMeshRenderer != null)
        {
            // Cache used values rather than accessing straight from the mesh on the loop below
            Vector3[]    cachedVertices    = skinnedMeshRenderer.sharedMesh.vertices;
            Matrix4x4[]  cachedBindposes   = skinnedMeshRenderer.sharedMesh.bindposes;
            BoneWeight[] cachedBoneWeights = skinnedMeshRenderer.sharedMesh.boneWeights;

            // Make a CWeightList for each bone in the skinned mesh
            nodeWeights = new CWeightList[skinnedMeshRenderer.bones.Length];
            for (int i = 0; i < skinnedMeshRenderer.bones.Length; i++)
            {
                nodeWeights[i]           = new CWeightList();
                nodeWeights[i].transform = skinnedMeshRenderer.bones[i];
            }

            // Create a bone weight list for each bone, ready for quick calculation during an update...
            for (int i = 0; i < cachedVertices.Length; i++)
            {
                BoneWeight bw = cachedBoneWeights[i];
                if (bw.weight0 != 0.0f)
                {
                    Vector3 localPt = cachedBindposes[bw.boneIndex0].MultiplyPoint3x4(cachedVertices[i]);
                    nodeWeights[bw.boneIndex0].weights.Add(new CVertexWeight(i, localPt, bw.weight0));
                }
                if (bw.weight1 != 0.0f)
                {
                    Vector3 localPt = cachedBindposes[bw.boneIndex1].MultiplyPoint3x4(cachedVertices[i]);
                    nodeWeights[bw.boneIndex1].weights.Add(new CVertexWeight(i, localPt, bw.weight1));
                }
                if (bw.weight2 != 0.0f)
                {
                    Vector3 localPt = cachedBindposes[bw.boneIndex2].MultiplyPoint3x4(cachedVertices[i]);
                    nodeWeights[bw.boneIndex2].weights.Add(new CVertexWeight(i, localPt, bw.weight2));
                }
                if (bw.weight3 != 0.0f)
                {
                    Vector3 localPt = cachedBindposes[bw.boneIndex3].MultiplyPoint3x4(cachedVertices[i]);
                    nodeWeights[bw.boneIndex3].weights.Add(new CVertexWeight(i, localPt, bw.weight3));
                }
            }

            UpdateCollisionMesh();
        }
        else
        {
            Debug.LogError("[SkinnedCollisionHelper] " + gameObject.name + " is missing SkinnedMeshRenderer or MeshCollider!");
        }
    }
    /// <summary>
    ///  This basically translates the information about the skinned mesh into
    /// data that we can internally use to quickly update the collision mesh.
    /// </summary>
    void Start()
    {
        skinnedMeshRenderer = GetComponent<SkinnedMeshRenderer>();
        meshCollider = GetComponent<MeshCollider>();

        if (meshCollider != null && skinnedMeshRenderer != null)
        {
            // Cache used values rather than accessing straight from the mesh on the loop below
            Vector3[] cachedVertices = skinnedMeshRenderer.sharedMesh.vertices;
            Matrix4x4[] cachedBindposes = skinnedMeshRenderer.sharedMesh.bindposes;
            BoneWeight[] cachedBoneWeights = skinnedMeshRenderer.sharedMesh.boneWeights;

            // Make a CWeightList for each bone in the skinned mesh
            nodeWeights = new CWeightList[skinnedMeshRenderer.bones.Length];
            for ( int i = 0 ; i < skinnedMeshRenderer.bones.Length ; i++ )
            {
                nodeWeights[i] = new CWeightList();
                nodeWeights[i].transform = skinnedMeshRenderer.bones[i];
            }

            // Create a bone weight list for each bone, ready for quick calculation during an update...
            for ( int i = 0 ; i < cachedVertices.Length ; i++ )
            {
                BoneWeight bw = cachedBoneWeights[i];
                if (bw.weight0 != 0.0f)
                {
                    Vector3 localPt = cachedBindposes[bw.boneIndex0].MultiplyPoint3x4( cachedVertices[i] );
                    nodeWeights[bw.boneIndex0].weights.Add( new CVertexWeight( i, localPt, bw.weight0 ) );
                }
                if (bw.weight1 != 0.0f)
                {
                    Vector3 localPt = cachedBindposes[bw.boneIndex1].MultiplyPoint3x4( cachedVertices[i] );
                    nodeWeights[bw.boneIndex1].weights.Add( new CVertexWeight( i, localPt, bw.weight1 ) );
                }
                if (bw.weight2 != 0.0f)
                {
                    Vector3 localPt = cachedBindposes[bw.boneIndex2].MultiplyPoint3x4( cachedVertices[i] );
                    nodeWeights[bw.boneIndex2].weights.Add( new CVertexWeight( i, localPt, bw.weight2 ) );
                }
                if (bw.weight3 != 0.0f)
                {
                    Vector3 localPt = cachedBindposes[bw.boneIndex3].MultiplyPoint3x4( cachedVertices[i] );
                    nodeWeights[bw.boneIndex3].weights.Add( new CVertexWeight( i, localPt, bw.weight3 ) );
                }
            }

            UpdateCollisionMesh();
        }
        else
        {
            Debug.LogError("[SkinnedCollisionHelper] "+ gameObject.name +" is missing SkinnedMeshRenderer or MeshCollider!");
        }
    }