コード例 #1
0
        public void UpdateLods(MeshCombiner meshCombiner, int lodAmount)
        {
            if (lods != null && lods.Length == lodAmount)
            {
                return;
            }

            lods = new LOD[lodAmount];
            float[] newDistances = new float[lodAmount];

            for (int i = 0; i < lods.Length; i++)
            {
                lods[i] = new LOD();

                if (lodDistanceMode == LodDistanceMode.Automatic)
                {
                    newDistances[i] = meshCombiner.cellSize * i;
                }
                else if (distances != null && i < distances.Length)
                {
                    newDistances[i] = distances[i];
                }
            }

            distances = newDistances;
        }
コード例 #2
0
            public void CombineMeshes(MeshCombiner meshCombiner, int lodLevel)
            {
                if (level == maxLevels)
                {
                    MaxCell thisCell = (MaxCell)this;
                    LOD     lod      = thisCell.lods[lodLevel];

                    if (lod == null)
                    {
                        return;
                    }

                    for (int i = 0; i < lod.sortedMeshes.Count; ++i)
                    {
                        meshCombiner.CombineMeshes(lod.sortedMeshes[i], bounds.center);
                    }
                }
                else
                {
                    for (int i = 0; i < 8; ++i)
                    {
                        if (cellsUsed[i])
                        {
                            cells[i].CombineMeshes(meshCombiner, lodLevel);
                        }
                    }
                }
            }
コード例 #3
0
        void Awake()
        {
            instance     = this;
            meshCombiner = GetComponent <MeshCombiner>();
            meshCombinerList.Add(meshCombiner);

            QualitySettings.vSyncCount = 0;
        }
コード例 #4
0
ファイル: MeshCombiner.cs プロジェクト: Hengle/LD43
 void OnEnable()
 {
     if (thisInstance == null)
     {
         instances.Add(this);
         thisInstance = this;
     }
 }
コード例 #5
0
 // Token: 0x06003076 RID: 12406 RVA: 0x000CDC20 File Offset: 0x000CBE20
 public void ApplyChanges(MeshCombiner meshCombiner)
 {
     for (int i = 0; i < this.changedMeshObjectsHolders.Count; i++)
     {
         this.changedMeshObjectsHolders.items[i].hasChanged = false;
     }
     this.changedMeshObjectsHolders.Clear();
 }
コード例 #6
0
 public void ApplyChanges(MeshCombiner meshCombiner)
 {
     for (int i = 0; i < lodLevels.Length; i++)
     {
         lodLevels[i].ApplyChanges(meshCombiner);
     }
     hasChanged = false;
 }
コード例 #7
0
 public CachedGameObject AddObject(Vector3 position, MeshCombiner meshCombiner, CachedGameObject cachedGO, int lodParentIndex, int lodLevel, bool isChangeMode = false)
 {
     if (InsideBounds(position))
     {
         AddObjectInternal(meshCombiner, cachedGO, position, lodParentIndex, lodLevel, isChangeMode);
         return(cachedGO);
     }
     return(null);
 }
コード例 #8
0
 public void ApplyChanges(MeshCombiner meshCombiner)
 {
     for (int i = 0; i < changedMeshObjectsHolders.Count; i++)
     {
         MeshObjectsHolder meshObjectHolder = changedMeshObjectsHolders.items[i];
         meshObjectHolder.hasChanged = false;
     }
     changedMeshObjectsHolders.Clear();
 }
コード例 #9
0
 public void ApplyChanges(MeshCombiner meshCombiner)
 {
     for (int i = 0; i < changedLodParents.Count; i++)
     {
         changedLodParents[i].ApplyChanges(meshCombiner);
     }
     changedLodParents.Clear();
     hasChanged = false;
 }
コード例 #10
0
        void OnCombineReady(MeshCombiner meshCombiner)
        {
            foreach (var goLayer in gos)
            {
                goLayer.RestoreLayer();
            }

            gos.Clear();
        }
