private void AddMeshVertex2Generate(SkinnedMeshRenderer[] meshRender, Transform[] boneTransform, Matrix4x4[] bindPose) { boneCount = boneTransform.Length; textureBlockWidth = 4; textureBlockHeight = boneCount; for (int i = 0; i != meshRender.Length; ++i) { Mesh m = meshRender[i].sharedMesh; if (m == null) { continue; } int nameCode = meshRender[i].name.GetHashCode(); if (generateVertexCachePool.ContainsKey(nameCode)) { continue; } VertexCache vertexCache = new VertexCache(); generateVertexCachePool[nameCode] = vertexCache; vertexCache.nameCode = nameCode; vertexCache.bonePose = boneTransform; vertexCache.bindPose = bindPose; break; } }
public VertexCache FindVertexCache(int renderName) { VertexCache cache = null; vertexCachePool.TryGetValue(renderName, out cache); return(cache); }
public void BindAttachment(VertexCache parentCache, VertexCache attachmentCache, Mesh sharedMesh, int boneIndex) { Matrix4x4 mat = parentCache.bindPose[boneIndex].inverse; attachmentCache.mesh = Instantiate(sharedMesh); Vector3 offset = mat.GetColumn(3); Quaternion q = RuntimeHelper.QuaternionFromMatrix(mat); Vector3[] vertices = attachmentCache.mesh.vertices; for (int k = 0; k != attachmentCache.mesh.vertexCount; ++k) { vertices[k] = q * vertices[k]; vertices[k] = vertices[k] + offset; } attachmentCache.mesh.vertices = vertices; for (int j = 0; j != attachmentCache.mesh.vertexCount; ++j) { attachmentCache.weight[j].x = 1.0f; attachmentCache.weight[j].y = -0.1f; attachmentCache.weight[j].z = -0.1f; attachmentCache.weight[j].w = -0.1f; attachmentCache.boneIndex[j].x = boneIndex; } }
private void GenerateBoneMatrix(int nameCode, int stateName, float stateTime, Matrix4x4 rootMatrix1stFrame, bool rootMotion) { UnityEngine.Profiling.Profiler.BeginSample("AddBoneMatrix()"); VertexCache vertexCache = null; bool find = generateVertexCachePool.TryGetValue(nameCode, out vertexCache); if (!find) { return; } GenerateOjbectInfo matrixData = generateObjectData[currentDataIndex++]; matrixData.nameCode = nameCode; matrixData.stateName = stateName; matrixData.animationTime = stateTime; matrixData.worldMatrix = Matrix4x4.identity; matrixData.frameIndex = -1; matrixData.boneListIndex = -1; UnityEngine.Profiling.Profiler.BeginSample("AddBoneMatrix:update the matrix"); if (generateMatrixDataPool.ContainsKey(stateName)) { ArrayList list = generateMatrixDataPool[stateName]; matrixData.boneMatrix = UtilityHelper.CalculateSkinMatrix( vertexCache.bonePose, vertexCache.bindPose, rootMatrix1stFrame, rootMotion); GenerateOjbectInfo data = new GenerateOjbectInfo(); UtilityHelper.CopyMatrixData(data, matrixData); list.Add(data); } else { UnityEngine.Profiling.Profiler.BeginSample("AddBoneMatrix:ContainsKey"); matrixData.boneMatrix = UtilityHelper.CalculateSkinMatrix( vertexCache.bonePose, vertexCache.bindPose, rootMatrix1stFrame, rootMotion); ArrayList list = new ArrayList(); GenerateOjbectInfo data = new GenerateOjbectInfo(); UtilityHelper.CopyMatrixData(data, matrixData); list.Add(data); generateMatrixDataPool[stateName] = list; UnityEngine.Profiling.Profiler.EndSample(); } UnityEngine.Profiling.Profiler.EndSample(); UnityEngine.Profiling.Profiler.EndSample(); }
int GetPackageCount(VertexCache vertexCache) { int packageCount = 1; if (vertexCache.boneTextureIndex >= 0) { AnimationTexture texture = animationTextureList[vertexCache.boneTextureIndex]; packageCount = texture.boneTexture.Length; } return(packageCount); }
public void PreparePackageMaterial(InstancingPackage package, VertexCache vertexCache, int aniTextureIndex) { if (vertexCache.boneTextureIndex < 0) { return; } for (int i = 0; i != package.subMeshCount; ++i) { AnimationTexture texture = animationTextureList[vertexCache.boneTextureIndex]; package.material[i].SetTexture("_boneTexture", texture.boneTexture[aniTextureIndex]); package.material[i].SetInt("_boneTextureWidth", texture.boneTexture[aniTextureIndex].width); package.material[i].SetInt("_boneTextureHeight", texture.boneTexture[aniTextureIndex].height); package.material[i].SetInt("_boneTextureBlockWidth", texture.blockWidth); package.material[i].SetInt("_boneTextureBlockHeight", texture.blockHeight); } }
private void RefreshAttachmentAnimation(int index) { for (int k = 0; k != listAttachment.Count; ++k) { AnimationInstancing attachment = listAttachment[k]; //attachment.aniIndex = aniIndex; for (int i = 0; i != attachment.lodInfo.Length; ++i) { LodInfo info = attachment.lodInfo[i]; for (int j = 0; j != info.meshRenderer.Length; ++j) { //MeshRenderer render = info.meshRenderer[j]; VertexCache cache = info.vertexCacheList[info.skinnedMeshRenderer.Length + j]; cache.boneTextureIndex = index; } } } }
public void SetupAdditionalData(VertexCache vertexCache) { Color[] colors = new Color[vertexCache.weight.Length]; for (int i = 0; i != colors.Length; ++i) { colors[i].r = vertexCache.weight[i].x; colors[i].g = vertexCache.weight[i].y; colors[i].b = vertexCache.weight[i].z; colors[i].a = vertexCache.weight[i].w; } vertexCache.mesh.colors = colors; List <Vector4> uv2 = new List <Vector4>(vertexCache.boneIndex.Length); for (int i = 0; i != vertexCache.boneIndex.Length; ++i) { uv2.Add(vertexCache.boneIndex[i]); } vertexCache.mesh.SetUVs(2, uv2); vertexCache.mesh.UploadMeshData(false); }
MaterialBlock CreateBlock(VertexCache cache, Material[] materials) { MaterialBlock block = new MaterialBlock(); int packageCount = GetPackageCount(cache); block.instanceData = CreateInstanceData(packageCount); block.packageList = new List <InstancingPackage> [packageCount]; for (int i = 0; i != block.packageList.Length; ++i) { block.packageList[i] = new List <InstancingPackage>(); InstancingPackage package = CreatePackage(block.instanceData, cache.mesh, materials, i); block.packageList[i].Add(package); PreparePackageMaterial(package, cache, i); package.instancingCount = 1; } block.runtimePackageIndex = new int[packageCount]; return(block); }
private VertexCache CreateVertexCache(string prefabName, int renderName, int alias, Mesh mesh) { VertexCache vertexCache = new VertexCache(); int cacheName = renderName + alias; vertexCachePool[cacheName] = vertexCache; vertexCache.nameCode = cacheName; vertexCache.mesh = mesh; vertexCache.boneTextureIndex = FindTexture_internal(prefabName); vertexCache.weight = new Vector4[mesh.vertexCount]; vertexCache.boneIndex = new Vector4[mesh.vertexCount]; int packageCount = GetPackageCount(vertexCache); InstanceData data = null; int instanceName = prefabName.GetHashCode() + alias; if (!instanceDataPool.TryGetValue(instanceName, out data)) { data = CreateInstanceData(packageCount); instanceDataPool.Add(instanceName, data); } vertexCache.instanceBlockList = new Dictionary <int, MaterialBlock>(); return(vertexCache); }
void RefreshMaterial() { if (vertexCachePool == null) { return; } foreach (var obj in vertexCachePool) { VertexCache cache = obj.Value; foreach (var block in cache.instanceBlockList) { for (int j = 0; j != block.Value.packageList.Length; ++j) { for (int k = 0; k != block.Value.packageList[j].Count; ++k) { InstancingPackage package = block.Value.packageList[j][k]; PreparePackageMaterial(package, cache, j); } } } } }
private void SetupVertexCache(VertexCache vertexCache, MaterialBlock block, MeshRenderer render, Mesh mesh, Transform[] boneTransform, int bonePerVertex) { int boneIndex = -1; if (boneTransform != null) { for (int k = 0; k != boneTransform.Length; ++k) { if (render.transform.parent.name.GetHashCode() == boneTransform[k].name.GetHashCode()) { boneIndex = k; break; } } } if (boneIndex >= 0) { //todo BindAttachment(vertexCache, vertexCache, vertexCache.mesh, boneIndex); } if (vertexCache.materials == null) { vertexCache.materials = render.sharedMaterials; } SetupAdditionalData(vertexCache); for (int i = 0; i != block.packageList.Length; ++i) { InstancingPackage package = CreatePackage(block.instanceData, vertexCache.mesh, render.sharedMaterials, i); block.packageList[i].Add(package); PreparePackageMaterial(package, vertexCache, i); } }
public void Attach(string boneName, AnimationInstancing attachment) { int index = -1; int hashBone = boneName.GetHashCode(); for (int i = 0; i != allTransforms.Length; ++i) { if (allTransforms[i].name.GetHashCode() == hashBone) { index = i; break; } } Debug.Assert(index >= 0); if (index < 0) { Debug.LogError("Can't find the bone."); return; } if (attachment.lodInfo[0].meshRenderer.Length == 0 && attachment.lodInfo[0].skinnedMeshRenderer.Length == 0) { Debug.LogError("The attachment doesn't have a Renderer"); return; } attachment.parentInstance = this; VertexCache parentCache = AnimationInstancingMgr.Instance.FindVertexCache(lodInfo[0].skinnedMeshRenderer[0].name.GetHashCode()); listAttachment.Add(attachment); int nameCode = boneName.GetHashCode(); nameCode += attachment.lodInfo[0].meshRenderer.Length > 0 ? attachment.lodInfo[0].meshRenderer[0].name.GetHashCode() : 0; if (attachment.lodInfo[0].meshRenderer.Length == 0) { //todo, to support the attachment that has skinnedMeshRenderer; int skinnedMeshRenderCount = attachment.lodInfo[0].skinnedMeshRenderer.Length; nameCode += skinnedMeshRenderCount > 0 ? attachment.lodInfo[0].skinnedMeshRenderer[0].name.GetHashCode() : 0; } VertexCache cache = AnimationInstancingMgr.Instance.FindVertexCache(nameCode); // if we can reuse the VertexCache, we don't need to create one if (cache != null) { cache.boneTextureIndex = parentCache.boneTextureIndex; return; } AnimationInstancingMgr.Instance.AddMeshVertex(attachment.aniFilename, attachment.lodInfo, null, null, attachment.bonePerVertex, boneName); for (int i = 0; i != attachment.lodInfo.Length; ++i) { LodInfo info = attachment.lodInfo[i]; for (int j = 0; j != info.meshRenderer.Length; ++j) { cache = info.vertexCacheList[info.skinnedMeshRenderer.Length + j]; Debug.Assert(cache != null); if (cache == null) { Debug.LogError("Can't find the VertexCache."); continue; } Debug.Assert(cache.boneTextureIndex < 0 || cache.boneIndex[0].x != index); AnimationInstancingMgr.Instance.BindAttachment(parentCache, cache, info.meshFilter[j].sharedMesh, index); AnimationInstancingMgr.Instance.SetupAdditionalData(cache); cache.boneTextureIndex = parentCache.boneTextureIndex; } } }
void ApplyBoneMatrix() { Vector3 cameraPosition = cameraTransform.position; for (int i = 0; i != aniInstancingList.Count; ++i) { AnimationInstancing instance = aniInstancingList[i]; if (!instance.IsPlaying()) { continue; } if (instance.aniIndex < 0 && instance.parentInstance == null) { continue; } if (instance.applyRootMotion) { ApplyRootMotion(instance); } instance.UpdateAnimation(); instance.boundingSpere.position = instance.worldTransform.position; boundingSphere[i] = instance.boundingSpere; if (!instance.visible) { continue; } instance.UpdateLod(cameraPosition); AnimationInstancing.LodInfo lod = instance.lodInfo[instance.lodLevel]; int aniTextureIndex = -1; if (instance.parentInstance != null) { aniTextureIndex = instance.parentInstance.aniTextureIndex; } else { aniTextureIndex = instance.aniTextureIndex; } Matrix4x4 worldMat = instance.worldTransform.localToWorldMatrix; for (int j = 0; j != lod.vertexCacheList.Length; ++j) { VertexCache cache = lod.vertexCacheList[j]; MaterialBlock block = lod.materialBlockList[j]; Debug.Assert(block != null); int packageIndex = block.runtimePackageIndex[aniTextureIndex]; Debug.Assert(packageIndex < block.packageList[aniTextureIndex].Count); InstancingPackage package = block.packageList[aniTextureIndex][packageIndex]; if (package.instancingCount + 1 > instancingPackageSize) { ++block.runtimePackageIndex[aniTextureIndex]; packageIndex = block.runtimePackageIndex[aniTextureIndex]; if (packageIndex >= block.packageList[aniTextureIndex].Count) { InstancingPackage newPackage = CreatePackage(block.instanceData, cache.mesh, cache.materials, aniTextureIndex); block.packageList[aniTextureIndex].Add(newPackage); PreparePackageMaterial(newPackage, cache, aniTextureIndex); newPackage.instancingCount = 1; } block.packageList[aniTextureIndex][packageIndex].instancingCount = 1; } else { ++package.instancingCount; } { VertexCache vertexCache = cache; InstanceData data = block.instanceData; int index = block.runtimePackageIndex[aniTextureIndex]; InstancingPackage pkg = block.packageList[aniTextureIndex][index]; int count = pkg.instancingCount - 1; if (count >= 0) { Matrix4x4[] arrayMat = data.worldMatrix[aniTextureIndex][index]; arrayMat[count].m00 = worldMat.m00; arrayMat[count].m01 = worldMat.m01; arrayMat[count].m02 = worldMat.m02; arrayMat[count].m03 = worldMat.m03; arrayMat[count].m10 = worldMat.m10; arrayMat[count].m11 = worldMat.m11; arrayMat[count].m12 = worldMat.m12; arrayMat[count].m13 = worldMat.m13; arrayMat[count].m20 = worldMat.m20; arrayMat[count].m21 = worldMat.m21; arrayMat[count].m22 = worldMat.m22; arrayMat[count].m23 = worldMat.m23; arrayMat[count].m30 = worldMat.m30; arrayMat[count].m31 = worldMat.m31; arrayMat[count].m32 = worldMat.m32; arrayMat[count].m33 = worldMat.m33; float frameIndex = 0, preFrameIndex = -1, transition = 0f; if (instance.parentInstance != null) { frameIndex = instance.parentInstance.aniInfo[instance.parentInstance.aniIndex].animationIndex + instance.parentInstance.curFrame; if (instance.parentInstance.preAniIndex >= 0) { preFrameIndex = instance.parentInstance.aniInfo[instance.parentInstance.preAniIndex].animationIndex + instance.parentInstance.preAniFrame; } transition = instance.parentInstance.transitionProgress; } else { frameIndex = instance.aniInfo[instance.aniIndex].animationIndex + instance.curFrame; if (instance.preAniIndex >= 0) { preFrameIndex = instance.aniInfo[instance.preAniIndex].animationIndex + instance.preAniFrame; } transition = instance.transitionProgress; } data.frameIndex[aniTextureIndex][index][count] = frameIndex; data.preFrameIndex[aniTextureIndex][index][count] = preFrameIndex; data.transitionProgress[aniTextureIndex][index][count] = transition; } } } } }
private void Render() { foreach (var obj in vertexCachePool) { VertexCache vertexCache = obj.Value; foreach (var block in vertexCache.instanceBlockList) { List <InstancingPackage>[] packageList = block.Value.packageList; for (int k = 0; k != packageList.Length; ++k) { for (int i = 0; i != packageList[k].Count; ++i) { InstancingPackage package = packageList[k][i]; if (package.instancingCount == 0) { continue; } for (int j = 0; j != package.subMeshCount; ++j) { InstanceData data = block.Value.instanceData; if (useInstancing) { #if UNITY_EDITOR PreparePackageMaterial(package, vertexCache, k); #endif package.propertyBlock.SetFloatArray("frameIndex", data.frameIndex[k][i]); package.propertyBlock.SetFloatArray("preFrameIndex", data.preFrameIndex[k][i]); package.propertyBlock.SetFloatArray("transitionProgress", data.transitionProgress[k][i]); Graphics.DrawMeshInstanced(vertexCache.mesh, j, package.material[j], data.worldMatrix[k][i], package.instancingCount, package.propertyBlock, vertexCache.shadowcastingMode, vertexCache.receiveShadow, vertexCache.layer); } else { package.material[j].SetFloat("frameIndex", data.frameIndex[k][i][0]); package.material[j].SetFloat("preFrameIndex", data.preFrameIndex[k][i][0]); package.material[j].SetFloat("transitionProgress", data.transitionProgress[k][i][0]); Graphics.DrawMesh(vertexCache.mesh, data.worldMatrix[k][i][0], package.material[j], 0, null, j); } } package.instancingCount = 0; } block.Value.runtimePackageIndex[k] = 0; } } // if (obj.Value.instancingData == null) // continue; // vertexCache.bufInstance.SetData(obj.Value.instancingData); // // for (int i = 0; i != vertexCache.subMeshCount; ++i) // { // Material material = vertexCache.instanceMaterial[i]; // material.SetBuffer("buf_InstanceMatrices", vertexCache.bufInstance); // vertexCache.args[i][1] = (uint)vertexCache.currentInstancingIndex; // vertexCache.bufArgs[i].SetData(vertexCache.args[i]); // // Graphics.DrawMeshInstancedIndirect(vertexCache.mesh, // i, // vertexCache.instanceMaterial[i], // new Bounds(Vector3.zero, new Vector3(10000.0f, 10000.0f, 10000.0f)), // vertexCache.bufArgs[i]); // } // vertexCache.currentInstancingIndex = 0; } }
private void SetupVertexCache(VertexCache vertexCache, MaterialBlock block, SkinnedMeshRenderer render, Transform[] boneTransform, int bonePerVertex) { int[] boneIndex = null; if (render.bones.Length != boneTransform.Length) { if (render.bones.Length == 0) { boneIndex = new int[1]; int hashRenderParentName = render.transform.parent.name.GetHashCode(); for (int k = 0; k != boneTransform.Length; ++k) { if (hashRenderParentName == boneTransform[k].name.GetHashCode()) { boneIndex[0] = k; break; } } } else { boneIndex = new int[render.bones.Length]; for (int j = 0; j != render.bones.Length; ++j) { boneIndex[j] = -1; Transform trans = render.bones[j]; int hashTransformName = trans.name.GetHashCode(); for (int k = 0; k != boneTransform.Length; ++k) { if (hashTransformName == boneTransform[k].name.GetHashCode()) { boneIndex[j] = k; break; } } } if (boneIndex.Length == 0) { boneIndex = null; } } } UnityEngine.Profiling.Profiler.BeginSample("Copy the vertex data in SetupVertexCache()"); Mesh m = render.sharedMesh; BoneWeight[] boneWeights = m.boneWeights; Debug.Assert(boneWeights.Length > 0); for (int j = 0; j != m.vertexCount; ++j) { vertexCache.weight[j].x = boneWeights[j].weight0; Debug.Assert(vertexCache.weight[j].x > 0.0f); vertexCache.weight[j].y = boneWeights[j].weight1; vertexCache.weight[j].z = boneWeights[j].weight2; vertexCache.weight[j].w = boneWeights[j].weight3; vertexCache.boneIndex[j].x = boneIndex == null ? boneWeights[j].boneIndex0 : boneIndex[boneWeights[j].boneIndex0]; vertexCache.boneIndex[j].y = boneIndex == null ? boneWeights[j].boneIndex1 : boneIndex[boneWeights[j].boneIndex1]; vertexCache.boneIndex[j].z = boneIndex == null ? boneWeights[j].boneIndex2 : boneIndex[boneWeights[j].boneIndex2]; vertexCache.boneIndex[j].w = boneIndex == null ? boneWeights[j].boneIndex3 : boneIndex[boneWeights[j].boneIndex3]; Debug.Assert(vertexCache.boneIndex[j].x >= 0); if (bonePerVertex == 3) { float rate = 1.0f / (vertexCache.weight[j].x + vertexCache.weight[j].y + vertexCache.weight[j].z); vertexCache.weight[j].x = vertexCache.weight[j].x * rate; vertexCache.weight[j].y = vertexCache.weight[j].y * rate; vertexCache.weight[j].z = vertexCache.weight[j].z * rate; vertexCache.weight[j].w = -0.1f; } else if (bonePerVertex == 2) { float rate = 1.0f / (vertexCache.weight[j].x + vertexCache.weight[j].y); vertexCache.weight[j].x = vertexCache.weight[j].x * rate; vertexCache.weight[j].y = vertexCache.weight[j].y * rate; vertexCache.weight[j].z = -0.1f; vertexCache.weight[j].w = -0.1f; } else if (bonePerVertex == 1) { vertexCache.weight[j].x = 1.0f; vertexCache.weight[j].y = -0.1f; vertexCache.weight[j].z = -0.1f; vertexCache.weight[j].w = -0.1f; } } UnityEngine.Profiling.Profiler.EndSample(); if (vertexCache.materials == null) { vertexCache.materials = render.sharedMaterials; } SetupAdditionalData(vertexCache); for (int i = 0; i != block.packageList.Length; ++i) { InstancingPackage package = CreatePackage(block.instanceData, vertexCache.mesh, render.sharedMaterials, i); block.packageList[i].Add(package); //vertexCache.packageList[i].Add(package); PreparePackageMaterial(package, vertexCache, i); } }
// alias is to use for attachment, it should be a bone name public void AddMeshVertex(string prefabName, AnimationInstancing.LodInfo[] lodInfo, Transform[] bones, List <Matrix4x4> bindPose, int bonePerVertex, string alias = null) { UnityEngine.Profiling.Profiler.BeginSample("AddMeshVertex()"); for (int x = 0; x != lodInfo.Length; ++x) { AnimationInstancing.LodInfo lod = lodInfo[x]; for (int i = 0; i != lod.skinnedMeshRenderer.Length; ++i) { Mesh m = lod.skinnedMeshRenderer[i].sharedMesh; if (m == null) { continue; } int nameCode = lod.skinnedMeshRenderer[i].name.GetHashCode(); int identify = GetIdentify(lod.skinnedMeshRenderer[i].sharedMaterials); VertexCache cache = null; if (vertexCachePool.TryGetValue(nameCode, out cache)) { MaterialBlock block = null; if (!cache.instanceBlockList.TryGetValue(identify, out block)) { block = CreateBlock(cache, lod.skinnedMeshRenderer[i].sharedMaterials); cache.instanceBlockList.Add(identify, block); } lod.vertexCacheList[i] = cache; lod.materialBlockList[i] = block; continue; } VertexCache vertexCache = CreateVertexCache(prefabName, nameCode, 0, m); vertexCache.bindPose = bindPose.ToArray(); MaterialBlock matBlock = CreateBlock(vertexCache, lod.skinnedMeshRenderer[i].sharedMaterials); vertexCache.instanceBlockList.Add(identify, matBlock); SetupVertexCache(vertexCache, matBlock, lod.skinnedMeshRenderer[i], bones, bonePerVertex); lod.vertexCacheList[i] = vertexCache; lod.materialBlockList[i] = matBlock; } for (int i = 0, j = lod.skinnedMeshRenderer.Length; i != lod.meshRenderer.Length; ++i, ++j) { Mesh m = lod.meshFilter[i].sharedMesh; if (m == null) { continue; } int renderName = lod.meshRenderer[i].name.GetHashCode(); int aliasName = (alias != null ? alias.GetHashCode() : 0); int identify = GetIdentify(lod.meshRenderer[i].sharedMaterials); VertexCache cache = null; if (vertexCachePool.TryGetValue(renderName + aliasName, out cache)) { MaterialBlock block = null; if (!cache.instanceBlockList.TryGetValue(identify, out block)) { block = CreateBlock(cache, lod.meshRenderer[i].sharedMaterials); cache.instanceBlockList.Add(identify, block); } lod.vertexCacheList[j] = cache; lod.materialBlockList[j] = block; continue; } VertexCache vertexCache = CreateVertexCache(prefabName, renderName, aliasName, m); if (bindPose != null) { vertexCache.bindPose = bindPose.ToArray(); } MaterialBlock matBlock = CreateBlock(vertexCache, lod.meshRenderer[i].sharedMaterials); vertexCache.instanceBlockList.Add(identify, matBlock); SetupVertexCache(vertexCache, matBlock, lod.meshRenderer[i], m, bones, bonePerVertex); lod.vertexCacheList[lod.skinnedMeshRenderer.Length + i] = vertexCache; lod.materialBlockList[lod.skinnedMeshRenderer.Length + i] = matBlock; } } UnityEngine.Profiling.Profiler.EndSample(); }