private static AABCGrid CreateGridWithSingleObject(GameObject gameObj, float cubeSide, bool includeInside)
{
//Ext Opt 1: Get objects once
Renderer rend = gameObj.GetComponent <Renderer>();
if (rend != null)
{
Mesh gameObjMesh = gameObj.GetComponent <MeshFilter>().mesh;
//Ext Opt 2: Create AABCGrid without temp objects
AABCGrid grid = new AABCGrid(rend.bounds.min, rend.bounds.max, cubeSide);
grid.FillGridWithGameObjectInfo(gameObj.transform, gameObjMesh.vertices, gameObjMesh.triangles, includeInside);
return(grid);
}
else
{
SkinnedMeshRenderer sRend = gameObj.GetComponent <SkinnedMeshRenderer>();
if (sRend != null)
{
Mesh gameObjMesh = new Mesh();
sRend.BakeMesh(gameObjMesh);
//Ext Opt 2: Create AABCGrid without temp objects
AABCGrid grid = new AABCGrid(sRend.bounds.min, sRend.bounds.max, cubeSide);
grid.FillGridWithGameObjectInfo(gameObj.transform, gameObjMesh.vertices, gameObjMesh.triangles, includeInside);
return(grid);
}
else
{
return(null);
}
}
}
//New API (Faster but some preprocess needed)
public static AABCGrid Create1Grid1Object(Transform transform, Mesh mesh, Renderer renderer, float cubeSide, bool includeInside)
{
AABCGrid grid = new AABCGrid(renderer.bounds.min, renderer.bounds.max, cubeSide);
grid.FillGridWithGameObjectInfo(transform, mesh.vertices, mesh.triangles, includeInside);
return(grid);
}
public static AABCGrid Create1GridNObjects(List <Transform> transforms, List <Mesh> meshes, List <Renderer> renderers, float cubeSide, bool includeInside)
{
if (transforms.Count == 0)
{
return(null);
}
Vector3 gridBoundsMin = renderers[0].bounds.min;
Vector3 gridBoundsMax = renderers[0].bounds.max;
for (int i = 1; i < renderers.Count; ++i)
{
gridBoundsMin = Vector3.Min(gridBoundsMin, renderers[i].bounds.min);
gridBoundsMax = Vector3.Max(gridBoundsMax, renderers[i].bounds.max);
}
AABCGrid grid = new AABCGrid(gridBoundsMin, gridBoundsMax, cubeSide);
for (int i = 0; i < transforms.Count; ++i)
{
grid.FillGridWithGameObjectInfo(transforms[i], meshes[i].vertices, meshes[i].triangles, includeInside);
}
return(grid);
}
public AABCGridSetAABCIterator(AABCGrid grid)
: base(grid)
{
position = new AABCPosition(0, 0, 0);
if (grid.IsAABCSet(position))
{
nextPosition = position;
}
nextFound = true;
}
// Warning: this method creates a grid at least as big as the total bounding box of the
// game object, if children are included there may be empty space. Consider to use
// CreateMultipleGridsWithGameObjectMeshShell in order to save memory.
public static AABCGrid CreateGridWithGameObjectMesh(GameObject gameObj,
float cubeSide, bool includeChildren, bool includeInside, bool debug, ComputeShader shader)
{
AABCGrid aABCGrid;
short width;
short height;
short depth;
var origin = new Vector3();
List <GameObject> gameObjectsWithMesh;
var gridBoundsMin = new Vector3(Mathf.Infinity, Mathf.Infinity, Mathf.Infinity);
var gridBoundsMax = new Vector3(Mathf.NegativeInfinity, Mathf.NegativeInfinity, Mathf.NegativeInfinity);
if (includeChildren)
{
gameObjectsWithMesh = GetChildrenWithMesh(gameObj);
}
else
{
gameObjectsWithMesh = new List <GameObject>();
}
if (gameObj.renderer)
{
gameObjectsWithMesh.Add(gameObj);
}
foreach (GameObject gameObjectWithMesh in gameObjectsWithMesh)
{
gridBoundsMin = MinVectorComponents(gridBoundsMin,
gameObjectWithMesh.renderer.bounds.min);
gridBoundsMax = MaxVectorComponents(gridBoundsMax,
gameObjectWithMesh.renderer.bounds.max);
}
width = (short)(Mathf.Ceil((gridBoundsMax.x - gridBoundsMin.x) / cubeSide) + 2);
height = (short)(Mathf.Ceil((gridBoundsMax.y - gridBoundsMin.y) / cubeSide) + 2);
depth = (short)(Mathf.Ceil((gridBoundsMax.z - gridBoundsMin.z) / cubeSide) + 2);
origin = gridBoundsMin - new Vector3(cubeSide, cubeSide, cubeSide);
aABCGrid = new AABCGrid(width, height, depth, cubeSide, origin);
aABCGrid.SetDebug(debug);
foreach (GameObject gameObjectWithMesh in gameObjectsWithMesh)
{
if (includeInside)
{
aABCGrid.FillGridWithGameObjectMesh(gameObjectWithMesh, shader);
}
else
{
aABCGrid.FillGridWithGameObjectMeshShell(gameObjectWithMesh, shader);
}
}
return(aABCGrid);
}
//Old API private functions
private static void CreateMultipleGridsWithGameObjectMeshRec(GameObject gameObj, List <AABCGrid> list, float cubeSide, bool includeInside)
{
AABCGrid res = CreateGridWithSingleObject(gameObj, cubeSide, includeInside);
if (res != null)
{
list.Add(res);
}
//Call children
for (int i = 0; i < gameObj.transform.childCount; ++i)
{
CreateMultipleGridsWithGameObjectMeshRec(gameObj.transform.GetChild(i).gameObject, list, cubeSide, includeInside);
}
}
public static AABCGrid CreateGridWithGameObjectMesh(GameObject gameObj, float cubeSide, bool includeChildren, bool includeInside)
{
Vector3 ori = new Vector3();
List <GameObject> childrenWithMesh = new List <GameObject>();
Vector3 a = new Vector3(MAX_FLOAT, MAX_FLOAT, MAX_FLOAT);
Vector3 vector3 = new Vector3(MIN_FLOAT, MIN_FLOAT, MIN_FLOAT);
if (includeChildren)
{
childrenWithMesh = GetChildrenWithMesh(gameObj);
}
else
{
childrenWithMesh = new List <GameObject>();
}
if (gameObj.GetComponent <Renderer>() != null)
{
childrenWithMesh.Add(gameObj);
}
foreach (GameObject obj2 in childrenWithMesh)
{
a = MinVectorComponents(a, obj2.GetComponent <Renderer>().bounds.min);
vector3 = MaxVectorComponents(vector3, obj2.GetComponent <Renderer>().bounds.max);
}
int x = (int)(Mathf.Ceil((vector3.x - a.x) / cubeSide) + 2f);
int y = (int)(Mathf.Ceil((vector3.y - a.y) / cubeSide) + 2f);
int z = (int)(Mathf.Ceil((vector3.z - a.z) / cubeSide) + 2f);
ori = a - new Vector3(cubeSide, cubeSide, cubeSide);
AABCGrid grid = new AABCGrid(x, y, z, cubeSide, ori);
foreach (GameObject obj3 in childrenWithMesh)
{
if (includeInside)
{
grid.FillGridWithGameObjectMesh(obj3);
}
else
{
grid.FillGridWithGameObjectMeshShell(obj3);
}
}
return(grid);
}
private static AABCGrid CreateGridWithMultipleObjects(GameObject gameObj, float cubeSide, bool includeInside)
{
List <GameObject> gameObjectsWithMesh = new List <GameObject>();
List <Bounds> gameObjectBounds = new List <Bounds>();
GetObjectsWithMeshRec(gameObj, gameObjectsWithMesh, gameObjectBounds);
if (gameObjectsWithMesh.Count == 0)
{
return(null);
}
Vector3 gridBoundsMin = gameObjectBounds[0].min;
Vector3 gridBoundsMax = gameObjectBounds[0].max;
for (int i = 1; i < gameObjectBounds.Count; ++i)
{
gridBoundsMin = Vector3.Min(gridBoundsMin, gameObjectBounds[i].min);
gridBoundsMax = Vector3.Max(gridBoundsMax, gameObjectBounds[i].max);
}
//Ext Opt 2: Create AABCGrid without temp objects
AABCGrid grid = new AABCGrid(gridBoundsMin, gridBoundsMax, cubeSide);
for (int i = 0; i < gameObjectsWithMesh.Count; ++i)
{
GameObject gameObjAux = gameObjectsWithMesh[i];
Mesh gameObjMesh = null;
if (gameObjAux.GetComponent <MeshFilter>() != null)
{
gameObjMesh = gameObjAux.GetComponent <MeshFilter>().mesh;
}
else if (gameObjAux.GetComponent <SkinnedMeshRenderer>() != null)
{
gameObjMesh = new Mesh();
gameObjAux.GetComponent <SkinnedMeshRenderer>().BakeMesh(gameObjMesh);
}
grid.FillGridWithGameObjectInfo(gameObjAux.transform, gameObjMesh.vertices, gameObjMesh.triangles, includeInside);
}
return(grid);
}
public AABC(AABCPosition position, AABCGrid grid)
: base(position)
{
this.grid = grid;
}
public AABC(short x, short y, short z, AABCGrid grid)
: base(x, y, z)
{
this.grid = grid;
}
public AABC(AABC aABC)
: base(aABC)
{
this.grid = aABC.grid;
}
public AABCGridIterator(AABCGrid grid)
: base(grid)
{
}
protected AABCGridIteratorBase(AABCGrid grid)
{
this.grid = grid;
}