コード例 #11
0
            void AddObjectInternal(MeshCombiner meshCombiner, CachedGameObject cachedGO, Vector3 position, int lodParentIndex, int lodLevel, bool isChangeMode)
            {
                if (level == maxLevels)
                {
                    MaxCell thisCell = (MaxCell)this;

                    if (thisCell.lodParents == null)
                    {
                        thisCell.lodParents = new LODParent[10];
                    }
                    if (thisCell.lodParents[lodParentIndex] == null)
                    {
                        thisCell.lodParents[lodParentIndex] = new LODParent(lodParentIndex + 1);
                    }

                    LODParent lodParent = thisCell.lodParents[lodParentIndex];
                    LODLevel  lod       = lodParent.lodLevels[lodLevel];

                    lod.cachedGOs.Add(cachedGO);
                    if (isChangeMode)
                    {
                        if (SortObject(meshCombiner, lod, cachedGO))
                        {
                            if (!thisCell.hasChanged)
                            {
                                thisCell.hasChanged = true;
                                if (meshCombiner.changedCells == null)
                                {
                                    meshCombiner.changedCells = new List <MaxCell>();
                                }
                                meshCombiner.changedCells.Add(thisCell);
                            }
                            if (!lodParent.hasChanged)
                            {
                                lodParent.hasChanged = true;
                                thisCell.changedLodParents.Add(lodParent);
                            }
                        }
                    }

                    lod.objectCount++;

                    lod.vertCount += cachedGO.mesh.vertexCount;
                    return;
                }
                else
                {
                    bool maxCellCreated;
                    int  index = AddCell <Cell, MaxCell>(ref cells, position, out maxCellCreated);
                    if (maxCellCreated)
                    {
                        MaxCell.maxCellCount++;
                    }
                    cells[index].AddObjectInternal(meshCombiner, cachedGO, position, lodParentIndex, lodLevel, isChangeMode);
                }
            }
コード例 #12
0
            public void Draw(MeshCombiner meshCombiner, bool onlyMaxLevel, bool drawLevel0)
            {
                if (!onlyMaxLevel || level == maxLevels || (drawLevel0 && level == 0))
                {
                    Gizmos.DrawWireCube(bounds.center, bounds.size);

                    if (level == maxLevels)
                    {
                        if (meshCombiner.drawMeshBounds)
                        {
                            MaxCell thisCell = (MaxCell)this;

                            LODParent[] lodParents = thisCell.lodParents;

                            for (int i = 0; i < lodParents.Length; i++)
                            {
                                if (lodParents[i] == null)
                                {
                                    continue;
                                }

                                LODLevel[] lods = lodParents[i].lodLevels;

                                Gizmos.color = meshCombiner.activeOriginal ? Color.blue : Color.green;
                                for (int j = 0; j < lods.Length; j++)
                                {
                                    for (int k = 0; k < lods[j].cachedGOs.Count; k++)
                                    {
                                        if (lods[j].cachedGOs.items[k].mr == null)
                                        {
                                            continue;
                                        }
                                        Bounds meshBounds = lods[j].cachedGOs.items[k].mr.bounds;
                                        Gizmos.DrawWireCube(meshBounds.center, meshBounds.size);
                                    }
                                }
                                Gizmos.color = Color.white;
                            }
                            return;
                        }
                    }
                }

                if (cells == null || cellsUsed == null)
                {
                    return;
                }

                for (int i = 0; i < 8; i++)
                {
                    if (cellsUsed[i])
                    {
                        cells[i].Draw(meshCombiner, onlyMaxLevel, drawLevel0);
                    }
                }
            }
コード例 #13
0
ファイル: Console.cs プロジェクト: Hengle/LD43
 public LogEntry(string logString, string stackTrace, LogType logType, bool unityLog = false, int commandType = 0, GameObject go = null, MeshCombiner meshCombiner = null)
 {
     this.logString    = logString;
     this.stackTrace   = stackTrace;
     this.logType      = logType;
     this.unityLog     = unityLog;
     this.commandType  = commandType;
     this.go           = go;
     this.meshCombiner = meshCombiner;
     // tStamp = Time.time;
 }
コード例 #14
0
 // Token: 0x060024BA RID: 9402 RVA: 0x000B4028 File Offset: 0x000B2228
 public void UpdateDistances(MeshCombiner meshCombiner)
 {
     if (this.lodDistanceMode != CombinedLODManager.LodDistanceMode.Automatic)
     {
         return;
     }
     for (int i = 0; i < this.distances.Length; i++)
     {
         this.distances[i] = (float)(meshCombiner.cellSize * i);
     }
 }
コード例 #15
0
 // Token: 0x060024A6 RID: 9382 RVA: 0x000B3507 File Offset: 0x000B1707
 public void Init(MeshCombiner meshCombiner, int lodGroupParentIndex)
 {
     this.meshCombiner        = meshCombiner;
     this.lodGroupParentIndex = lodGroupParentIndex;
     this.lodCount            = lodGroupParentIndex + 1;
     if (this.lodGroup == null)
     {
         this.lodGroup = base.gameObject.AddComponent <LODGroup>();
     }
     this.GetSetup();
 }
