public static void BuildMeshFromNodeHandleForColoredCubesVolume(Mesh mesh, uint nodeHandle, bool onlyPositions) { // Get the data from Cubiquity. ColoredCubesVertex[] vertices; ushort[] indices; CubiquityDLL.GetMesh <ColoredCubesVertex>(nodeHandle, out vertices, out indices); int noOfVertices = vertices.Length; int noOfIndices = indices.Length; #endif // Cubiquity uses 16-bit index arrays to save space, and it appears Unity does the same (at least, there is // a limit of 65535 vertices per mesh). However, the Mesh.triangles property is of the signed 32-bit int[] // type rather than the unsigned 16-bit ushort[] type. Perhaps this is so they can switch to 32-bit index // buffers in the future? At any rate, it means we have to perform a conversion. int[] indicesAsInt = new int[noOfIndices]; for (int ct = 0; ct < noOfIndices; ct++) { indicesAsInt[ct] = indices[ct]; } // Clear any previous mesh data. mesh.Clear(true); // Required for the CubicVertex decoding process. Vector3 offset = new Vector3(0.5f, 0.5f, 0.5f); // Copy the vertex positions from Cubiquity into the Unity mesh. Vector3[] positions = new Vector3[noOfVertices]; for (int ct = 0; ct < noOfVertices; ct++) { // Get and decode the position positions[ct].Set(vertices[ct].x, vertices[ct].y, vertices[ct].z); positions[ct] -= offset; } // Assign vertex data to the mesh. mesh.vertices = positions; // For collision meshes the vertex positions are enough, but // for meshes which are rendered we want all vertex attributes. if (!onlyPositions) { Color32[] colors32 = new Color32[noOfVertices]; for (int ct = 0; ct < noOfVertices; ct++) { // Get and decode the color colors32[ct] = (Color32)vertices[ct].color; } // Assign vertex data to the mesh. mesh.colors32 = colors32; } // Assign index data to the mesh. mesh.triangles = indicesAsInt; }
public static void BuildMeshFromNodeHandleForTerrainVolume(Mesh mesh, uint nodeHandle, bool onlyPositions) { // Get the data from Cubiquity. TerrainVertex[] vertices; ushort[] indices; CubiquityDLL.GetMesh <TerrainVertex>(nodeHandle, out vertices, out indices); int noOfVertices = vertices.Length; int noOfIndices = indices.Length; #endif // Cubiquity uses 16-bit index arrays to save space, and it appears Unity does the same (at least, there is // a limit of 65535 vertices per mesh). However, the Mesh.triangles property is of the signed 32-bit int[] // type rather than the unsigned 16-bit ushort[] type. Perhaps this is so they can switch to 32-bit index // buffers in the future? At any rate, it means we have to perform a conversion. int[] indicesAsInt = new int[noOfIndices]; for (int ct = 0; ct < noOfIndices; ct++) { indicesAsInt[ct] = indices[ct]; } // Clear any previous mesh data. mesh.Clear(true); // Create the arrays which we'll copy the data to. Vector3[] positions = new Vector3[noOfVertices]; Vector3[] normals = new Vector3[noOfVertices]; Color32[] colors32 = new Color32[noOfVertices]; Vector2[] uv = new Vector2[noOfVertices]; Vector2[] uv2 = new Vector2[noOfVertices]; // Copy the vertex positions from Cubiquity into the Unity mesh. for (int ct = 0; ct < noOfVertices; ct++) { // Get and decode the position positions[ct].Set(vertices[ct].x, vertices[ct].y, vertices[ct].z); positions[ct] *= (1.0f / 256.0f); } // Assign vertex data to the mesh. mesh.vertices = positions; // For collision meshes the vertex positions are enough, but // for meshes which are rendered we want all vertex attributes. if (!onlyPositions) { for (int ct = 0; ct < noOfVertices; ct++) { // Get the materials. Some are stored in color... colors32[ct].r = vertices[ct].m0; colors32[ct].g = vertices[ct].m1; colors32[ct].b = vertices[ct].m2; colors32[ct].a = vertices[ct].m3; // And some are stored in UVs. uv[ct].Set(vertices[ct].m4 / 255.0f, vertices[ct].m5 / 255.0f); uv2[ct].Set(vertices[ct].m6 / 255.0f, vertices[ct].m7 / 255.0f); // Get and decode the normal ushort ux = (ushort)((vertices[ct].normal >> (ushort)8) & (ushort)0xFF); ushort uy = (ushort)((vertices[ct].normal) & (ushort)0xFF); // Convert to floats in the range [-1.0f, +1.0f]. float ex = ux * (1.0f / 127.5f) - 1.0f; float ey = uy * (1.0f / 127.5f) - 1.0f; // Reconstruct the origninal vector. This is a C++ implementation // of Listing 2 of http://jcgt.org/published/0003/02/01/ float vx = ex; float vy = ey; float vz = 1.0f - Math.Abs(ex) - Math.Abs(ey); if (vz < 0.0f) { float refX = ((1.0f - Math.Abs(vy)) * (vx >= 0.0f ? +1.0f : -1.0f)); float refY = ((1.0f - Math.Abs(vx)) * (vy >= 0.0f ? +1.0f : -1.0f)); vx = refX; vy = refY; } normals[ct].Set(vx, vy, vz); } // Assign vertex data to the mesh. mesh.normals = normals; mesh.colors32 = colors32; mesh.uv = uv; mesh.uv2 = uv2; } // Assign index data to the mesh. mesh.triangles = indicesAsInt; }