In Unity3D, sto seguendo un tutorial sulla tilemap. Tuttavia, il layout UV sta venendo fuori strano. Come posso risolvere questo?

Question

Sto seguendo questo set di esercitazioni: https://www.youtube.com/watch?v=owBt9SNKXCI&index=6&list=PLbghT7MmckI4qGA0Wm_TZS8LVrqS47I9R per creare dinamicamente un layout di mappa di tile. Funziona su un punto, ma genera un layout molto strano con piastrelle di dimensioni 128 x 128.

Chiaramente quella strana partizionamento non dovrebbe succedere, ma io non riesco a rintracciare quello che sta succedendo a causare. Ecco la mia versione del codice, che è in gran parte identica a delle quill18creates versione sans alcune piccole differenze:

using UnityEngine; 
using System.Collections; 

[ExecuteInEditMode] 
public class TileMap : MonoBehaviour { 

    public int size_x = 100; 
    public int size_z = 50; 
    public float tileSize = 1.0f; 

    public Texture2D terrainTiles; 
    int tileResolution = 128; 

    // Use this for initialization 
    void Start() { 
     BuildMesh(); 
    } 

    Color[][] ChopUpTiles() { 
     int numTilesPerRow = terrainTiles.width/tileResolution; 
     int numRows = terrainTiles.height/tileResolution; 

     Color[][] tiles = new Color[numTilesPerRow*numRows][]; 

     for(int y=0; y < numRows; y++) { 
      for(int x=0; x < numTilesPerRow; x++) { 
       tiles[y * numTilesPerRow + x] = terrainTiles.GetPixels(x*tileResolution , y*tileResolution, tileResolution, tileResolution); 
      } 
     } 

     return tiles; 
    } 

    void BuildTexture() { 
     //DTileMap map = new DTileMap(size_x, size_z); 

     int texWidth = size_x * tileResolution; 
     int texHeight = size_z * tileResolution; 
     Texture2D texture = new Texture2D(texWidth, texHeight); 

     Color[][] tiles = ChopUpTiles(); 


     for(int y=0; y < size_z; y++) { 
      for(int x=0; x < size_x; x++) { 
       Color[] p = tiles[Mathf.RoundToInt(Random.Range(0, 5))]; 
       texture.SetPixels(x * tileResolution, y * tileResolution, tileResolution, tileResolution, p); 
      } 
     } 

     //texture.filterMode = FilterMode.Bilinear; 
     texture.wrapMode = TextureWrapMode.Clamp; 
     texture.Apply(); 

     MeshRenderer mesh_renderer = GetComponent<MeshRenderer>(); 
     mesh_renderer.sharedMaterials[0].mainTexture = texture; 
    } 

    public void BuildMesh() { 
     int numTiles = size_x * size_z; 
     int numTris = numTiles * 2; 

     int vsize_x = size_x + 1; 
     int vsize_z = size_z + 1; 
     int numVerts = vsize_x * vsize_z; 

     // Generate the mesh data 
     Vector3[] vertices = new Vector3[ numVerts ]; 
     Vector3[] normals = new Vector3[numVerts]; 
     Vector2[] uv = new Vector2[numVerts]; 

     int[] triangles = new int[ numTris * 3 ]; 

     int x, z; 
     for(z=0; z < vsize_z; z++) { 
      for(x=0; x < vsize_x; x++) { 
       vertices[ z * vsize_x + x ] = new Vector3(x*tileSize, 0, -z*tileSize); 
       normals[ z * vsize_x + x ] = Vector3.up; 
       uv[ (z * vsize_x) + x ] = new Vector2((float)x/size_x, (float)z/size_z); 
      } 
     } 
     Debug.Log ("Done Verts!"); 

     for(z=0; z < size_z; z++) { 
      for(x=0; x < size_x; x++) { 
       int squareIndex = z * size_x + x; 
       int triOffset = squareIndex * 6; 
       triangles[triOffset + 0] = z * vsize_x + x +   0; 
       triangles[triOffset + 2] = z * vsize_x + x + vsize_x + 0; 
       triangles[triOffset + 1] = z * vsize_x + x + vsize_x + 1; 

       triangles[triOffset + 3] = z * vsize_x + x +   0; 
       triangles[triOffset + 5] = z * vsize_x + x + vsize_x + 1; 
       triangles[triOffset + 4] = z * vsize_x + x +   1; 
      } 
     } 

     // Create a new Mesh and populate with the data 
     Mesh mesh = new Mesh(); 
     mesh.vertices = vertices; 
     mesh.triangles = triangles; 
     mesh.normals = normals; 
     mesh.uv = uv; 

     // Assign our mesh to our filter/renderer/collider 
     MeshFilter mesh_filter = GetComponent<MeshFilter>(); 
     MeshCollider mesh_collider = GetComponent<MeshCollider>(); 

     mesh_filter.mesh = mesh; 
     mesh_collider.sharedMesh = mesh; 


     BuildTexture(); 
    } 
} 

Answer 1

Non capisco esattamente quale parte è sbagliato nell'immagine, ma penso che sia che le stesse piastrelle stanno ammassando insieme. Ho provato il tuo codice e funziona bene per me. Ma credo che la parte seguente potrebbe essere la causa del problema senza distinzione insieme per voi:

Color[] p = tiles[Mathf.RoundToInt(Random.Range(0, 5))]; 

Invece si dovrebbe fare:

Color[] p = tiles[Random.Range(0, 5)]; 

Perché, al contrario, a caso sta generando numeri float e forse lo sono vicini l'uno all'altra che arrotondandoli all'intero dà la stessa tessera. Provaci. Anche solo ricordando, assicurati che la larghezza e l'altezza della tua trama siano divisibili per 128.

Answer 2

Beh, era sicuramente un problema di dimensioni, ma c'era anche un problema con il posizionamento. Le tessere devono iniziare nell'angolo in basso a sinistra per il sistema di coordinate per trovarle.