809 lines
30 KiB
C#
809 lines
30 KiB
C#
using UnityEngine;
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using DigitalOpus.MB.Core;
|
|
|
|
#if UNITY_EDITOR
|
|
using UnityEditor;
|
|
#endif
|
|
|
|
public class MB3_MeshBakerGrouper : MonoBehaviour, MB_IMeshBakerSettingsHolder
|
|
{
|
|
public enum ClusterType
|
|
{
|
|
none,
|
|
grid,
|
|
pie,
|
|
agglomerative,
|
|
}
|
|
|
|
public MB3_MeshBakerGrouperCore grouper;
|
|
public ClusterType clusterType = ClusterType.none;
|
|
public GrouperData data = new GrouperData();
|
|
|
|
//these are for getting a resonable bounds in which to draw gizmos.
|
|
[HideInInspector] public Bounds sourceObjectBounds = new Bounds(Vector3.zero, Vector3.one);
|
|
|
|
public MB3_MeshCombinerSettings meshBakerSettingsAsset;
|
|
public MB3_MeshCombinerSettingsData meshBakerSettings;
|
|
|
|
public MB_IMeshBakerSettings GetMeshBakerSettings()
|
|
{
|
|
if (meshBakerSettingsAsset == null)
|
|
{
|
|
return meshBakerSettings;
|
|
}
|
|
else
|
|
{
|
|
return meshBakerSettingsAsset.GetMeshBakerSettings();
|
|
}
|
|
}
|
|
|
|
#if UNITY_EDITOR
|
|
public SerializedProperty GetMeshBakerSettingsAsSerializedProperty()
|
|
{
|
|
if (meshBakerSettingsAsset == null)
|
|
{
|
|
UnityEditor.SerializedObject so = new UnityEditor.SerializedObject(this);
|
|
return so.FindProperty("meshBakerSettings");
|
|
}
|
|
else
|
|
{
|
|
UnityEditor.SerializedObject so = new UnityEditor.SerializedObject(meshBakerSettingsAsset);
|
|
return so.FindProperty("data");
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
void OnDrawGizmosSelected()
|
|
{
|
|
if (grouper == null)
|
|
{
|
|
grouper = CreateGrouper(clusterType, data);
|
|
}
|
|
if (grouper.d == null)
|
|
{
|
|
grouper.d = data;
|
|
}
|
|
grouper.DrawGizmos(sourceObjectBounds);
|
|
}
|
|
|
|
public MB3_MeshBakerGrouperCore CreateGrouper(ClusterType t, GrouperData data)
|
|
{
|
|
if (t == ClusterType.grid) grouper = new MB3_MeshBakerGrouperGrid(data);
|
|
if (t == ClusterType.pie) grouper = new MB3_MeshBakerGrouperPie(data);
|
|
if (t == ClusterType.agglomerative)
|
|
{
|
|
MB3_TextureBaker tb = GetComponent<MB3_TextureBaker>();
|
|
List<GameObject> gos;
|
|
if (tb != null)
|
|
{
|
|
gos = tb.GetObjectsToCombine();
|
|
}
|
|
else
|
|
{
|
|
gos = new List<GameObject>();
|
|
}
|
|
grouper = new MB3_MeshBakerGrouperCluster(data, gos);
|
|
}
|
|
if (t == ClusterType.none) grouper = new MB3_MeshBakerGrouperNone(data);
|
|
return grouper;
|
|
}
|
|
|
|
public void DeleteAllChildMeshBakers()
|
|
{
|
|
MB3_MeshBakerCommon[] mBakers = GetComponentsInChildren<MB3_MeshBakerCommon>();
|
|
for (int i = 0; i < mBakers.Length; i++)
|
|
{
|
|
MB3_MeshBakerCommon mb = mBakers[i];
|
|
GameObject resultGameObject = mb.meshCombiner.resultSceneObject;
|
|
MB_Utility.Destroy(resultGameObject);
|
|
MB_Utility.Destroy(mb.gameObject);
|
|
}
|
|
}
|
|
}
|
|
|
|
namespace DigitalOpus.MB.Core
|
|
{
|
|
/// all properties go here so that settings are remembered as user switches between cluster types
|
|
[Serializable]
|
|
public class GrouperData
|
|
{
|
|
public bool clusterOnLMIndex;
|
|
public bool clusterByLODLevel;
|
|
public Vector3 origin;
|
|
|
|
//Normally these properties would be in the subclasses but putting them here makes writing the inspector much easier
|
|
//for grid
|
|
public Vector3 cellSize;
|
|
|
|
//for pie
|
|
public int pieNumSegments = 4;
|
|
public Vector3 pieAxis = Vector3.up;
|
|
public float ringSpacing = 100f;
|
|
public bool combineSegmentsInInnermostRing = false;
|
|
|
|
//for clustering
|
|
public int height = 1;
|
|
public float maxDistBetweenClusters = 1f;
|
|
public bool includeCellsWithOnlyOneRenderer = true;
|
|
}
|
|
|
|
[Serializable]
|
|
public abstract class MB3_MeshBakerGrouperCore
|
|
{
|
|
|
|
public GrouperData d;
|
|
public abstract Dictionary<string, List<Renderer>> FilterIntoGroups(List<GameObject> selection);
|
|
public abstract void DrawGizmos(Bounds sourceObjectBounds);
|
|
public void DoClustering(MB3_TextureBaker tb, MB3_MeshBakerGrouper grouper)
|
|
{
|
|
//todo warn for no objects and no Texture Bake Result
|
|
Dictionary<string, List<Renderer>> cell2objs = FilterIntoGroups(tb.GetObjectsToCombine());
|
|
|
|
if (d.clusterOnLMIndex)
|
|
{
|
|
Dictionary<string, List<Renderer>> cell2objsNew = new Dictionary<string, List<Renderer>>();
|
|
foreach (string key in cell2objs.Keys)
|
|
{
|
|
List<Renderer> gaws = cell2objs[key];
|
|
Dictionary<int, List<Renderer>> idx2objs = GroupByLightmapIndex(gaws);
|
|
foreach (int keyIdx in idx2objs.Keys)
|
|
{
|
|
string keyNew = key + "-LM-" + keyIdx;
|
|
cell2objsNew.Add(keyNew, idx2objs[keyIdx]);
|
|
}
|
|
}
|
|
cell2objs = cell2objsNew;
|
|
}
|
|
if (d.clusterByLODLevel)
|
|
{
|
|
//visit each cell
|
|
//visit each renderer
|
|
//check if that renderer is a child of an LOD group
|
|
// visit each LOD level check if this renderer is in that list.
|
|
// if not add it to LOD0 for that cell
|
|
// otherwise add it to LODX for that cell creating LODs as necessary
|
|
Dictionary<string, List<Renderer>> cell2objsNew = new Dictionary<string, List<Renderer>>();
|
|
foreach (string key in cell2objs.Keys)
|
|
{
|
|
List<Renderer> gaws = cell2objs[key];
|
|
foreach (Renderer r in gaws)
|
|
{
|
|
if (r == null) continue;
|
|
bool foundInLOD = false;
|
|
LODGroup lodg = r.GetComponentInParent<LODGroup>();
|
|
if (lodg != null)
|
|
{
|
|
LOD[] lods = lodg.GetLODs();
|
|
for (int i = 0; i < lods.Length; i++)
|
|
{
|
|
LOD lod = lods[i];
|
|
if (Array.Find<Renderer>(lod.renderers, x => x == r) != null)
|
|
{
|
|
foundInLOD = true;
|
|
List<Renderer> rs;
|
|
string newKey = String.Format("{0}_LOD{1}", key, i);
|
|
if (!cell2objsNew.TryGetValue(newKey, out rs))
|
|
{
|
|
rs = new List<Renderer>();
|
|
cell2objsNew.Add(newKey, rs);
|
|
}
|
|
if (!rs.Contains(r)) rs.Add(r);
|
|
}
|
|
}
|
|
}
|
|
if (!foundInLOD)
|
|
{
|
|
List<Renderer> rs;
|
|
string newKey = String.Format("{0}_LOD0", key);
|
|
if (!cell2objsNew.TryGetValue(newKey, out rs))
|
|
{
|
|
rs = new List<Renderer>();
|
|
cell2objsNew.Add(newKey, rs);
|
|
}
|
|
if (!rs.Contains(r)) rs.Add(r);
|
|
}
|
|
}
|
|
}
|
|
cell2objs = cell2objsNew;
|
|
}
|
|
int clustersWithOnlyOneRenderer = 0;
|
|
foreach (string key in cell2objs.Keys)
|
|
{
|
|
List<Renderer> gaws = cell2objs[key];
|
|
if (gaws.Count > 1 || grouper.data.includeCellsWithOnlyOneRenderer)
|
|
{
|
|
AddMeshBaker(grouper, tb, key, gaws);
|
|
}
|
|
else
|
|
{
|
|
clustersWithOnlyOneRenderer++;
|
|
}
|
|
}
|
|
Debug.Log(String.Format("Found {0} cells with Renderers. Not creating bakers for {1} because there is only one mesh in the cell. Creating {2} bakers.", cell2objs.Count, clustersWithOnlyOneRenderer, cell2objs.Count - clustersWithOnlyOneRenderer));
|
|
}
|
|
|
|
Dictionary<int, List<Renderer>> GroupByLightmapIndex(List<Renderer> gaws)
|
|
{
|
|
Dictionary<int, List<Renderer>> idx2objs = new Dictionary<int, List<Renderer>>();
|
|
for (int i = 0; i < gaws.Count; i++)
|
|
{
|
|
List<Renderer> objs = null;
|
|
if (idx2objs.ContainsKey(gaws[i].lightmapIndex))
|
|
{
|
|
objs = idx2objs[gaws[i].lightmapIndex];
|
|
}
|
|
else
|
|
{
|
|
objs = new List<Renderer>();
|
|
idx2objs.Add(gaws[i].lightmapIndex, objs);
|
|
}
|
|
objs.Add(gaws[i]);
|
|
}
|
|
return idx2objs;
|
|
}
|
|
|
|
void AddMeshBaker(MB3_MeshBakerGrouper grouper, MB3_TextureBaker tb, string key, List<Renderer> gaws)
|
|
{
|
|
int numVerts = 0;
|
|
for (int i = 0; i < gaws.Count; i++)
|
|
{
|
|
Mesh m = MB_Utility.GetMesh(gaws[i].gameObject);
|
|
if (m != null)
|
|
numVerts += m.vertexCount;
|
|
}
|
|
|
|
GameObject nmb = new GameObject("MeshBaker-" + key);
|
|
nmb.transform.position = Vector3.zero;
|
|
MB3_MeshBakerCommon newMeshBaker;
|
|
if (numVerts >= 65535)
|
|
{
|
|
newMeshBaker = nmb.AddComponent<MB3_MultiMeshBaker>();
|
|
newMeshBaker.useObjsToMeshFromTexBaker = false;
|
|
}
|
|
else
|
|
{
|
|
newMeshBaker = nmb.AddComponent<MB3_MeshBaker>();
|
|
newMeshBaker.useObjsToMeshFromTexBaker = false;
|
|
}
|
|
|
|
newMeshBaker.textureBakeResults = tb.textureBakeResults;
|
|
newMeshBaker.transform.parent = tb.transform;
|
|
newMeshBaker.meshCombiner.settingsHolder = grouper;
|
|
for (int i = 0; i < gaws.Count; i++)
|
|
{
|
|
newMeshBaker.GetObjectsToCombine().Add(gaws[i].gameObject);
|
|
}
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
public class MB3_MeshBakerGrouperNone : MB3_MeshBakerGrouperCore
|
|
{
|
|
public MB3_MeshBakerGrouperNone(GrouperData d)
|
|
{
|
|
this.d = d;
|
|
}
|
|
|
|
public override Dictionary<string, List<Renderer>> FilterIntoGroups(List<GameObject> selection)
|
|
{
|
|
Debug.Log("Filtering into groups none");
|
|
|
|
Dictionary<string, List<Renderer>> cell2objs = new Dictionary<string, List<Renderer>>();
|
|
|
|
List<Renderer> rs = new List<Renderer>();
|
|
for (int i = 0; i < selection.Count; i++)
|
|
{
|
|
if (selection[i] != null)
|
|
{
|
|
rs.Add(selection[i].GetComponent<Renderer>());
|
|
}
|
|
}
|
|
|
|
cell2objs.Add("MeshBaker", rs);
|
|
return cell2objs;
|
|
}
|
|
|
|
public override void DrawGizmos(Bounds sourceObjectBounds)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
public class MB3_MeshBakerGrouperGrid : MB3_MeshBakerGrouperCore
|
|
{
|
|
public MB3_MeshBakerGrouperGrid(GrouperData d)
|
|
{
|
|
this.d = d;
|
|
}
|
|
|
|
public override Dictionary<string, List<Renderer>> FilterIntoGroups(List<GameObject> selection)
|
|
{
|
|
Dictionary<string, List<Renderer>> cell2objs = new Dictionary<string, List<Renderer>>();
|
|
if (d.cellSize.x <= 0f || d.cellSize.y <= 0f || d.cellSize.z <= 0f)
|
|
{
|
|
Debug.LogError("cellSize x,y,z must all be greater than zero.");
|
|
return cell2objs;
|
|
}
|
|
|
|
Debug.Log("Collecting renderers in each cell");
|
|
foreach (GameObject t in selection)
|
|
{
|
|
if (t == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
GameObject go = t;
|
|
Renderer mr = go.GetComponent<Renderer>();
|
|
if (mr is MeshRenderer || mr is SkinnedMeshRenderer)
|
|
{
|
|
//get the cell this gameObject is in
|
|
Vector3 gridVector = mr.bounds.center;
|
|
gridVector.x = Mathf.Floor((gridVector.x - d.origin.x) / d.cellSize.x) * d.cellSize.x;
|
|
gridVector.y = Mathf.Floor((gridVector.y - d.origin.y) / d.cellSize.y) * d.cellSize.y;
|
|
gridVector.z = Mathf.Floor((gridVector.z - d.origin.z) / d.cellSize.z) * d.cellSize.z;
|
|
List<Renderer> objs = null;
|
|
string gridVectorStr = gridVector.ToString();
|
|
if (cell2objs.ContainsKey(gridVectorStr))
|
|
{
|
|
objs = cell2objs[gridVectorStr];
|
|
}
|
|
else
|
|
{
|
|
objs = new List<Renderer>();
|
|
cell2objs.Add(gridVectorStr, objs);
|
|
}
|
|
|
|
if (!objs.Contains(mr))
|
|
{
|
|
//Debug.Log("Adding " + mr + " todo " + gridVectorStr);
|
|
objs.Add(mr);
|
|
}
|
|
}
|
|
}
|
|
return cell2objs;
|
|
}
|
|
|
|
public override void DrawGizmos(Bounds sourceObjectBounds)
|
|
{
|
|
Vector3 cs = d.cellSize;
|
|
if (cs.x <= .00001f || cs.y <= .00001f || cs.z <= .00001f) return;
|
|
Vector3 p = sourceObjectBounds.center - sourceObjectBounds.extents;
|
|
Vector3 offset = d.origin;
|
|
offset.x = offset.x % cs.x;
|
|
offset.y = offset.y % cs.y;
|
|
offset.z = offset.z % cs.z;
|
|
//snap p to closest cell center
|
|
Vector3 start;
|
|
p.x = Mathf.Round((p.x) / cs.x) * cs.x + offset.x;
|
|
p.y = Mathf.Round((p.y) / cs.y) * cs.y + offset.y;
|
|
p.z = Mathf.Round((p.z) / cs.z) * cs.z + offset.z;
|
|
if (p.x > sourceObjectBounds.center.x - sourceObjectBounds.extents.x) p.x = p.x - cs.x;
|
|
if (p.y > sourceObjectBounds.center.y - sourceObjectBounds.extents.y) p.y = p.y - cs.y;
|
|
if (p.z > sourceObjectBounds.center.z - sourceObjectBounds.extents.z) p.z = p.z - cs.z;
|
|
start = p;
|
|
int numcells = Mathf.CeilToInt(sourceObjectBounds.size.x / cs.x + sourceObjectBounds.size.y / cs.y + sourceObjectBounds.size.z / cs.z);
|
|
if (numcells > 200)
|
|
{
|
|
Gizmos.DrawWireCube(d.origin + cs / 2f, cs);
|
|
}
|
|
else
|
|
{
|
|
for (; p.x < sourceObjectBounds.center.x + sourceObjectBounds.extents.x; p.x += cs.x)
|
|
{
|
|
p.y = start.y;
|
|
for (; p.y < sourceObjectBounds.center.y + sourceObjectBounds.extents.y; p.y += cs.y)
|
|
{
|
|
p.z = start.z;
|
|
for (; p.z < sourceObjectBounds.center.z + sourceObjectBounds.extents.z; p.z += cs.z)
|
|
{
|
|
Gizmos.DrawWireCube(p + cs / 2f, cs);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
public class MB3_MeshBakerGrouperPie : MB3_MeshBakerGrouperCore
|
|
{
|
|
public MB3_MeshBakerGrouperPie(GrouperData data)
|
|
{
|
|
d = data;
|
|
}
|
|
|
|
public override Dictionary<string, List<Renderer>> FilterIntoGroups(List<GameObject> selection)
|
|
{
|
|
Dictionary<string, List<Renderer>> cell2objs = new Dictionary<string, List<Renderer>>();
|
|
if (d.pieNumSegments == 0)
|
|
{
|
|
Debug.LogError("pieNumSegments must be greater than zero.");
|
|
return cell2objs;
|
|
}
|
|
|
|
if (d.pieAxis.magnitude <= .000001f)
|
|
{
|
|
Debug.LogError("Pie axis vector is too short.");
|
|
return cell2objs;
|
|
}
|
|
|
|
if (d.ringSpacing <= .000001f)
|
|
{
|
|
Debug.LogError("Ring spacing is too small.");
|
|
return cell2objs;
|
|
}
|
|
|
|
d.pieAxis.Normalize();
|
|
Quaternion pieAxis2yIsUp = Quaternion.FromToRotation(d.pieAxis, Vector3.up);
|
|
|
|
Debug.Log("Collecting renderers in each cell");
|
|
foreach (GameObject t in selection)
|
|
{
|
|
if (t == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
GameObject go = t;
|
|
Renderer mr = go.GetComponent<Renderer>();
|
|
if (mr is MeshRenderer || mr is SkinnedMeshRenderer)
|
|
{
|
|
//get the cell this gameObject is in
|
|
Vector3 origin2obj = mr.bounds.center - d.origin;
|
|
origin2obj = pieAxis2yIsUp * origin2obj;
|
|
Vector2 origin2Obj2D = new Vector2(origin2obj.x, origin2obj.z);
|
|
float radius = origin2Obj2D.magnitude;
|
|
origin2obj.Normalize();
|
|
|
|
float deg_aboutY = 0f;
|
|
if (Mathf.Abs(origin2obj.x) < 10e-5f && Mathf.Abs(origin2obj.z) < 10e-5f)
|
|
{
|
|
deg_aboutY = 0f;
|
|
}
|
|
else
|
|
{
|
|
deg_aboutY = Mathf.Atan2(origin2obj.x, origin2obj.z) * Mathf.Rad2Deg;
|
|
if (deg_aboutY < 0f) deg_aboutY = 360f + deg_aboutY;
|
|
}
|
|
|
|
// Debug.Log ("Obj " + mr + " angle " + d_aboutY);
|
|
int segment = Mathf.FloorToInt(deg_aboutY / 360f * d.pieNumSegments);
|
|
int ring = Mathf.FloorToInt(radius / d.ringSpacing);
|
|
if (ring == 0 && d.combineSegmentsInInnermostRing)
|
|
{
|
|
segment = 0;
|
|
}
|
|
|
|
List<Renderer> objs = null;
|
|
string segStr = "seg_" + segment + "_ring_" + ring;
|
|
if (cell2objs.ContainsKey(segStr))
|
|
{
|
|
objs = cell2objs[segStr];
|
|
}
|
|
else
|
|
{
|
|
objs = new List<Renderer>();
|
|
cell2objs.Add(segStr, objs);
|
|
}
|
|
|
|
if (!objs.Contains(mr))
|
|
{
|
|
objs.Add(mr);
|
|
}
|
|
}
|
|
}
|
|
|
|
return cell2objs;
|
|
}
|
|
|
|
public override void DrawGizmos(Bounds sourceObjectBounds)
|
|
{
|
|
if (d.pieAxis.magnitude < .1f) return;
|
|
if (d.pieNumSegments < 1) return;
|
|
float rad = sourceObjectBounds.extents.magnitude;
|
|
|
|
int numRings = Mathf.CeilToInt(rad / d.ringSpacing);
|
|
numRings = Mathf.Max(1, numRings);
|
|
for (int i = 0; i < numRings; i++)
|
|
{
|
|
DrawCircle(d.pieAxis.normalized, d.origin, d.ringSpacing * (i + 1), 24);
|
|
}
|
|
|
|
Gizmos.color = Color.white;
|
|
Quaternion yIsUp2PieAxis = Quaternion.FromToRotation(Vector3.up, d.pieAxis);
|
|
Quaternion rStep = Quaternion.AngleAxis(180f / d.pieNumSegments, Vector3.up);
|
|
Vector3 r = Vector3.forward;
|
|
for (int i = 0; i < d.pieNumSegments; i++)
|
|
{
|
|
Vector3 rr = yIsUp2PieAxis * r;
|
|
Vector3 origin = d.origin;
|
|
int nr = numRings;
|
|
if (d.combineSegmentsInInnermostRing)
|
|
{
|
|
origin = d.origin + rr.normalized * d.ringSpacing;
|
|
nr = numRings - 1;
|
|
}
|
|
|
|
if (nr == 0) break;
|
|
|
|
Gizmos.DrawLine(origin, origin + nr * d.ringSpacing * rr.normalized);
|
|
r = rStep * r;
|
|
r = rStep * r;
|
|
}
|
|
}
|
|
|
|
static int MaxIndexInVector3(Vector3 v)
|
|
{
|
|
int idx = 0;
|
|
float val = v.x;
|
|
if (v.y > val)
|
|
{
|
|
idx = 1;
|
|
val = v.y;
|
|
}
|
|
if (v.z > val)
|
|
{
|
|
idx = 2;
|
|
val = v.z;
|
|
}
|
|
return idx;
|
|
}
|
|
|
|
public static void DrawCircle(Vector3 axis, Vector3 center, float radius, int subdiv)
|
|
{
|
|
Quaternion q = Quaternion.AngleAxis(360 / subdiv, axis);
|
|
int maxIdx = MaxIndexInVector3(axis);
|
|
int otherIdx = maxIdx == 0 ? maxIdx + 1 : maxIdx - 1;
|
|
Vector3 r = axis; //r construct a vector perpendicular to axis
|
|
float temp = r[maxIdx];
|
|
r[maxIdx] = r[otherIdx];
|
|
r[otherIdx] = -temp;
|
|
r = Vector3.ProjectOnPlane(r, axis);
|
|
r.Normalize();
|
|
r *= radius;
|
|
for (int i = 0; i < subdiv + 1; i++)
|
|
{
|
|
Vector3 r2 = q * r;
|
|
Gizmos.color = Color.white;
|
|
Gizmos.DrawLine(center + r, center + r2);
|
|
r = r2;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
[Serializable]
|
|
public class MB3_MeshBakerGrouperKMeans : MB3_MeshBakerGrouperCore
|
|
{
|
|
public int numClusters = 4;
|
|
public Vector3[] clusterCenters = new Vector3[0];
|
|
public float[] clusterSizes = new float[0];
|
|
|
|
public MB3_MeshBakerGrouperKMeans(GrouperData data)
|
|
{
|
|
d = data;
|
|
}
|
|
|
|
public override Dictionary<string, List<Renderer>> FilterIntoGroups(List<GameObject> selection)
|
|
{
|
|
Dictionary<string, List<Renderer>> cell2objs = new Dictionary<string, List<Renderer>>();
|
|
List<GameObject> validObjs = new List<GameObject>();
|
|
int numClusters = 20;
|
|
foreach (GameObject t in selection)
|
|
{
|
|
if (t == null)
|
|
{
|
|
continue;
|
|
}
|
|
GameObject go = t;
|
|
Renderer mr = go.GetComponent<Renderer>();
|
|
if (mr is MeshRenderer || mr is SkinnedMeshRenderer)
|
|
{
|
|
//get the cell this gameObject is in
|
|
validObjs.Add(go);
|
|
}
|
|
}
|
|
if (validObjs.Count > 0 && numClusters > 0 && numClusters < validObjs.Count)
|
|
{
|
|
MB3_KMeansClustering kmc = new MB3_KMeansClustering(validObjs, numClusters);
|
|
kmc.Cluster();
|
|
clusterCenters = new Vector3[numClusters];
|
|
clusterSizes = new float[numClusters];
|
|
for (int i = 0; i < numClusters; i++)
|
|
{
|
|
List<Renderer> lr = kmc.GetCluster(i, out clusterCenters[i], out clusterSizes[i]);
|
|
if (lr.Count > 0)
|
|
{
|
|
cell2objs.Add("Cluster_" + i, lr);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//todo error messages
|
|
}
|
|
return cell2objs;
|
|
}
|
|
|
|
public override void DrawGizmos(Bounds sceneObjectBounds)
|
|
{
|
|
if (clusterCenters != null && clusterSizes != null && clusterCenters.Length == clusterSizes.Length)
|
|
{
|
|
for (int i = 0; i < clusterSizes.Length; i++)
|
|
{
|
|
Gizmos.DrawWireSphere(clusterCenters[i], clusterSizes[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
public class MB3_MeshBakerGrouperCluster : MB3_MeshBakerGrouperCore
|
|
{
|
|
|
|
public MB3_AgglomerativeClustering cluster;
|
|
float _lastMaxDistBetweenClusters;
|
|
public float _ObjsExtents = 10f;
|
|
public float _minDistBetweenClusters = .001f;
|
|
List<MB3_AgglomerativeClustering.ClusterNode> _clustersToDraw = new List<MB3_AgglomerativeClustering.ClusterNode>();
|
|
float[] _radii;
|
|
|
|
public MB3_MeshBakerGrouperCluster(GrouperData data, List<GameObject> gos)
|
|
{
|
|
d = data;
|
|
}
|
|
|
|
public override Dictionary<string, List<Renderer>> FilterIntoGroups(List<GameObject> selection)
|
|
{
|
|
Dictionary<string, List<Renderer>> cell2objs = new Dictionary<string, List<Renderer>>();
|
|
for (int i = 0; i < _clustersToDraw.Count; i++)
|
|
{
|
|
MB3_AgglomerativeClustering.ClusterNode node = _clustersToDraw[i];
|
|
List<Renderer> rrs = new List<Renderer>();
|
|
for (int j = 0; j < node.leafs.Length; j++)
|
|
{
|
|
Renderer r = cluster.clusters[node.leafs[j]].leaf.go.GetComponent<Renderer>();
|
|
if (r is MeshRenderer || r is SkinnedMeshRenderer)
|
|
{
|
|
rrs.Add(r);
|
|
}
|
|
}
|
|
cell2objs.Add("Cluster_" + i, rrs);
|
|
}
|
|
return cell2objs;
|
|
}
|
|
|
|
public void BuildClusters(List<GameObject> gos, ProgressUpdateCancelableDelegate progFunc)
|
|
{
|
|
if (gos.Count == 0)
|
|
{
|
|
Debug.LogWarning("No objects to cluster. Add some objects to the list of Objects To Combine.");
|
|
return;
|
|
}
|
|
if (cluster == null) cluster = new MB3_AgglomerativeClustering();
|
|
List<MB3_AgglomerativeClustering.item_s> its = new List<MB3_AgglomerativeClustering.item_s>();
|
|
for (int i = 0; i < gos.Count; i++)
|
|
{
|
|
if (gos[i] != null && its.Find(x => x.go == gos[i]) == null)
|
|
{
|
|
Renderer mr = gos[i].GetComponent<Renderer>();
|
|
if (mr != null && (mr is MeshRenderer || mr is SkinnedMeshRenderer))
|
|
{
|
|
MB3_AgglomerativeClustering.item_s ii = new MB3_AgglomerativeClustering.item_s();
|
|
ii.go = gos[i];
|
|
ii.coord = mr.bounds.center;
|
|
its.Add(ii);
|
|
}
|
|
}
|
|
}
|
|
cluster.items = its;
|
|
//yield return cluster.agglomerate();
|
|
cluster.agglomerate(progFunc);
|
|
if (!cluster.wasCanceled)
|
|
{
|
|
float smallest, largest;
|
|
_BuildListOfClustersToDraw(progFunc, out smallest, out largest);
|
|
d.maxDistBetweenClusters = Mathf.Lerp(smallest, largest, .9f);
|
|
}
|
|
}
|
|
|
|
void _BuildListOfClustersToDraw(ProgressUpdateCancelableDelegate progFunc, out float smallest, out float largest)
|
|
{
|
|
_clustersToDraw.Clear();
|
|
if (cluster.clusters == null)
|
|
{
|
|
smallest = 1f;
|
|
largest = 10f;
|
|
return;
|
|
}
|
|
if (progFunc != null) progFunc("Building Clusters To Draw A:", 0);
|
|
List<MB3_AgglomerativeClustering.ClusterNode> removeMe = new List<MB3_AgglomerativeClustering.ClusterNode>();
|
|
largest = 1f;
|
|
smallest = 10e6f;
|
|
for (int i = 0; i < cluster.clusters.Length; i++)
|
|
{
|
|
MB3_AgglomerativeClustering.ClusterNode node = cluster.clusters[i];
|
|
//don't draw clusters that were merged too far apart and only want leaf nodes
|
|
if (node.distToMergedCentroid <= d.maxDistBetweenClusters /*&& node.leaf == null*/)
|
|
{
|
|
if (d.includeCellsWithOnlyOneRenderer)
|
|
{
|
|
_clustersToDraw.Add(node);
|
|
}
|
|
else if (node.leaf == null)
|
|
{
|
|
_clustersToDraw.Add(node);
|
|
}
|
|
}
|
|
if (node.distToMergedCentroid > largest)
|
|
{
|
|
largest = node.distToMergedCentroid;
|
|
}
|
|
if (node.height > 0 && node.distToMergedCentroid < smallest)
|
|
{
|
|
smallest = node.distToMergedCentroid;
|
|
}
|
|
}
|
|
if (progFunc != null) progFunc("Building Clusters To Draw B:", 0);
|
|
for (int i = 0; i < _clustersToDraw.Count; i++)
|
|
{
|
|
removeMe.Add(_clustersToDraw[i].cha);
|
|
removeMe.Add(_clustersToDraw[i].chb);
|
|
}
|
|
|
|
for (int i = 0; i < removeMe.Count; i++)
|
|
{
|
|
_clustersToDraw.Remove(removeMe[i]);
|
|
}
|
|
_radii = new float[_clustersToDraw.Count];
|
|
if (progFunc != null) progFunc("Building Clusters To Draw C:", 0);
|
|
for (int i = 0; i < _radii.Length; i++)
|
|
{
|
|
MB3_AgglomerativeClustering.ClusterNode n = _clustersToDraw[i];
|
|
Bounds b = new Bounds(n.centroid, Vector3.one);
|
|
for (int j = 0; j < n.leafs.Length; j++)
|
|
{
|
|
Renderer r = cluster.clusters[n.leafs[j]].leaf.go.GetComponent<Renderer>();
|
|
if (r != null)
|
|
{
|
|
b.Encapsulate(r.bounds);
|
|
}
|
|
}
|
|
_radii[i] = b.extents.magnitude;
|
|
}
|
|
if (progFunc != null) progFunc("Building Clusters To Draw D:", 0);
|
|
_ObjsExtents = largest + 1f;
|
|
_minDistBetweenClusters = Mathf.Lerp(smallest, 0f, .9f);
|
|
|
|
if (_ObjsExtents < 2f) _ObjsExtents = 2f;
|
|
}
|
|
|
|
public override void DrawGizmos(Bounds sceneObjectBounds)
|
|
{
|
|
if (cluster == null || cluster.clusters == null)
|
|
{
|
|
return;
|
|
}
|
|
if (_lastMaxDistBetweenClusters != d.maxDistBetweenClusters)
|
|
{
|
|
float s, l;
|
|
_BuildListOfClustersToDraw(null, out s, out l);
|
|
_lastMaxDistBetweenClusters = d.maxDistBetweenClusters;
|
|
}
|
|
for (int i = 0; i < _clustersToDraw.Count; i++)
|
|
{
|
|
Gizmos.color = Color.white;
|
|
MB3_AgglomerativeClustering.ClusterNode node = _clustersToDraw[i];
|
|
Gizmos.DrawWireSphere(node.centroid, _radii[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|