Come ottenere la dimensione dell'oggetto gioco principale?

Question

Ho tre oggetti di gioco del bambino (come potete vedere qui sotto nella foto con Red, Rosa & Blu). Sono figli del gioco genitore oggetto Verde.

Non so, come calcolare la dimensione del genitore (verde) GameObject?

sto creando tutti questi oggetti del gioco in fase di esecuzione utilizzando questo codice:

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

Questa funzione restituisce genitore (verde) gameObject dopo l'aggiunta di tutti i bambino. Mio padre (verde) non ha nulla a che fare con esso nemmeno alcun componente (BoxCollider, MeshFilter, MeshRenderer, ecc.).

avevo attaccato BoxCollider, MeshRenderer & MeshFilter (Solo per la prova) & ho provato il genitore:

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

Ma non funziona nulla. Ci restituiscono 1 o zero nei casi. Please help me in come ottenere dimensioni di GameObject (verde) Parent?

Answer 1

Con dimensioni vuoi dire i limiti? Se è così, dovrebbe essere molto più semplice di quello che hai fatto. Il mio codice non è stato testato, non ho Unity a portata di mano, ma dovrebbe funzionare. Suppone che "genitore" sia un oggetto di gioco nella tua gerarchia e che abbia "figli" sotto di esso nella gerarchia.

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

Aggiornamento:

In alternativa, se non si vuole un genitore con un renderer:

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

non Lei ha parlato di voler utilizzare una gerarchia padre/figlio. Se non segui questa strada, devi aggiungere i "bambini" ad una sorta di array o dovrai usare il metodo GameObject.Find() per trovare ogni bambino per nome. Se si assegna qualcosa come "child_1", "child_2", è possibile cercarli abbastanza facilmente, ma è molto più semplice creare un oggetto genitore.

Answer 2

Questo è un messaggio vecchio, ma ho avuto una simile esigenza e corse in alcuni problemi a causa di un paio di GOT-yas

prima ho notato che la mia casella di genitore calcolato era più ampio di quello che avrebbe dovuto essere e che wasn 'centrato abbastanza a destra

La causa era che i miei oggetti avevano una rotazione applicata a loro e che i limiti non lo fanno mai; quindi, prima di eseguire i miei calcoli, dovevo innanzitutto tornare a zero; quindi una volta calcolato potrei ripristinare la rotazione originale.

Secondo nel mio caso, non tutti gli oggetti figlio mio avevano i renderer in aggiunta i miei figli potevano avere figli di li propri quindi non voglio calcolare al centro i bambini di trasformazione volevo che i componenti di rendering figlio.

Di seguito è il codice risultante mi è venuto in mente; commenti pesanti; non ottimizzato ma fa il trucco, conti per i nipoti se vuoi e gestisce gli oggetti con una rotazione all'avvio.

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