¿Cómo obtener el tamaño del objeto de juego principal?

Question

que tengo tres objetos del juego infantil (como se puede ver en la imagen de abajo con Rojo, Rosa & azul). Son hijos del objeto de juego padre Verde.

No sé, cómo calcular el tamaño de Parent (verde) GameObject?

estoy creando todos estos juegos objetos en tiempo de ejecución utilizando este código:

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;  
    } 

Esta función devuelve los padres GameObject (verde) después de añadir todos los niño. My Parent (Green) no tiene nada asociado, ni siquiera ningún componente (BoxCollider, MeshFilter, MeshRenderer, etc.).

me había fijado BoxCollider, MeshRenderer & MeshFilter (sólo para las pruebas) & me probé los padres:

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

Pero nada funciona. Allí devuelve 1 o cero en los casos. ¿Por favor, ayúdame en cómo obtener el tamaño de GameObject para padres (verde)?

Answer 1

Por tamaño Qué quiere decir los límites? Si es así, debería ser mucho más simple de lo que lo hizo. Mi código no ha sido probado, no tengo Unity a mano pero esto debería funcionar. Asume que 'padre' es un objeto del juego en su jerarquía y que tiene 'hijos' debajo de él en la jerarquía.

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

Actualización:

Como alternativa, si no desea que un padre con un procesador:

// 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); 
} 

Usted no se menciona que deseen utilizar una jerarquía de padre/hijo. Si no sigue esa ruta, debe agregar los "niños" a algún tipo de matriz o deberá usar el método GameObject.Find() para buscar a cada niño por su nombre. Si nombra algo como "child_1", "child_2", puede buscarlos con bastante facilidad, pero es mucho más sencillo crear un objeto principal.

Answer 2

Este es un mensaje más antiguo, pero yo tenía una necesidad similar y se encontró con algunos problemas debido a un par de GOT-yas

primera Noté que mi caja padre calculado fue mayor de lo que debería haber sido y que no estaba 'centrado bastante derecho

La causa fue que mis objetos tenían una rotación aplicada a ellos y los límites nunca lo hacen; entonces, antes de ejecutar mis cálculos, primero tuve que volver a girar a cero; luego, una vez calculado, pude restaurar la rotación original.

2º en mi caso no todos mis objetos secundarios tenían renderizadores, además mis hijos podrían tener hijos propios, así que no quiero calcular el centro en transformar niños. Quería que el niño representara los componentes.

A continuación se muestra el código resultante que se me ocurrió; comentarios pesados; no está optimizado, pero funciona, cuenta para los nietos si se quiere y maneja los objetos con una rotación al inicio.

 //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;