internal static void CheckRectangle(Brush brush, Pen pen, Rect rectangle, int width, int height, [CallerMemberName] string methodName = "unknown") { Application.EnableMSAA = false; MeshBuffer meshBuffer = new MeshBuffer(); MeshList meshList = new MeshList(); BuiltinGeometryRenderer renderer = new BuiltinGeometryRenderer(); byte[] bytes; using (var context = new RenderContextForTest(width, height)) { renderer.OnBeforeRead(); renderer.DrawRectangle(brush, pen, rectangle);//This must be called after the RenderContextForTest is created, for uploading textures to GPU via OpenGL. renderer.OnAfterRead(meshList); //rebuild mesh buffer meshBuffer.Clear(); meshBuffer.Init(); meshBuffer.Append(meshList); //draw mesh buffer to screen context.Clear(); context.DrawMeshes(meshBuffer); bytes = context.GetRenderedRawBytes(); } Util.CheckExpectedImage(bytes, width, height, $"{RootDir}{nameof(DrawRectangle)}\\{methodName}.png"); }
void generateMultiple16bitMeshbuffers(int N) { Vertex3D[] vertices32bit; uint[] indices32bit; generateVerticesAndIndices(N, out vertices32bit, out indices32bit); List <Vertex3D> verticesChunk = new List <Vertex3D>(); List <ushort> indicesChunk = new List <ushort>(); int totalCubes = N * N * N; int indicesInCube = indices32bit.Length / totalCubes; int verticesInCube = vertices32bit.Length / totalCubes; int maximumVerticesPerChunk = ushort.MaxValue; // must not be more than 0xffff (because we use 16-bit indices) int verticesIndexOffset = 0; device.Logger.Log("Batching cubes into 16-bit meshbuffers..."); for (int cubeIndex = 0; cubeIndex < totalCubes; cubeIndex++) { // add vertices for (int i = 0; i < verticesInCube; i++) { verticesChunk.Add(vertices32bit[cubeIndex * verticesInCube + i]); } // add indices for (int i = 0; i < indicesInCube; i++) { indicesChunk.Add((ushort)(indices32bit[cubeIndex * indicesInCube + i] - verticesIndexOffset)); } if (verticesChunk.Count + verticesInCube > maximumVerticesPerChunk || // if this chunk is full cubeIndex == totalCubes - 1) // or this is last cube { // we create meshbuffer and add it to the main mesh MeshBuffer mb = MeshBuffer.Create(VertexType.Standard, IndexType._16Bit); mb.SetHardwareMappingHint(HardwareMappingHint.Static, HardwareBufferType.VertexAndIndex); //mb.Append(verticesChunk.ToArray(), indicesChunk.ToArray()); mb.Append(verticesChunk.ToArray(), indicesChunk.ToArray()); mb.RecalculateBoundingBox(); mesh.AddMeshBuffer(mb); mb.Drop(); // clean up vertex and index chunks verticesIndexOffset += verticesChunk.Count; verticesChunk.Clear(); indicesChunk.Clear(); device.Logger.Log( (((cubeIndex + 1) * 100) / totalCubes) + "%: " + mesh + ". ~" + Program.MemUsageText); GC.Collect(); } } }
/// <summary> /// Generates a MeshBuffer which represents all the vertices and indices for values of y /// between y0 and y1, and add it to the mesh. /// </summary> void addStrip(HeightMap map, ColorFunc cf, int y0, int y1) { Vertex3D[] vertices = new Vertex3D[(y1 - y0 + 1) * width]; ushort[] indices = new ushort[(y1 - y0) * (width - 1) * 6]; // "6" is a number of indices in 2 triangles (which forms a quad) // calculate vertices int i = 0; for (int y = y0; y <= y1; ++y) { for (int x = 0; x < width; ++x) { float z = map.GetHeight(x, y); float xf = (float)x / (float)width; float yf = (float)y / (float)height; vertices[i++] = new Vertex3D( new Vector3Df(x, scale * z, y), // position map.GetNormal(x, y, scale), // normal calculate(cf, xf, yf, z), // color new Vector2Df(xf, yf) // tcoords ); } } // calculate indices i = 0; for (int y = y0; y < y1; ++y) { for (int x = 0; x < width - 1; ++x) { int n = (y - y0) * width + x; indices[i++] = (ushort)n; indices[i++] = (ushort)(n + width); indices[i++] = (ushort)(n + width + 1); indices[i++] = (ushort)(n + width + 1); indices[i++] = (ushort)(n + 1); indices[i++] = (ushort)n; } } // append calculated verices and indices to mesh buffer MeshBuffer buf = MeshBuffer.Create(VertexType.Standard, IndexType._16Bit); // create new buffer Mesh.AddMeshBuffer(buf); buf.Append(vertices, indices); buf.RecalculateBoundingBox(); buf.Drop(); }
internal static void DrawNodeTreeToImage(out byte[] imageRawBytes, Node root, int width, int height, Rect clipRect) { if (root == null) { throw new ArgumentNullException(nameof(root)); } MeshBuffer meshBuffer = new MeshBuffer(); MeshList meshList = new MeshList(); BuiltinGeometryRenderer geometryRenderer = new BuiltinGeometryRenderer(); using (var context = new RenderContextForTest(width, height)) { if (root is Node rootNode) { using (var dc = rootNode.RenderOpen()) { dc.DrawBoxModel(rootNode.RuleSet, rootNode.Rect); } } root.Foreach(visual => { if (!(visual is Node node)) { return(true); } using (var dc = node.RenderOpen()) { dc.DrawBoxModel(node.RuleSet, node.Rect); } return(true); }); //This must be called after the context is created, for uploading textures to GPU via OpenGL. root.Render(new RenderContext(geometryRenderer, meshList)); //rebuild mesh buffer meshBuffer.Clear(); meshBuffer.Init(); meshBuffer.Append(meshList); //draw mesh buffer to screen context.Clear(); context.DrawMeshes(meshBuffer); imageRawBytes = context.GetRenderedRawBytes(); } }
void generateSingle32BitMeshbuffer(int N) { Vertex3D[] vertices32bit; uint[] indices32bit; generateVerticesAndIndices(N, out vertices32bit, out indices32bit); MeshBuffer mb = MeshBuffer.Create(VertexType.Standard, IndexType._32Bit); mesh.AddMeshBuffer(mb); mb.Drop(); device.Logger.Log("Appending " + vertices32bit.Length + " vertices and " + indices32bit.Length + " indices to 32-bit meshbuffer..."); mb.Append(vertices32bit, indices32bit); mb.SetHardwareMappingHint(HardwareMappingHint.Static, HardwareBufferType.VertexAndIndex); }
internal static void DrawDrawingVisualToImage(out byte[] imageRawBytes, int width, int height, DrawingVisual drawingVisual) { //convert geometries inside the drawingVisual's content to meshes stored in a MeshList with a BuiltinGeometryRenderer MeshList meshList = new MeshList(); using BuiltinGeometryRenderer geometryRenderer = new BuiltinGeometryRenderer(); RenderContext renderContext = new RenderContext(geometryRenderer, meshList); drawingVisual.RenderContent(renderContext); //merge meshes in the MeshList to a MeshBuffer MeshBuffer meshBuffer = new MeshBuffer(); meshBuffer.Clear(); meshBuffer.Init(); meshBuffer.Append(meshList); //created a mesh IRenderer Application.Init(); var window = Application.PlatformContext.CreateWindow(Point.Zero, new Size(100, 100), WindowTypes.Hidden); var renderer = Application.PlatformContext.CreateRenderer(window) as Win32OpenGLRenderer;//TEMP HACK Debug.Assert(renderer != null, nameof(renderer) + " != null"); renderer.Init(window.Pointer, window.ClientSize); //clear the canvas and draw mesh in the MeshBuffer with the mesh renderer renderer.Clear(Color.White); renderer.StartDrawMeshToImage(width, height); imageRawBytes = renderer.DrawMeshToImage(width, height, meshBuffer.ShapeMesh, OpenGLMaterial.shapeMaterial); renderer.EndDrawMeshToImage(); //clear native resources: window and IRenderer renderer.ShutDown(); window.Close(); }
/// <summary> /// Read mesh chunk and buffer infos. /// </summary> public void LoadData(CR2WFile meshFile) { // IMPLEMENTED FROM jlouis' witcherconverter // http://jlouisb.users.sourceforge.net/ // https://bitbucket.org/jlouis/witcherconverter SBufferInfos bufferInfos = new SBufferInfos(); // *************** READ CHUNK INFOS *************** foreach (var chunk in meshFile.chunks) { if (chunk.Type == "CMesh") { List <SVertexBufferInfos> vertexBufferInfos = new List <SVertexBufferInfos>(); var cookedDatas = chunk.GetVariableByName("cookedData") as CVector; foreach (var cookedData in cookedDatas.variables) { switch (cookedData.Name) { case "renderChunks": { var bytes = ((CByteArray)cookedData).Bytes; using (MemoryStream ms = new MemoryStream(bytes)) using (BinaryReader br = new BinaryReader(ms)) { var nbBuffers = br.ReadByte(); for (uint i = 0; i < nbBuffers; i++) { SVertexBufferInfos buffInfo = new SVertexBufferInfos(); br.BaseStream.Position += 1; // Unknown buffInfo.verticesCoordsOffset = br.ReadUInt32(); buffInfo.uvOffset = br.ReadUInt32(); buffInfo.normalsOffset = br.ReadUInt32(); br.BaseStream.Position += 9; // Unknown buffInfo.indicesOffset = br.ReadUInt32(); br.BaseStream.Position += 1; // 0x1D buffInfo.nbVertices = br.ReadUInt16(); buffInfo.nbIndices = br.ReadUInt32(); br.BaseStream.Position += 3; // Unknown buffInfo.lod = br.ReadByte(); // lod ? vertexBufferInfos.Add(buffInfo); } } break; } case "indexBufferOffset": { bufferInfos.indexBufferOffset = uint.Parse(cookedData.ToString()); break; } case "indexBufferSize": { bufferInfos.indexBufferSize = uint.Parse(cookedData.ToString()); break; } case "vertexBufferOffset": { bufferInfos.vertexBufferOffset = uint.Parse(cookedData.ToString()); break; } case "vertexBufferSize": { bufferInfos.vertexBufferSize = uint.Parse(cookedData.ToString()); break; } case "quantizationOffset": { bufferInfos.quantizationOffset.X = float.Parse((cookedData as CVector).variables[0].ToString()); bufferInfos.quantizationOffset.Y = float.Parse((cookedData as CVector).variables[1].ToString()); bufferInfos.quantizationOffset.Z = float.Parse((cookedData as CVector).variables[2].ToString()); break; } case "quantizationScale": { bufferInfos.quantizationScale.X = float.Parse((cookedData as CVector).variables[0].ToString()); bufferInfos.quantizationScale.Y = float.Parse((cookedData as CVector).variables[1].ToString()); bufferInfos.quantizationScale.Z = float.Parse((cookedData as CVector).variables[2].ToString()); break; } case "bonePositions": { foreach (CVector item in cookedData as CArray) { if (item.variables.Count == 4) { Vector3Df pos = new Vector3Df(); pos.X = (item.variables[0] as CFloat).val; pos.Y = (item.variables[1] as CFloat).val; pos.Z = (item.variables[2] as CFloat).val; bonePositions.Add(pos); } } break; } } } bufferInfos.verticesBuffer = vertexBufferInfos; var meshChunks = chunk.GetVariableByName("chunks") as CArray; foreach (var meshChunk in meshChunks.array) { SMeshInfos meshInfo = new SMeshInfos(); foreach (var meshinfo in (meshChunk as CVector).variables) { switch (meshinfo.Name) { case "numVertices": { meshInfo.numVertices = uint.Parse(meshinfo.ToString()); break; } case "numIndices": { meshInfo.numIndices = uint.Parse(meshinfo.ToString()); break; } case "numBonesPerVertex": { meshInfo.numBonesPerVertex = uint.Parse(meshinfo.ToString()); break; } case "firstVertex": { meshInfo.firstVertex = uint.Parse(meshinfo.ToString()); break; } case "firstIndex": { meshInfo.firstIndex = uint.Parse(meshinfo.ToString()); break; } case "vertexType": { if ((meshinfo as CName).Value == "MVT_StaticMesh") { meshInfo.vertexType = SMeshInfos.EMeshVertexType.EMVT_STATIC; } else if ((meshinfo as CName).Value == "MVT_SkinnedMesh") { meshInfo.vertexType = SMeshInfos.EMeshVertexType.EMVT_SKINNED; } break; } case "materialID": { meshInfo.materialID = uint.Parse(meshinfo.ToString()); break; } } } CData.meshInfos.Add(meshInfo); } // TODO: Create a more reliable solution var unknownBytes = chunk.unknownBytes.Bytes; using (var ms = new MemoryStream(unknownBytes)) using (var br = new BinaryReader(ms)) { long prevPos = 0; bool correctPos = false; do { prevPos = br.BaseStream.Position; CData.boneData.nbBones = (uint)br.ReadBit6(); if (CData.boneData.nbBones == bonePositions.Count) { var backPos = br.BaseStream.Position; correctPos = true; for (int i = 0; i < CData.boneData.nbBones; i++) { var stringIdx = br.ReadUInt16(); if (stringIdx == 0 || stringIdx >= meshFile.names.Count) { CData.boneData.nbBones = 0; correctPos = false; break; } } br.BaseStream.Position = backPos; } } while (CData.boneData.nbBones != bonePositions.Count && br.BaseStream.Position < unknownBytes.Length && !correctPos); if (br.BaseStream.Position < unknownBytes.Length) { br.BaseStream.Position = prevPos; CData.boneData.nbBones = (uint)br.ReadBit6(); for (uint i = 0; i < CData.boneData.nbBones; i++) { var stringIdx = br.ReadUInt16(); CData.boneData.jointNames.Add(meshFile.names[stringIdx].str); } br.ReadBit6(); for (uint i = 0; i < CData.boneData.nbBones; i++) { Matrix matrix = new Matrix(); for (int j = 0; j < 16; j++) { var value = br.ReadSingle(); matrix.SetElement(j, value); } CData.boneData.boneMatrices.Add(matrix); } } } } else if (chunk.Type == "CMaterialInstance") { CData.materialInstances.Add(chunk.data as CMaterialInstance); } } // *************** READ MESH BUFFER INFOS *************** foreach (var meshInfo in CData.meshInfos) { SVertexBufferInfos vBufferInf = new SVertexBufferInfos(); uint nbVertices = 0; uint firstVertexOffset = 0; uint nbIndices = 0; uint firstIndiceOffset = 0; for (int i = 0; i < bufferInfos.verticesBuffer.Count; i++) { nbVertices += bufferInfos.verticesBuffer[i].nbVertices; if (nbVertices > meshInfo.firstVertex) { vBufferInf = bufferInfos.verticesBuffer[i]; // the index of the first vertex in the buffer firstVertexOffset = meshInfo.firstVertex - (nbVertices - vBufferInf.nbVertices); break; } } for (int i = 0; i < bufferInfos.verticesBuffer.Count; i++) { nbIndices += bufferInfos.verticesBuffer[i].nbIndices; if (nbIndices > meshInfo.firstIndex) { vBufferInf = bufferInfos.verticesBuffer[i]; firstIndiceOffset = meshInfo.firstIndex - (nbIndices - vBufferInf.nbIndices); break; } } // Load only best LOD if (vBufferInf.lod == 1) { using (BinaryReader br = new BinaryReader(File.Open(meshFile.FileName + ".1.buffer", FileMode.Open))) { uint vertexSize = 8; if (meshInfo.vertexType == SMeshInfos.EMeshVertexType.EMVT_SKINNED) { vertexSize += meshInfo.numBonesPerVertex * 2; } br.BaseStream.Seek(vBufferInf.verticesCoordsOffset + firstVertexOffset * vertexSize, SeekOrigin.Begin); List <Vertex3D> vertex3DCoords = new List <Vertex3D>(); Color defaultColor = new Color(255, 255, 255, 255); for (uint i = 0; i < meshInfo.numVertices; i++) { ushort x = br.ReadUInt16(); ushort y = br.ReadUInt16(); ushort z = br.ReadUInt16(); ushort w = br.ReadUInt16(); if (meshInfo.vertexType == SMeshInfos.EMeshVertexType.EMVT_SKINNED) { //sr.BaseStream.Seek(meshInfo.numBonesPerVertex * 2, SeekOrigin.Current); byte[] skinningData = new byte[meshInfo.numBonesPerVertex * 2]; br.BaseStream.Read(skinningData, 0, (int)meshInfo.numBonesPerVertex * 2); for (uint j = 0; j < meshInfo.numBonesPerVertex; ++j) { uint boneId = skinningData[j]; uint weight = skinningData[j + meshInfo.numBonesPerVertex]; float fweight = weight / 255.0f; if (weight != 0) { var vertexSkinningEntry = new W3_DataCache.VertexSkinningEntry(); vertexSkinningEntry.boneId = boneId; vertexSkinningEntry.meshBufferId = 0; vertexSkinningEntry.vertexId = i; vertexSkinningEntry.strength = fweight; CData.w3_DataCache.vertices.Add(vertexSkinningEntry); } } } Vertex3D vertex3DCoord = new Vertex3D(); vertex3DCoord.Position = new Vector3Df(x, y, z) / 65535f * bufferInfos.quantizationScale + bufferInfos.quantizationOffset; vertex3DCoord.Color = defaultColor; vertex3DCoords.Add(vertex3DCoord); } br.BaseStream.Seek(vBufferInf.uvOffset + firstVertexOffset * 4, SeekOrigin.Begin); for (int i = 0; i < meshInfo.numVertices; i++) { float uf = br.ReadHalfFloat(); float vf = br.ReadHalfFloat(); Vertex3D vertex3DCoord = vertex3DCoords[i]; vertex3DCoord.TCoords = new Vector2Df(uf, vf); vertex3DCoords[i] = vertex3DCoord; } // Indices ------------------------------------------------------------------- br.BaseStream.Seek(bufferInfos.indexBufferOffset + vBufferInf.indicesOffset + firstIndiceOffset * 2, SeekOrigin.Begin); List <ushort> indices = new List <ushort>(); for (int i = 0; i < meshInfo.numIndices; i++) { indices.Add(0); } for (int i = 0; i < meshInfo.numIndices; i++) { ushort index = br.ReadUInt16(); // Indice need to be inversed for the normals if (i % 3 == 0) { indices[i] = index; } else if (i % 3 == 1) { indices[i + 1] = index; } else if (i % 3 == 2) { indices[i - 1] = index; } } MeshBuffer meshBuff = MeshBuffer.Create(VertexType.Standard, IndexType._16Bit); CData.staticMesh.AddMeshBuffer(meshBuff); meshBuff.Append(vertex3DCoords, indices); meshBuff.RecalculateBoundingBox(); meshBuff.Drop(); } } } }
/// <summary> /// Read mesh chunk and buffer infos. /// </summary> public void LoadData(CR2WFile meshFile) { // IMPLEMENTED FROM jlouis' witcherconverter // http://jlouisb.users.sourceforge.net/ // https://bitbucket.org/jlouis/witcherconverter SBufferInfos bufferInfos = new SBufferInfos(); // *************** READ CHUNK INFOS *************** foreach (var chunk in meshFile.Chunks) { if (chunk.REDType == "CMesh" && chunk.data is CMesh cmesh) { List <SVertexBufferInfos> vertexBufferInfos = new List <SVertexBufferInfos>(); SMeshCookedData meshCookedData = cmesh.CookedData; var bytes = meshCookedData.RenderChunks.Bytes; using (MemoryStream ms = new MemoryStream(bytes)) using (BinaryReader br = new BinaryReader(ms)) { var nbBuffers = br.ReadByte(); for (uint i = 0; i < nbBuffers; i++) { SVertexBufferInfos buffInfo = new SVertexBufferInfos(); br.BaseStream.Position += 1; // Unknown buffInfo.verticesCoordsOffset = br.ReadUInt32(); buffInfo.uvOffset = br.ReadUInt32(); buffInfo.normalsOffset = br.ReadUInt32(); br.BaseStream.Position += 9; // Unknown buffInfo.indicesOffset = br.ReadUInt32(); br.BaseStream.Position += 1; // 0x1D buffInfo.nbVertices = br.ReadUInt16(); buffInfo.nbIndices = br.ReadUInt32(); buffInfo.materialID = br.ReadByte(); br.BaseStream.Position += 2; // Unknown buffInfo.lod = br.ReadByte(); // lod ? vertexBufferInfos.Add(buffInfo); } } bufferInfos.indexBufferOffset = meshCookedData.IndexBufferOffset.val; bufferInfos.indexBufferSize = meshCookedData.IndexBufferSize.val; //bufferInfos.vertexBufferOffset = meshCookedData.vertexBufferOffset.val; //FIXME bufferInfos.vertexBufferSize = meshCookedData.VertexBufferSize.val; bufferInfos.quantizationOffset.X = meshCookedData.QuantizationOffset.X.val; bufferInfos.quantizationOffset.Y = meshCookedData.QuantizationOffset.Y.val; bufferInfos.quantizationOffset.Z = meshCookedData.QuantizationOffset.Z.val; bufferInfos.quantizationScale.X = meshCookedData.QuantizationScale.X.val; bufferInfos.quantizationScale.Y = meshCookedData.QuantizationScale.Y.val; bufferInfos.quantizationScale.Z = meshCookedData.QuantizationScale.Z.val; if (meshCookedData.BonePositions != null) { foreach (var item in meshCookedData.BonePositions) { Vector3Df pos = new Vector3Df(); pos.X = item.X.val; pos.Y = item.Y.val; pos.Z = item.Z.val; bonePositions.Add(pos); } } bufferInfos.verticesBuffer = vertexBufferInfos; CArray <SMeshChunkPacked> meshChunks = cmesh.Chunks; foreach (SMeshChunkPacked meshChunk in meshChunks.Elements) { SMeshInfos meshInfo = new SMeshInfos(); meshInfo.numVertices = meshChunk.NumVertices == null ? 0 : meshChunk.NumVertices.val; meshInfo.numIndices = meshChunk.NumIndices == null ? 0 : meshChunk.NumIndices.val; meshInfo.numBonesPerVertex = meshChunk.NumBonesPerVertex == null ? (uint)0 : meshChunk.NumBonesPerVertex.val; meshInfo.firstVertex = meshChunk.FirstVertex == null ? 0 : meshChunk.FirstVertex.val; meshInfo.firstIndex = meshChunk.FirstIndex == null ? 0 : meshChunk.FirstIndex.val; meshInfo.materialID = meshChunk.MaterialID == null ? 0 : meshChunk.MaterialID.val; if (meshChunk.VertexType != null) { if (meshChunk.VertexType.WrappedEnum == Enums.EMeshVertexType.MVT_StaticMesh) { meshInfo.vertexType = SMeshInfos.EMeshVertexType.EMVT_STATIC; } else if (meshChunk.VertexType.WrappedEnum == Enums.EMeshVertexType.MVT_SkinnedMesh) { meshInfo.vertexType = SMeshInfos.EMeshVertexType.EMVT_SKINNED; } } CData.meshInfos.Add(meshInfo); } // bone names and matrices CBufferVLQInt32 <CName> boneNames = cmesh.BoneNames; CBufferVLQInt32 <CMatrix4x4> bonematrices = cmesh.Bonematrices; CData.boneData.nbBones = (uint)boneNames.elements.Count; for (int i = 0; i < CData.boneData.nbBones; i++) { CName name = boneNames.elements[i]; CData.boneData.jointNames.Add(name.Value); CMatrix4x4 cmatrix = bonematrices.elements[i]; Matrix matrix = new Matrix(); for (int j = 0; j < 16; j++) { float value = (cmatrix.fields[j] as CFloat).val; matrix.SetElement(j, value); } CData.boneData.boneMatrices.Add(matrix); } } else if (chunk.REDType == "CMaterialInstance") { CData.materialInstances.Add(chunk.data as CMaterialInstance); } } // *************** READ MESH BUFFER INFOS *************** foreach (var meshInfo in CData.meshInfos) { SVertexBufferInfos vBufferInf = new SVertexBufferInfos(); uint nbVertices = 0; uint firstVertexOffset = 0; uint nbIndices = 0; uint firstIndiceOffset = 0; for (int i = 0; i < bufferInfos.verticesBuffer.Count; i++) { nbVertices += bufferInfos.verticesBuffer[i].nbVertices; if (nbVertices > meshInfo.firstVertex) { vBufferInf = bufferInfos.verticesBuffer[i]; // the index of the first vertex in the buffer firstVertexOffset = meshInfo.firstVertex - (nbVertices - vBufferInf.nbVertices); break; } } for (int i = 0; i < bufferInfos.verticesBuffer.Count; i++) { nbIndices += bufferInfos.verticesBuffer[i].nbIndices; if (nbIndices > meshInfo.firstIndex) { vBufferInf = bufferInfos.verticesBuffer[i]; firstIndiceOffset = meshInfo.firstIndex - (nbIndices - vBufferInf.nbIndices); break; } } // Load only best LOD if (vBufferInf.lod == 1) { using (BinaryReader br = new BinaryReader(File.Open(meshFile.FileName + ".1.buffer", FileMode.Open))) { uint vertexSize = 8; if (meshInfo.vertexType == SMeshInfos.EMeshVertexType.EMVT_SKINNED) { vertexSize += meshInfo.numBonesPerVertex * 2; } br.BaseStream.Seek(vBufferInf.verticesCoordsOffset + firstVertexOffset * vertexSize, SeekOrigin.Begin); List <Vertex3D> vertex3DCoords = new List <Vertex3D>(); Color defaultColor = new Color(255, 255, 255, 255); for (uint i = 0; i < meshInfo.numVertices; i++) { ushort x = br.ReadUInt16(); ushort y = br.ReadUInt16(); ushort z = br.ReadUInt16(); ushort w = br.ReadUInt16(); if (meshInfo.vertexType == SMeshInfos.EMeshVertexType.EMVT_SKINNED) { //sr.BaseStream.Seek(meshInfo.numBonesPerVertex * 2, SeekOrigin.Current); byte[] skinningData = new byte[meshInfo.numBonesPerVertex * 2]; br.BaseStream.Read(skinningData, 0, (int)meshInfo.numBonesPerVertex * 2); for (uint j = 0; j < meshInfo.numBonesPerVertex; ++j) { uint boneId = skinningData[j]; uint weight = skinningData[j + meshInfo.numBonesPerVertex]; float fweight = weight / 255.0f; if (weight != 0) { var vertexSkinningEntry = new W3_DataCache.VertexSkinningEntry(); vertexSkinningEntry.boneId = boneId; vertexSkinningEntry.meshBufferId = 0; vertexSkinningEntry.vertexId = i; vertexSkinningEntry.strength = fweight; CData.w3_DataCache.vertices.Add(vertexSkinningEntry); } } } Vertex3D vertex3DCoord = new Vertex3D(); vertex3DCoord.Position = new Vector3Df(x, y, z) / 65535f * bufferInfos.quantizationScale + bufferInfos.quantizationOffset; vertex3DCoord.Color = defaultColor; vertex3DCoords.Add(vertex3DCoord); } br.BaseStream.Seek(vBufferInf.uvOffset + firstVertexOffset * 4, SeekOrigin.Begin); for (int i = 0; i < meshInfo.numVertices; i++) { float uf = br.ReadHalfFloat(); float vf = br.ReadHalfFloat(); Vertex3D vertex3DCoord = vertex3DCoords[i]; vertex3DCoord.TCoords = new Vector2Df(uf, vf); vertex3DCoords[i] = vertex3DCoord; } // Indices ------------------------------------------------------------------- br.BaseStream.Seek(bufferInfos.indexBufferOffset + vBufferInf.indicesOffset + firstIndiceOffset * 2, SeekOrigin.Begin); List <ushort> indices = new List <ushort>(); for (int i = 0; i < meshInfo.numIndices; i++) { indices.Add(0); } for (int i = 0; i < meshInfo.numIndices; i++) { ushort index = br.ReadUInt16(); // Indice need to be inversed for the normals if (i % 3 == 0) { indices[i] = index; } else if (i % 3 == 1) { indices[i + 1] = index; } else if (i % 3 == 2) { indices[i - 1] = index; } } MeshBuffer meshBuff = MeshBuffer.Create(VertexType.Standard, IndexType._16Bit); meshBuff.Append(vertex3DCoords.ToArray(), indices.ToArray()); meshBuff.RecalculateBoundingBox(); CData.staticMesh.AddMeshBuffer(meshBuff); meshBuff.Drop(); } } } }
private void meshGeneratorThread_generateMesh(int layerIndex) { GridLayer l = layers[layerIndex]; if (l.Mesh != null) { l.Mesh.Drop(); } l.Mesh = Mesh.Create(); if (gridCubeCount > 0) { Vertex3D[] cubeVerts = null; ushort[] cubeInds = null; int cubeIndex = maxCubesPerBuffer; // this way we force buffers to be recreated at next new cube int totalCubesAdded = 0; float baseX = -(CubeSize * GridDim) / 2; float baseZ = -(CubeSize * GridDim) / 2; for (int i = 0; i < GridDim; i++) { for (int j = 0; j < GridDim; j++) { if (grid[i, j] == 0) { continue; } // check if current buffer is out of room, if so make a mesh buffer and attach it to the gridMesh and init next cubeVerts&Inds if (cubeIndex == maxCubesPerBuffer) { if (cubeVerts != null && cubeInds != null) { MeshBuffer b = MeshBuffer.Create(VertexType.Standard, IndexType._16Bit); b.Append(cubeVerts, cubeInds); l.Mesh.AddMeshBuffer(b); b.Drop(); totalCubesAdded += cubeIndex; } int cubeCount = gridCubeCount - totalCubesAdded; if (cubeCount > maxCubesPerBuffer) { cubeCount = maxCubesPerBuffer; } cubeIndex = 0; cubeVerts = new Vertex3D[cubeCount * 8]; // 8 verts per cube cubeInds = new ushort[cubeCount * 3 * 2 * 6]; // 3 indices per triangle; 2 triangles per face; 6 faces per cube } // build the cube and add it // note: we build 8 vertices cube because we don't need to texture it; if you want to change that (to use texture instead of vertex colors) - you need to build 12 vertices cube and initialize UV coords float x = baseX + i * CubeSize; float y = 0; float z = baseZ + j * CubeSize; int iv = cubeIndex * 8; cubeVerts[iv + 0] = new Vertex3D(x, y, z); cubeVerts[iv + 1] = new Vertex3D(x + CubeSize, y, z); cubeVerts[iv + 2] = new Vertex3D(x + CubeSize, y + CubeSize, z); cubeVerts[iv + 3] = new Vertex3D(x, y + CubeSize, z); cubeVerts[iv + 4] = new Vertex3D(x, y, z + CubeSize); cubeVerts[iv + 5] = new Vertex3D(x + CubeSize, y, z + CubeSize); cubeVerts[iv + 6] = new Vertex3D(x + CubeSize, y + CubeSize, z + CubeSize); cubeVerts[iv + 7] = new Vertex3D(x, y + CubeSize, z + CubeSize); int ii = cubeIndex * 3 * 2 * 6; // top cubeInds[ii + 0] = (ushort)(iv + 3); cubeInds[ii + 1] = (ushort)(iv + 7); cubeInds[ii + 2] = (ushort)(iv + 6); cubeInds[ii + 3] = (ushort)(iv + 3); cubeInds[ii + 4] = (ushort)(iv + 6); cubeInds[ii + 5] = (ushort)(iv + 2); // front cubeInds[ii + 6] = (ushort)(iv + 0); cubeInds[ii + 7] = (ushort)(iv + 3); cubeInds[ii + 8] = (ushort)(iv + 2); cubeInds[ii + 9] = (ushort)(iv + 0); cubeInds[ii + 10] = (ushort)(iv + 2); cubeInds[ii + 11] = (ushort)(iv + 1); // right cubeInds[ii + 12] = (ushort)(iv + 1); cubeInds[ii + 13] = (ushort)(iv + 2); cubeInds[ii + 14] = (ushort)(iv + 6); cubeInds[ii + 15] = (ushort)(iv + 1); cubeInds[ii + 16] = (ushort)(iv + 6); cubeInds[ii + 17] = (ushort)(iv + 5); // left cubeInds[ii + 18] = (ushort)(iv + 0); cubeInds[ii + 19] = (ushort)(iv + 4); cubeInds[ii + 20] = (ushort)(iv + 7); cubeInds[ii + 21] = (ushort)(iv + 0); cubeInds[ii + 22] = (ushort)(iv + 7); cubeInds[ii + 23] = (ushort)(iv + 3); // back cubeInds[ii + 24] = (ushort)(iv + 4); cubeInds[ii + 25] = (ushort)(iv + 5); cubeInds[ii + 26] = (ushort)(iv + 6); cubeInds[ii + 27] = (ushort)(iv + 4); cubeInds[ii + 28] = (ushort)(iv + 6); cubeInds[ii + 29] = (ushort)(iv + 7); // bottom cubeInds[ii + 30] = (ushort)(iv + 0); cubeInds[ii + 31] = (ushort)(iv + 1); cubeInds[ii + 32] = (ushort)(iv + 5); cubeInds[ii + 33] = (ushort)(iv + 0); cubeInds[ii + 34] = (ushort)(iv + 5); cubeInds[ii + 35] = (ushort)(iv + 4); cubeIndex++; } } if (cubeIndex > 0) { MeshBuffer b = MeshBuffer.Create(VertexType.Standard, IndexType._16Bit); b.Append(cubeVerts, cubeInds); l.Mesh.AddMeshBuffer(b); b.Drop(); } device.SceneManager.MeshManipulator.SetVertexColors(l.Mesh, cubeColor); } l.Transform.Rotation = new Vector3Df(gridGeneration * 0.93f, gridGeneration * 0.81f, gridGeneration * 0.69f); l.Generation = gridGeneration; l.CubeCount = gridCubeCount; l.MeshIsReady = true; }
/// <summary> /// Reads mesh buffer infos. /// </summary> void ReadMeshBufferInfos() { // IMPLEMENTED FROM jlouis' witcherconverter // http://jlouisb.users.sourceforge.net/ // https://bitbucket.org/jlouis/witcherconverter SBufferInfos bufferInfos = new SBufferInfos(); // *************** READ CHUNK INFOS *************** foreach (var chunk in _file.chunks) { if (chunk.Type == "CMesh") { List <SVertexBufferInfos> vertexBufferInfos = new List <SVertexBufferInfos>(); var cookedDatas = chunk.GetVariableByName("cookedData") as CVector; foreach (var cookedData in cookedDatas.variables) { switch (cookedData.Name) { case "renderChunks": { var bytes = ((CByteArray)cookedData).Bytes; var nbBuffers = bytes[0]; int curr = 1; for (uint i = 0; i < nbBuffers; i++) { SVertexBufferInfos buffInfo = new SVertexBufferInfos(); curr += 1; // Unknown buffInfo.verticesCoordsOffset = bytes.SubArray(ref curr, 4).GetUint(); buffInfo.uvOffset = bytes.SubArray(ref curr, 4).GetUint(); buffInfo.normalsOffset = bytes.SubArray(ref curr, 4).GetUint(); curr += 9; // Unknown buffInfo.indicesOffset = bytes.SubArray(ref curr, 4).GetUint(); curr += 1; // 0x1D buffInfo.nbVertices = bytes.SubArray(ref curr, 2).GetUshort(); buffInfo.nbIndices = bytes.SubArray(ref curr, 4).GetUint(); curr += 3; // Unknown buffInfo.lod = bytes.SubArray(ref curr, 1).GetByte(); // lod ? vertexBufferInfos.Add(buffInfo); } break; } case "indexBufferOffset": { bufferInfos.indexBufferOffset = uint.Parse(cookedData.ToString()); break; } case "indexBufferSize": { bufferInfos.indexBufferSize = uint.Parse(cookedData.ToString()); break; } case "vertexBufferOffset": { bufferInfos.vertexBufferOffset = uint.Parse(cookedData.ToString()); break; } case "vertexBufferSize": { bufferInfos.vertexBufferSize = uint.Parse(cookedData.ToString()); break; } case "quantizationOffset": { bufferInfos.quantizationOffset.X = float.Parse((cookedData as CVector).variables[0].ToString()); bufferInfos.quantizationOffset.Y = float.Parse((cookedData as CVector).variables[1].ToString()); bufferInfos.quantizationOffset.Z = float.Parse((cookedData as CVector).variables[2].ToString()); break; } case "quantizationScale": { bufferInfos.quantizationScale.X = float.Parse((cookedData as CVector).variables[0].ToString()); bufferInfos.quantizationScale.Y = float.Parse((cookedData as CVector).variables[1].ToString()); bufferInfos.quantizationScale.Z = float.Parse((cookedData as CVector).variables[2].ToString()); break; } case "bonePositions": { foreach (CVector item in cookedData as CArray) { if (item.variables.Count == 4) { Vector3Df pos = new Vector3Df(); pos.X = (item.variables[0] as CFloat).val; pos.Y = (item.variables[1] as CFloat).val; pos.Z = (item.variables[2] as CFloat).val; bonePositions.Add(pos); } } break; } } } bufferInfos.verticesBuffer = vertexBufferInfos; var meshChunks = chunk.GetVariableByName("chunks") as CArray; foreach (var meshChunk in meshChunks.array) { SMeshInfos meshInfo = new SMeshInfos(); foreach (var mesh in (meshChunk as CVector).variables) { switch (mesh.Name) { case "numVertices": { meshInfo.numVertices = uint.Parse(mesh.ToString()); break; } case "numIndices": { meshInfo.numIndices = uint.Parse(mesh.ToString()); break; } case "numBonesPerVertex": { meshInfo.numBonesPerVertex = uint.Parse(mesh.ToString()); break; } case "firstVertex": { meshInfo.firstVertex = uint.Parse(mesh.ToString()); break; } case "firstIndex": { meshInfo.firstIndex = uint.Parse(mesh.ToString()); break; } case "vertexType": { if ((mesh as CName).Value == "MVT_StaticMesh") { meshInfo.vertexType = SMeshInfos.EMeshVertexType.EMVT_STATIC; } else if ((mesh as CName).Value == "MVT_SkinnedMesh") { meshInfo.vertexType = SMeshInfos.EMeshVertexType.EMVT_SKINNED; } break; } case "materialID": { meshInfo.materialID = uint.Parse(mesh.ToString()); break; } } } meshInfos.Add(meshInfo); } } else if (chunk.Type == "CMaterialInstance") { materialInstances.Add(chunk.data as CMaterialInstance); } } // *************** READ MESH BUFFER INFOS *************** foreach (var meshInfo in meshInfos) { SVertexBufferInfos vBufferInf = new SVertexBufferInfos(); uint nbVertices = 0; uint firstVertexOffset = 0; uint nbIndices = 0; uint firstIndiceOffset = 0; for (int i = 0; i < bufferInfos.verticesBuffer.Count; i++) { nbVertices += bufferInfos.verticesBuffer[i].nbVertices; if (nbVertices > meshInfo.firstVertex) { vBufferInf = bufferInfos.verticesBuffer[i]; // the index of the first vertex in the buffer firstVertexOffset = meshInfo.firstVertex - (nbVertices - vBufferInf.nbVertices); break; } } for (int i = 0; i < bufferInfos.verticesBuffer.Count; i++) { nbIndices += bufferInfos.verticesBuffer[i].nbIndices; if (nbIndices > meshInfo.firstIndex) { vBufferInf = bufferInfos.verticesBuffer[i]; firstIndiceOffset = meshInfo.firstIndex - (nbIndices - vBufferInf.nbIndices); break; } } using (StreamReader sr = new StreamReader(_file.FileName + ".1.buffer")) { uint vertexSize = 8; if (meshInfo.vertexType == SMeshInfos.EMeshVertexType.EMVT_SKINNED) { vertexSize += meshInfo.numBonesPerVertex * 2; } sr.BaseStream.Seek(vBufferInf.verticesCoordsOffset + firstVertexOffset * vertexSize, SeekOrigin.Begin); List <Vertex3D> vertex3DCoords = new List <Vertex3D>(); Color defaultColor = new Color(255, 255, 255, 255); for (int i = 0; i < meshInfo.numVertices; i++) { ushort x, y, z, w; byte[] buff = new byte[2]; sr.BaseStream.Read(buff, 0, 2); x = buff.GetUshort(); sr.BaseStream.Read(buff, 0, 2); y = buff.GetUshort(); sr.BaseStream.Read(buff, 0, 2); z = buff.GetUshort(); sr.BaseStream.Read(buff, 0, 2); w = buff.GetUshort(); // skip skinning data if (meshInfo.vertexType == SMeshInfos.EMeshVertexType.EMVT_SKINNED) { sr.BaseStream.Seek(meshInfo.numBonesPerVertex * 2, SeekOrigin.Current); } Vertex3D vertex3DCoord = new Vertex3D(); vertex3DCoord.Position = new Vector3Df(x, y, z) / 65535f * bufferInfos.quantizationScale + bufferInfos.quantizationOffset; vertex3DCoord.Color = defaultColor; vertex3DCoords.Add(vertex3DCoord); } sr.BaseStream.Seek(vBufferInf.uvOffset + firstVertexOffset * 4, SeekOrigin.Begin); for (int i = 0; i < meshInfo.numVertices; i++) { ushort u, v; byte[] buff = new byte[2]; sr.BaseStream.Read(buff, 0, 2); u = buff.GetUshort(); sr.BaseStream.Read(buff, 0, 2); v = buff.GetUshort(); float uf = u.ToFloat(); float vf = v.ToFloat(); Vertex3D vertex3DCoord = vertex3DCoords[i]; vertex3DCoord.TCoords = new Vector2Df(uf, vf); vertex3DCoords[i] = vertex3DCoord; } // Indices ------------------------------------------------------------------- sr.BaseStream.Seek(bufferInfos.indexBufferOffset + vBufferInf.indicesOffset + firstIndiceOffset * 2, SeekOrigin.Begin); List <ushort> indices = new List <ushort>(); for (int i = 0; i < meshInfo.numIndices; i++) { indices.Add(0); } for (int i = 0; i < meshInfo.numIndices; i++) { ushort index; byte[] buff = new byte[2]; sr.BaseStream.Read(buff, 0, 2); index = buff.GetUshort(); // Indice need to be inversed for the normals if (i % 3 == 0) { indices[i] = index; } else if (i % 3 == 1) { indices[i + 1] = index; } else if (i % 3 == 2) { indices[i - 1] = index; } } MeshBuffer meshBuff = MeshBuffer.Create(VertexType.Standard, IndexType._16Bit); staticMesh.AddMeshBuffer(meshBuff); meshBuff.Append(vertex3DCoords, indices); meshBuff.RecalculateBoundingBox(); meshBuff.Drop(); } } // *************** READ RIG DATA *************** if (RigFile != null) { foreach (var chunk in RigFile.chunks) { if (chunk.Type == "CSkeleton") { var bones = chunk.GetVariableByName("bones") as CArray; meshSkeleton.nbBones = (uint)bones.array.Count; foreach (CVector bone in bones) { var boneName = bone.variables.GetVariableByName("nameAsCName") as CName; meshSkeleton.names.Add(boneName.Value); } var parentIndices = chunk.GetVariableByName("parentIndices") as CArray; foreach (CVariable parentIndex in parentIndices) { meshSkeleton.parentIdx.Add(short.Parse(parentIndex.ToString())); } var unknownBytes = chunk.unknownBytes.Bytes; int currPos = 0; for (uint i = 0; i < meshSkeleton.nbBones; i++) { Vector3Df position = new Vector3Df(); position.X = unknownBytes.SubArray(ref currPos, 4).GetFloat(); position.Y = unknownBytes.SubArray(ref currPos, 4).GetFloat(); position.Z = unknownBytes.SubArray(ref currPos, 4).GetFloat(); unknownBytes.SubArray(ref currPos, 4).GetFloat(); // the w component Quaternion orientation = new Quaternion(); orientation.X = unknownBytes.SubArray(ref currPos, 4).GetFloat(); orientation.Y = unknownBytes.SubArray(ref currPos, 4).GetFloat(); orientation.Z = unknownBytes.SubArray(ref currPos, 4).GetFloat(); orientation.W = unknownBytes.SubArray(ref currPos, 4).GetFloat(); Vector3Df scale; scale.X = unknownBytes.SubArray(ref currPos, 4).GetFloat(); scale.Y = unknownBytes.SubArray(ref currPos, 4).GetFloat(); scale.Z = unknownBytes.SubArray(ref currPos, 4).GetFloat(); unknownBytes.SubArray(ref currPos, 4).GetFloat(); // the w component Matrix posMat = new Matrix(); posMat.Translation = position; Matrix rotMat = new Matrix(); Vector3Df euler = orientation.ToEuler(); // chechNaNErrors(euler); rotMat.SetRotationRadians(euler); Matrix scaleMat = new Matrix(); scaleMat.Scale = scale; Matrix localTransform = posMat * rotMat * scaleMat; orientation = orientation.MakeInverse(); meshSkeleton.matrix.Add(localTransform); meshSkeleton.positions.Add(position); meshSkeleton.rotations.Add(orientation); meshSkeleton.scales.Add(scale); } } } } }