protected virtual void Start()
{
var objects = GetComponent <TileCreator>().Create();
var colliders = objects.Select(o => o.GetComponent <ColliderHelper>());
group = new ColliderGroup(colliders);
}
public static void Initialise()
{
for (int i = 0; i < DestructibleColliders.Length; ++i)
{
DestructibleColliders[i] = new ColliderGroup();
}
}
//-------------------------------------------------------------------------
public void ReInitColliderGroups()
{
mColliderGroups.Clear();
object[] alphaMeshColliders = GameObject.FindSceneObjectsOfType(typeof(AlphaMeshCollider));
Array.Sort(alphaMeshColliders, delegate(object first, object second) {
return(((AlphaMeshCollider)first).mColliderMeshFilename.CompareTo(
((AlphaMeshCollider)second).mColliderMeshFilename));
});
foreach (AlphaMeshCollider collider in alphaMeshColliders)
{
string colliderMeshPath = collider.FullColliderMeshPath();
ColliderGroup colliderGroup = FindColliderGroup(colliderMeshPath);
if (colliderGroup == null)
{
// first AlphaMeshCollider with path colliderMeshPath.
colliderGroup = new ColliderGroup();
colliderGroup.mFullColliderMeshPath = colliderMeshPath;
mColliderGroups.Add(colliderGroup);
AssignValuesFromInstanceToGroup(collider, colliderGroup);
colliderGroup.mAlphaMeshColliderObjects = new List <WeakReference>();
colliderGroup.mAlphaMeshColliderObjects.Add(new WeakReference(collider));
}
else
{
// not the first one - add it to the list of weak references.
colliderGroup.mAlphaMeshColliderObjects.Add(new WeakReference(collider));
}
}
}
private ColliderGroup CreateColliderGroup(ColliderGrid grid, ColliderCell cell, ColliderKey key)
{
ColliderGroup colliderGroup = Facepunch.Pool.Get <ColliderGroup>();
colliderGroup.Initialize(grid, cell, key);
return(colliderGroup);
}
//-------------------------------------------------------------------------
public void ReloadOrRecalculateSingleCollider(AlphaMeshCollider target)
{
if (!target.CanReloadCollider)
{
return;
}
string colliderMeshPath = target.FullColliderMeshPath();
ColliderGroup colliderGroup = FindColliderGroup(colliderMeshPath);
if (colliderGroup == null || !IsColliderGroupValid(colliderGroup))
{
if (!target.CanRecalculateCollider)
{
return;
}
target.RecalculateCollider();
UpdateSimilarCollidersAndGroupToTarget(target);
}
else
{
AssignValuesFromColliderGroup(target, colliderGroup);
}
}
//-------------------------------------------------------------------------
protected void EnsureColliderGroupIsValid(ColliderGroup colliderGroup)
{
if (IsColliderGroupValid(colliderGroup))
{
return;
}
string colliderMeshPath = colliderGroup.mFullColliderMeshPath;
object[] alphaMeshColliders = GameObject.FindSceneObjectsOfType(typeof(AlphaMeshCollider));
colliderGroup.mAlphaMeshColliderObjects = new List <WeakReference>();
AlphaMeshCollider target = null;
foreach (AlphaMeshCollider collider in alphaMeshColliders)
{
if (collider.FullColliderMeshPath().Equals(colliderMeshPath))
{
target = collider;
colliderGroup.mAlphaMeshColliderObjects.Add(new WeakReference(collider));
}
}
if (target != null)
{
AssignValuesFromInstanceToGroup(target, colliderGroup);
}
}
//-------------------------------------------------------------------------
protected void UpdateSimilarCollidersAndGroupToTarget(AlphaMeshCollider target)
{
string colliderMeshPath = target.FullColliderMeshPath();
object[] alphaMeshColliders = GameObject.FindSceneObjectsOfType(typeof(AlphaMeshCollider));
ColliderGroup colliderGroup = FindColliderGroup(colliderMeshPath);
if (colliderGroup == null)
{
// add new group.
colliderGroup = new ColliderGroup();
colliderGroup.mFullColliderMeshPath = colliderMeshPath;
mColliderGroups.Add(colliderGroup);
}
AssignValuesFromInstanceToGroup(target, colliderGroup);
colliderGroup.mAlphaMeshColliderObjects = new List <WeakReference>();
foreach (AlphaMeshCollider collider in alphaMeshColliders)
{
if (collider.FullColliderMeshPath().Equals(colliderMeshPath))
{
colliderGroup.mAlphaMeshColliderObjects.Add(new WeakReference(collider));
// reassign previously calculated values.
AssignValuesFromColliderGroup(collider, colliderGroup);
}
}
}
public void Refresh()
{
this.interrupt = false;
BufferList <ColliderGroup> values = this.batches.Values;
for (int i = 0; i < values.Count; i++)
{
ColliderGroup item = values[i];
if (!item.Processing)
{
if (item.Count <= 0)
{
item.Clear();
this.DestroyColliderGroup(ref item);
int num = i;
i = num - 1;
this.batches.RemoveAt(num);
}
else
{
item.Start();
if (item.Processing)
{
item.UpdateData();
item.CreateBatches();
item.RefreshBatches();
item.ApplyBatches();
item.DisplayBatches();
}
item.End();
}
}
}
}
void MergeGroup(ColliderGroup groupA, ColliderGroup groupB)//B融進A
{
for (int i = 0; i < groupB.colliders.Count; i++)
{
TransferGroup(groupB, groupA, groupB.colliders[i]);
}
}
//檢查移動後的物體是否還在該group範圍內
public void GroupCheck(MyCollider collider)
{
//移動距離不大時，跳過
//if (CheckIsInsideBoundsCircle(collider.belongGroup.center, collider.belongGroup.bounds.extents * 0.5f, collider))return;
//if (CheckIsInsideBoundsCircle(collider.belongGroup.center, (Vector2)collider.spr.bounds.size * 0.1f, collider)) return;
//找到有沾到邊的其他群組加入
for (int i = 0; i < colliderGroups.Count; i++)
{
if (collider.belongGroup == colliderGroups[i])
{
continue;
}
if (CheckIsInsideBoundsCircle(colliderGroups[i].center, colliderGroups[i].bounds.extents, collider))
{
//把目前碰撞中的物體也加進來
ColliderGroup to = colliderGroups[i];
//collider.current_colliding_objs.ForEach(a => MergeGroup(a.belongGroup, to));
MergeGroup(collider.belongGroup, to);
return;
}
}
//離組的中心太遠
if ((collider.belongGroup.center - (Vector2)collider.transform.position).magnitude > group_max_distance)
{
//創個組給自己
ColliderGroup self_group = new ColliderGroup();
//把目前碰撞中的物體也加進來
collider.current_colliding_objs.ForEach(a => MergeGroup(self_group, a.belongGroup));
TransferGroup(collider.belongGroup, self_group, collider);
return;
}
}
public void Add()
{
if (this.batchGroup != null)
{
this.Remove();
}
if (!Batching.colliders || Object.op_Equality((Object)this.BatchTransform, (Object)null) || (Object.op_Equality((Object)this.BatchCollider, (Object)null) || this.BatchCollider.get_sharedMesh().get_subMeshCount() > Batching.collider_submeshes) || this.BatchCollider.get_sharedMesh().get_vertexCount() > Batching.collider_vertices)
{
return;
}
this.batchGroup = ((ColliderGrid)SingletonComponent <ColliderGrid> .Instance)[this.BatchTransform.get_position()].FindBatchGroup(this);
this.batchGroup.Add(this);
this.batchInstance.mesh = this.BatchCollider.get_sharedMesh();
this.batchInstance.position = this.BatchTransform.get_position();
this.batchInstance.rotation = this.BatchTransform.get_rotation();
this.batchInstance.scale = this.BatchTransform.get_lossyScale();
this.batchInstance.transform = this.BatchTransform;
this.batchInstance.rigidbody = this.BatchRigidbody;
this.batchInstance.collider = (Collider)this.BatchCollider;
this.batchInstance.bounds = new OBB(this.BatchTransform, this.BatchCollider.get_sharedMesh().get_bounds());
if (Application.isLoading == null)
{
return;
}
((Collider)this.BatchCollider).set_enabled(false);
}
public void Refresh()
{
this.interrupt = false;
BufferList <ColliderGroup> values = this.batches.get_Values();
for (int index = 0; index < values.get_Count(); ++index)
{
ColliderGroup grp = values.get_Item(index);
if (!grp.Processing)
{
if (grp.Count > 0)
{
grp.Start();
if (grp.Processing)
{
grp.UpdateData();
grp.CreateBatches();
grp.RefreshBatches();
grp.ApplyBatches();
grp.DisplayBatches();
}
grp.End();
}
else
{
grp.Clear();
this.DestroyColliderGroup(ref grp);
this.batches.RemoveAt(index--);
}
}
}
}
//-------------------------------------------------------------------------
protected void AssignValuesFromInstanceToGroup(AlphaMeshCollider target, ColliderGroup colliderGroup)
{
colliderGroup.mRegionIndependentParameters = target.RegionIndependentParams;
colliderGroup.mIslandRegionParameters = target.IslandRegionParams;
colliderGroup.mSeaRegionParameters = target.SeaRegionParams;
colliderGroup.mGeneratedColliderData = target.GeneratedColliderData;
colliderGroup.mColliderMeshes = target.ColliderMeshes;
}
//-------------------------------------------------------------------------
protected void AssignValuesFromInstanceToGroup(AlphaMeshCollider target, ColliderGroup colliderGroup)
{
colliderGroup.mColliderMesh = target.ColliderMesh;
colliderGroup.mRegionIndependentParameters = target.RegionIndependentParams;
colliderGroup.mColliderRegionParameters = target.ColliderRegionParams;
colliderGroup.mColliderRegions = target.ColliderRegions;
colliderGroup.mOutlineAlgorithm = target.OutlineAlgorithm;
}
//-------------------------------------------------------------------------
public void AssignValuesFromColliderGroup(AlphaMeshCollider target, ColliderGroup colliderGroup)
{
target.ColliderMesh = colliderGroup.mColliderMesh; // sets the sharedMesh to null first, so no need to set it here.
target.RegionIndependentParams = colliderGroup.mRegionIndependentParameters;
target.ColliderRegionParams = colliderGroup.mColliderRegionParameters;
target.ColliderRegions = colliderGroup.mColliderRegions;
target.OutlineAlgorithm = colliderGroup.mOutlineAlgorithm;
}
//-------------------------------------------------------------------------
public void AssignValuesFromColliderGroup(AlphaMeshCollider target, ColliderGroup colliderGroup)
{
target.ColliderMesh = colliderGroup.mColliderMesh; // sets the sharedMesh to null first, so no need to set it here.
target.RegionIndependentParams = colliderGroup.mRegionIndependentParameters;
target.ColliderRegionParams = colliderGroup.mColliderRegionParameters;
target.ColliderRegions = colliderGroup.mColliderRegions;
target.OutlineAlgorithm = colliderGroup.mOutlineAlgorithm;
}
ColliderGroup MergeGroup(ColliderGroup groupA, MyCollider collider)//B融進A
{
ColliderGroup newGroup = new ColliderGroup();
newGroup.colliders = groupA.colliders;
newGroup.colliders.Add(collider);
return(newGroup);
}
protected override Task Startup()
{
PauseManager = new PauseManager();
DefaultColliderGroup = new ColliderGroup(this)
{
PauseManager = PauseManager
};
return(Task.CompletedTask);
}
public void Remove()
{
if (this.batchGroup == null)
{
return;
}
this.batchGroup.Invalidate();
this.batchGroup.Remove(this);
this.batchGroup = null;
}
//-------------------------------------------------------------------------
protected bool IsColliderGroupValid(ColliderGroup colliderGroup)
{
if (colliderGroup.mIslandRegionParameters == null ||
colliderGroup.mSeaRegionParameters == null ||
colliderGroup.mGeneratedColliderData == null || colliderGroup.mGeneratedColliderData.Length == 0 ||
colliderGroup.mColliderMeshes == null ||
colliderGroup.mRegionIndependentParameters == null)
{
return(false);
}
else
{
if (colliderGroup.mRegionIndependentParameters.TargetColliderType == AlphaMeshCollider.TargetColliderType.MeshCollider)
{
// MeshCollider
if (colliderGroup.mColliderMeshes == null || colliderGroup.mColliderMeshes.Length == 0)
{
return(false);
}
bool allMeshCollidersAreNull = true;
for (int index = 0; index < colliderGroup.mColliderMeshes.Length; ++index)
{
if (colliderGroup.mColliderMeshes[index] != null)
{
allMeshCollidersAreNull = false;
}
}
if (allMeshCollidersAreNull)
{
return(false);
}
}
else
{
// PolygonCollider2D
bool allPolygonCollidersAreNull = true;
for (int index = 0; index < colliderGroup.mGeneratedColliderData.Length; ++index)
{
if (colliderGroup.mGeneratedColliderData[index] != null &&
colliderGroup.mGeneratedColliderData[index].mColliderRegions != null &&
colliderGroup.mGeneratedColliderData[index].mColliderRegions.Length > 0 &&
colliderGroup.mGeneratedColliderData[index].mColliderRegions[0].mReducedOutlineVertices != null)
{
allPolygonCollidersAreNull = false;
}
}
if (allPolygonCollidersAreNull)
{
return(false);
}
}
return(true);
}
}
private void Awake()
{
renderer = GetComponent <Renderer>();
// 作ったタイルの子供達のColliderHelperを取得して配列にする
var colliders = GetComponent <CreateTile>().children
.Select(o => o.GetComponent <ColliderHelper>())
.ToArray();
group = new ColliderGroup(colliders);
}
//-------------------------------------------------------------------------
public void AssignValuesFromColliderGroup(AlphaMeshCollider target, ColliderGroup colliderGroup)
{
target.RegionIndependentParams = colliderGroup.mRegionIndependentParameters;
target.IslandRegionParams = colliderGroup.mIslandRegionParameters;
target.SeaRegionParams = colliderGroup.mSeaRegionParameters;
target.GeneratedColliderData = colliderGroup.mGeneratedColliderData;
target.CorrectColliderTypeToParameters();
target.ColliderMeshes = colliderGroup.mColliderMeshes; // sets the sharedMesh to null first, so no need to set it here.
#if UNITY_4_3_AND_LATER
target.ReassignCollidersIfNeeded();
#endif
}
//-------------------------------------------------------------------------
public void AssignValuesFromColliderGroup(AlphaMeshCollider target, ColliderGroup colliderGroup)
{
target.RegionIndependentParams = colliderGroup.mRegionIndependentParameters;
target.ColliderRegionParams = colliderGroup.mColliderRegionParameters;
target.ColliderRegions = colliderGroup.mColliderRegions;
target.OutlineAlgorithm = colliderGroup.mOutlineAlgorithm;
target.CorrectColliderTypeToParameters();
target.ColliderMesh = colliderGroup.mColliderMesh; // sets the sharedMesh to null first, so no need to set it here.
#if UNITY_4_3_AND_LATER
target.ReassignPolygonCollider2DDataIfNeeded();
#endif
}
//-------------------------------------------------------------------------
public bool AssignValuesFromColliderGroup(AlphaMeshCollider target, string fullMeshPath)
{
ColliderGroup colliderGroup = this.FindColliderGroup(fullMeshPath);
if (colliderGroup == null)
{
return(false);
}
else
{
AssignValuesFromColliderGroup(target, colliderGroup);
return(true);
}
}
//-------------------------------------------------------------------------
protected bool IsColliderGroupValid(ColliderGroup colliderGroup)
{
if (colliderGroup.mOutlineAlgorithm == null ||
colliderGroup.mColliderRegionParameters == null ||
colliderGroup.mColliderRegions == null ||
colliderGroup.mColliderRegionParameters.Length != colliderGroup.mColliderRegions.Length ||
colliderGroup.mColliderMesh == null)
{
return(false);
}
else
{
return(true);
}
}
public virtual void Initialize(Instantiator instantiator, GameObject wall)
{
this.instantiator = instantiator;
this.indicator = instantiator.Instantiate(indicatorPrefab, transform.position, Quaternion.identity).GetComponent <DensityIndicator>();
var rate = gameObject.size().y / indicator.gameObject.size().y;
var scale = indicator.gameObject.transform.localScale;
scale.y *= rate;
indicator.gameObject.transform.localScale = scale;
indicator.Initialize(wall);
var objects = GetComponent <TileCreator>().Create();
var colliders = objects.Select(o => o.GetComponent <ColliderHelper>());
group = new ColliderGroup(colliders);
}
private void Awake()
{
renderer = GetComponent <Renderer>();
// タイル生成
var creator = GetComponent <TileCreator>();
creator.Create();
// 作ったタイルの子供達のColliderHelperを取得
var colliders = creator.Children.Select(o => o.GetComponent <ColliderHelper>());
group = new ColliderGroup(colliders);
MinoDeleteEffect = this.GetComponentInChildren <ParticleSystem>();
MinoDeleteEffect.Stop();
}
public List <ColliderGroup> SetUpAllGroups(float max_size) //設定所有group
{
colliderGroups.Clear();
List <ColliderGroup> groups = new List <ColliderGroup>();
List <ColliderGroup> groups_tmp = new List <ColliderGroup>();
//TODO:分群演算法
MyCollider[] allColliders = FindObjectsOfType <MyCollider>();
//一開始所有物件都自己一組
foreach (MyCollider c in allColliders)
{
ColliderGroup tmp = new ColliderGroup();
tmp.colliders.Add(c);
tmp.UpdateCenter();
c.belongGroup = tmp;
groups_tmp.Add(tmp);
}
//===開始合併===
groups.Add(groups_tmp[0]);
groups_tmp.RemoveAt(0);
for (int i = 0; i < groups.Count; i++)
{
for (int j = 0; j < groups_tmp.Count; j++)
{
if (groups[i].colliders.Exists(a => a == groups_tmp[j].colliders[0]))
{
continue;
}
if (CheckIsInsideBoundsCircle(groups[i].center, groups_tmp[j].colliders[0].spr.bounds.extents, groups_tmp[j].colliders[0]))
{
groups[i] = MergeGroup(groups[i], groups_tmp[j].colliders[0]);
groups[i].UpdateCenter();
}
else if (i == 0)
{
groups.Add(groups_tmp[j]);
}
}
}
groups.Distinct();
return(groups);
}
//-------------------------------------------------------------------------
protected void UpdateSimilarCollidersToGroup(ColliderGroup colliderGroup)
{
string colliderMeshPath = colliderGroup.mFullColliderMeshPath;
object[] alphaMeshColliders = GameObject.FindSceneObjectsOfType(typeof(AlphaMeshCollider));
colliderGroup.mAlphaMeshColliderObjects = new List <WeakReference>();
foreach (AlphaMeshCollider collider in alphaMeshColliders)
{
if (collider.FullColliderMeshPath().Equals(colliderMeshPath))
{
colliderGroup.mAlphaMeshColliderObjects.Add(new WeakReference(collider));
// reassign previously calculated values.
AssignValuesFromColliderGroup(collider, colliderGroup);
}
}
}
public void Add()
{
if (this.batchGroup != null)
{
this.Remove();
}
if (!Batching.colliders)
{
return;
}
if (this.BatchTransform == null)
{
return;
}
if (this.BatchCollider == null)
{
return;
}
if (this.BatchCollider.sharedMesh.subMeshCount > Batching.collider_submeshes)
{
return;
}
if (this.BatchCollider.sharedMesh.vertexCount > Batching.collider_vertices)
{
return;
}
ColliderCell item = SingletonComponent <ColliderGrid> .Instance[this.BatchTransform.position];
this.batchGroup = item.FindBatchGroup(this);
this.batchGroup.Add(this);
this.batchInstance.mesh = this.BatchCollider.sharedMesh;
this.batchInstance.position = this.BatchTransform.position;
this.batchInstance.rotation = this.BatchTransform.rotation;
this.batchInstance.scale = this.BatchTransform.lossyScale;
this.batchInstance.transform = this.BatchTransform;
this.batchInstance.rigidbody = this.BatchRigidbody;
this.batchInstance.collider = this.BatchCollider;
this.batchInstance.bounds = new OBB(this.BatchTransform, this.BatchCollider.sharedMesh.bounds);
if (Rust.Application.isLoading)
{
this.BatchCollider.enabled = false;
}
}
//-------------------------------------------------------------------------
public void ReloadOrRecalculateColliderAndUpdateSimilar(AlphaMeshCollider target)
{
if (!target.CanRecalculateCollider)
{
return;
}
string colliderMeshPath = target.FirstFrameFullColliderMeshPath();
ColliderGroup colliderGroup = FindColliderGroup(colliderMeshPath);
if (colliderGroup == null || !IsColliderGroupValid(colliderGroup))
{
target.RecalculateCollider();
UpdateSimilarCollidersAndGroupToTarget(target);
}
else
{
UpdateSimilarCollidersToGroup(colliderGroup);
}
}
//-------------------------------------------------------------------------
protected void UpdateSimilarCollidersToGroup(ColliderGroup colliderGroup) {
string colliderMeshPath = colliderGroup.mFullColliderMeshPath;
#if UNITY_4_AND_LATER
object[] alphaMeshColliders = GameObject.FindObjectsOfType(typeof(AlphaMeshCollider));
#else
object[] alphaMeshColliders = GameObject.FindSceneObjectsOfType(typeof(AlphaMeshCollider));
#endif
colliderGroup.mAlphaMeshColliderObjects = new List<WeakReference>();
foreach (AlphaMeshCollider collider in alphaMeshColliders)
{
if (collider.FirstFrameFullColliderMeshPath().Equals(colliderMeshPath)) {
colliderGroup.mAlphaMeshColliderObjects.Add(new WeakReference(collider));
// reassign previously calculated values.
AssignValuesFromColliderGroup(collider, colliderGroup);
}
}
}
//-------------------------------------------------------------------------
protected bool IsColliderGroupValid(ColliderGroup colliderGroup) {
if (colliderGroup.mOutlineAlgorithm == null ||
colliderGroup.mColliderRegionParameters == null ||
colliderGroup.mColliderRegions == null ||
colliderGroup.mColliderRegionParameters.Length != colliderGroup.mColliderRegions.Length ||
colliderGroup.mColliderMesh == null) {
return false;
}
else {
return true;
}
}
//-------------------------------------------------------------------------
public void AssignValuesFromColliderGroup(AlphaMeshCollider target, ColliderGroup colliderGroup) {
target.RegionIndependentParams = colliderGroup.mRegionIndependentParameters;
target.ColliderRegionParams = colliderGroup.mColliderRegionParameters;
target.ColliderRegions = colliderGroup.mColliderRegions;
target.OutlineAlgorithm = colliderGroup.mOutlineAlgorithm;
target.CorrectColliderTypeToParameters();
target.ColliderMesh = colliderGroup.mColliderMesh; // sets the sharedMesh to null first, so no need to set it here.
#if UNITY_4_3_AND_LATER
target.ReassignPolygonCollider2DDataIfNeeded();
#endif
}
//-------------------------------------------------------------------------
protected void AssignValuesFromInstanceToGroup(AlphaMeshCollider target, ColliderGroup colliderGroup) {
colliderGroup.mRegionIndependentParameters = target.RegionIndependentParams;
colliderGroup.mColliderRegionParameters = target.ColliderRegionParams;
colliderGroup.mColliderRegions = target.ColliderRegions;
colliderGroup.mOutlineAlgorithm = target.OutlineAlgorithm;
colliderGroup.mColliderMesh = target.ColliderMesh;
}
//-------------------------------------------------------------------------
public void ReInitColliderGroups() {
mColliderGroups.Clear();
#if UNITY_4_AND_LATER
object[] alphaMeshColliders = GameObject.FindObjectsOfType(typeof(AlphaMeshCollider));
#else
object[] alphaMeshColliders = GameObject.FindSceneObjectsOfType(typeof(AlphaMeshCollider));
#endif
Array.Sort(alphaMeshColliders, delegate(object first, object second) {
return ((AlphaMeshCollider)first).mColliderMeshFilename.CompareTo(
((AlphaMeshCollider)second).mColliderMeshFilename);
});
foreach (AlphaMeshCollider collider in alphaMeshColliders) {
string colliderMeshPath = collider.FirstFrameFullColliderMeshPath();
ColliderGroup colliderGroup = FindColliderGroup(colliderMeshPath);
if (colliderGroup == null) {
// first AlphaMeshCollider with path colliderMeshPath.
colliderGroup = new ColliderGroup();
colliderGroup.mFullColliderMeshPath = colliderMeshPath;
mColliderGroups.Add(colliderGroup);
AssignValuesFromInstanceToGroup(collider, colliderGroup);
colliderGroup.mAlphaMeshColliderObjects = new List<WeakReference>();
colliderGroup.mAlphaMeshColliderObjects.Add(new WeakReference(collider));
}
else {
// not the first one - add it to the list of weak references.
colliderGroup.mAlphaMeshColliderObjects.Add(new WeakReference(collider));
}
}
}
//-------------------------------------------------------------------------
protected void EnsureColliderGroupIsValid(ColliderGroup colliderGroup) {
if (IsColliderGroupValid(colliderGroup))
return;
string colliderMeshPath = colliderGroup.mFullColliderMeshPath;
#if UNITY_4_AND_LATER
object[] alphaMeshColliders = GameObject.FindObjectsOfType(typeof(AlphaMeshCollider));
#else
object[] alphaMeshColliders = GameObject.FindSceneObjectsOfType(typeof(AlphaMeshCollider));
#endif
colliderGroup.mAlphaMeshColliderObjects = new List<WeakReference>();
AlphaMeshCollider target = null;
foreach (AlphaMeshCollider collider in alphaMeshColliders)
{
if (collider.FirstFrameFullColliderMeshPath().Equals(colliderMeshPath)) {
target = collider;
colliderGroup.mAlphaMeshColliderObjects.Add(new WeakReference(collider));
}
}
if (target != null) {
AssignValuesFromInstanceToGroup(target, colliderGroup);
}
}
//-------------------------------------------------------------------------
protected bool IsColliderGroupValid(ColliderGroup colliderGroup) {
if (colliderGroup.mIslandRegionParameters == null ||
colliderGroup.mSeaRegionParameters == null ||
colliderGroup.mGeneratedColliderData == null || colliderGroup.mGeneratedColliderData.Length == 0 ||
colliderGroup.mColliderMeshes == null ||
colliderGroup.mRegionIndependentParameters == null) {
return false;
}
else {
if (colliderGroup.mRegionIndependentParameters.TargetColliderType == AlphaMeshCollider.TargetColliderType.MeshCollider) {
// MeshCollider
if (colliderGroup.mColliderMeshes == null || colliderGroup.mColliderMeshes.Length == 0) {
return false;
}
bool allMeshCollidersAreNull = true;
for (int index = 0; index < colliderGroup.mColliderMeshes.Length; ++index) {
if (colliderGroup.mColliderMeshes[index] != null)
allMeshCollidersAreNull = false;
}
if (allMeshCollidersAreNull) {
return false;
}
}
else {
// PolygonCollider2D
bool allPolygonCollidersAreNull = true;
for (int index = 0; index < colliderGroup.mGeneratedColliderData.Length; ++index) {
if (colliderGroup.mGeneratedColliderData[index] != null &&
colliderGroup.mGeneratedColliderData[index].mColliderRegions != null &&
colliderGroup.mGeneratedColliderData[index].mColliderRegions.Length > 0 &&
colliderGroup.mGeneratedColliderData[index].mColliderRegions[0].mReducedOutlineVertices != null)
allPolygonCollidersAreNull = false;
}
if (allPolygonCollidersAreNull) {
return false;
}
}
return true;
}
}
//-------------------------------------------------------------------------
public void AssignValuesFromColliderGroup(AlphaMeshCollider target, ColliderGroup colliderGroup) {
target.RegionIndependentParams = colliderGroup.mRegionIndependentParameters;
target.IslandRegionParams = colliderGroup.mIslandRegionParameters;
target.SeaRegionParams = colliderGroup.mSeaRegionParameters;
target.GeneratedColliderData = colliderGroup.mGeneratedColliderData;
target.CorrectColliderTypeToParameters();
target.ColliderMeshes = colliderGroup.mColliderMeshes; // sets the sharedMesh to null first, so no need to set it here.
#if UNITY_4_3_AND_LATER
target.ReassignCollidersIfNeeded();
#endif
}
//-------------------------------------------------------------------------
protected void AssignValuesFromInstanceToGroup(AlphaMeshCollider target, ColliderGroup colliderGroup) {
colliderGroup.mRegionIndependentParameters = target.RegionIndependentParams;
colliderGroup.mIslandRegionParameters = target.IslandRegionParams;
colliderGroup.mSeaRegionParameters = target.SeaRegionParams;
colliderGroup.mGeneratedColliderData = target.GeneratedColliderData;
colliderGroup.mColliderMeshes = target.ColliderMeshes;
}
//-------------------------------------------------------------------------
protected void UpdateSimilarCollidersAndGroupToTarget(AlphaMeshCollider target) {
string colliderMeshPath = target.FirstFrameFullColliderMeshPath();
#if UNITY_4_AND_LATER
object[] alphaMeshColliders = GameObject.FindObjectsOfType(typeof(AlphaMeshCollider));
#else
object[] alphaMeshColliders = GameObject.FindSceneObjectsOfType(typeof(AlphaMeshCollider));
#endif
ColliderGroup colliderGroup = FindColliderGroup(colliderMeshPath);
if (colliderGroup == null) {
// add new group.
colliderGroup = new ColliderGroup();
colliderGroup.mFullColliderMeshPath = colliderMeshPath;
mColliderGroups.Add(colliderGroup);
}
AssignValuesFromInstanceToGroup(target, colliderGroup);
colliderGroup.mAlphaMeshColliderObjects = new List<WeakReference>();
foreach (AlphaMeshCollider collider in alphaMeshColliders)
{
if (collider.FirstFrameFullColliderMeshPath().Equals(colliderMeshPath)) {
colliderGroup.mAlphaMeshColliderObjects.Add(new WeakReference(collider));
if (collider == target) {
continue;
}
else {
// reassign previously calculated values.
AssignValuesFromColliderGroup(collider, colliderGroup);
}
}
}
}