コード例 #16
0
        public void UpdateDistances(MeshCombiner meshCombiner)
        {
            if (lodDistanceMode != LodDistanceMode.Automatic)
            {
                return;
            }

            for (int i = 0; i < distances.Length; i++)
            {
                distances[i] = meshCombiner.cellSize * i;
            }
        }
コード例 #17
0
            // Token: 0x0600307F RID: 12415 RVA: 0x000CDF0C File Offset: 0x000CC10C
            public bool SortObject(MeshCombiner meshCombiner, ObjectOctree.LODLevel lod, CachedGameObject cachedGO, bool isChangeMode = false)
            {
                if (cachedGO.mr == null)
                {
                    return(false);
                }
                if (lod.meshObjectsHoldersLookup == null)
                {
                    lod.meshObjectsHoldersLookup = new Dictionary <CombineCondition, MeshObjectsHolder>();
                }
                CombineConditionSettings combineConditionSettings = meshCombiner.combineConditionSettings;

                Material[] sharedMaterials = cachedGO.mr.sharedMaterials;
                int        num             = Mathf.Min(cachedGO.mesh.subMeshCount, sharedMaterials.Length);
                int        i = 0;

                while (i < num)
                {
                    Material material;
                    if (!combineConditionSettings.sameMaterial)
                    {
                        material = combineConditionSettings.material;
                        goto IL_75;
                    }
                    material = sharedMaterials[i];
                    if (!(material == null))
                    {
                        goto IL_75;
                    }
IL_119:
                    i++;
                    continue;
IL_75:
                    CombineCondition combineCondition = default(CombineCondition);
                    combineCondition.ReadFromGameObject(combineConditionSettings, meshCombiner.copyBakedLighting && meshCombiner.validCopyBakedLighting, cachedGO.go, cachedGO.mr, material);
                    MeshObjectsHolder meshObjectsHolder;
                    if (!lod.meshObjectsHoldersLookup.TryGetValue(combineCondition, out meshObjectsHolder))
                    {
                        meshCombiner.foundCombineConditions.combineConditions.Add(combineCondition);
                        meshObjectsHolder = new MeshObjectsHolder(ref combineCondition, material);
                        lod.meshObjectsHoldersLookup.Add(combineCondition, meshObjectsHolder);
                    }
                    meshObjectsHolder.meshObjects.Add(new MeshObject(cachedGO, i));
                    if (isChangeMode && !meshObjectsHolder.hasChanged)
                    {
                        meshObjectsHolder.hasChanged = true;
                        lod.changedMeshObjectsHolders.Add(meshObjectsHolder);
                        goto IL_119;
                    }
                    goto IL_119;
                }
                return(true);
            }
コード例 #18
0
            public bool SortObject(MeshCombiner meshCombiner, LODLevel lod, CachedGameObject cachedGO, bool isChangeMode = false)
            {
                if (cachedGO.mr == null)
                {
                    return(false);
                }

                if (lod.meshObjectsHolders == null)
                {
                    lod.meshObjectsHolders = new List <MeshObjectsHolder>();
                }

                Material[] mats = cachedGO.mr.sharedMaterials;

                // TODO check submeshes and material
                int length = Mathf.Min(cachedGO.mesh.subMeshCount, mats.Length);

                for (int l = 0; l < length; l++)
                {
                    Material mat = mats[l];
                    if (mat == null)
                    {
                        continue;
                    }

                    bool shadowCastingModeTwoSided = (cachedGO.mr.shadowCastingMode == UnityEngine.Rendering.ShadowCastingMode.TwoSided);
                    int  lightmapIndex             = meshCombiner.validCopyBakedLighting ? cachedGO.mr.lightmapIndex : -1;

                    int index = lod.GetSortMeshIndex(mat, shadowCastingModeTwoSided, lightmapIndex);

                    MeshObjectsHolder meshObjectHolder;
                    if (index == -1)
                    {
                        meshObjectHolder = new MeshObjectsHolder(cachedGO, mat, l, shadowCastingModeTwoSided, lightmapIndex);
                        lod.meshObjectsHolders.Add(meshObjectHolder);
                    }
                    else
                    {
                        meshObjectHolder = lod.meshObjectsHolders[index];
                        meshObjectHolder.meshObjects.Add(new MeshObject(cachedGO, l));
                    }

                    if (isChangeMode && !meshObjectHolder.hasChanged)
                    {
                        meshObjectHolder.hasChanged = true;
                        lod.changedMeshObjectsHolders.Add(meshObjectHolder);
                    }
                }

                return(true);
            }
