/// <summary>
/// Calculates and returns the AABB that encloses all the 3D shapes which belong to the handle.
/// If the handle doesn't contain any 3D shapes or if none of them are marked as visible, an
/// invalid AABB will be returned. The 'Is3DVisible' property is ignored.
/// </summary>
public AABB GetVisible3DShapesAABB()
{
AABB aabb = AABB.GetInvalid();
if (Num3DShapes == 0)
{
return(aabb);
}
foreach (var shape in _3DShapes)
{
if (!shape.IsVisible)
{
continue;
}
AABB shapeAABB = shape.Shape.GetAABB();
if (shapeAABB.IsValid)
{
if (aabb.IsValid)
{
aabb.Encapsulate(shapeAABB);
}
else
{
aabb = shapeAABB;
}
}
}
return(aabb);
}
public AABB GetTargetObjectGroupWorldAABB()
{
if (_targetObjects == null)
{
return(AABB.GetInvalid());
}
var boundsQConfig = GetObjectBoundsQConfig();
AABB targetGroupAABB = AABB.GetInvalid();
foreach (var targetObject in _targetObjects)
{
AABB targetAABB = ObjectBounds.CalcWorldAABB(targetObject, boundsQConfig);
if (targetGroupAABB.IsValid)
{
targetGroupAABB.Encapsulate(targetAABB);
}
else
{
targetGroupAABB = targetAABB;
}
}
return(targetGroupAABB);
}
public void FitBoxToTargets()
{
if (NumTargetParents == 0)
{
_boxSize = Vector3.zero;
return;
}
if (ExtrudeSpace == GizmoSpace.Global)
{
AABB worldAABB = AABB.GetInvalid();
foreach (var parent in _targetParents)
{
AABB aabb = ObjectBounds.CalcHierarchyWorldAABB(parent, _boundsQConfig);
if (aabb.IsValid)
{
if (worldAABB.IsValid)
{
worldAABB.Encapsulate(aabb);
}
else
{
worldAABB = aabb;
}
}
}
SetAABB(worldAABB);
UpdateSnapSteps();
}
else
if (ExtrudeSpace == GizmoSpace.Local)
{
OBB worldOBB = ObjectBounds.CalcHierarchyWorldOBB(_targetParents[0], _boundsQConfig);
for (int parentIndex = 1; parentIndex < NumTargetParents; ++parentIndex)
{
GameObject parent = _targetParents[parentIndex];
OBB obb = ObjectBounds.CalcHierarchyWorldOBB(parent, _boundsQConfig);
if (obb.IsValid)
{
if (worldOBB.IsValid)
{
worldOBB.Encapsulate(obb);
}
else
{
worldOBB = obb;
}
}
}
SetOBB(worldOBB);
UpdateSnapSteps();
}
}
public static AABB CalcSpriteModelAABB(GameObject spriteObject)
{
SpriteRenderer spriteRenderer = spriteObject.GetComponent <SpriteRenderer>();
if (spriteRenderer == null)
{
return(AABB.GetInvalid());
}
return(spriteRenderer.GetModelSpaceAABB());
}
public static AABB CalcMeshModelAABB(GameObject gameObject)
{
Mesh mesh = gameObject.GetMesh();
if (mesh == null)
{
return(AABB.GetInvalid());
}
return(new AABB(mesh.bounds));
}
public static AABB CalcHierarchyWorldAABB(GameObject root, QueryConfig queryConfig)
{
AABB modelAABB = CalcHierarchyModelAABB(root, queryConfig);
if (!modelAABB.IsValid)
{
return(AABB.GetInvalid());
}
modelAABB.Transform(root.transform.localToWorldMatrix);
return(modelAABB);
}
/// <summary>
/// Returns the sprite's model space AABB. The function will return an invalid
/// AABB if the sprite renderer doesn't have a sprite associated with it.
/// </summary>
public static AABB GetModelSpaceAABB(this SpriteRenderer spriteRenderer)
{
// Store sprite for easy access and bail if no sprite exists
Sprite sprite = spriteRenderer.sprite;
if (sprite == null)
{
return(AABB.GetInvalid());
}
// Retrieve the sprite's verts and use them to build the AABB
List <Vector2> spriteVerts = new List <Vector2>(sprite.vertices);
return(new AABB(spriteVerts));
}
public static AABB CalcObjectCollectionWorldAABB(IEnumerable <GameObject> gameObjectCollection, QueryConfig queryConfig)
{
AABB aabb = AABB.GetInvalid();
foreach (var gameObject in gameObjectCollection)
{
AABB worldAABB = CalcWorldAABB(gameObject, queryConfig);
if (worldAABB.IsValid)
{
if (aabb.IsValid)
{
aabb.Encapsulate(worldAABB);
}
else
{
aabb = worldAABB;
}
}
}
return(aabb);
}
public static AABB CalcModelAABB(GameObject gameObject, QueryConfig queryConfig, GameObjectType objectType)
{
if ((objectType & queryConfig.ObjectTypes) == 0)
{
return(AABB.GetInvalid());
}
if (objectType == GameObjectType.Mesh)
{
Mesh mesh = gameObject.GetMesh();
if (mesh == null)
{
return(AABB.GetInvalid());
}
return(new AABB(mesh.bounds));
}
else
if (objectType == GameObjectType.Sprite)
{
return(CalcSpriteModelAABB(gameObject));
}
else if (objectType == GameObjectType.Terrain)
{
Terrain terrain = gameObject.GetComponent <Terrain>();
TerrainData terrainData = terrain.terrainData;
if (terrainData == null)
{
return(AABB.GetInvalid());
}
Vector3 terrainSize = terrainData.bounds.size;
return(new AABB(terrainData.bounds.center, terrainSize));
}
else
{
return(new AABB(Vector3.zero, queryConfig.NoVolumeSize));
}
}
public static AABB CalcHierarchyCollectionWorldAABB(List <GameObject> roots, QueryConfig queryConfig)
{
AABB aabb = AABB.GetInvalid();
foreach (var root in roots)
{
AABB hierarchyAABB = CalcHierarchyWorldAABB(root, queryConfig);
if (hierarchyAABB.IsValid)
{
if (aabb.IsValid)
{
aabb.Encapsulate(hierarchyAABB);
}
else
{
aabb = hierarchyAABB;
}
}
}
return(aabb);
}
public AABB GetVisible3DHandlesAABB()
{
AABB aabb = AABB.GetInvalid();
int numHandles = _handles.Count;
for (int handleIndex = 0; handleIndex < numHandles; ++handleIndex)
{
var handle = _handles[handleIndex];
AABB handleAABB = handle.GetVisible3DShapesAABB();
if (handleAABB.IsValid)
{
if (aabb.IsValid)
{
aabb.Encapsulate(handleAABB);
}
else
{
aabb = handleAABB;
}
}
}
return(aabb);
}
public void FitBoxToTargets()
{
if (NumTargetParents == 0)
{
_boxSize = Vector3.zero;
return;
}
if (ExtrudeSpace == GizmoSpace.Global)
{
AABB worldAABB = AABB.GetInvalid();
foreach (var parent in _targetParents)
{
if (_ignoredParentObjects.Contains(parent))
{
continue;
}
AABB aabb = ObjectBounds.CalcHierarchyWorldAABB(parent, _boundsQConfig);
if (aabb.IsValid)
{
if (worldAABB.IsValid)
{
worldAABB.Encapsulate(aabb);
}
else
{
worldAABB = aabb;
}
}
}
SetAABB(worldAABB);
UpdateSnapSteps();
}
else
if (ExtrudeSpace == GizmoSpace.Local)
{
int firstParentIndex = 0;
while (firstParentIndex < NumTargetParents)
{
if (_ignoredParentObjects.Contains(_targetParents[firstParentIndex]))
{
++firstParentIndex;
}
else
{
break;
}
}
if (firstParentIndex == NumTargetParents)
{
SetOBB(OBB.GetInvalid());
UpdateSnapSteps();
return;
}
OBB worldOBB = ObjectBounds.CalcHierarchyWorldOBB(_targetParents[firstParentIndex], _boundsQConfig);
for (int parentIndex = firstParentIndex; parentIndex < NumTargetParents; ++parentIndex)
{
GameObject parent = _targetParents[parentIndex];
if (_ignoredParentObjects.Contains(parent))
{
continue;
}
OBB obb = ObjectBounds.CalcHierarchyWorldOBB(parent, _boundsQConfig);
if (obb.IsValid)
{
if (worldOBB.IsValid)
{
worldOBB.Encapsulate(obb);
}
else
{
worldOBB = obb;
}
}
}
SetOBB(worldOBB);
UpdateSnapSteps();
}
}
public bool Initialize(GameObject gameObject)
{
if (gameObject == null || _gameObject != null)
{
return(false);
}
Mesh mesh = gameObject.GetMesh();
Sprite sprite = gameObject.GetSprite();
if (mesh == null && sprite == null)
{
return(false);
}
bool useMesh = true;
if (mesh == null)
{
useMesh = false;
}
RTMesh rtMesh = null;
if (useMesh)
{
Renderer meshRenderer = gameObject.GetMeshRenderer();
if (meshRenderer == null || !meshRenderer.enabled)
{
useMesh = false;
}
rtMesh = RTMeshDb.Get.GetRTMesh(mesh);
if (rtMesh == null)
{
useMesh = false;
}
}
if (rtMesh == null && sprite == null)
{
return(false);
}
List <AABB> vertOverlapAABBs = BuildVertOverlapAABBs(gameObject, useMesh ? null : sprite, useMesh ? rtMesh : null);
if (vertOverlapAABBs.Count == 0)
{
return(false);
}
AABB modelAABB = useMesh ? rtMesh.AABB : ObjectBounds.CalcSpriteModelAABB(gameObject);
var aabbFaces = BoxMath.AllBoxFaces;
_gameObject = gameObject;
if (useMesh)
{
foreach (var aabbFace in aabbFaces)
{
AABB overlapAABB = vertOverlapAABBs[(int)aabbFace];
List <Vector3> overlappedVerts = rtMesh.OverlapModelVerts(overlapAABB);
Plane facePlane = BoxMath.CalcBoxFacePlane(modelAABB.Center, modelAABB.Size, Quaternion.identity, aabbFace);
overlappedVerts = facePlane.ProjectAllPoints(overlappedVerts);
_snapAreaBounds[(int)aabbFace] = new AABB(overlappedVerts);
_snapAreaDesc[(int)aabbFace] = BoxMath.GetBoxFaceAreaDesc(_snapAreaBounds[(int)aabbFace].Size, aabbFace);
}
}
else
{
foreach (var aabbFace in aabbFaces)
{
if (aabbFace != BoxFace.Front && aabbFace != BoxFace.Back)
{
AABB overlapAABB = vertOverlapAABBs[(int)aabbFace];
List <Vector3> overlappedVerts = ObjectVertexCollect.CollectModelSpriteVerts(sprite, overlapAABB);
Plane facePlane = BoxMath.CalcBoxFacePlane(modelAABB.Center, modelAABB.Size, Quaternion.identity, aabbFace);
overlappedVerts = facePlane.ProjectAllPoints(overlappedVerts);
_snapAreaBounds[(int)aabbFace] = new AABB(overlappedVerts);
_snapAreaDesc[(int)aabbFace] = BoxMath.GetBoxFaceAreaDesc(_snapAreaBounds[(int)aabbFace].Size, aabbFace);
}
else
{
_snapAreaBounds[(int)aabbFace] = AABB.GetInvalid();
_snapAreaDesc[(int)aabbFace] = BoxFaceAreaDesc.GetInvalid();
}
}
}
return(true);
}
