void AddTransforms(Transform[] transforms, bool useSearchOptions = true)
{
int uniqueLodObjectsCount = uniqueLodObjects.Count;
for (int i = 0; i < transforms.Length; i++)
{
Transform t = transforms[i];
if (uniqueLodObjectsCount > 0 && uniqueLodObjects.Contains(t))
{
continue;
}
CachedGameObject cachedGO = null;
if (ValidObject(t, ObjectType.Normal, useSearchOptions, ref cachedGO) == 1)
{
if (!hasFoundFirstObject)
{
bounds.center = cachedGO.mr.bounds.center; hasFoundFirstObject = true;
}
bounds.Encapsulate(cachedGO.mr.bounds);
foundObjects.Add(cachedGO);
lodParentHolders[0].lods[0]++;
}
}
if (foundObjects.Count > 0)
{
lodParentHolders[0].found = true;
}
// Debug.Log("Count " + count);
// Debug.Log(foundObjects.Count);
}
public void AddFoundObjectsToOctree()
{
if (foundObjects.Count > 0 || foundLodObjects.Count > 0)
{
octreeContainsObjects = true;
}
else
{
Debug.Log("No matching GameObjects with chosen search options are found for combining.");
return;
}
foundMaterials.Clear();
CalcOctreeSize(bounds);
ObjectOctree.MaxCell.maxCellCount = 0;
for (int i = 0; i < foundObjects.Count; i++)
{
CachedGameObject foundObject = foundObjects[i];
AddFoundMaterials(foundObject.mr);
Vector3 position = (searchOptions.objectCenter == ObjectCenter.TransformPosition ? foundObject.t.position : foundObject.mr.bounds.center);
octree.AddObject(position, this, foundObject, 0, 0);
}
for (int i = 0; i < foundLodObjects.Count; i++)
{
CachedLodGameObject cachedLodGO = foundLodObjects[i];
AddFoundMaterials(cachedLodGO.mr);
octree.AddObject(cachedLodGO.center, this, cachedLodGO, cachedLodGO.lodCount, cachedLodGO.lodLevel);
}
foundMaterialsCount = foundMaterials.Count;
}
public MeshObjectsHolder(CachedGameObject cachedGO, Material mat, int subMeshIndex, bool shadowCastingModeTwoSided, int lightmapIndex)
{
// Debug.Log(useForLightmapping);
this.mat = mat;
this.shadowCastingModeTwoSided = shadowCastingModeTwoSided;
this.lightmapIndex = lightmapIndex;
meshObjects.Add(new MeshObject(cachedGO, subMeshIndex));
}
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);
}
}
public MeshObject(CachedGameObject cachedGO, int subMeshIndex)
{
this.cachedGO = cachedGO;
this.subMeshIndex = subMeshIndex;
Transform t = cachedGO.t;
position = t.position;
rotation = t.rotation;
scale = t.lossyScale;
lightmapScaleOffset = cachedGO.mr.lightmapScaleOffset;
}
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);
}
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);
}
}
}
}
// 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);
}
// Token: 0x0600307E RID: 12414 RVA: 0x000CDE1C File Offset: 0x000CC01C
public void SortObjects(MeshCombiner meshCombiner)
{
if (this.level == this.maxLevels)
{
foreach (ObjectOctree.LODParent lodparent in ((ObjectOctree.MaxCell) this).lodParents)
{
if (lodparent != null)
{
for (int j = 0; j < lodparent.lodLevels.Length; j++)
{
ObjectOctree.LODLevel lodlevel = lodparent.lodLevels[j];
if (lodlevel == null || lodlevel.cachedGOs.Count == 0)
{
return;
}
for (int k = 0; k < lodlevel.cachedGOs.Count; k++)
{
CachedGameObject cachedGO = lodlevel.cachedGOs.items[k];
if (!this.SortObject(meshCombiner, lodlevel, cachedGO, false))
{
lodlevel.cachedGOs.RemoveAt(k--);
}
}
}
}
}
return;
}
for (int l = 0; l < 8; l++)
{
if (this.cellsUsed[l])
{
this.cells[l].SortObjects(meshCombiner);
}
}
}
public bool SortObject(MeshCombiner meshCombiner, LODLevel lod, CachedGameObject cachedGO, bool isChangeMode = false)
{
if (cachedGO.mr == null)
{
return(false);
}
if (lod.meshObjectsHoldersLookup == null)
{
lod.meshObjectsHoldersLookup = new Dictionary <CombineCondition, MeshObjectsHolder>();
}
CombineConditionSettings combineConditions = meshCombiner.combineConditionSettings;
Material[] mats = cachedGO.mr.sharedMaterials;
// TODO check submeshes and material
int length = Mathf.Min(cachedGO.mesh.subMeshCount, mats.Length);
int rootInstanceId = -1;
if (meshCombiner.combineMode == CombineMode.DynamicObjects)
{
rootInstanceId = cachedGO.rootInstanceId;
if (rootInstanceId == -1)
{
cachedGO.GetRoot();
rootInstanceId = cachedGO.rootInstanceId;
}
}
for (int l = 0; l < length; l++)
{
Material mat;
if (combineConditions.sameMaterial)
{
mat = mats[l];
if (mat == null)
{
continue;
}
}
else
{
mat = combineConditions.material;
}
CombineCondition combineCondition = new CombineCondition();
combineCondition.ReadFromGameObject(rootInstanceId, combineConditions, meshCombiner.copyBakedLighting && meshCombiner.validCopyBakedLighting, cachedGO.go, cachedGO.t, cachedGO.mr, mat);
MeshObjectsHolder meshObjectHolder;
if (!lod.meshObjectsHoldersLookup.TryGetValue(combineCondition, out meshObjectHolder))
{
meshCombiner.foundCombineConditions.combineConditions.Add(combineCondition);
meshObjectHolder = new MeshObjectsHolder(ref combineCondition, mat);
lod.meshObjectsHoldersLookup.Add(combineCondition, meshObjectHolder);
}
meshObjectHolder.meshObjects.Add(new MeshObject(cachedGO, l));
if (isChangeMode && !meshObjectHolder.hasChanged)
{
meshObjectHolder.hasChanged = true;
lod.changedMeshObjectsHolders.Add(meshObjectHolder);
}
}
return(true);
}
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);
}
static public void RemoveOverlap(Transform t, MeshCombineJobManager.MeshCombineJob meshCombineJob, MeshCache.SubMeshCache newMeshCache, ref byte[] vertexIsInsideCollider)
{
if (vertexIsInsideCollider == null)
{
vertexIsInsideCollider = new byte[65534];
}
int overlapLayerMask = meshCombineJob.meshCombiner.overlapLayerMask;
int voxelizeLayer = meshCombineJob.meshCombiner.voxelizeLayer;
int voxelizeLayerMask = 1 << voxelizeLayer;
int lodGroupLayer = meshCombineJob.meshCombiner.lodGroupLayer;
int lodGroupLayerMask = 1 << lodGroupLayer;
int lodLevel = meshCombineJob.meshObjectsHolder.lodLevel;
Vector3 cellOffset = meshCombineJob.position;
CreateOverlapColliders.newT.position = -cellOffset;
t.parent.position -= cellOffset;
#if !UNITY_2017
if (!Physics.autoSyncTransforms)
{
Physics.SyncTransforms();
}
#endif
CreateOverlapColliders.EnableLodLevelCollider(lodLevel, lodGroupLayer);
Vector3[] newVertices = newMeshCache.vertices;
int[] newTriangles = newMeshCache.triangles;
FastList <MeshObject> meshObjects = meshCombineJob.meshObjectsHolder.meshObjects;
int startIndex = meshCombineJob.startIndex;
int endIndex = meshCombineJob.endIndex;
bool queriesHitBackfaces = Physics.queriesHitBackfaces;
Physics.queriesHitBackfaces = true;
toCombineGos.Clear();
for (int i = startIndex; i < endIndex; i++)
{
toCombineGos.Add(meshObjects.items[i].cachedGO.go);
}
for (int a = startIndex; a < endIndex; a++)
{
MeshObject meshObject = meshObjects.items[a];
CachedGameObject cachedGO = meshObject.cachedGO;
GameObject go;
CreateOverlapColliders.lookupOrigCollider.TryGetValue(cachedGO.go, out go);
int startTriangleIndex = meshObject.startNewTriangleIndex;
int endTriangleIndex = meshObject.newTriangleCount + startTriangleIndex;
Bounds bounds = cachedGO.mr.bounds;
bounds.center -= cellOffset;
int oldLayer = 0;
if (go)
{
oldLayer = go.layer;
go.layer = voxelizeLayer;
}
colliders.SetCount(Physics.OverlapBoxNonAlloc(bounds.center, bounds.extents, colliders.items, Quaternion.identity, overlapLayerMask));
if (go)
{
go.layer = oldLayer;
}
// Debug.Log("collider Count " + colliders.Count);
if (colliders.Count == 0)
{
continue;
}
collidersInfo.SetCount(colliders.Count);
for (int i = 0; i < colliders.Count; i++)
{
GameObject colliderGo = colliders.items[i].gameObject;
collidersInfo.items[i] = new ColliderInfo()
{
layer = colliderGo.layer, go = colliderGo
};
colliderGo.layer = voxelizeLayer;
}
// Debug.Log("start " + startTriangleIndex + " end " + endTriangleIndex);
for (int i = startTriangleIndex; i < endTriangleIndex; i += 3)
{
int vertIndexA = newTriangles[i];
if (vertIndexA == -1)
{
continue;
}
byte isInsideVoxel = vertexIsInsideCollider[vertIndexA];
if (isInsideVoxel != outsideVoxel)
{
tri.a = t.TransformPoint(newVertices[vertIndexA]);
hitInfos.SetCount(Physics.RaycastNonAlloc(tri.a, Vector3.up, hitInfos.items, Mathf.Infinity, voxelizeLayerMask));
if (!AnythingInside())
{
vertexIsInsideCollider[vertIndexA] = outsideVoxel; continue;
}
tri.b = t.TransformPoint(newVertices[newTriangles[i + 1]]);
tri.c = t.TransformPoint(newVertices[newTriangles[i + 2]]);
if (LinecastAll(tri.a, tri.b, voxelizeLayerMask) && IntersectAny())
{
continue;
}
if (LinecastAll(tri.b, tri.c, voxelizeLayerMask) && IntersectAny())
{
continue;
}
if (LinecastAll(tri.c, tri.a, voxelizeLayerMask) && IntersectAny())
{
continue;
}
if (LinecastAll(tri.a, (tri.b + tri.c) * 0.5f, voxelizeLayerMask) && IntersectAny())
{
continue;
}
if (LinecastAll(tri.b, (tri.c + tri.a) * 0.5f, voxelizeLayerMask) && IntersectAny())
{
continue;
}
if (LinecastAll(tri.c, (tri.a + tri.b) * 0.5f, voxelizeLayerMask) && IntersectAny())
{
continue;
}
//tri.Calc();
//Vector3 origin = tri.a + (tri.dirAb / 2) + ((tri.c - tri.h1) / 2);
//if (Physics.CheckBox(origin, new Vector3(0.05f, tri.h, tri.ab) / 2, Quaternion.LookRotation(tri.dirAb, tri.dirAc), voxelizeLayerMask))
//{
// colliderGO.layer = oldLayer;
// continue;
//}
if (CreateOverlapColliders.foundLodGroup && AreAllHitInfosALodGroup() && !IsOneColliderGOInToCombineGos() && !CheckAnyInsideOfLodGroups(lodGroupLayerMask, lodLevel))
{
continue;
}
meshCombineJob.trianglesRemoved += 3;
newTriangles[i] = -1;
}
}
for (int i = 0; i < colliders.Count; i++)
{
ColliderInfo colliderInfo = collidersInfo.items[i];
colliderInfo.go.layer = colliderInfo.layer;
}
}
Array.Clear(vertexIsInsideCollider, 0, newVertices.Length);
// Debug.Log("Removed " + meshCombineJob.trianglesRemoved);
newMeshCache.triangles = newTriangles;
Physics.queriesHitBackfaces = queriesHitBackfaces;
t.parent.position += cellOffset;
}
// ==========================================================================================================================
int ValidObject(Transform t, ObjectType objectType, bool useSearchOptions, ref CachedGameObject cachedGameObject)
{
GameObject go = t.gameObject;
MeshRenderer mr = null;
MeshFilter mf = null;
Mesh mesh = null;
if (objectType != ObjectType.LodGroup || searchOptions.lodGroupSearchMode == SearchOptions.LODGroupSearchMode.LodRenderers)
{
mr = t.GetComponent <MeshRenderer>();
if (mr == null || !mr.enabled)
{
return(-1);
}
mf = t.GetComponent <MeshFilter>();
if (mf == null)
{
return(-1);
}
mesh = mf.sharedMesh;
if (mesh == null)
{
return(-1);
}
if (!mesh.isReadable)
{
Debug.LogError("Mesh Combine Studio -> Read/Write is disabled on the mesh on GameObject " + go.name + " and can't be combined. Click the 'Make Meshes Readable' in the MCS Inspector to make it automatically readable in the mesh import settings.");
unreadableMeshes.Add(mesh);
return(-1);
}
}
if (useSearchOptions)
{
if (searchOptions.onlyActive && !go.activeInHierarchy)
{
return(-1);
}
if (objectType != ObjectType.LodRenderer || searchOptions.lodGroupSearchMode == SearchOptions.LODGroupSearchMode.LodRenderers)
{
if (searchOptions.useLayerMask)
{
int layer = 1 << t.gameObject.layer;
if ((searchOptions.layerMask.value & layer) != layer)
{
return(-1);
}
}
if (searchOptions.onlyStatic && !go.isStatic)
{
return(-1);
}
if (searchOptions.useTag)
{
if (!t.CompareTag(searchOptions.tag))
{
return(-1);
}
}
if (searchOptions.useComponentsFilter)
{
if (searchOptions.componentCondition == SearchOptions.ComponentCondition.And)
{
bool pass = true;
for (int j = 0; j < searchOptions.componentNameList.Count; j++)
{
if (t.GetComponent(searchOptions.componentNameList[j]) == null)
{
pass = false; break;
}
}
if (!pass)
{
return(-1);
}
}
else if (searchOptions.componentCondition == SearchOptions.ComponentCondition.Or)
{
bool pass = false;
for (int j = 0; j < searchOptions.componentNameList.Count; j++)
{
if (t.GetComponent(searchOptions.componentNameList[j]) != null)
{
pass = true; break;
}
}
if (!pass)
{
return(-1);
}
}
else
{
bool pass = true;
for (int j = 0; j < searchOptions.componentNameList.Count; j++)
{
if (t.GetComponent(searchOptions.componentNameList[j]) != null)
{
pass = false; break;
}
}
if (!pass)
{
return(-1);
}
}
}
if (searchOptions.useNameContains)
{
bool found = false;
for (int k = 0; k < searchOptions.nameContainList.Count; k++)
{
if (Methods.Contains(t.name, searchOptions.nameContainList[k]))
{
found = true; break;
}
}
if (!found)
{
return(-1);
}
}
if (searchOptions.useSearchBox)
{
if (searchOptions.objectCenter == ObjectCenter.BoundsCenter)
{
if (!searchOptions.searchBoxBounds.Contains(mr.bounds.center))
{
return(-2);
}
}
else if (!searchOptions.searchBoxBounds.Contains(t.position))
{
return(-2);
}
}
}
if (objectType != ObjectType.LodGroup)
{
if (searchOptions.useVertexInputLimit && mesh.vertexCount > searchOptions.vertexInputLimit)
{
return(-2);
}
if (useVertexOutputLimit && mesh.vertexCount > vertexOutputLimit)
{
return(-2);
}
if (searchOptions.useMaxBoundsFactor && useCells)
{
if (Mathw.GetMax(mr.bounds.size) > cellSize * searchOptions.maxBoundsFactor)
{
return(-2);
}
}
}
}
if (objectType != ObjectType.LodGroup)
{
cachedGameObject = new CachedGameObject(go, t, mr, mf, mesh);
}
return(1);
}
// 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);
}
} // Dummy constructor
public MeshObject(CachedGameObject cachedGO, int subMeshIndex)
{
} // 0x0000000181390260-0x0000000181390330
public void ExecuteHandleObjects(bool active, HandleComponent handleOriginalObjects, HandleComponent handleOriginalLodGroups, bool includeColliders = true)
{
Methods.SetChildrenActive(transform, !active);
if (handleOriginalObjects == HandleComponent.Disable)
{
if (includeColliders)
{
SetOriginalCollidersActive(active);
}
for (int i = 0; i < foundObjects.Count; i++)
{
CachedGameObject cachedGO = foundObjects[i];
if (cachedGO.mr)
{
cachedGO.mr.enabled = active;
}
else
{
Methods.ListRemoveAt(foundObjects, i--);
}
}
for (int i = 0; i < foundLodObjects.Count; i++)
{
CachedLodGameObject cachedLodGO = foundLodObjects[i];
if (cachedLodGO.mr)
{
cachedLodGO.mr.enabled = active;
}
else
{
Methods.ListRemoveAt(foundLodObjects, i--);
}
}
}
if (handleOriginalObjects == HandleComponent.Destroy)
{
for (int i = 0; i < foundColliders.Count; i++)
{
Collider collider = foundColliders[i];
if (collider)
{
Destroy(collider);
}
else
{
Methods.ListRemoveAt(foundColliders, i--);
}
}
for (int i = 0; i < foundObjects.Count; i++)
{
bool remove = false;
CachedGameObject cachedGO = foundObjects[i];
if (cachedGO.mf)
{
Destroy(cachedGO.mf);
}
else
{
remove = true;
}
if (cachedGO.mr)
{
Destroy(cachedGO.mr);
}
else
{
remove = true;
}
if (remove)
{
Methods.ListRemoveAt(foundObjects, i--);
}
}
for (int i = 0; i < foundLodObjects.Count; i++)
{
bool remove = false;
CachedGameObject cachedGO = foundLodObjects[i];
if (cachedGO.mf)
{
Destroy(cachedGO.mf);
}
else
{
remove = true;
}
if (cachedGO.mr)
{
Destroy(cachedGO.mr);
}
else
{
remove = true;
}
if (remove)
{
Methods.ListRemoveAt(foundLodObjects, i--);
}
}
}
if (handleOriginalLodGroups == HandleComponent.Disable)
{
for (int i = 0; i < foundLodGroups.Count; i++)
{
LODGroup lodGroup = foundLodGroups[i];
if (lodGroup)
{
lodGroup.enabled = active;
}
}
}
else if (handleOriginalLodGroups == HandleComponent.Destroy)
{
for (int i = 0; i < foundLodGroups.Count; i++)
{
LODGroup lodGroup = foundLodGroups[i];
if (lodGroup != null)
{
Destroy(lodGroup);
}
}
}
}
} // Dummy constructor
public CachedLodGameObject(CachedGameObject cachedGO, int lodCount, int lodLevel)
{
} // 0x0000000180BEA560-0x0000000180BEA770
public void ExecuteHandleObjects(bool active)
{
// DisableRenderes, DisableGameObject, DisableParentGameObject, DeleteRenderers, DeleteGameObject, DeleteParentGameObject
if (originalObjects == HandleObjects.DisableRenderes)
{
for (int i = 0; i < originalObjectList.Count; i++)
{
originalObjectList[i].mr.enabled = active;
}
}
else if (originalObjects == HandleObjects.DisableGameObject)
{
for (int i = 0; i < originalObjectList.Count; i++)
{
originalObjectList[i].go.SetActive(active);
}
}
else if (originalObjects == HandleObjects.DisableParentGameObject)
{
for (int i = 0; i < originalObjectList.Count; i++)
{
CachedGameObject cachedGO = originalObjectList[i];
if (cachedGO.t.parent != null)
{
cachedGO.t.parent.gameObject.SetActive(active);
}
}
}
else if (originalObjects == HandleObjects.DeleteRenderers)
{
for (int i = 0; i < originalObjectList.Count; i++)
{
CachedGameObject cachedGO = originalObjectList[i];
Destroy(cachedGO.mf);
Destroy(cachedGO.mr);
}
}
else if (originalObjects == HandleObjects.DeleteGameObject)
{
for (int i = 0; i < originalObjectList.Count; i++)
{
CachedGameObject cachedGO = originalObjectList[i];
if (cachedGO.go != null)
{
Destroy(cachedGO.go);
}
}
}
else if (originalObjects == HandleObjects.DeleteParentGameObject)
{
for (int i = 0; i < originalObjectList.Count; i++)
{
CachedGameObject cachedGO = originalObjectList[i];
if (cachedGO.t != null)
{
if (cachedGO.t.parent != null)
{
Destroy(cachedGO.t.parent.gameObject);
}
}
}
}
if (originalObjectsLODGroups == HandleLODGroups.Disable)
{
for (int i = 0; i < originalObjectList.Count; i++)
{
CachedGameObject cachedGO = originalObjectList[i];
if (cachedGO.t != null)
{
LODGroup lodGroup = cachedGO.t.GetComponentInParent <LODGroup>();
if (lodGroup != null)
{
lodGroup.enabled = active;
}
}
}
}
else if (originalObjectsLODGroups == HandleLODGroups.Delete)
{
for (int i = 0; i < originalObjectList.Count; i++)
{
CachedGameObject cachedGO = originalObjectList[i];
if (cachedGO.t != null)
{
LODGroup lodGroup = cachedGO.t.GetComponentInParent <LODGroup>();
if (lodGroup != null)
{
Destroy(lodGroup);
}
}
}
}
}
public CachedLodGameObject(CachedGameObject cachedGO, int lodCount, int lodLevel) : base(cachedGO.searchParentT, cachedGO.go, cachedGO.t, cachedGO.mr, cachedGO.mf, cachedGO.mesh)
{
this.lodCount = lodCount;
this.lodLevel = lodLevel;
}
// ==========================================================================================================================
void AddLodGroups(LODGroup[] lodGroups, bool useSearchOptions = true)
{
List <CachedLodGameObject> cachedLodRenderers = new List <CachedLodGameObject>();
CachedGameObject cachedGODummy = null;
for (int i = 0; i < lodGroups.Length; i++)
{
LODGroup lodGroup = lodGroups[i];
bool validLodGroup;
if (searchOptions.lodGroupSearchMode == SearchOptions.LODGroupSearchMode.LodGroup)
{
validLodGroup = (ValidObject(lodGroup.transform, ObjectType.LodGroup, useSearchOptions, ref cachedGODummy) == 1);
}
else
{
if (searchOptions.onlyActive && !lodGroup.gameObject.activeInHierarchy)
{
continue;
}
validLodGroup = true;
}
LOD[] lods = lodGroup.GetLODs();
int lodParentIndex = lods.Length - 1;
if (lodParentIndex <= 0)
{
continue;
}
// Debug.Log(lods.Length);
Vector3 center = Vector3.zero;
int rendererCount = 0;
for (int j = 0; j < lods.Length; j++)
{
LOD lod = lods[j];
for (int k = 0; k < lod.renderers.Length; k++)
{
Renderer r = lod.renderers[k];
if (!r)
{
continue;
}
if (validLodGroup)
{
CachedGameObject cachedGO = null;
int result = ValidObject(r.transform, ObjectType.LodRenderer, useSearchOptions, ref cachedGO);
if (result == -1)
{
continue;
}
else if (result == -2)
{
cachedLodRenderers.Clear();
goto breakLoop;
}
cachedLodRenderers.Add(new CachedLodGameObject(cachedGO, lodParentIndex, j));
if (searchOptions.objectCenter == ObjectCenter.BoundsCenter)
{
center += cachedGO.mr.bounds.center;
rendererCount++;
}
}
uniqueLodObjects.Add(r.transform);
}
}
breakLoop:
if (cachedLodRenderers.Count > 0)
{
if (searchOptions.objectCenter == ObjectCenter.BoundsCenter)
{
center /= rendererCount;
}
else
{
center = lodGroup.transform.position;
}
for (int j = 0; j < cachedLodRenderers.Count; j++)
{
CachedLodGameObject cachedLodGO = cachedLodRenderers[j];
cachedLodGO.center = center;
if (!hasFoundFirstObject)
{
bounds.center = cachedLodGO.mr.bounds.center; hasFoundFirstObject = true;
}
bounds.Encapsulate(cachedLodGO.mr.bounds);
foundLodObjects.Add(cachedLodGO);
lodParentHolders[lodParentIndex].found = true;
lodParentHolders[lodParentIndex].lods[cachedLodGO.lodLevel]++;
}
uniqueFoundLodGroups.Add(lodGroup);
cachedLodRenderers.Clear();
}
}
foundLodGroups = new List <LODGroup>(uniqueFoundLodGroups);
}
