Jak uzyskać rozmiar obiektu gry nadrzędnej?

Question

mam trzy obiekty gry dziecko (jak widać na zdjęciu poniżej z Red, Różowy & Niebieski). Są dzieckiem obiektu gry dla rodziców Green.

Nie wiem, jak obliczyć rozmiar Parent (Green) GameObject?

tworzę te wszystkie gry obiektów w czasie wykonywania przy użyciu tego kodu:

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

Funkcja ta zwraca rodzica (zielony) GameObject po dodaniu wszystkich Childs. Mój rodzic (zielony) nie ma nic z tym związanego, nawet żadnego komponentu (BoxCollider, MeshFilter, MeshRenderer itp.).

miałem dołączone BoxCollider, MeshRenderer & MeshFilter (tylko do testowania) & próbowałem na rodzica:

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

Ale nic nie działa. Zwraca 1 lub zero w przypadkach. Proszę mi pomóc, jak uzyskać rozmiar Parent (Green) GameObject?

Answer 1

Przez wielkości masz na myśli granice? Jeśli tak, to powinno być o wiele prostsze niż to, co zrobiłeś. Mój kod jest niesprawdzony, nie mam pod ręką Jedności, ale to powinno zadziałać. Zakłada on, że "rodzic" jest obiektem gry w hierarchii i ma pod nim "potomek" w hierarchii.

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

Aktualizacja:

Ewentualnie, jeśli nie chcesz rodzica z renderujący:

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

Nie wspomniano chcących korzystać z hierarchii nadrzędny/podrzędny. Jeśli nie pójdziesz tą drogą, musisz dodać "dzieci" do jakiejś tablicy lub będziesz musiał użyć metody GameObject.Find(), aby znaleźć każde dziecko według nazwy. Jeśli wymienisz coś takiego jak "child_1", "child_2", możesz dość łatwo je wyszukać, ale łatwiej jest po prostu utworzyć obiekt nadrzędny.

Answer 2

Jest to starszy post ale miałem podobną potrzebę i wpadł niektórych kwestiach z powodu kilku dostali-Yas

1-cia Zauważyłam, że moja oblicza pole rodzic był szerszy niż powinno być i że to nie było Centralnie całkiem dobrze

Powodem było to, że moje obiekty były obrócone w stosunku do nich i nigdy się nie zgadzają; więc przed uruchomieniem moich obliczeń najpierw musiałem obrócić się z powrotem do zera; po obliczeniu mogłem przywrócić pierwotny obrót.

Po drugie w moim przypadku nie wszystkie moje obiekty dziecięce miały renderers dodatkowo moje dzieci mogą mieć własne dzieci, więc nie chcę kalkulować na środku transformacji dzieci Chciałem, żeby dziecko renderowało komponenty.

Poniżej znajduje się wynikowy kod, który wymyśliłem; ciężkie komentarze; nie zoptymalizowany, ale działa, odpowiada wnuczkom, jeśli zechcesz i obsługuje obiekty z rotacją na starcie.

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