create barcode c#.net s GENERATING A TERRAIN in Font

Creator Data Matrix in Font s GENERATING A TERRAIN

private int[] GenerateTerrainIndices() { int numIndices = numTriangles * 3; int[] indices = new int[numIndices]; int indicesCount = 0; for (int i = 0; i < (vertexCountZ - 1); i++) { for (int j = 0; j < (vertexCountX - 1); j++) { int index = j + i * vertexCountZ; // First triangle indices[indicesCount++] indices[indicesCount++] indices[indicesCount++] // Second triangle indices[indicesCount++] indices[indicesCount++] indices[indicesCount++] } } return indices; }

= index; = index + 1; = index + vertexCountX + 1; = index + vertexCountX + 1; = index + vertexCountX; = index;

In this section you ll create the GenerateTerrainVertices method to generate the mesh s vertices. You ll place the terrain vertices over the world s XZ plane, centering the terrain at the world position (0, 0). To do that, you first need to calculate half the terrain size along the X and Z axes, and then set the terrain s start position at minus its half size along the X and Z axes (-halfTerrainWidth, -halfTerrainDepth). You can calculate the terrain size through the terrain attributes: vertexCountX, which stores the number of vertices of the terrain along the X axis; vertexCountZ, which stores the number of vertices of the terrain along the Z axis; and blockScale, which stores the distance between the vertices in the X and Z axes. After calculating the terrain size, you just need to divide it by two, as shown next:

float float float float terrainWidth = (vertexCountX - 1) terrainDepth = (vertexCountZ - 1) halfTerrainWidth = terrainWidth * halfTerrainDepth = terrainDepth * * blockScale; * blockScale; 0.5f; 0.5f;

You can generate the terrain s vertex grid beginning at the terrain s start position and going over each row of the vertex grid, placing the vertices (going from X to +X), where each row is placed in a different grid column (going from Z to +Z). In this way, the grid s vertices have its position incremented along the X and Z axes according to the block scale that you defined, as shown in Figure 10-2. While placing the vertices, you ll use the previously stored height map data to set the vertex height along the Y axis. You ll also scale the height of the terrain by multiplying the height of each vertex by a scale factor: the heightScale attribute of the Terrain class. You can use the following code to correctly position the vertices over the terrain s vertex grid:

for (float i = -halfTerrainDepth; i <= halfTerrainDepth; i += blockScale) for (float j = -halfTerrainWidth; j <= halfTerrainWidth; j += blockScale) Position = (j, heightmap[vertexCount] * heightScale, i)

Each vertex also has a U and V texture coordinate that should vary between (0, 0) and (1, 1), where (0, 0) is the initial texture coordinate and (1, 1) the final texture coordinate. Figure 10-5 shows the texture coordinates of some vertices in a grid.

Figure 10-5. (Left) The texture coordinates for a grid of vertices. (Right) The UV axes over a texture map.

To calculate the correct texture coordinate for each vertex in the terrain, you first need to calculate the increment of the texture coordinate in the UV axis. You do so by dividing the maximum texture coordinate value (1.0) by the number of vertices minus 1, in each axis:

float tu = 0; float tv = 0; float tuDerivative = 1.0f / (vertexCountX - 1); float tvDerivative = 1.0f / (vertexCountZ - 1);

Then, you go through each vertex, setting its texture coordinate and incrementing it. Besides the position and texture coordinate, you still need to calculate the normal, tangent, and binormal for each vertex. To do that, create the GenerateTerrainNormals and GenerateTerrainTangentBinormal methods, which you call at the end of the GenerateTerrainVertices method. Next is the complete code for the GenerateTerrainVertices method:

private VertexPositionNormalTangentBinormal[] GenerateTerrainVertices( int[] terrainIndices) { float halfTerrainWidth = (vertexCountX - 1) * blockScale * 0.5f; float halfTerrainDepth = (vertexCountZ - 1) * blockScale * 0.5f; // Texture coordinates float tu = 0; float tv = 0; float tuDerivative = 1.0f / (vertexCountX - 1); float tvDerivative = 1.0f / (vertexCountZ - 1); int vertexCount = 0; // Create the vertex array VertexPositionNormalTangentBinormal[] vertices = new VertexPositionNormalTangentBinormal[vertexCountX * vertexCountZ]; // Set position and texture coordinate of each vertex for (float i = -halfTerrainDepth; i <= halfTerrainDepth; i += blockScale) { tu = 0.0f; for (float j = -halfTerrainWidth; j <= halfTerrainWidth; j += blockScale) { // Set vertex position and UV vertices[vertexCount].Position = new Vector3(j, heightmap[vertexCount] * heightScale, i); vertices[vertexCount].TextureCoordinate = new Vector2(tu, tv); tu += tuDerivative; vertexCount++; } tv += tvDerivative; }