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

posicion de un objeto en unity

Question

Tengo tres objetos de juego para niños (como puedes ver en la imagen de abajo con Rojo , Rosa y Azul ). Son hijos del objeto de juego padre Verde.

No sé, ¿cómo calcular el tamaño del GameObject Parent (Green)?

Estoy creando todos estos objetos del juego en tiempo de ejecución usando 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 gameObject principal (verde) después de agregar todos los elementos secundarios. My Parent (Green) no tiene nada asociado, ni siquiera ningún componente (BoxCollider, MeshFilter, MeshRenderer, etc.).

Adjunté BoxCollider, MeshRenderer & MeshFilter (solo para probar) y lo intenté con el padre:

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 del GameObject para Padres (Verde)?

Answer 1

Esta es una publicación más antigua, pero tenía una necesidad similar y me encontré con algunos problemas debido a unos pocos y-yas

Primero noté que mi caja principal calculada era más ancha de lo que debería haber sido y que no estaba centrada del todo bien

La causa fue que mis objetos tenían una rotación aplicada 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.

Segundo en mi caso, no todos los objetos de mi hijo tenían procesadores, además, mis hijos podrían tener hijos propios, así que no quiero centrarme en los niños transformados. 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;

Answer 2

Por tamaño ¿te refieres a 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);
}

Actualizar:

Alternativamente, si no desea un padre con un procesador de renders:

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

Mencionaste que no deseas usar una jerarquía de padres / hijos. 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.