public void Load(EndianBinaryReader stream) { // Store the position of the stream so we can reset back to it after we jump to read children. long streamPos = stream.BaseStream.Position; DisplayName = Encoding.GetEncoding("shift-jis").GetString(stream.ReadBytesUntil(0)); stream.BaseStream.Position = streamPos + 0x20; short entryCount = stream.ReadInt16(); Trace.Assert(stream.ReadInt16() == 0x00); // Padding int entryOffset = stream.ReadInt32(); stream.BaseStream.Position = entryOffset; for (int i = 0; i < entryCount; i++) { CategoryEntry entry = new CategoryEntry(); entry.Load(stream); Entries.Add(entry); } // Reset the stream to the start of the struct (+ size of struct) since reading the sub-options jumps us // around in the stream. stream.BaseStream.Position = streamPos + 0x28; }
private static SceneNode LoadINF1FromFile(SceneNode rootNode, EndianBinaryReader reader, long chunkStart) { ushort unknown1 = reader.ReadUInt16(); // A lot of Link's models have it but no idea what it means. Alt. doc says: "0 for BDL, 01 for BMD" ushort padding = reader.ReadUInt16(); uint packetCount = reader.ReadUInt32(); // Total number of Packets across all Batches in file. uint vertexCount = reader.ReadUInt32(); // Total number of vertexes across all batches within the file. uint hierarchyDataOffset = reader.ReadUInt32(); // The Hierarchy defines how Joints, Materials and Shapes are laid out. This allows them to bind a material // and draw multiple shapes (batches) with the material. It also complicates drawing things, but whatever. reader.BaseStream.Position = chunkStart + hierarchyDataOffset; List<InfoNode> infoNodes = new List<InfoNode>(); InfoNode curNode = null; do { curNode = new InfoNode(); curNode.Type = (HierarchyDataTypes)reader.ReadUInt16(); curNode.Value = reader.ReadUInt16(); // "Index into Joint, Material, or Shape table. infoNodes.Add(curNode); } while (curNode.Type != HierarchyDataTypes.Finish); ConvertInfoHiearchyToSceneGraph(ref rootNode, infoNodes, 0); return rootNode; }
private static Envelopes LoadEVP1FromStream(EndianBinaryReader reader, long chunkStart) { Envelopes envelopes = new Envelopes(); ushort numEnvelopes = reader.ReadUInt16(); reader.ReadUInt16(); // Padding // numEnvelope many uint8 - each one describes how many bones belong to this index. uint boneCountOffset = reader.ReadUInt32(); // "sum over all bytes in boneCountOffset many shorts (index into some joint stuff? into matrix table?)" uint indexDataOffset = reader.ReadUInt32(); // Bone Weights (as many floats here as there are ushorts at indexDataOffset) uint weightOffset = reader.ReadUInt32(); // Matrix Table (3x4 float array) - Inverse Bind Pose uint boneMatrixOffset = reader.ReadUInt32(); // - Is this the number of bones which influence the vert? reader.BaseStream.Position = chunkStart + boneCountOffset; for (int b = 0; b < numEnvelopes; b++) envelopes.numBonesAffecting.Add(reader.ReadByte()); // ??? reader.BaseStream.Position = chunkStart + indexDataOffset; for (int m = 0; m < envelopes.numBonesAffecting.Count; m++) { for (int j = 0; j < envelopes.numBonesAffecting[m]; j++) { envelopes.indexRemap.Add(reader.ReadUInt16()); } } // Bone Weights reader.BaseStream.Position = chunkStart + weightOffset; for (int w = 0; w < envelopes.numBonesAffecting.Count; w++) { for (int j = 0; j < envelopes.numBonesAffecting[w]; j++) { envelopes.weights.Add(reader.ReadSingle()); } } // Inverse Bind Pose Matrices reader.BaseStream.Position = chunkStart + boneMatrixOffset; for (int w = 0; w < numEnvelopes; w++) { Matrix3x4 matrix = new Matrix3x4(); for (int j = 0; j < 3; j++) { for (int k = 0; k < 4; k++) matrix[j, k] = reader.ReadSingle(); } envelopes.inverseBindPose.Add(matrix); } return envelopes; }
private static DrawInfo LoadDRW1FromStream(EndianBinaryReader reader, long chunkStart) { DrawInfo drawInfo = new DrawInfo(); ushort sectionCount = reader.ReadUInt16(); Trace.Assert(reader.ReadUInt16() == 0xFFFF); // Padding - 0xFFFF uint isWeightedOffset = reader.ReadUInt32(); uint indexOffset = reader.ReadUInt32(); reader.BaseStream.Position = chunkStart + isWeightedOffset; for (int k = 0; k < sectionCount; k++) drawInfo.IsWeighted.Add(reader.ReadBoolean()); reader.BaseStream.Position = chunkStart + indexOffset; for (int k = 0; k < sectionCount; k++) drawInfo.Indexes.Add(reader.ReadUInt16()); return drawInfo; }
public void Load(EndianBinaryReader stream) { if (stream == null || stream.BaseStream.Length == 0) throw new ArgumentException("Null or empty stream specified", "stream"); // Read the header byte entryCount = stream.ReadByte(); stream.Skip(3); // Unknown Constants (0x5E, 0, 0x61) // Offset to the first entry (realistically it's right after the header and always 0x8 int offsetToFirstEntry = stream.ReadInt32(); // Load categories and their entries. stream.BaseStream.Position = offsetToFirstEntry; for(int i = 0; i < entryCount; i++) { Category category = new Category(); category.Load(stream); Categories.Add(category); } }
public static StringTable FromStream(EndianBinaryReader stream) { StringTable newTable = new StringTable(); long headerStart = stream.BaseStream.Position; ushort stringCount = stream.ReadUInt16(); stream.ReadUInt16(); // Padding for (int i = 0; i < stringCount; i++) { // Jump us to the string 'header' by calculating 0x4 for for the StringTable header and then 0x4 for each string header. stream.BaseStream.Position = headerStart + ((i + 1) * 0x4); ushort stringHash = stream.ReadUInt16(); ushort stringOffset = stream.ReadUInt16(); // Jump forward to the offset to read the string. stream.BaseStream.Position = headerStart + stringOffset; string value = stream.ReadStringUntil('\0'); newTable.Strings.Add(new Entry(value, stringHash)); } return newTable; }
public void Load(EndianBinaryReader stream) { long streamPos = stream.BaseStream.Position; DisplayName = Encoding.GetEncoding("shift-jis").GetString(stream.ReadBytesUntil(0)); stream.BaseStream.Position = streamPos + 0x21; MapName = Encoding.GetEncoding("shift-jis").GetString(stream.ReadBytesUntil(0)); stream.BaseStream.Position = streamPos + 0x29; RoomIndex = stream.ReadByte(); SpawnIndex = stream.ReadByte(); LayerIndex = (Layer)stream.ReadByte(); }
private static void LoadSHP1SectionFromFile(MeshVertexAttributeHolder vertexData, Mesh j3dMesh, EndianBinaryReader reader, long chunkStart) { short batchCount = reader.ReadInt16(); short padding = reader.ReadInt16(); int batchOffset = reader.ReadInt32(); int unknownTableOffset = reader.ReadInt32(); // Another one of those 0->(n-1) counters. I think all sections have it? Might be part of the way they used inheritance to write files. int alwaysZero = reader.ReadInt32(); Trace.Assert(alwaysZero == 0); int attributeOffset = reader.ReadInt32(); int matrixTableOffset = reader.ReadInt32(); int primitiveDataOffset = reader.ReadInt32(); int matrixDataOffset = reader.ReadInt32(); int packetLocationOffset = reader.ReadInt32(); // Batches can have different attributes (ie: some have pos, some have normal, some have texcoords, etc.) they're split by batches, // where everything in the batch uses the same set of vertex attributes. Each batch then has several packets, which are a collection // of primitives. for (int b = 0; b < batchCount; b++) { MeshBatch meshBatch = new MeshBatch(); j3dMesh.SubMeshes.Add(meshBatch); int overallVertexCount = 0; meshBatch.PrimitveType = OpenTK.Graphics.OpenGL.PrimitiveType.TriangleStrip; // HackHack, this varies per primitive. // We need to look on each primitive and convert them to trianglestrips, most are TS some are TF's. // We re-use the list struct here to dynamically add paired pos/col/tex as we load them // then we convert them into arrays for the MeshBatch afterwards. MeshVertexAttributeHolder meshVertexData = new MeshVertexAttributeHolder(); // chunkStart + batchOffset gets you the position where the batches are listed // 0x28 * b gives you the right batch - a batch is 0x28 in length reader.BaseStream.Position = chunkStart + batchOffset + (0x28 * b); long batchStart = reader.BaseStream.Position; byte matrixType = reader.ReadByte(); Trace.Assert(reader.ReadByte() == 0xFF); // Padding ushort packetCount = reader.ReadUInt16(); ushort batchAttributeOffset = reader.ReadUInt16(); ushort firstMatrixIndex = reader.ReadUInt16(); ushort firstPacketIndex = reader.ReadUInt16(); ushort unknownpadding = reader.ReadUInt16(); Trace.Assert(unknownpadding == 0xFFFF); float boundingSphereDiameter = reader.ReadSingle(); Vector3 boundingBoxMin = new Vector3(); boundingBoxMin.X = reader.ReadSingle(); boundingBoxMin.Y = reader.ReadSingle(); boundingBoxMin.Z = reader.ReadSingle(); Vector3 boundingBoxMax = new Vector3(); boundingBoxMax.X = reader.ReadSingle(); boundingBoxMax.Y = reader.ReadSingle(); boundingBoxMax.Z = reader.ReadSingle(); // We need to figure out how many primitive attributes there are in the SHP1 section. This can differ from the number of // attributes in the VTX1 section, as the SHP1 can also include things like PositionMatrixIndex, so the count can be different. // This also varies *per batch* as not all batches will have the things like PositionMatrixIndex. reader.BaseStream.Position = chunkStart + attributeOffset + batchAttributeOffset; var batchAttributes = new List<ShapeAttribute>(); do { ShapeAttribute attribute = new ShapeAttribute(); attribute.ArrayType = (VertexArrayType)reader.ReadInt32(); attribute.DataType = (VertexDataType)reader.ReadInt32(); if (attribute.ArrayType == VertexArrayType.NullAttr) break; batchAttributes.Add(attribute); } while (true); for (ushort p = 0; p < packetCount; p++) { // Packet Location reader.BaseStream.Position = chunkStart + packetLocationOffset; reader.BaseStream.Position += (firstPacketIndex + p) * 0x8; // A Packet Location is 0x8 long, so we skip ahead to the right one. int packetSize = reader.ReadInt32(); int packetOffset = reader.ReadInt32(); // Read the matrix data for this packet reader.BaseStream.Position = chunkStart + matrixDataOffset + (firstMatrixIndex + p) * 0x08; ushort matrixUnknown0 = reader.ReadUInt16(); ushort matrixCount = reader.ReadUInt16(); uint matrixFirstIndex = reader.ReadUInt32(); // Skip ahead to the actual data. reader.BaseStream.Position = chunkStart + matrixTableOffset + (matrixFirstIndex * 0x2); List<ushort> matrixTable = new List<ushort>(); for (int m = 0; m < matrixCount; m++) { matrixTable.Add(reader.ReadUInt16()); } // Jump the read head to the location of the primitives for this packet. reader.BaseStream.Position = chunkStart + primitiveDataOffset + packetOffset; int numVertexesAtPacketStart = meshVertexData.PositionMatrixIndexes.Count; uint numPrimitiveBytesRead = 0; while (numPrimitiveBytesRead < packetSize) { // Jump to the primitives // Primitives GXPrimitiveType type = (GXPrimitiveType)reader.ReadByte(); // Game pads the chunks out with zeros, so this is the signal for an early break; if (type == 0 || numPrimitiveBytesRead >= packetSize) break; ushort vertexCount = reader.ReadUInt16(); meshBatch.PrimitveType = type == GXPrimitiveType.TriangleStrip ? OpenTK.Graphics.OpenGL.PrimitiveType.TriangleStrip : OpenTK.Graphics.OpenGL.PrimitiveType.TriangleFan; //if (type != GXPrimitiveType.TriangleStrip) //{ // WLog.Warning(LogCategory.ModelLoading, null, "Unsupported GXPrimitiveType {0}", type); //} numPrimitiveBytesRead += 0x3; // Advance us by 3 for the Primitive header. for (int v = 0; v < vertexCount; v++) { meshVertexData.Indexes.Add(overallVertexCount); overallVertexCount++; // Iterate through the attribute types. I think the actual vertices are stored in interleaved format, // ie: there's say 13 vertexes but those 13 vertexes will have a pos/color/tex index listed after it // depending on the overall attributes of the file. for (int attrib = 0; attrib < batchAttributes.Count; attrib++) { // Jump to primitive location //reader.BaseStream.Position = chunkStart + primitiveDataOffset + numPrimitiveBytesRead + packetOffset; // Now that we know how big the vertex type is stored in (either a Signed8 or a Signed16) we can read that much data // and then we can use that index and index into int val = 0; uint numBytesRead = 0; switch (batchAttributes[attrib].DataType) { case VertexDataType.Signed8: val = reader.ReadByte(); numBytesRead = 1; break; case VertexDataType.Signed16: val = reader.ReadInt16(); numBytesRead = 2; break; default: WLog.Warning(LogCategory.ModelLoading, null, "Unknown Batch Index Type: {0}", batchAttributes[attrib].DataType); break; } // Now that we know what the index is, we can retrieve it from the appropriate array // and stick it into our vertex. The J3D format removes all duplicate vertex attributes // so we need to re-duplicate them here so that we can feed them to a PC GPU in a normal fashion. switch (batchAttributes[attrib].ArrayType) { case VertexArrayType.Position: meshVertexData.Position.Add(vertexData.Position[val]); break; case VertexArrayType.PositionMatrixIndex: meshVertexData.PositionMatrixIndexes.Add(val); break; case VertexArrayType.Normal: meshVertexData.Normal.Add(vertexData.Normal[val]); break; case VertexArrayType.Color0: meshVertexData.Color0.Add(vertexData.Color0[val]); break; case VertexArrayType.Color1: meshVertexData.Color1.Add(vertexData.Color1[val]); break; case VertexArrayType.Tex0: meshVertexData.Tex0.Add(vertexData.Tex0[val]); break; case VertexArrayType.Tex1: meshVertexData.Tex1.Add(vertexData.Tex1[val]); break; case VertexArrayType.Tex2: meshVertexData.Tex2.Add(vertexData.Tex2[val]); break; case VertexArrayType.Tex3: meshVertexData.Tex3.Add(vertexData.Tex3[val]); break; case VertexArrayType.Tex4: meshVertexData.Tex4.Add(vertexData.Tex4[val]); break; case VertexArrayType.Tex5: meshVertexData.Tex5.Add(vertexData.Tex5[val]); break; case VertexArrayType.Tex6: meshVertexData.Tex6.Add(vertexData.Tex6[val]); break; case VertexArrayType.Tex7: meshVertexData.Tex7.Add(vertexData.Tex7[val]); break; default: WLog.Warning(LogCategory.ModelLoading, null, "Unsupported attribType {0}", batchAttributes[attrib].ArrayType); break; } numPrimitiveBytesRead += numBytesRead; } // Gonna try a weird hack, where if the mesh doesn't have PMI values, we're going to use just use the packet index into the matrixtable // so that all meshes always have PMI values, to abstract out the ones that don't seem to (but still have matrixtable) junk. It's a guess // here. if (batchAttributes.Find(x => x.ArrayType == VertexArrayType.PositionMatrixIndex) == null) { meshVertexData.PositionMatrixIndexes.Add(p); } } // After we write a primitive, write a special null-terminator which signifies the GPU to do a primitive restart for the next tri-strip. meshVertexData.Indexes.Add(0xFFFF); } // The Matrix Table is per-packet, so we need to reach into the the matrix table after processing each packet // and transform the indexes. Yuck. Yay. for (int j = numVertexesAtPacketStart; j < meshVertexData.PositionMatrixIndexes.Count; j++) { // Yes you divide this by 3. No, no one knows why. $20 to the person who figures out why. meshBatch.drawIndexes.Add(matrixTable[meshVertexData.PositionMatrixIndexes[j] / 3]); } } meshBatch.Vertices = meshVertexData.Position.ToArray(); meshBatch.Color0 = meshVertexData.Color0.ToArray(); meshBatch.Color1 = meshVertexData.Color1.ToArray(); meshBatch.TexCoord0 = meshVertexData.Tex0.ToArray(); meshBatch.TexCoord1 = meshVertexData.Tex0.ToArray(); meshBatch.TexCoord2 = meshVertexData.Tex0.ToArray(); meshBatch.TexCoord3 = meshVertexData.Tex0.ToArray(); meshBatch.TexCoord4 = meshVertexData.Tex0.ToArray(); meshBatch.TexCoord5 = meshVertexData.Tex0.ToArray(); meshBatch.TexCoord6 = meshVertexData.Tex0.ToArray(); meshBatch.TexCoord7 = meshVertexData.Tex0.ToArray(); meshBatch.Indexes = meshVertexData.Indexes.ToArray(); meshBatch.PositionMatrixIndexs = meshVertexData.PositionMatrixIndexes; // This should be obsolete as they should be transformed already. } }
public Mesh LoadFromStream(EndianBinaryReader reader) { MeshVertexAttributeHolder vertexData = null; SceneNode rootNode = new SceneNode(); List<Texture2D> textureList = new List<Texture2D>(); List<WEditor.Common.Nintendo.J3D.Material> materialList = null; List<SkeletonBone> joints = new List<SkeletonBone>(); DrawInfo drawInfo = null; Envelopes envelopes = null; Mesh j3dMesh = new Mesh(); // Read the Header int magic = reader.ReadInt32(); // J3D1, J3D2, etc if (magic != 1244873778) { WLog.Warning(LogCategory.ModelLoading, null, "Attempted to load model with invalid magic, ignoring!"); return null; } int j3dType = reader.ReadInt32(); // BMD3 (models) BDL4 (models), jpa1 (particles), bck1 (animations), etc. int totalFileSize = reader.ReadInt32(); int chunkCount = reader.ReadInt32(); // Skip over an unused tag (consistent in all files) and some padding. reader.ReadBytes(16); for (int i = 0; i < chunkCount; i++) { long chunkStart = reader.BaseStream.Position; string tagName = reader.ReadString(4); int chunkSize = reader.ReadInt32(); switch (tagName) { // INFO - Vertex Count, Scene Hierarchy case "INF1": rootNode = LoadINF1FromFile(rootNode, reader, chunkStart); break; // VERTEX - Stores vertex arrays for pos/normal/color0/tex0 etc. Contains VertexAttributes which describe // how this data is stored/laid out. case "VTX1": vertexData = LoadVTX1FromFile(reader, chunkStart, chunkSize); break; // ENVELOPES - Defines vertex weights for skinning. case "EVP1": envelopes = LoadEVP1FromStream(reader, chunkStart); break; // DRAW (Skeletal Animation Data) - Stores which matrices are weighted, and which are used directly. case "DRW1": drawInfo = LoadDRW1FromStream(reader, chunkStart); break; // JOINTS - Stores the skeletal joints (position, rotation, scale, etc.) case "JNT1": joints = LoadJNT1SectionFromStream(reader, chunkStart); break; // SHAPE - Face/Triangle information for model. case "SHP1": LoadSHP1SectionFromFile(vertexData, j3dMesh, reader, chunkStart); break; // MATERIAL - Stores materials (which describes how textures, etc. are drawn) case "MAT3": materialList = LoadMAT3SectionFromStream(reader, chunkStart, chunkSize); break; // TEXTURES - Stores binary texture images. case "TEX1": textureList = LoadTEX1FromFile(reader, chunkStart); break; // MODEL - Seems to be bypass commands for Materials and invokes GX registers directly. case "MDL3": break; } reader.BaseStream.Position = chunkStart + chunkSize; } // Resolve the texture indexes into actual textures now that we've loaded the TEX1 section. foreach (Material mat in materialList) { for (int i = 0; i < mat.TextureIndexes.Length; i++) { short index = mat.TextureIndexes[i]; if (index < 0) continue; mat.Textures[i] = textureList[index]; } } // loltests for (int i = 0; i < materialList.Count; i++) { materialList[i].VtxDesc = j3dMesh.SubMeshes[0].GetVertexDescription(); Shader shader = TEVShaderGenerator.GenerateShader(materialList[i]); materialList[i].Shader = shader; } // We're going to do something a little crazy - we're going to read the scene view and apply textures to meshes (for now) Material curMat = null; AssignMaterialsToMeshRecursive(rootNode, j3dMesh, ref curMat, materialList); List<SkeletonBone> skeleton = new List<SkeletonBone>(); BuildSkeletonRecursive(rootNode, skeleton, joints, 0); j3dMesh.Skeleton = skeleton; j3dMesh.BindPoses = envelopes.inverseBindPose; // Let's do some ugly post-processing here to see if we can't resolve all of the cross-references and turn it into // a normal computer-readable format that we can digest in our RenderSytem. { for (int i = 0; i < j3dMesh.SubMeshes.Count; i++) { MeshBatch batch = j3dMesh.SubMeshes[i]; batch.BoneWeights = new BoneWeight[batch.Vertices.Length]; for (int j = 0; j < batch.PositionMatrixIndexs.Count; j++) { // Okay so this is where it gets more complicated. The PMI gives us an index into the MatrixTable for the packet, which we // resolve and call "drawIndexes" - however we have to divide the number they give us by three for some reason, so that is // already done and now our drawIndexes array should be one-index-for-every-vertex-in-batch and it should be the index into // the draw section we need. ushort drw1Index = batch.drawIndexes[j]; // The drw1Index can be set as 0xFFFF - if so, this means that you need to use the dr1Index of the previous one. // until it is no longer 0xFFFF. int counter = 0; while (drw1Index == 0xFFFF) { drw1Index = batch.drawIndexes[j - counter]; counter++; } bool isWeighted = drawInfo.IsWeighted[drw1Index]; BoneWeight weight = new BoneWeight(); if (isWeighted) { // Something on this doesn't work for models that actually specify a PositionMatrixIndex. // So... some math is off somewhere and I don't know where for the moment. ushort numBonesAffecting = envelopes.numBonesAffecting[drw1Index]; weight.BoneIndexes = new ushort[numBonesAffecting]; weight.BoneWeights = new float[numBonesAffecting]; // "Much WTFs" ushort offset = 0; for (ushort e = 0; e < envelopes.indexRemap[drw1Index]; e++) { offset += envelopes.numBonesAffecting[e]; } offset *= 2; Matrix4 finalTransform = Matrix4.Identity; for (ushort k = 0; k < numBonesAffecting; k++) { ushort boneIndex = envelopes.indexRemap[offset + (k * 0x2)]; float boneWeight = envelopes.weights[(offset / 2) + k]; weight.BoneIndexes[k] = boneIndex; weight.BoneWeights[k] = boneWeight; // This was apaprently a partial thought I never finished or got working in the old one? :S } } else { // If the vertex isn't weighted, we just use the position from the bone matrix. SkeletonBone joint = skeleton[drawInfo.Indexes[drw1Index]]; Matrix4 translation = Matrix4.CreateTranslation(joint.Translation); Matrix4 rotation = Matrix4.CreateFromQuaternion(joint.Rotation); Matrix4 finalMatrix = rotation * translation; // Move the mesh by transforming the position by this much. // I think we can just assign full weight to the first bone index and call it good. weight.BoneIndexes = new[] { drawInfo.Indexes[drw1Index] }; weight.BoneWeights = new[] { 1f }; } batch.BoneWeights[j] = weight; } } } return j3dMesh; }
private void LoadModels(Dictionary<Scene, VirtualFilesystemDirectory> archiveMap) { // We're going to search the archives for a specific list of meshes that the game supports and load those. List<string> supportedModelPaths = new List<string>(new string[] { "model", "model1", "model2", "model3"}); foreach (var kvp in archiveMap) { List<VirtualFilesystemFile> filesByExtension = kvp.Value.FindByExtension(".bmd", ".bdl"); foreach (var vfsFile in filesByExtension) { if (!supportedModelPaths.Contains(vfsFile.Name)) continue; using (EndianBinaryReader reader = new EndianBinaryReader(new System.IO.MemoryStream(vfsFile.File.GetData()), Endian.Big)) { WLog.Info(LogCategory.EntityLoading, null, "Loading {1} (3D Model) for {0}{1}...", vfsFile.Name, vfsFile.Extension); J3DLoader j3dLoader = new J3DLoader(); Mesh resultMesh = j3dLoader.LoadFromStream(reader); kvp.Key.MeshList.Add(resultMesh); WLog.Info(LogCategory.EntityLoading, null, "Finished loading {1} (3D Model) for {0}{1}.", vfsFile.Name, vfsFile.Extension); } } } }
private void LoadEntities(Map newMap, EditorCore core, Dictionary<Scene, VirtualFilesystemDirectory> archiveMap, WWorld world) { MapEntityLoader entityLoader = new MapEntityLoader(core, newMap); // For each room/scene, find the associated dzr/dzs file and load its // contents into the entityLoader. foreach (var kvp in archiveMap) { // Check to see if this Archive has stage/room entity data. var roomEntData = kvp.Value.FindByExtension(".dzr"); var stageEntData = kvp.Value.FindByExtension(".dzs"); VirtualFilesystemFile vfsFile = null; if (roomEntData.Count > 0) vfsFile = roomEntData[0]; else if (stageEntData.Count > 0) vfsFile = stageEntData[0]; else continue; using (EndianBinaryReader reader = new EndianBinaryReader(new System.IO.MemoryStream(vfsFile.File.GetData()), Endian.Big)) { WLog.Info(LogCategory.EntityLoading, null, "Loading .dzr/.dzs (Room/Stage Entity Dat) for {0}{1}...", vfsFile.Name, vfsFile.Extension); entityLoader.LoadFromStream(kvp.Key, reader); WLog.Info(LogCategory.EntityLoading, null, "Finished loading .dzr/.dzs (Room/Stage Entity Dat) for {0}{1}.", vfsFile.Name, vfsFile.Extension); } } // Once we've loaded all of the entities from the stream, we're going to // post-process them to resolve object references. entityLoader.PostProcessEntities(); // Finally, we can actually convert these into map objects foreach (var roomOrStageData in entityLoader.GetData()) { Stage stage = roomOrStageData.Key as Stage; Room room = roomOrStageData.Key as Room; if (stage != null) { PostProcessStage(stage, roomOrStageData.Value); foreach (var entity in stage.Entities) entity.World = world; } if (room != null) { PostProcessRoom(room, roomOrStageData.Value); foreach (var entity in room.Entities) entity.World = world; } } }
private static List<SkeletonBone> LoadJNT1SectionFromStream(EndianBinaryReader reader, long chunkStart) { List<SkeletonBone> skeletonBones = new List<SkeletonBone>(); ushort numJoints = reader.ReadUInt16(); ushort padding = reader.ReadUInt16(); uint jointDataOffset = reader.ReadUInt32(); // Relative to JNT1 Header Start uint jointRemapOffset = reader.ReadUInt32(); uint stringTableOffset = reader.ReadUInt32(); // Grab the joint names from file reader.BaseStream.Position = chunkStart + stringTableOffset; StringTable jointNames = StringTable.FromStream(reader); // This is always 0 to (numJoints-1) - unsure if it's a joint // remap (likely) or a string-table remap (less likely). It's unknown // if any models don't follow this 0 to (n-1) pattern. ushort[] jointRemaps = new ushort[numJoints]; reader.BaseStream.Position = chunkStart + jointRemapOffset; for (int j = 0; j < numJoints; j++) jointRemaps[j] = reader.ReadUInt16(); // Grab the actual joints reader.BaseStream.Position = chunkStart + jointDataOffset; for (int j = 0; j < numJoints; j++) { SkeletonBone bone = new SkeletonBone(); bone.Name = jointNames[j]; ushort unknown1 = reader.ReadUInt16(); // Values of 0, 2 or 1. yaz0r calls it Matrix Type (referring to 'MatrixTable' which is an index into DRW1 - Draw type? // If value is 1 or 2 then Bounding Box / Radius is Vector3.Zero / 0f // And seems to be 0 if a joint has direct non-joint children (Maybe 0 is a 'bone with children' and the BBMin/Max contain // the bounds of children? ushort unknown2 = reader.ReadUInt16(); // No one seems to know what it is, often 0xFF or 0 or 1. May be two individual bytes with a pad afterwards. for (int f = 0; f < 3; f++) bone.Scale[f] = reader.ReadSingle(); Vector3 eulerAngles = new Vector3(); for (int f = 0; f < 3; f++) eulerAngles[f] = (reader.ReadInt16() * (180 / 32786f)); Quaternion xAxis = Quaternion.FromAxisAngle(new Vector3(1, 0, 0), eulerAngles.X * MathE.Deg2Rad); Quaternion yAxis = Quaternion.FromAxisAngle(new Vector3(0, 1, 0), eulerAngles.Y * MathE.Deg2Rad); Quaternion zAxis = Quaternion.FromAxisAngle(new Vector3(0, 0, 1), eulerAngles.Z * MathE.Deg2Rad); // Swizzling to the ZYX order seems to be the right one. Quaternion finalRot = zAxis * yAxis * xAxis; bone.Rotation = finalRot; Trace.Assert(reader.ReadUInt16() == 0xFFFF); // Padding for (int f = 0; f < 3; f++) bone.Translation[f] = reader.ReadSingle(); bone.BoundingSphereDiameter = reader.ReadSingle(); for (int f = 0; f < 3; f++) bone.BoundingBoxMin[f] = reader.ReadSingle(); for (int f = 0; f < 3; f++) bone.BoundingBoxMax[f] = reader.ReadSingle(); skeletonBones.Add(bone); } return skeletonBones; }
public static ZUD FromStream(EndianBinaryReader reader) { /*===================================================================== ZUD HEADER =====================================================================*/ byte IDCharacter = reader.ReadByte(); byte IDWeapon = reader.ReadByte(); byte IDWeaponCategory = reader.ReadByte(); byte IDWeaponMaterial = reader.ReadByte(); byte IDShield = reader.ReadByte(); byte IDShieldMaterial = reader.ReadByte(); byte unknown = reader.ReadByte(); reader.SkipByte(); UInt32 ptrCharacterSHP = reader.ReadUInt32(); UInt32 lenCharacterSHP = reader.ReadUInt32(); UInt32 ptrWeaponWEP = reader.ReadUInt32(); UInt32 lenWeaponWEP= reader.ReadUInt32(); UInt32 ptrShieldWEP = reader.ReadUInt32(); UInt32 lenShieldWEP = reader.ReadUInt32(); UInt32 ptrCommonSEQ = reader.ReadUInt32(); UInt32 lenCommonSEQ = reader.ReadUInt32(); UInt32 ptrBattleSEQ = reader.ReadUInt32(); UInt32 lenBattleSEQ = reader.ReadUInt32(); /*===================================================================== STREAM READER =====================================================================*/ ZUD zud = new ZUD(); if (lenCharacterSHP != 0) { zud.Character = SHPLoader.FromStream(reader); } if (lenWeaponWEP != 0) { zud.HasWeapon = true; reader.BaseStream.Seek(ptrWeaponWEP, System.IO.SeekOrigin.Begin); zud.Weapon = WEPLoader.FromStream(reader); } if (lenShieldWEP != 0) { zud.HasShield = true; reader.BaseStream.Seek(ptrShieldWEP, System.IO.SeekOrigin.Begin); zud.Shield = WEPLoader.FromStream(reader); } if (lenCommonSEQ != 0) { zud.HasCommon = true; reader.BaseStream.Seek(ptrCommonSEQ, System.IO.SeekOrigin.Begin); zud.Common = SEQLoader.FromStream(reader, zud.Character); } if (lenBattleSEQ != 0) { zud.HasBattle = true; reader.BaseStream.Seek(ptrBattleSEQ, System.IO.SeekOrigin.Begin); zud.Battle = SEQLoader.FromStream(reader, zud.Character); } return zud; }