コード例 #19
0
 // Token: 0x0600251C RID: 9500 RVA: 0x000B7634 File Offset: 0x000B5834
 private void ReportMeshCombiner(MeshCombiner meshCombiner, bool foundText = false)
 {
     Console.Log(string.Concat(new object[]
     {
         foundText ? "Found MCS -> " : "",
         meshCombiner.name,
         " (",
         meshCombiner.combined ? "*color-green#Combined" : "*color-blue#Uncombined",
         ") -> Cell Size ",
         meshCombiner.cellSize,
         meshCombiner.searchOptions.useMaxBoundsFactor ? (" | Max Bounds Factor " + meshCombiner.searchOptions.maxBoundsFactor) : "",
         meshCombiner.searchOptions.useVertexInputLimit ? (" | Vertex Input Limit " + (meshCombiner.searchOptions.useVertexInputLimit ? meshCombiner.searchOptions.vertexInputLimit : 65534)) : ""
     }), 0, null, meshCombiner);
 }
コード例 #20
0
 // Token: 0x06003080 RID: 12416 RVA: 0x000CE040 File Offset: 0x000CC240
 public void CombineMeshes(MeshCombiner meshCombiner, int lodParentIndex)
 {
     if (this.level != this.maxLevels)
     {
         for (int i = 0; i < 8; i++)
         {
             if (this.cellsUsed[i])
             {
                 this.cells[i].CombineMeshes(meshCombiner, lodParentIndex);
             }
         }
         return;
     }
     ObjectOctree.LODParent lodparent = ((ObjectOctree.MaxCell) this).lodParents[lodParentIndex];
     if (lodparent == null)
     {
         return;
     }
     lodparent.cellGO         = new GameObject(meshCombiner.useCells ? ("Cell " + this.bounds.center) : "Combined Objects");
     lodparent.cellT          = lodparent.cellGO.transform;
     lodparent.cellT.position = this.bounds.center;
     lodparent.cellT.parent   = meshCombiner.lodParentHolders[lodParentIndex].t;
     if (lodParentIndex > 0)
     {
         lodparent.lodGroup = lodparent.cellGO.AddComponent <LODGroup>();
         lodparent.lodGroup.localReferencePoint = (lodparent.cellT.position = this.bounds.center);
     }
     ObjectOctree.LODLevel[] lodLevels = lodparent.lodLevels;
     for (int j = 0; j < lodLevels.Length; j++)
     {
         ObjectOctree.LODLevel lodlevel = lodparent.lodLevels[j];
         if (lodlevel == null || lodlevel.meshObjectsHoldersLookup == null)
         {
             return;
         }
         Transform transform = null;
         if (lodParentIndex > 0)
         {
             transform        = new GameObject("LOD" + j).transform;
             transform.parent = lodparent.cellT;
         }
         foreach (MeshObjectsHolder meshObjectsHolder in lodlevel.meshObjectsHoldersLookup.Values)
         {
             meshObjectsHolder.lodParent = lodparent;
             meshObjectsHolder.lodLevel  = j;
             MeshCombineJobManager.instance.AddJob(meshCombiner, meshObjectsHolder, (lodParentIndex > 0) ? transform : lodparent.cellT, this.bounds.center);
         }
     }
 }
コード例 #21
0
            public void AssignLODGroup(MeshCombiner meshCombiner)
            {
                LOD[] lods = new LOD[lodLevels.Length];
                int   lodGroupParentIndex = lods.Length - 1;

                for (int i = 0; i < lodLevels.Length; i++)
                {
                    LODLevel lodLevel = lodLevels[i];
                    // Debug.Log(i + " " + lodLevel.newMeshRenderers.Count);
                    lods[i] = new LOD(meshCombiner.lodGroupsSettings[lodGroupParentIndex].lodSettings[i].screenRelativeTransitionHeight, lodLevel.newMeshRenderers.ToArray());
                }

                lodGroup.SetLODs(lods);
                lodGroup.size = meshCombiner.cellSize;
            }
