如何获取父游戏对象的大小？

Question

我有三个孩子的游戏对象（如你可以看到下面的图片与红，粉红 & 蓝）。他们是父母游戏对象Green的孩子。

我不知道，如何计算家长的大小（绿色）GameObject？

我在运行时使用此代码创建所有这些游戏对象：

GameObject CreatePattern(int difficultyLevel)  
    {  
     GameObject gameObjectTemp = new GameObject();  
     SinglePattern singlePattern;  
     gameObjectTemp = (GameObject) Instantiate(gameObjectTemp); 


     singlePattern = freeRunDataHandler.GetSinglePatternRandom(1);  
     GameObject gameObjectSingleObject = null;  
     foreach (SingleObject singleObject in singlePattern.singleObjectList)  
     { 
       gameObjectSingleObject = GetGameObjectByCategory(singleObject.catergory, singleObject.type); 

      if (gameObjectSingleObject != null)  
      {  
       gameObjectSingleObject = (GameObject) Instantiate(gameObjectSingleObject, new Vector3(singleObject.positionX, singleObject.positionY, singleObject.positionZ), Quaternion.identity);  
       gameObjectSingleObject.transform.localScale = new Vector3(singleObject.length, 1, singleObject.width);  
       gameObjectSingleObject.transform.parent = gameObjectTemp.transform;  
      }  
     }   

     return gameObjectTemp;  
    } 

此功能将所有孩子的后返回母（绿色）游戏对象。我的父母（绿色）没有任何附件，甚至没有任何组件（BoxCollider，MeshFilter，MeshRenderer等）。

我已经连接了BoxCollider，MeshRenderer & MeshFilter（只是用于测试）&我试着父：

parent.collider.bounds.size.x ----- > box collider 
parent.renderer.bounds.size.x ----- > mesh renderer 

但没有任何工程。在这种情况下返回1或零。 请帮我了解如何获取Parent（Green）GameObject的大小？

Answer 1

按大小你的意思是界限？如果是这样，它应该比你做得更简单。我的代码没有经过测试，我没有Unity方便，但这应该工作。它假定'父'是层次结构中的游戏对象，并且它在层次结构中具有“子”。

Bounds bounds = parent.renderer.bounds; 
foreach (Transform child in parent.transform) 
{ 
    bounds.encapsulate(child.gameObject.renderer.bounds); 
} 

更新：

另外，如果你不想渲染父：

// First find a center for your bounds. 
Vector3 center = Vector3.zero; 

foreach (Transform child in parent.transform) 
{ 
    center += child.gameObject.renderer.bounds.center; 
} 
center /= parent.transform.childCount; //center is average center of children 

//Now you have a center, calculate the bounds by creating a zero sized 'Bounds', 
Bounds bounds = new Bounds(center,Vector3.zero); 

foreach (Transform child in parent.transform) 
{ 
    bounds.encapsulate(child.gameObject.renderer.bounds); 
} 

你提到不想使用父/子层次结构。如果你不走这条路线，你需要将“children”添加到某种数组中，否则你必须使用GameObject.Find（）方法来按名称查找每个孩子。如果你命名为“child_1”，“child_2”，你可以很容易地查看它们，但是简单地创建一个父对象只是一个简单的黑客攻击。

Answer 2

这是一个老的文章，但我也有类似的需求，并遇到了一些问题，由于一些有-亚斯

1我注意到我的计算父盒子是宽度比它应该是，它WASN不太对中

原因是我的对象有一个旋转适用于他们和界限永远不会;所以在运行我的计算之前，我首先需要回到零点;然后一旦计算，我可以恢复原来的旋转。

在我的情况下，并非所有的子对象都具有渲染器此外，我的孩子可能有自己的孩子，所以我不想计算转换子对象的中心我想要子渲染组件。

下面是我想出的结果代码;沉重的评论;没有优化，但做的伎俩，如果你愿意和孙子，并开始旋转处理对象。

 //Store our current rotation 
     Vector3 LocalAngle = transform.localEulerAngles; 
     //Zero the rotation before we calculate as bounds are never rotated 
     transform.localEulerAngles = Vector3.zero; 
     //Establish a default center location 
     Vector3 center = Vector3.zero; 
     //Establish a default empty bound 
     occupiedSpace = new Bounds (Vector3.zero, Vector3.zero); 
     //Count the children with renderers 
     int count = 0; 
     //We only count childrent with renderers which should be fine as the bounds center is global space 
     foreach (Renderer render in transform.GetComponentsInChildren<Renderer>()) { 
      center += render.bounds.center; 
      count++; 
     } 
     //Return the average center assuming we have any renderers 
     if(count > 0) 
      center /= count; 
     //Update the parent bound accordingly 
     occupiedSpace.center = center; 
     //Again for each and only after updating the center expand via encapsulate 
     foreach (Renderer render in transform.GetComponentsInChildren<Renderer>()) { 
      occupiedSpace.Encapsulate(render.bounds); 
     } 
     //In by case I want to update the parents box collider so first I need to bring things into local space 
     occupiedSpace.center -= transform.position; 
     boxCollider.center = occupiedSpace.center; 
     boxCollider.size = occupiedSpace.size; 
     //Restore our original rotation 
     transform.localEulerAngles = LocalAngle;