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 LoadFromStream(BinaryReader br, MMDImportSettings importSettings)
{
int boneIndex;
if (importSettings.Format == MMDImportSettings.ModelFormat.PMX)
{
this.NameJP = PMXParser.ReadString(br, importSettings.TextEncoding);
this.NameEN = PMXParser.ReadString(br, importSettings.TextEncoding);
boneIndex = PMXParser.ReadIndex(br, importSettings.BitSettings.BoneIndexLength);
}
else
{
this.NameJP = PMDParser.ReadString(br, 20, importSettings.TextEncoding);
this.NameEN = this.NameJP;
boneIndex = br.ReadInt16();
}
if (boneIndex < 0)
{
this.Bone = null;
}
else
{
this.Bone = this.Model.Bones[boneIndex];
}
this.CollissionGroup = br.ReadByte();
this.NoCollissionGroups.LoadFromStream(br, importSettings);
this.Shape = (BodyShape)(int)br.ReadByte();
this._shapeSize = PMXVector3.LoadFromStreamStatic(br);
this.Position = PMXVector3.LoadFromStreamStatic(br);
this.Rotation = PMXVector3.LoadFromStreamStatic(br);
this.Mass = br.ReadSingle();
this.LinearDamping = br.ReadSingle();
this.AngularDamping = br.ReadSingle();
this.Repulsion = br.ReadSingle();
this.Friction = br.ReadSingle();
this.Type = (BodyType)(int)br.ReadByte();
if (importSettings.Format == MMDImportSettings.ModelFormat.PMD && this.Bone != null)
{ //PMD location fix
this.Position += this.Bone.Position;
}
}
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 LoadFromStream(BinaryReader br, MMDImportSettings importSettings)
{
int rigidBodyIndexA, rigidBodyIndexB;
if (importSettings.Format == MMDImportSettings.ModelFormat.PMX)
{
this.NameJP = PMXParser.ReadString(br, importSettings.TextEncoding);
this.NameEN = PMXParser.ReadString(br, importSettings.TextEncoding);
this.Type = (JointType)(int)br.ReadByte();
rigidBodyIndexA = PMXParser.ReadIndex(br, importSettings.BitSettings.RigidBodyIndexLength);
rigidBodyIndexB = PMXParser.ReadIndex(br, importSettings.BitSettings.RigidBodyIndexLength);
}
else
{
this.NameJP = PMDParser.ReadString(br, 20, importSettings.TextEncoding);
this.NameEN = this.NameJP;
this.Type = JointType.SpringSixDOF;
rigidBodyIndexA = br.ReadInt32();
rigidBodyIndexB = br.ReadInt32();
}
this.RigidBodyA = this.Model.RigidBodies[rigidBodyIndexA];
this.RigidBodyB = this.Model.RigidBodies[rigidBodyIndexB];
this.Position = PMXVector3.LoadFromStreamStatic(br);
this.Rotation = PMXVector3.LoadFromStreamStatic(br);
this.TranslationLimitMin = PMXVector3.LoadFromStreamStatic(br);
this.TranslationLimitMax = PMXVector3.LoadFromStreamStatic(br);
this.RotationLimitMin = PMXVector3.LoadFromStreamStatic(br);
this.RotationLimitMax = PMXVector3.LoadFromStreamStatic(br);
this.SpringConstantTranslation = PMXVector3.LoadFromStreamStatic(br);
this.SpringConstantRotation = PMXVector3.LoadFromStreamStatic(br);
}
/// <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>
/// Loads a model from a PMD file and converts it to PMX internally.
/// </summary>
/// <param name="pmdFile">PMD file name</param>
/// <param name="modelDescriptor">Classes to use during import</param>
/// <returns></returns>
public static PMXModel LoadFromPMDFile(string pmdFile, PMXModelDescriptor modelDescriptor)
{
FileStream fs = new FileStream(pmdFile, FileMode.Open, FileAccess.Read, FileShare.Read);
byte[] buffer = new byte[3];
fs.Read(buffer, 0, 3);
string head = Encoding.ASCII.GetString(buffer);
if (head != "Pmd")
{
throw new Exception("Not a PMD file!");
}
BinaryReader br = new BinaryReader(fs);
float PMDVersion = br.ReadSingle();
if (PMDVersion != 1.0f)
{
throw new Exception("Unsupported PMD Version!");
}
MMDImportSettings settings = new MMDImportSettings(MMDImportSettings.ModelFormat.PMD);
List <PMXBasePart> allParts = new List <PMXBasePart>();
settings.ClassDescriptor = modelDescriptor;
settings.TextEncoding = Encoding.GetEncoding(932);
settings.ExtendedUV = 0;
PMXModel md = new PMXModel();
md.NameJP = PMDParser.ReadString(br, 20, settings.TextEncoding);
md.DescriptionJP = PMDParser.ReadString(br, 256, settings.TextEncoding);
//Vertices
uint vertexCount = br.ReadUInt32();
for (int i = 0; i < vertexCount; i++)
{
PMXVertex v = (PMXVertex)Activator.CreateInstance(modelDescriptor.VertexType.StoredType, new object[] { md });
v.LoadFromStream(br, settings);
md.Vertices.Add(v);
allParts.Add(v);
}
//Triangles
uint vertexRefCount = br.ReadUInt32();
if (vertexRefCount % 3 != 0)
{
throw new Exception("Invalid triangle count!");
}
uint triangleCount = vertexRefCount / 3;
List <PMXTriangle> importTriangles = new List <PMXTriangle>();
for (int i = 0; i < triangleCount; i++)
{
PMXTriangle t = (PMXTriangle)Activator.CreateInstance(modelDescriptor.TriangleType.StoredType, new object[] { md });
t.LoadFromStream(br, settings);
importTriangles.Add(t);
allParts.Add(t);
}
//Materials
uint materialCount = br.ReadUInt32();
for (int i = 0; i < materialCount; i++)
{
PMXMaterial mt = (PMXMaterial)Activator.CreateInstance(modelDescriptor.MaterialType.StoredType, new object[] { md });
mt.LoadFromStream(br, settings, null, importTriangles);
md.Materials.Add(mt);
mt.NameJP = "Material" + (i + 1).ToString(); //Initialise default names
mt.NameEN = "Material" + (i + 1).ToString(); //Initialise default names
allParts.Add(mt);
}
//Bones
uint boneCount = (uint)br.ReadUInt16();
for (int i = 0; i < boneCount; i++)
{
PMXBone bn = (PMXBone)Activator.CreateInstance(modelDescriptor.BoneType.StoredType, new object[] { md });
bn.LoadFromStream(br, settings);
md.Bones.Add(bn);
allParts.Add(bn);
}
//PMD IKs - will be handled internally
uint ikCount = (uint)br.ReadUInt16();
for (int i = 0; i < ikCount; i++)
{
int boneId = br.ReadUInt16();
PMXBone bn = md.Bones[boneId];
bn.IK = new PMXIK(md, bn);
bn.IK.LoadFromStream(br, settings);
}
//Morphs
uint mCount = (uint)br.ReadUInt16();
for (int i = 0; i < mCount; i++)
{
PMXMorph mrph = (PMXMorph)Activator.CreateInstance(modelDescriptor.MorphType.StoredType, new object[] { md });
mrph.LoadFromStream(br, settings);
if (mrph.NameJP == "base")
{
settings.BaseMorph = mrph;
}
md.Morphs.Add(mrph);
allParts.Add(mrph);
}
//Display groups - kinda insanely set up for PMD
//Initialising root slot manually
md.DisplaySlots[0].References.Add(md.Bones[0]);
allParts.Add(md.DisplaySlots[0]);
//Exp slot is initialised differently (cause why not?)
uint miCount = (uint)br.ReadByte();
for (int i = 0; i < miCount; i++)
{
int morphId = br.ReadUInt16();
md.DisplaySlots[1].References.Add(md.Morphs[morphId]);
}
allParts.Add(md.DisplaySlots[1]);
//Display slots.. guess.. work completely different as well - first of all: Let's gather the names!
uint nameCount = (uint)br.ReadByte();
for (int i = 0; i < nameCount; i++)
{
PMXDisplaySlot ds = new PMXDisplaySlot(md);
ds.NameJP = PMDParser.ReadString(br, 50, settings.TextEncoding);
md.DisplaySlots.Add(ds);
allParts.Add(ds);
}
//We've got the names - now let's put the bones in
uint boneIndexCount = (uint)br.ReadUInt32();
for (int i = 0; i < boneIndexCount; i++)
{
ushort bI = br.ReadUInt16();
byte slot = br.ReadByte();
md.DisplaySlots[slot + 1].References.Add(md.Bones[bI]);
}
//Those were the display slots!
//Does the model have English names?
bool hasEnglishNames = false;
if (br.BaseStream.Position < br.BaseStream.Length) //Not EOF yet
{
hasEnglishNames = (br.ReadByte() == 1);
}
if (hasEnglishNames) //Read English names
{
md.NameEN = PMDParser.ReadString(br, 20, settings.TextEncoding);
md.DescriptionEN = PMDParser.ReadString(br, 256, settings.TextEncoding);
foreach (PMXBone bn in md.Bones)
{
bn.NameEN = PMDParser.ReadString(br, 20, settings.TextEncoding);
}
bool firstMorph = true;
foreach (PMXMorph mrph in md.Morphs)
{
if (firstMorph && mrph.NameJP == "base")
{
continue;
}
mrph.NameEN = PMDParser.ReadString(br, 20, settings.TextEncoding);
firstMorph = false;
}
for (int i = 2; i < md.DisplaySlots.Count; i++)
{
md.DisplaySlots[i].NameEN = PMDParser.ReadString(br, 50, settings.TextEncoding);
}
}
else //At least initialise them by using JP names
{
md.NameEN = md.NameJP;
md.DescriptionEN = md.DescriptionJP;
foreach (PMXBone bn in md.Bones)
{
bn.NameEN = bn.NameJP;
}
foreach (PMXMorph mrph in md.Morphs)
{
mrph.NameEN = mrph.NameJP;
}
for (int i = 2; i < md.DisplaySlots.Count; i++)
{
md.DisplaySlots[i].NameEN = md.DisplaySlots[i].NameJP;
}
}
//Are there special toon textures?
string[] defaultToons = new string[]
{
"toon01.bmp", "toon02.bmp", "toon03.bmp", "toon04.bmp", "toon05.bmp",
"toon06.bmp", "toon07.bmp", "toon08.bmp", "toon09.bmp", "toon10.bmp"
};
string[] thisModelToons = new string[10];
if (br.BaseStream.Position < br.BaseStream.Length) //Not EOF yet
{
for (int i = 0; i < 10; i++)
{
thisModelToons[i] = PMDParser.ReadString(br, 100, settings.TextEncoding);
}
}
else
{
Array.Copy(defaultToons, thisModelToons, 10);
}
//Does the PMD file have physics?
if (br.BaseStream.Position < br.BaseStream.Length) //Not EOF yet
{
//Rigid bodies
uint rigidBodyCount = br.ReadUInt32();
for (int i = 0; i < rigidBodyCount; i++)
{
PMXRigidBody rb = (PMXRigidBody)Activator.CreateInstance(modelDescriptor.RigidBodyType.StoredType, new object[] { md });
rb.LoadFromStream(br, settings);
md.RigidBodies.Add(rb);
allParts.Add(rb);
}
//Joints
uint jointsCount = br.ReadUInt32();
for (int i = 0; i < jointsCount; i++)
{
PMXJoint jt = (PMXJoint)Activator.CreateInstance(modelDescriptor.JointType.StoredType, new object[] { md });
jt.LoadFromStream(br, settings);
md.Joints.Add(jt);
allParts.Add(jt);
}
}
foreach (PMXBasePart part in allParts)
{
part.FinaliseAfterImport();
}
foreach (PMXMaterial mt in md.Materials)
{
mt.AssignToonForPMD(defaultToons, thisModelToons);
}
foreach (PMXBone bn in md.Bones)
{
bn.ParsePMDTwist();
bn.CreateLocalCoodinateAxisForPMD();
bn.UpdatePMDIKs();
}
if (md.Morphs[0].NameJP == "base")
{
md.Morphs.RemoveAt(0);
}
br = null;
fs.Close();
fs = null;
return(md);
}
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 void LoadFromStream(BinaryReader br, MMDImportSettings importSettings, out int pmdIKIndex)
{
pmdIKIndex = -1;
if (importSettings.Format == MMDImportSettings.ModelFormat.PMX)
{ //PMX
this.NameJP = PMXParser.ReadString(br, importSettings.TextEncoding);
this.NameEN = PMXParser.ReadString(br, importSettings.TextEncoding);
this.Position = PMXVector3.LoadFromStreamStatic(br);
this.parentIndex = PMXParser.ReadIndex(br, importSettings.BitSettings.BoneIndexLength);
this.Layer = br.ReadInt32();
short flags = br.ReadInt16();
this.HasChildBone = ((flags & PMXBone.BONE_TAILPOS_IS_BONE) != 0);
if (this.HasChildBone)
{
this.childBoneIndex = PMXParser.ReadIndex(br, importSettings.BitSettings.BoneIndexLength);
}
else
{
this.ChildVector = PMXVector3.LoadFromStreamStatic(br);
}
this.Rotatable = ((flags & PMXBone.BONE_CAN_ROTATE) != 0);
this.Translatable = ((flags & PMXBone.BONE_CAN_TRANSLATE) != 0);
this.Visible = ((flags & PMXBone.BONE_IS_VISIBLE) != 0);
this.Operating = ((flags & PMXBone.BONE_CAN_MANIPULATE) != 0);
bool extRotation = ((flags & PMXBone.BONE_IS_EXTERNAL_ROTATION) != 0);
bool extTranslation = ((flags & PMXBone.BONE_IS_EXTERNAL_TRANSLATION) != 0);
int rotFlag = 0;
if (extRotation)
{
rotFlag |= 1;
}
if (extTranslation)
{
rotFlag |= 2;
}
this.ExternalModificationType = (BoneExternalModificationType)rotFlag;
if (this.ExternalModificationType != BoneExternalModificationType.None)
{
this.externalBoneIndex = PMXParser.ReadIndex(br, importSettings.BitSettings.BoneIndexLength);
this.ExternalBoneEffect = br.ReadSingle();
}
this.FixedAxis = ((flags & PMXBone.BONE_HAS_FIXED_AXIS) != 0);
if (this.FixedAxis)
{
this.AxisLimit = PMXVector3.LoadFromStreamStatic(br);
}
this.LocalCoordinates = ((flags & PMXBone.BONE_HAS_LOCAL_COORDINATE) != 0);
if (this.LocalCoordinates)
{
this.LocalCoordinatesX = PMXVector3.LoadFromStreamStatic(br);
this.LocalCoordinatesZ = PMXVector3.LoadFromStreamStatic(br);
}
this.HasExternalParent = ((flags & PMXBone.BONE_IS_EXTERNAL_PARENT_DEFORM) != 0);
if (this.HasExternalParent)
{
this.ExternalParentKey = br.ReadInt32();
}
this.TransformPhysicsFirst = ((flags & PMXBone.BONE_IS_AFTER_PHYSICS_DEFORM) != 0);
bool isIKBone = ((flags & PMXBone.BONE_IS_IK) != 0);
if (isIKBone)
{
PMXIK ikData = new PMXIK(this.Model, this);
ikData.LoadFromStream(br, importSettings);
this.IK = ikData;
}
else
{
this.IK = null;
}
}
else
{ //PMD
this.NameJP = PMDParser.ReadString(br, 20, importSettings.TextEncoding);
this.parentIndex = br.ReadInt16();
this.HasChildBone = true;
this.childBoneIndex = br.ReadUInt16();
byte type = br.ReadByte();
ushort ikIndex = br.ReadUInt16();
this.Position = PMXVector3.LoadFromStreamStatic(br);
switch (type)
{
case PMD_BONE_TYPE_ROTATE:
//Default
break;
case PMD_BONE_TYPE_ROTATE_MOVE:
this.Translatable = true;
break;
case PMD_BONE_TYPE_IK:
//IK parameters will be initialised later
this.Translatable = true;
break;
case PMD_BONE_TYPE_IK_CHILD:
//PMX doesn't even bother about these
break;
case PMD_BONE_TYPE_EXTERNAL_ROTATOR:
this.ExternalModificationType = BoneExternalModificationType.Rotation;
this.externalBoneIndex = (int)ikIndex;
break;
case PMD_BONE_TYPE_IK_TARGET:
//PMX doesn't bother either
this.Visible = false;
break;
case PMD_BONE_TYPE_INVISIBLE:
this.Visible = false;
break;
case PMD_BONE_TYPE_TWIST:
//PMX handles these differently
this._isPMDTwist = true;
break;
case PMD_BONE_TYPE_TWIST_INVISIBLE:
//PMX handles these differently
this._isPMDTwist = true;
this.Visible = false;
break;
}
}
}
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 void LoadFromStream(BinaryReader br, MMDImportSettings importSettings, string[] textures, List <PMXTriangle> triangles)
{
if (textures == null)
{
textures = new string[0];
}
int triangleVerticesCount;
if (importSettings.Format == MMDImportSettings.ModelFormat.PMX)
{ //PMX format
this.NameJP = PMXParser.ReadString(br, importSettings.TextEncoding);
this.NameEN = PMXParser.ReadString(br, importSettings.TextEncoding);
this.Diffuse = PMXColorRGB.LoadFromStreamStatic(br);
this.Alpha = br.ReadSingle();
this.Specular = PMXColorRGB.LoadFromStreamStatic(br);
this.SpecularFactor = br.ReadSingle();
this.Ambient = PMXColorRGB.LoadFromStreamStatic(br);
byte flags = br.ReadByte();
//Flag parsing
//1st bit = double sided
this.DoubleSided = ((flags & PMXMaterial.MATERIAL_DOUBLE_SIDED) != 0);
//2nd bit = ground shadow
this.GroundShadow = ((flags & PMXMaterial.MATERIAL_GROUND_SHADOW) != 0);
//3rd bit - self shadow
this.SelfShadow = ((flags & PMXMaterial.MATERIAL_SELF_SHADOW) != 0);
//4th bit - self shadow+
this.SelfShadowPlus = ((flags & PMXMaterial.MATERIAL_SELF_SHADOW_PLUS) != 0);
//5th bit - has edge line
this.EdgeEnabled = ((flags & PMXMaterial.MATERIAL_EDGE_ENABLED) != 0);
//6th bit - shine with vertex colour
this.VertexColor = ((flags & PMXMaterial.MATERIAL_VERTEX_COLOR) != 0);
//7th and 8bit - Tri, Point or Line shadow
int shadowType = ((flags & 0xC0) >> 6);
this.GroundShadowType = (PMXGroundShadowType)shadowType;
this.EdgeColor = PMXColorRGBA.LoadFromStreamStatic(br);
this.EdgeSize = br.ReadSingle();
int diffIndex = PMXParser.ReadIndex(br, importSettings.BitSettings.TextureIndexLength);
this.DiffuseTexture = this.GetTextureFromIndex(diffIndex, textures);
int sphereIndex = PMXParser.ReadIndex(br, importSettings.BitSettings.TextureIndexLength);
this.SphereTexture = this.GetTextureFromIndex(sphereIndex, textures);
this.SphereMode = (PMXSphereMode)(int)(br.ReadByte());
this.StandardToon = (br.ReadByte() == 1);
if (this.StandardToon)
{
this.StandardToonIndex = br.ReadSByte();
}
else
{
int toonTexIndex = PMXParser.ReadIndex(br, importSettings.BitSettings.TextureIndexLength);
this.NonStandardToonTexture = this.GetTextureFromIndex(toonTexIndex, textures);
}
this.Comment = PMXParser.ReadString(br, importSettings.TextEncoding);
triangleVerticesCount = br.ReadInt32();
}
else
{ //PMD format
this.Diffuse = PMXColorRGB.LoadFromStreamStatic(br);
this.Alpha = br.ReadSingle();
this.SpecularFactor = br.ReadSingle();
this.Specular = PMXColorRGB.LoadFromStreamStatic(br);
this.Ambient = PMXColorRGB.LoadFromStreamStatic(br);
this._pmdToonIndex = br.ReadSByte();
byte flags = br.ReadByte();
this.EdgeEnabled = (flags == 1);
this.GroundShadow = this.EdgeEnabled;
triangleVerticesCount = br.ReadInt32();
string textureFile = PMDParser.ReadString(br, 20, importSettings.TextEncoding);
if (textureFile != null)
{
string[] textureRefs = textureFile.Split(new char[] { '*' }, 2, StringSplitOptions.RemoveEmptyEntries);
this.DiffuseTexture = textureRefs[0];
if (textureRefs.Length > 1)
{
this.SphereTexture = textureRefs[1];
}
}
}
if (triangleVerticesCount % 3 != 0)
{
throw new InvalidDataException("Invalid triangle format!");
}
if (triangles != null)
{
int triangleCount = triangleVerticesCount / 3;
if (triangleCount > triangles.Count)
{
throw new InvalidDataException("Model doesn't have enough triangles!");
}
this.Triangles = triangles.GetRange(0, triangleCount);
triangles.RemoveRange(0, triangleCount);
}
}
public override void LoadFromStream(BinaryReader br, MMDImportSettings importSettings)
{
int offsets;
byte morphType;
if (importSettings.Format == MMDImportSettings.ModelFormat.PMX)
{ //PMX format
this.NameJP = PMXParser.ReadString(br, importSettings.TextEncoding);
this.NameEN = PMXParser.ReadString(br, importSettings.TextEncoding);
this.Panel = (PanelType)(int)br.ReadByte();
morphType = br.ReadByte();
offsets = br.ReadInt32();
}
else
{ //PMD format
this.NameJP = PMDParser.ReadString(br, 20, importSettings.TextEncoding);
offsets = br.ReadInt32();
this.Panel = (PanelType)(int)br.ReadByte();
morphType = PMXMorph.MORPH_IDENTIFY_VERTEX;
}
for (int i = 0; i < offsets; i++)
{
PMXMorphOffsetBase mb = null;
switch (morphType)
{
case PMXMorph.MORPH_IDENTIFY_GROUP:
mb = new PMXMorphOffsetGroup(this.Model, this);
break;
case PMXMorph.MORPH_IDENTIFY_VERTEX:
mb = new PMXMorphOffsetVertex(this.Model, this);
break;
case PMXMorph.MORPH_IDENTIFY_BONE:
mb = new PMXMorphOffsetBone(this.Model, this);
break;
case PMXMorph.MORPH_IDENTIFY_UV:
mb = new PMXMorphOffsetUV(this.Model, this, PMXMorphOffsetUV.UVAddIndexType.UV);
break;
case PMXMorph.MORPH_IDENTIFY_UV_EXTENDED1:
mb = new PMXMorphOffsetUV(this.Model, this, PMXMorphOffsetUV.UVAddIndexType.AddUV1);
break;
case PMXMorph.MORPH_IDENTIFY_UV_EXTENDED2:
mb = new PMXMorphOffsetUV(this.Model, this, PMXMorphOffsetUV.UVAddIndexType.AddUV2);
break;
case PMXMorph.MORPH_IDENTIFY_UV_EXTENDED3:
mb = new PMXMorphOffsetUV(this.Model, this, PMXMorphOffsetUV.UVAddIndexType.AddUV3);
break;
case PMXMorph.MORPH_IDENTIFY_UV_EXTENDED4:
mb = new PMXMorphOffsetUV(this.Model, this, PMXMorphOffsetUV.UVAddIndexType.AddUV4);
break;
case PMXMorph.MORPH_IDENTIFY_MATERIAL:
mb = new PMXMorphOffsetMaterial(this.Model, this);
break;
default:
throw new InvalidDataException("Unknown morph type " + morphType);
}
mb.LoadFromStream(br, importSettings);
this.Offsets.Add(mb);
}
}