コード例 #22
0
ファイル: MeshCombiner.cs プロジェクト: Hengle/LD43
        // ==========================================================================================================================

        void OnDestroy()
        {
            RestoreOriginalRenderersAndLODGroups();

            thisInstance = null;
            instances.Remove(this);

            // if (!Application.isPlaying && Application.isEditor) return;

            if (instances.Count == 0 && MeshCombineJobManager.instance != null)
            {
                Methods.Destroy(MeshCombineJobManager.instance.gameObject);
                MeshCombineJobManager.instance = null;
            }
        }
コード例 #23
0
            public void SortObjects(MeshCombiner meshCombiner)
            {
                if (level == maxLevels)
                {
                    MaxCell thisCell = (MaxCell)this;

                    LODParent[] lodParents = thisCell.lodParents;

                    for (int i = 0; i < lodParents.Length; i++)
                    {
                        LODParent lodParent = lodParents[i];
                        if (lodParent == null)
                        {
                            continue;
                        }

                        for (int j = 0; j < lodParent.lodLevels.Length; j++)
                        {
                            LODLevel lod = lodParent.lodLevels[j];

                            if (lod == null || lod.cachedGOs.Count == 0)
                            {
                                return;
                            }

                            for (int k = 0; k < lod.cachedGOs.Count; ++k)
                            {
                                CachedGameObject cachedGO = lod.cachedGOs.items[k];

                                if (!SortObject(meshCombiner, lod, cachedGO))
                                {
                                    lod.cachedGOs.RemoveAt(k--);
                                }
                            }
                        }
                    }
                }
                else
                {
                    for (int i = 0; i < 8; ++i)
                    {
                        if (cellsUsed[i])
                        {
                            cells[i].SortObjects(meshCombiner);
                        }
                    }
                }
            }
        void ApplyCombinedLock()
        {
            meshCombiner = (MeshCombiner)target;
            if (meshCombiner.transform.childCount == 0)
            {
                meshCombiner.combined = false;
            }

            if (!meshCombiner.combined)
            {
                return;
            }

            meshCombiner.transform.position   = meshCombiner.oldPosition;
            meshCombiner.transform.localScale = meshCombiner.oldScale;
        }
コード例 #25
0
            // Token: 0x0600307D RID: 12413 RVA: 0x000CDCEC File Offset: 0x000CBEEC
            private void AddObjectInternal(MeshCombiner meshCombiner, CachedGameObject cachedGO, Vector3 position, int lodParentIndex, int lodLevel, bool isChangeMode)
            {
                if (this.level == this.maxLevels)
                {
                    ObjectOctree.MaxCell maxCell = (ObjectOctree.MaxCell) this;
                    if (maxCell.lodParents == null)
                    {
                        maxCell.lodParents = new ObjectOctree.LODParent[10];
                    }
                    if (maxCell.lodParents[lodParentIndex] == null)
                    {
                        maxCell.lodParents[lodParentIndex] = new ObjectOctree.LODParent(lodParentIndex + 1);
                    }
                    ObjectOctree.LODParent lodparent = maxCell.lodParents[lodParentIndex];
                    ObjectOctree.LODLevel  lodlevel  = lodparent.lodLevels[lodLevel];
                    lodlevel.cachedGOs.Add(cachedGO);
                    if (isChangeMode && this.SortObject(meshCombiner, lodlevel, cachedGO, false))
                    {
                        if (!maxCell.hasChanged)
                        {
                            maxCell.hasChanged = true;
                            if (meshCombiner.changedCells == null)
                            {
                                meshCombiner.changedCells = new List <ObjectOctree.MaxCell>();
                            }
                            meshCombiner.changedCells.Add(maxCell);
                        }
                        if (!lodparent.hasChanged)
                        {
                            lodparent.hasChanged = true;
                            maxCell.changedLodParents.Add(lodparent);
                        }
                    }
                    lodlevel.objectCount++;
                    lodlevel.vertCount += cachedGO.mesh.vertexCount;
                    return;
                }
                bool flag;
                int  num = base.AddCell <ObjectOctree.Cell, ObjectOctree.MaxCell>(ref this.cells, position, out flag);

                if (flag)
                {
                    ObjectOctree.MaxCell.maxCellCount++;
                }
                this.cells[num].AddObjectInternal(meshCombiner, cachedGO, position, lodParentIndex, lodLevel, isChangeMode);
            }
