public override void WriteToStream(BinaryWriter bw, MMDExportSettings exportSettings) { if (exportSettings.Format == MMDExportSettings.ModelFormat.PMX) { base.WriteToStream(bw, exportSettings); PMXParser.WriteIndex(bw, exportSettings.BitSettings.BoneIndexLength, PMXBone.CheckIndexInModel(this.Bone2, exportSettings)); bw.Write(this.Bone1Weight); } else { int b1i = PMXBone.CheckIndexInModel(this.Bone1, exportSettings); int b2i = PMXBone.CheckIndexInModel(this.Bone2, exportSettings); List <KeyValuePair <int, float> > sortKeys = new List <KeyValuePair <int, float> >(); if (b1i >= 0) { sortKeys.Add(new KeyValuePair <int, float>(b1i, this.Bone1Weight)); } if (b2i >= 0) { sortKeys.Add(new KeyValuePair <int, float>(b2i, 1.0f - this.Bone1Weight)); } this.ExportToPMDBase(sortKeys, bw); } }
/// <summary> /// Remove a vertex index into the vertex to allow very quick exporting. /// </summary> /// <param name="index"></param> /// <param name="settings"></param> public void RemoveIndexForExport(MMDExportSettings settings) { if (this._exportHashNumbers.ContainsKey(settings.ExportHash)) { this._exportHashNumbers.Remove(settings.ExportHash); } }
public override void WriteToStream(BinaryWriter bw, MMDExportSettings exportSettings) { if (exportSettings.Format == MMDExportSettings.ModelFormat.PMX) { PMXParser.WriteString(bw, exportSettings.TextEncoding, this.NameJP); PMXParser.WriteString(bw, exportSettings.TextEncoding, this.NameEN); bw.Write((byte)(int)this.Type); PMXParser.WriteIndex(bw, exportSettings.BitSettings.RigidBodyIndexLength, PMXRigidBody.CheckIndexInModel(this.RigidBodyA, exportSettings)); PMXParser.WriteIndex(bw, exportSettings.BitSettings.RigidBodyIndexLength, PMXRigidBody.CheckIndexInModel(this.RigidBodyB, exportSettings)); } else { PMDParser.WriteString(bw, 20, exportSettings.TextEncoding, this.NameJP); PMXParser.WriteIndex(bw, 4, PMXRigidBody.CheckIndexInModel(this.RigidBodyA, exportSettings)); PMXParser.WriteIndex(bw, 4, PMXRigidBody.CheckIndexInModel(this.RigidBodyB, exportSettings)); } this.Position.WriteToStream(bw); this.Rotation.WriteToStream(bw); this.TranslationLimitMin.WriteToStream(bw); this.TranslationLimitMax.WriteToStream(bw); this.RotationLimitMin.WriteToStream(bw); this.RotationLimitMax.WriteToStream(bw); this.SpringConstantTranslation.WriteToStream(bw); this.SpringConstantRotation.WriteToStream(bw); }
public override void WriteToStream(BinaryWriter bw, MMDExportSettings exportSettings) { this.Position.WriteToStream(bw); this.Normals.WriteToStream(bw); this.UV.WriteToStream(bw); if (exportSettings.Format == MMDExportSettings.ModelFormat.PMX) { //PMX format for (int i = 0; i < exportSettings.ExtendedUV; i++) { PMXQuaternion set = ((i >= this.AddedUVs.Count) ? (new PMXQuaternion()) : this.AddedUVs[i]); set.WriteToStream(bw); } this.Deform.WriteToStream(bw, exportSettings); bw.Write(this.OutlineMagnification); } else { this.Deform.WriteToStream(bw, exportSettings); bw.Write((byte)((this.OutlineMagnification > 0.2f) ? 0:1)); } }
public override void WriteToStream(BinaryWriter bw, MMDExportSettings exportSettings) { PMXParser.WriteString(bw, exportSettings.TextEncoding, this.NameJP); PMXParser.WriteString(bw, exportSettings.TextEncoding, this.NameEN); bool isImportant = (this.Model.DisplaySlots.IndexOf(this) <= 1); //Root and EXP Displays if (isImportant) { bw.Write((byte)1); } else { bw.Write((byte)0); } bw.Write((Int32)this.References.Count); foreach (PMXBasePart rfr in this.References) { if (rfr is PMXBone) { bw.Write((byte)PMXDisplaySlot.REF_IDENTIFY_BONE); PMXParser.WriteIndex(bw, exportSettings.BitSettings.BoneIndexLength, PMXBone.CheckIndexInModel((PMXBone)rfr, exportSettings, false)); } else if (rfr is PMXMorph) { bw.Write((byte)PMXDisplaySlot.REF_IDENTIFY_MORPH); PMXParser.WriteIndex(bw, exportSettings.BitSettings.MorphIndexLength, PMXMorph.CheckIndexInModel((PMXMorph)rfr, exportSettings, false)); } else { throw new InvalidDataException("Invalid reference in display slots. Only bones and morphs are supported!"); } } }
public override void WriteToStream(BinaryWriter bw, MMDExportSettings exportSettings) { PMXParser.WriteIndex(bw, exportSettings.BitSettings.VertexIndexLength, PMXVertex.CheckIndexInModel(this.Vertex, exportSettings)); this.UVTranslation.WriteToStream(bw); this.UVTranslation2.WriteToStream(bw); }
public override void WriteToStream(BinaryWriter bw, MMDExportSettings exportSettings) { byte indexLength = ((exportSettings.Format == MMDExportSettings.ModelFormat.PMX) ? exportSettings.BitSettings.VertexIndexLength : (byte)2); PMXParser.WriteIndex(bw, indexLength, PMXVertex.CheckIndexInModel(this.Vertex1, exportSettings)); PMXParser.WriteIndex(bw, indexLength, PMXVertex.CheckIndexInModel(this.Vertex2, exportSettings)); PMXParser.WriteIndex(bw, indexLength, PMXVertex.CheckIndexInModel(this.Vertex3, exportSettings)); }
public override void WriteToStream(BinaryWriter bw, MMDExportSettings exportSettings) { base.WriteToStream(bw, exportSettings); if (exportSettings.Format == MMDExportSettings.ModelFormat.PMX) { this.C.WriteToStream(bw); this.R0.WriteToStream(bw); this.R1.WriteToStream(bw); } }
public override void WriteToStream(BinaryWriter bw, MMDExportSettings exportSettings) { if (exportSettings.Format == MMDExportSettings.ModelFormat.PMX) { //PMX PMXParser.WriteIndex(bw, exportSettings.BitSettings.VertexIndexLength, PMXVertex.CheckIndexInModel(this.Vertex, exportSettings)); } else { //PMD PMXParser.WriteIndex(bw, 4, exportSettings.BaseMorphVertices.IndexOf(this.Vertex)); } this.Translation.WriteToStream(bw); }
public override void WriteToStream(BinaryWriter bw, MMDExportSettings exportSettings) { byte[] buffer = new byte[2]; this._noCollissionGroup.CopyTo(buffer, 0); for (int i = 0; i < 2; i++) { buffer[i] = (byte)(~((int)buffer[i]) & 0xFF); } bw.BaseStream.Write(buffer, 0, 2); }
/// <summary> /// Checks if the rigid body is part of a given model. /// </summary> /// <param name="bdy"></param> /// <param name="exportSettings"></param> /// <param name="nullAcceptable"></param> /// <returns></returns> public static int CheckIndexInModel(PMXRigidBody bdy, MMDExportSettings exportSettings) { if (bdy == null) { throw new InvalidDataException("Rigid body mustn't be null!"); } PMXModel model = exportSettings.Model; int index = model.RigidBodies.IndexOf(bdy); if (index < 0) { throw new InvalidDataException("Rigid body is not a member of model!"); } return(index); }
public override void WriteToStream(BinaryWriter bw, MMDExportSettings exportSettings) { PMXParser.WriteIndex(bw, exportSettings.BitSettings.MaterialIndexLength, PMXMaterial.CheckIndexInModel(this.Material, exportSettings, true)); bw.Write((byte)(int)this.Type); this.Diffuse.WriteToStream(bw); this.Specular.WriteToStream(bw); this.Ambient.WriteToStream(bw); this.EdgeColor.WriteToStream(bw); bw.Write(this.EdgeSize); this.TextureFactor.WriteToStream(bw); this.SphereTextureFactor.WriteToStream(bw); this.ToonTextureFactor.WriteToStream(bw); }
public override void WriteToStream(BinaryWriter bw, MMDExportSettings exportSettings) { if (exportSettings.Format == MMDExportSettings.ModelFormat.PMX) { //PMX format PMXParser.WriteString(bw, exportSettings.TextEncoding, this.NameJP); PMXParser.WriteString(bw, exportSettings.TextEncoding, this.NameEN); bw.Write((byte)(int)this.Panel); if (this.Offsets.Count == 0) { bw.Write((byte)PMXMorph.MORPH_IDENTIFY_VERTEX); bw.Write((Int32)0); } else { byte morphTypeId = this.Offsets[0].MorphTargetType; bw.Write((byte)morphTypeId); bw.Write((Int32)this.Offsets.Count); foreach (PMXMorphOffsetBase offset in this.Offsets) { if (offset.MorphTargetType != morphTypeId) { throw new InvalidDataException("Morph offset types mustn't be mixed types"); } offset.WriteToStream(bw, exportSettings); } } } //PMD format else { PMDParser.WriteString(bw, 20, exportSettings.TextEncoding, this.NameJP); bw.Write((Int32)this.Offsets.Count); bw.Write((byte)(int)this.Panel); foreach (PMXMorphOffsetBase offset in this.Offsets) { if (!(offset is PMXMorphOffsetVertex)) { throw new InvalidDataException("PMD only supports vertex morphs."); } offset.WriteToStream(bw, exportSettings); } } }
public override void WriteToStream(BinaryWriter bw, MMDExportSettings exportSettings) { if (exportSettings.Format == MMDExportSettings.ModelFormat.PMX) { PMXParser.WriteString(bw, exportSettings.TextEncoding, this.NameJP); PMXParser.WriteString(bw, exportSettings.TextEncoding, this.NameEN); PMXParser.WriteIndex(bw, exportSettings.BitSettings.BoneIndexLength, PMXBone.CheckIndexInModel(this.Bone, exportSettings, true)); } else { PMDParser.WriteString(bw, 20, exportSettings.TextEncoding, this.NameEN); PMXParser.WriteIndex(bw, 2, PMXBone.CheckIndexInModel(this.Bone, exportSettings, true)); } bw.Write((byte)this.CollissionGroup); this.NoCollissionGroups.WriteToStream(bw, exportSettings); bw.Write((byte)(int)this.Shape); this._shapeSize.WriteToStream(bw); if (exportSettings.Format == MMDExportSettings.ModelFormat.PMD && this.Bone != null) { //PMD location fix PMXVector3 pos = new PMXVector3(this.Position.X, this.Position.Y, this.Position.Z); pos -= this.Bone.Position; pos.WriteToStream(bw); } else { this.Position.WriteToStream(bw); } this.Rotation.WriteToStream(bw); bw.Write(this.Mass); bw.Write(this.LinearDamping); bw.Write(this.AngularDamping); bw.Write(this.Repulsion); bw.Write(this.Friction); bw.Write((byte)(int)this.Type); }
public override void WriteToStream(BinaryWriter bw, MMDExportSettings exportSettings) { if (exportSettings.Format == MMDExportSettings.ModelFormat.PMX) { //PMX IK PMXParser.WriteIndex(bw, exportSettings.BitSettings.BoneIndexLength, PMXBone.CheckIndexInModel(this.Bone, exportSettings, true)); if (this.HasLimits) { bw.Write((byte)1); this.Minimum.WriteToStream(bw); this.Maximum.WriteToStream(bw); } else { bw.Write((byte)0); } } else { //PMD IK PMXParser.WriteIndex(bw, 2, PMXBone.CheckIndexInModel(this.Bone, exportSettings, true)); } }
/// <summary> /// Checks if the bone is part of a given model. /// </summary> /// <param name="model"></param> /// <returns></returns> public static int CheckIndexInModel(PMXVertex vtx, MMDExportSettings settings) { if (vtx == null) { throw new InvalidDataException("Vertex mustn't be null!"); } if (vtx._exportHashNumbers.ContainsKey(settings.ExportHash)) { return(vtx._exportHashNumbers[settings.ExportHash]); } PMXModel model = settings.Model; int index = model.Vertices.IndexOf(vtx); if (index < 0) { throw new InvalidDataException("Vertex not a member of model!"); } return(index); }
public override void WriteToStream(BinaryWriter bw, MMDExportSettings exportSettings) { if (exportSettings.Format == MMDExportSettings.ModelFormat.PMX) { //PMX IK PMXParser.WriteIndex(bw, exportSettings.BitSettings.BoneIndexLength, PMXBone.CheckIndexInModel(this.Target, exportSettings, true)); bw.Write((Int32)this.Loop); bw.Write(this.RadianLimit); bw.Write((Int32)this.IKLinks.Count); } else { //PMD PMXParser.WriteIndex(bw, 2, PMXBone.CheckIndexInModel(this.Target, exportSettings, true)); bw.Write((byte)this.IKLinks.Count); bw.Write((UInt16)this.Loop); bw.Write(this.RadianLimit); } foreach (PMXIKLink link in this.IKLinks) { link.WriteToStream(bw, exportSettings); } }
/// <summary> /// Checks if the bone is part of a given model. /// </summary> /// <param name="bn"></param> /// <param name="exportSettings"></param> /// <param name="nullAcceptable"></param> /// <returns></returns> public static int CheckIndexInModel(PMXBone bn, MMDExportSettings exportSettings, bool nullAcceptable = true) { if (bn == null) { if (nullAcceptable) { return(-1); } else { throw new InvalidDataException("Bone mustn't be null!"); } } PMXModel model = exportSettings.Model; int index = model.Bones.IndexOf(bn); if (index < 0) { throw new InvalidDataException("Bone not a member of model!"); } return(index); }
/// <summary> /// Checks if the material is part of a given model. /// </summary> /// <param name="bn"></param> /// <param name="exportSettings"></param> /// <param name="nullAcceptable"></param> /// <returns></returns> public static int CheckIndexInModel(PMXMaterial mat, MMDExportSettings exportSettings, bool nullAcceptable = true) { if (mat == null) { if (nullAcceptable) { return(-1); } else { throw new InvalidDataException("Material mustn't be null!"); } } PMXModel model = exportSettings.Model; int index = model.Materials.IndexOf(mat); if (index < 0) { throw new InvalidDataException("Material not a member of model!"); } return(index); }
/// <summary> /// Write this part to an existing model. /// </summary> /// <param name="bw">Writer for the output.</param> /// <param name="exportSettings">Export settings.</param> public abstract void WriteToStream(BinaryWriter bw, MMDExportSettings exportSettings);
/// <summary> /// Saves to a stream as PMD. /// </summary> /// <param name="fs"></param> public void SaveToStreamPMD(Stream stream) { List <string> requiredToons = new List <string>(); //List of textures to export string[] defaultToons = new string[] { "toon01.bmp", "toon02.bmp", "toon03.bmp", "toon04.bmp", "toon05.bmp", "toon06.bmp", "toon07.bmp", "toon08.bmp", "toon09.bmp", "toon10.bmp" }; int triangleCount = 0; foreach (PMXMaterial mat in this.Materials) { //this.AddToListIfRequired(requiredToons, mat.DiffuseTexture); if (mat.StandardToon) { this.AddToListIfRequired(requiredToons, defaultToons[mat.StandardToonIndex]); } else { this.AddToListIfRequired(requiredToons, mat.NonStandardToonTexture); } triangleCount += mat.Triangles.Count; } string[] toonFiles = new string[10]; for (int i = 0; i < 10; i++) { if (i < requiredToons.Count) { toonFiles[i] = requiredToons[i]; } else { toonFiles[i] = defaultToons[i]; } } MemoryStream ms = new MemoryStream(); BinaryWriter bw = new BinaryWriter(ms); byte[] magic = Encoding.ASCII.GetBytes("Pmd"); ms.Write(magic, 0, 3); Random rnd = new Random(); int randomNumber = rnd.Next(); MMDExportSettings settings = new MMDExportSettings(MMDExportSettings.ModelFormat.PMD); settings.Model = this; settings.ExportHash = randomNumber; settings.TextEncoding = Encoding.GetEncoding(932); float version = 1.0f; bw.Write(version); PMDParser.WriteString(bw, 20, settings.TextEncoding, this.NameJP); PMDParser.WriteString(bw, 256, settings.TextEncoding, this.DescriptionJP); //Vertices bw.Write((int)this.Vertices.Count); int vtxIndex = 0; foreach (PMXVertex v in this.Vertices) { v.AddIndexForExport(settings, vtxIndex); v.WriteToStream(bw, settings); vtxIndex++; } //Triangles bw.Write((Int32)(triangleCount * 3)); foreach (PMXMaterial mat in this.Materials) { foreach (PMXTriangle t in mat.Triangles) { t.WriteToStream(bw, settings); } } //Materials bw.Write((Int32)this.Materials.Count); foreach (PMXMaterial mat in this.Materials) { mat.WriteToStream(bw, settings, toonFiles, defaultToons); } //Bones bw.Write((Int16)this.Bones.Count); List <PMXBone> ikBonesList = new List <PMXBone>(); foreach (PMXBone bn in this.Bones) { if (bn.IK != null) { ikBonesList.Add(bn); } } PMXBone[] ikBones = ikBonesList.ToArray(); foreach (PMXBone bn in this.Bones) { bn.WriteToStream(bw, settings, ikBones); } //PMD IKs bw.Write((Int16)ikBones.Length); foreach (PMXBone bn in ikBones) { PMXParser.WriteIndex(bw, 2, PMXBone.CheckIndexInModel(bn, settings, true)); bn.IK.WriteToStream(bw, settings); } //PMD Morphs List <PMXMorph> exportableMorphs = new List <PMXMorph>(); List <PMXVertex> baseVertices = new List <PMXVertex>(); foreach (PMXMorph mrph in this.Morphs) { bool exportable = true; foreach (PMXMorphOffsetBase mofb in mrph.Offsets) { if (!(mofb is PMXMorphOffsetVertex)) { exportable = false; } } if (exportable) { exportableMorphs.Add(mrph); foreach (PMXMorphOffsetBase mofb in mrph.Offsets) { PMXMorphOffsetVertex mofv = (PMXMorphOffsetVertex)mofb; if (!baseVertices.Contains(mofv.Vertex)) { baseVertices.Add(mofv.Vertex); } } } } settings.BaseMorphVertices = baseVertices; bw.Write((Int16)(exportableMorphs.Count + 1)); PMDParser.WriteString(bw, 20, settings.TextEncoding, "base"); bw.Write((Int32)baseVertices.Count); bw.Write((byte)0); foreach (PMXVertex vtx in baseVertices) { PMXParser.WriteIndex(bw, 4, PMXVertex.CheckIndexInModel(vtx, settings)); vtx.Position.WriteToStream(bw); } foreach (PMXMorph mrph in exportableMorphs) { mrph.WriteToStream(bw, settings); } //Display groups - kinda insanely set up for PMD //PMD doesn't have a root slot //Expression display slots List <PMXMorph> morphs = new List <PMXMorph>(); //List of facial expressions foreach (PMXDisplaySlot ds in this.DisplaySlots) { foreach (PMXBasePart reference in ds.References) { if (reference is PMXMorph) { morphs.Add((PMXMorph)reference); } } } bw.Write((byte)morphs.Count); foreach (PMXMorph mrph in morphs) { int morphId = this.Morphs.IndexOf(mrph) + 1; bw.Write((UInt16)morphId); } //Bone display slots bw.Write((byte)(this.DisplaySlots.Count - 2)); for (int dsidx = 2; dsidx < this.DisplaySlots.Count; dsidx++) { PMDParser.WriteString(bw, 50, settings.TextEncoding, this.DisplaySlots[dsidx].NameJP); } //We've got the names - now let's put the bones in uint totalBoneRefCount = 0; for (int dsidx = 2; dsidx < this.DisplaySlots.Count; dsidx++) { PMXDisplaySlot ds = this.DisplaySlots[dsidx]; foreach (PMXBasePart reference in ds.References) { if (reference is PMXBone) { totalBoneRefCount++; } } } bw.Write((uint)totalBoneRefCount); for (int dsidx = 2; dsidx < this.DisplaySlots.Count; dsidx++) { PMXDisplaySlot ds = this.DisplaySlots[dsidx]; foreach (PMXBasePart reference in ds.References) { if (reference is PMXBone) { PMXBone bref = (PMXBone)reference; bw.Write((UInt16)this.Bones.IndexOf(bref)); bw.Write((byte)(dsidx - 1)); } } } //Always write english names bw.Write((byte)1); PMDParser.WriteString(bw, 20, settings.TextEncoding, this.NameEN); PMDParser.WriteString(bw, 256, settings.TextEncoding, this.DescriptionEN); foreach (PMXBone bn in this.Bones) { PMDParser.WriteString(bw, 20, settings.TextEncoding, bn.NameEN); } foreach (PMXMorph mrph in exportableMorphs) { PMDParser.WriteString(bw, 20, settings.TextEncoding, mrph.NameEN); } for (int i = 2; i < this.DisplaySlots.Count; i++) { PMDParser.WriteString(bw, 50, settings.TextEncoding, this.DisplaySlots[i].NameEN); } //Toon files foreach (string toon in toonFiles) { PMDParser.WriteString(bw, 100, settings.TextEncoding, toon); } //Rigid bodies bw.Write((uint)this.RigidBodies.Count); foreach (PMXRigidBody rb in this.RigidBodies) { rb.WriteToStream(bw, settings); } //Joints bw.Write((uint)this.Joints.Count); foreach (PMXJoint jt in this.Joints) { jt.WriteToStream(bw, settings); } //Vertex restore foreach (PMXVertex v in this.Vertices) { v.RemoveIndexForExport(settings); } long length = ms.Position; ms.Seek(0, SeekOrigin.Begin); ms.CopyTo(stream); ms.Close(); ms = null; }
/// <summary> /// Saves a model to a stream. /// </summary> /// <param name="stream"></param> public void SaveToStream(Stream stream) { List <string> requiredTextureList = new List <string>(); //List of textures to export int triangleCount = 0; foreach (PMXMaterial mat in this.Materials) { this.AddToListIfRequired(requiredTextureList, mat.DiffuseTexture); this.AddToListIfRequired(requiredTextureList, mat.SphereTexture); if (!mat.StandardToon) { this.AddToListIfRequired(requiredTextureList, mat.NonStandardToonTexture); } triangleCount += mat.Triangles.Count; } int maxAddUV = 0; foreach (PMXVertex v in this.Vertices) { maxAddUV = Math.Max(v.AddedUVs.Count, maxAddUV); } if (maxAddUV > 4) { throw new InvalidDataException("Maximum Add UV data is 4"); } MemoryStream ms = new MemoryStream(); BinaryWriter bw = new BinaryWriter(ms); byte[] magic = Encoding.ASCII.GetBytes("PMX "); stream.Write(magic, 0, 4); Random rnd = new Random(); int randomNumber = rnd.Next(); MMDExportSettings settings = new MMDExportSettings(MMDExportSettings.ModelFormat.PMX); settings.Model = this; settings.ExportHash = randomNumber; settings.ExtendedUV = (byte)maxAddUV; float version = 2.0f; foreach (PMXJoint j in this.Joints) { if (j.Type != PMXJoint.JointType.SpringSixDOF) { version = 2.1f; break; } } bw.Write(version); //Flag length bw.Write((byte)8); //Encoding (UTF-16 LE only) settings.TextEncoding = Encoding.Unicode; bw.Write((byte)0); bw.Write((byte)settings.ExtendedUV); settings.BitSettings.VertexIndexLength = this.DetermineRequiredBitLength(this.Vertices.Count); settings.BitSettings.TextureIndexLength = this.DetermineRequiredBitLength(requiredTextureList.Count); settings.BitSettings.MaterialIndexLength = this.DetermineRequiredBitLength(this.Materials.Count); settings.BitSettings.BoneIndexLength = this.DetermineRequiredBitLength(this.Bones.Count); settings.BitSettings.MorphIndexLength = this.DetermineRequiredBitLength(this.Morphs.Count); settings.BitSettings.RigidBodyIndexLength = this.DetermineRequiredBitLength(this.RigidBodies.Count); bw.Write(settings.BitSettings.VertexIndexLength); bw.Write(settings.BitSettings.TextureIndexLength); bw.Write(settings.BitSettings.MaterialIndexLength); bw.Write(settings.BitSettings.BoneIndexLength); bw.Write(settings.BitSettings.MorphIndexLength); bw.Write(settings.BitSettings.RigidBodyIndexLength); PMXParser.WriteString(bw, settings.TextEncoding, this.NameJP); PMXParser.WriteString(bw, settings.TextEncoding, this.NameEN); PMXParser.WriteString(bw, settings.TextEncoding, this.DescriptionJP); PMXParser.WriteString(bw, settings.TextEncoding, this.DescriptionEN); //Vertices bw.Write((Int32)this.Vertices.Count); int vtxIndex = 0; foreach (PMXVertex v in this.Vertices) { v.AddIndexForExport(settings, vtxIndex); v.WriteToStream(bw, settings); vtxIndex++; } //Triangles bw.Write((Int32)(triangleCount * 3)); foreach (PMXMaterial mat in this.Materials) { foreach (PMXTriangle t in mat.Triangles) { t.WriteToStream(bw, settings); } } //Textures string[] textures = requiredTextureList.ToArray(); bw.Write((Int32)textures.Length); foreach (string textureFile in textures) { PMXParser.WriteString(bw, settings.TextEncoding, textureFile); } //Materials bw.Write((Int32)this.Materials.Count); foreach (PMXMaterial mat in this.Materials) { mat.WriteToStream(bw, settings, textures); } //Bones bw.Write((Int32)this.Bones.Count); foreach (PMXBone bn in this.Bones) { bn.WriteToStream(bw, settings); } //Morphs bw.Write((Int32)this.Morphs.Count); foreach (PMXMorph mrph in this.Morphs) { mrph.WriteToStream(bw, settings); } //Displays bw.Write((Int32)this.DisplaySlots.Count); foreach (PMXDisplaySlot dsp in this.DisplaySlots) { dsp.WriteToStream(bw, settings); } //Rigid bodies bw.Write((Int32)this.RigidBodies.Count); foreach (PMXRigidBody bdy in this.RigidBodies) { bdy.WriteToStream(bw, settings); } //Joints bw.Write((Int32)this.Joints.Count); foreach (PMXJoint jt in this.Joints) { jt.WriteToStream(bw, settings); } //Reset triangles foreach (PMXVertex v in this.Vertices) { v.RemoveIndexForExport(settings); } long length = ms.Position; ms.Seek(0, SeekOrigin.Begin); ms.CopyTo(stream); ms.Close(); ms = null; }
public override void WriteToStream(BinaryWriter bw, MMDExportSettings exportSettings) { PMXParser.WriteIndex(bw, exportSettings.BitSettings.BoneIndexLength, PMXBone.CheckIndexInModel(this.Bone, exportSettings, false)); this.Translation.WriteToStream(bw); this.Rotation.WriteToStream(bw); }
public void WriteToStream(BinaryWriter bw, MMDExportSettings exportSettings, PMXBone[] ikBones) { if (exportSettings.Format == MMDExportSettings.ModelFormat.PMX) { //PMX export short flags = 0x0000; flags |= (short)(this.HasChildBone ? PMXBone.BONE_TAILPOS_IS_BONE : 0x0000); flags |= (short)(this.Rotatable ? PMXBone.BONE_CAN_ROTATE : 0x0000); flags |= (short)(this.Translatable ? PMXBone.BONE_CAN_TRANSLATE : 0x0000); flags |= (short)(this.Visible ? PMXBone.BONE_IS_VISIBLE : 0x0000); flags |= (short)(this.Operating ? PMXBone.BONE_CAN_MANIPULATE : 0x0000); flags |= (short)((this.ExternalModificationType == BoneExternalModificationType.Both || this.ExternalModificationType == BoneExternalModificationType.Rotation) ? PMXBone.BONE_IS_EXTERNAL_ROTATION : 0x0000); flags |= (short)((this.ExternalModificationType == BoneExternalModificationType.Both || this.ExternalModificationType == BoneExternalModificationType.Translation) ? PMXBone.BONE_IS_EXTERNAL_TRANSLATION : 0x0000); flags |= (short)(this.FixedAxis ? PMXBone.BONE_HAS_FIXED_AXIS : 0x0000); flags |= (short)(this.LocalCoordinates ? PMXBone.BONE_HAS_LOCAL_COORDINATE : 0x0000); flags |= (short)(this.HasExternalParent ? PMXBone.BONE_IS_EXTERNAL_PARENT_DEFORM : 0x0000); flags |= (short)(this.TransformPhysicsFirst ? PMXBone.BONE_IS_AFTER_PHYSICS_DEFORM : 0x0000); flags |= (short)((this.IK != null) ? PMXBone.BONE_IS_IK : 0x0000); PMXParser.WriteString(bw, exportSettings.TextEncoding, this.NameJP); PMXParser.WriteString(bw, exportSettings.TextEncoding, this.NameEN); this.Position.WriteToStream(bw); PMXParser.WriteIndex(bw, exportSettings.BitSettings.BoneIndexLength, PMXBone.CheckIndexInModel(this.Parent, exportSettings, true)); bw.Write((Int32)this.Layer); bw.Write((Int16)flags); if (this.HasChildBone) { PMXParser.WriteIndex(bw, exportSettings.BitSettings.BoneIndexLength, PMXBone.CheckIndexInModel(this.ChildBone, exportSettings, true)); } else { this.ChildVector.WriteToStream(bw); } if (this.ExternalModificationType != BoneExternalModificationType.None) { PMXParser.WriteIndex(bw, exportSettings.BitSettings.BoneIndexLength, PMXBone.CheckIndexInModel(this.ExternalBone, exportSettings, true)); bw.Write(this.ExternalBoneEffect); } if (this.FixedAxis) { this.AxisLimit.WriteToStream(bw); } if (this.LocalCoordinates) { this.LocalCoordinatesX.WriteToStream(bw); this.LocalCoordinatesZ.WriteToStream(bw); } if (this.HasExternalParent) { bw.Write((Int32)this.ExternalParentKey); } if (this.IK != null) { this.IK.WriteToStream(bw, exportSettings); } } else { //PMD format PMDParser.WriteString(bw, 20, exportSettings.TextEncoding, this.NameJP); bw.Write((Int16)PMXBone.CheckIndexInModel(this.Parent, exportSettings, true)); if (this.HasChildBone) { bw.Write((Int16)PMXBone.CheckIndexInModel(this.ChildBone, exportSettings, true)); } else { bw.Write((Int16)(-1)); } byte type = PMD_BONE_TYPE_ROTATE; short ikIndex = 0; if (this.Translatable) { type = PMD_BONE_TYPE_ROTATE_MOVE; } if (this.IK != null) { type = PMD_BONE_TYPE_IK; } if (this.IK != null) { bool isIkTarget = false; foreach (PMXBone ikBone in ikBones) { foreach (PMXIKLink link in ikBone.IK.IKLinks) { if (link.Bone == this) { ikIndex = (Int16)PMXBone.CheckIndexInModel(ikBone, exportSettings, true); isIkTarget = true; break; } } if (isIkTarget) { break; } } if (isIkTarget) { type = (this.Visible ? PMD_BONE_TYPE_IK_CHILD:PMD_BONE_TYPE_IK_TARGET); } else if (!this.Visible) { type = PMD_BONE_TYPE_INVISIBLE; } else if (this.FixedAxis) { type = (this.Visible ? PMD_BONE_TYPE_TWIST : PMD_BONE_TYPE_TWIST_INVISIBLE); } else if (this.ExternalModificationType != BoneExternalModificationType.Both) { type = PMD_BONE_TYPE_EXTERNAL_ROTATOR; ikIndex = (Int16)PMXBone.CheckIndexInModel(this.ExternalBone, exportSettings, true); } } bw.Write(type); bw.Write(ikIndex); this.Position.WriteToStream(bw); } }
public override void WriteToStream(BinaryWriter bw, MMDExportSettings exportSettings) { PMXParser.WriteIndex(bw, exportSettings.BitSettings.MorphIndexLength, PMXMorph.CheckIndexInModel(this.MorphTarget, exportSettings, false)); bw.Write(this.Strength); }
/// <summary> /// Set a vertex index into the vertex to allow very quick exporting. /// </summary> /// <param name="index"></param> /// <param name="settings"></param> public void AddIndexForExport(MMDExportSettings settings, int index) { this._exportHashNumbers[settings.ExportHash] = index; }
public void WriteToStream(BinaryWriter bw, MMDExportSettings exportSettings, string[] textures, string[] defaultToons = null) { if (exportSettings.Format == MMDExportSettings.ModelFormat.PMX) { //PMX Export if (textures == null) { textures = new string[0]; } PMXParser.WriteString(bw, exportSettings.TextEncoding, this.NameJP); PMXParser.WriteString(bw, exportSettings.TextEncoding, this.NameEN); this.Diffuse.WriteToStream(bw); bw.Write(this.Alpha); this.Specular.WriteToStream(bw); bw.Write(this.SpecularFactor); this.Ambient.WriteToStream(bw); byte flags = (byte)(((int)this.GroundShadowType) << 6); flags |= (byte)(this.DoubleSided ? PMXMaterial.MATERIAL_DOUBLE_SIDED : 0); flags |= (byte)(this.GroundShadow ? PMXMaterial.MATERIAL_GROUND_SHADOW : 0); flags |= (byte)(this.SelfShadow ? PMXMaterial.MATERIAL_SELF_SHADOW : 0); flags |= (byte)(this.SelfShadowPlus ? PMXMaterial.MATERIAL_SELF_SHADOW_PLUS : 0); flags |= (byte)(this.EdgeEnabled ? PMXMaterial.MATERIAL_EDGE_ENABLED : 0); flags |= (byte)(this.VertexColor ? PMXMaterial.MATERIAL_VERTEX_COLOR : 0); bw.Write(flags); this.EdgeColor.WriteToStream(bw); bw.Write(this.EdgeSize); PMXParser.WriteIndex(bw, exportSettings.BitSettings.TextureIndexLength, this.GetTextureIndex(this.DiffuseTexture, textures)); PMXParser.WriteIndex(bw, exportSettings.BitSettings.TextureIndexLength, this.GetTextureIndex(this.SphereTexture, textures)); bw.Write((byte)this.SphereMode); if (this.StandardToon) { bw.Write((byte)1); bw.Write(this.StandardToonIndex); } else { bw.Write((byte)0); PMXParser.WriteIndex(bw, exportSettings.BitSettings.TextureIndexLength, this.GetTextureIndex(this.NonStandardToonTexture, textures)); } PMXParser.WriteString(bw, exportSettings.TextEncoding, this.Comment); int triangleVerticesCount = (this.Triangles.Count * 3); bw.Write((Int32)triangleVerticesCount); } else { if (defaultToons == null || textures == null) { throw new InvalidDataException("Toon data required for PMD."); } //PMD format this.Diffuse.WriteToStream(bw); bw.Write(this.Alpha); bw.Write(this.SpecularFactor); this.Specular.WriteToStream(bw); this.Ambient.WriteToStream(bw); int toonIndex = -1; string toonFile = null; if (this.StandardToon && this.StandardToonIndex >= 0) { if (this.StandardToonIndex < 10) { toonFile = defaultToons[this.StandardToonIndex]; } } else if (!this.StandardToon) { toonFile = this.NonStandardToonTexture; } if (toonFile != null) { int index = Array.IndexOf <string>(textures, toonFile); if (index >= 0 && index < 10) { toonIndex = index; } } bw.Write((sbyte)toonIndex); bw.Write((byte)(this.EdgeEnabled ? 1 : 0)); bw.Write((Int32)(this.Triangles.Count * 3)); string textureFile = ""; if (this.DiffuseTexture != null) { textureFile += this.DiffuseTexture; } if (this.SphereTexture != null) { textureFile += "*" + this.DiffuseTexture; } PMDParser.WriteString(bw, 20, exportSettings.TextEncoding, textureFile); } }
public override void WriteToStream(BinaryWriter bw, MMDExportSettings exportSettings) { this.WriteToStream(bw, exportSettings, null); }