コード例 #26
0
            // Token: 0x06003074 RID: 12404 RVA: 0x000CDB5C File Offset: 0x000CBD5C
            public void AssignLODGroup(MeshCombiner meshCombiner)
            {
                LOD[] array = new LOD[this.lodLevels.Length];
                int   num   = array.Length - 1;

                for (int i = 0; i < this.lodLevels.Length; i++)
                {
                    ObjectOctree.LODLevel lodlevel = this.lodLevels[i];
                    LOD[]      array2 = array;
                    int        num2   = i;
                    float      screenRelativeTransitionHeight = meshCombiner.lodGroupsSettings[num].lodSettings[i].screenRelativeTransitionHeight;
                    Renderer[] renderers = lodlevel.newMeshRenderers.ToArray();
                    array2[num2] = new LOD(screenRelativeTransitionHeight, renderers);
                }
                this.lodGroup.SetLODs(array);
                this.lodGroup.size = (float)meshCombiner.cellSize;
            }
コード例 #27
0
ファイル: Console.cs プロジェクト: Hengle/LD43
        public int SelectMeshCombiner(string name)
        {
            if (meshCombiners == null && meshCombiners.Length == 0)
            {
                return(0);
            }

            for (int i = 0; i < meshCombiners.Length; i++)
            {
                MeshCombiner meshCombiner = meshCombiners[i];
                if (meshCombiner.name == name)
                {
                    Log("Selected MCS -> " + meshCombiner.name + " (" + (meshCombiner.combined ? "*color-green#Combined" : "*color-blue#Uncombined") + ")", 0, null, meshCombiner);
                    selectedMeshCombiner = meshCombiner; return(2);
                }
            }
            return(0);
        }
コード例 #28
0
 // Token: 0x06003081 RID: 12417 RVA: 0x000CE228 File Offset: 0x000CC428
 public void Draw(MeshCombiner meshCombiner, bool onlyMaxLevel, bool drawLevel0)
 {
     if (!onlyMaxLevel || this.level == this.maxLevels || (drawLevel0 && this.level == 0))
     {
         Gizmos.DrawWireCube(this.bounds.center, this.bounds.size);
         if (this.level == this.maxLevels && meshCombiner.drawMeshBounds)
         {
             ObjectOctree.LODParent[] lodParents = ((ObjectOctree.MaxCell) this).lodParents;
             for (int i = 0; i < lodParents.Length; i++)
             {
                 if (lodParents[i] != null)
                 {
                     ObjectOctree.LODLevel[] lodLevels = lodParents[i].lodLevels;
                     Gizmos.color = (meshCombiner.activeOriginal ? Color.blue : Color.green);
                     for (int j = 0; j < lodLevels.Length; j++)
                     {
                         for (int k = 0; k < lodLevels[j].cachedGOs.Count; k++)
                         {
                             if (!(lodLevels[j].cachedGOs.items[k].mr == null))
                             {
                                 Bounds bounds = lodLevels[j].cachedGOs.items[k].mr.bounds;
                                 Gizmos.DrawWireCube(bounds.center, bounds.size);
                             }
                         }
                     }
                     Gizmos.color = Color.white;
                 }
             }
             return;
         }
     }
     if (this.cells == null || this.cellsUsed == null)
     {
         return;
     }
     for (int l = 0; l < 8; l++)
     {
         if (this.cellsUsed[l])
         {
             this.cells[l].Draw(meshCombiner, onlyMaxLevel, drawLevel0);
         }
     }
 }
コード例 #29
0
        void Unregister()
        {
            if (!hasRegistered)
            {
                return;
            }
            hasRegistered = false;
            OnCombineReady(null);

            MeshCombiner.onInit -= Init;

            for (int i = 0; i < MeshCombiner.instances.Count; i++)
            {
                MeshCombiner meshCombiner = MeshCombiner.instances[i];
                meshCombiner.onCombiningStart -= OnCombine;
                meshCombiner.onCombiningAbort -= OnCombineReady;
                meshCombiner.onCombiningReady -= OnCombineReady;
            }
        }
コード例 #30
0
        private void OnGUI()
        {
            GUI.color = Color.red;
            GUI.Label(new Rect(10, 10, 200, 20), "Toggle with '" + meshCombiner.combineSwapKey.ToString() + "' key.");

            for (int i = 0; i < meshCombinerList.Count; i++)
            {
                MeshCombiner meshCombiner = meshCombinerList[i];
                if (meshCombiner.combinedActive)
                {
                    GUI.Label(new Rect(10, 30 + (i * 20), 300, 20), meshCombiner.gameObject.name + " is Enabled.");
                }
                else
                {
                    GUI.Label(new Rect(10, 30 + (i * 20), 300, 20), meshCombiner.gameObject.name + " is Disabled.");
                }
            }
            GUI.color = Color.white;
        }