BrawlLib.Modeling.PMDModel Class Reference

Public Types
enum	CoordinateType

Static Public Member Functions
static MDL0Node	ImportModel (string filepath)
static void	Export (MDL0Node model, string filename)
static void	Read (BinaryReader reader, CoordinateType coordinate)
static void	Write (BinaryWriter writer)
static unsafe void	PMD2MDL0 (MDL0Node model)
static void	AssignParent (MDL0BoneNode pBone, ModelBone child, MDL0BoneNode cBone, ModelBone parent)
static void	MDL02PMD (MDL0Node model)

Static Public Attributes
static float	_version = 1.0f
static ModelHeader	_header
static ModelVertex[]	_vertices
static ushort[]	_faceIndices
static ModelMaterial[]	_materials
static ModelBone[]	_bones
static ModelIK[]	_IKs
static ModelSkin[]	_skins
static ushort[]	_skinIndex
static ModelBoneDispName[]	_boneDispNames
static ModelBoneDisp[]	_boneDisps
static bool	_expansion
static bool	_toonExpansion
static string[]	_toonFileNames
const int	_numToonFileName = 10
static bool	_physicsExpansion
static ModelRigidBody[]	_rigidBodies
static ModelJoint[]	_joints
static CoordinateType	_coordinate

Properties
static float	CoordZ [get]
static MDL0ShaderNode	TexSpaShader [get]
static MDL0ShaderNode	ColorSpaShader [get]
static MDL0ShaderNode	TexShader [get]
static MDL0ShaderNode	ColorShader [get]

Member Enumeration Documentation

CoordinateType

enum BrawlLib.Modeling.PMDModel.CoordinateType

        {
            //MMD standard coordinate system
            RightHanded = 1,
 
            //XNA standard coordinate system
            LeftHanded = -1
        }

Member Function Documentation

AssignParent()

static void BrawlLib.Modeling.PMDModel.AssignParent ( MDL0BoneNode  pBone, ModelBone  child, MDL0BoneNode  cBone, ModelBone  parent  )

inlinestatic

        {
            if (pBone._entryIndex == child._parentBoneIndex)
            {
                //Link child to its parent
                (cBone._parent = pBone)._children.Add(cBone);
 
                //Convert the world point into a local point relative to the bone's parent
                Matrix m = Matrix.TranslationMatrix(child._wPos) *
                           Matrix.Invert(Matrix.TranslationMatrix(parent._wPos));
 
                //Derive to state and recalc bind matrices
                cBone._bindState = m.Derive();
                cBone.RecalcBindState(false, false);
            }
            else //Parent not found, continue searching children.
            {
                foreach (MDL0BoneNode pMatch in pBone._children)
                {
                    AssignParent(pMatch, child, cBone, parent);
                }
            }
        }

Export()

static void BrawlLib.Modeling.PMDModel.Export ( MDL0Node  model, string  filename  )

inlinestatic

        {
            filename = Path.GetFullPath(filename);
            using (FileStream fs = new FileStream(filename, FileMode.Create))
            {
                BinaryWriter writer = new BinaryWriter(fs);
                writer.Write(encoder.GetBytes("Pmd"));
                writer.Write(1.0f); //Version
                MDL02PMD(model);
                Write(writer);
            }
        }

ImportModel()

static MDL0Node BrawlLib.Modeling.PMDModel.ImportModel ( string  filepath )

inlinestatic

        {
            filepath = Path.GetFullPath(filepath);
            if (!File.Exists(filepath))
            {
                throw new FileNotFoundException("PMD model file " + filepath + " not found.");
            }
 
            MDL0Node model = null;
            using (FileStream fs = new FileStream(filepath, FileMode.Open))
            {
                BinaryReader reader = new BinaryReader(fs);
                string magic = encoder.GetString(reader.ReadBytes(3));
                if (magic != "Pmd")
                {
                    throw new FileLoadException("Model format not recognized.");
                }
 
                float version = BitConverter.ToSingle(reader.ReadBytes(4), 0);
                if (version == 1.0f)
                {
                    model = new MDL0Node();
                }
                else
                {
                    throw new Exception("Version " + version + " models are not supported.");
                }
 
                if (model != null)
                {
                    Read(reader, CoordinateType.LeftHanded); //Will flip model backwards if right handed
                    PMD2MDL0(model);
                }
            }
 
            return model;
        }

MDL02PMD()

static void BrawlLib.Modeling.PMDModel.MDL02PMD ( MDL0Node  model )

inlinestatic

        {
            _header = new ModelHeader
            {
                _modelName = model.Name,
 
                //To do: Add the ability to change the comment
                _comment = "MDL0 model converted to PMD by BrawlCrate."
            };
 
            foreach (MDL0MaterialNode m in model._matList)
            {
                ModelMaterial mat = new ModelMaterial
                {
                    _textureFileName = m.Children[0].Name
                };
            }
 
            _bones = new ModelBone[model._linker.BoneCache.Length];
            for (int i = 0; i < model._linker.BoneCache.Length; i++)
            {
                ModelBone bone = new ModelBone();
                MDL0BoneNode mBone = model._linker.BoneCache[i];
 
                Vector3 wPos = mBone._bindMatrix.GetPoint();
                bone._wPos[0] = wPos._x;
                bone._wPos[1] = wPos._y;
                bone._wPos[2] = wPos._z;
 
                bone._boneName = mBone.Name;
 
                bone._boneType = 0;
                bone._parentBoneIndex = (ushort) model._linker.BoneCache.ToList<ResourceNode>().IndexOf(mBone.Parent);
 
                _bones[i] = bone;
            }
        }

PMD2MDL0()

static unsafe void BrawlLib.Modeling.PMDModel.PMD2MDL0 ( MDL0Node  model )

inlinestatic

        {
            Collada.Collada._importOptions = Properties.Settings.Default.ColladaImportOptions;
            Collada.Collada._importOptions._forceCCW = true;
            Collada.Collada._importOptions._fltVerts = true;
            Collada.Collada._importOptions._fltNrms = true;
            Collada.Collada._importOptions._fltUVs = true;
            Collada.Collada.CurrentModel = model;
 
            model.BeginImport();
            model._version = 9;
 
            List<MDL0BoneNode> BoneCache = new List<MDL0BoneNode>();
 
            int index = 0;
            if (!string.IsNullOrWhiteSpace(_header._modelNameEnglish))
            {
                model.Name = _header._modelNameEnglish;
            }
            else
            {
                model.Name = _header._modelName;
            }
 
            if (!string.IsNullOrWhiteSpace(_header._commentEnglish))
            {
                MessageBox.Show(_header._commentEnglish);
            }
            else
            {
                MessageBox.Show(_header._comment);
            }
 
            ModelBone parent = null;
            foreach (ModelBone b in _bones)
            {
                MDL0BoneNode bone = new MDL0BoneNode();
 
                if (!string.IsNullOrWhiteSpace(b._boneNameEnglish))
                {
                    bone._name = b._boneNameEnglish;
                }
                else
                {
                    bone._name = b._boneName;
                }
 
                bone._entryIndex = index++;
 
                if (b._parentBoneIndex != ushort.MaxValue)
                {
                    parent = _bones[b._parentBoneIndex];
                    foreach (MDL0BoneNode v in model._boneGroup._children)
                    {
                        AssignParent(v, b, bone, parent);
                    }
                }
                else
                {
                    bone.Parent = model._boneGroup;
                    bone._bindState._scale = new Vector3(1.0f);
                    bone._bindState._translate = new Vector3(b._wPos[0], b._wPos[1], b._wPos[2]);
                    bone._bindState.CalcTransforms();
                    bone.RecalcBindState(false, false);
                }
 
                BoneCache.Add(bone);
            }
 
            MDL0ShaderNode texSpa = null, tex = null, colorSpa = null, color = null;
 
            index = 0;
            foreach (ModelMaterial m in _materials)
            {
                MDL0MaterialNode mn = new MDL0MaterialNode
                {
                    Name = "Material" + index++
                };
 
                MDL0MaterialRefNode texRef = null;
                MDL0MaterialRefNode spaRef = null;
 
                if (!string.IsNullOrEmpty(m._textureFileName))
                {
                    if (m._textureFileName.Contains('*'))
                    {
                        string[] names = m._textureFileName.Split('*');
                        if (!string.IsNullOrEmpty(names[0]))
                        {
                            texRef = new MDL0MaterialRefNode
                            {
                                Name = names[0].Substring(0, names[0].IndexOf('.'))
                            };
                        }
 
                        if (!string.IsNullOrEmpty(names[1]))
                        {
                            spaRef = new MDL0MaterialRefNode
                            {
                                Name = names[1].Substring(0, names[1].IndexOf('.')),
                                MapMode = MappingMethod.EnvCamera,
                                UWrapMode = MatWrapMode.Clamp,
                                VWrapMode = MatWrapMode.Clamp,
                                Projection = TexProjection.STQ,
                                InputForm = TexInputForm.ABC1,
                                Coordinates = TexSourceRow.Normals,
                                Normalize = true
                            };
                        }
                    }
                    else
                    {
                        texRef = new MDL0MaterialRefNode
                        {
                            Name = m._textureFileName.Substring(0, m._textureFileName.IndexOf('.')),
                            Coordinates = TexSourceRow.TexCoord0
                        };
                    }
                }
 
                if (texRef != null)
                {
                    (texRef._texture = model.FindOrCreateTexture(texRef.Name))._references.Add(texRef);
                    texRef._parent = mn;
                    mn._children.Add(texRef);
                }
 
                if (spaRef != null)
                {
                    (spaRef._texture = model.FindOrCreateTexture(spaRef.Name))._references.Add(spaRef);
                    spaRef._parent = mn;
                    mn._children.Add(spaRef);
                }
 
                mn._chan1._matColor = new RGBAPixel((byte) (m._diffuseColor[0] * 255),
                    (byte) (m._diffuseColor[1] * 255), (byte) (m._diffuseColor[2] * 255), 255);
                mn._chan1.ColorMaterialSource = GXColorSrc.Register;
 
                if (texRef != null && spaRef != null)
                {
                    if (texSpa == null)
                    {
                        MDL0ShaderNode n = TexSpaShader;
                        n._parent = model._shadGroup;
                        model._shadList.Add(n);
                        texSpa = n;
                    }
 
                    mn.ShaderNode = texSpa;
                }
                else if (texRef != null)
                {
                    if (tex == null)
                    {
                        MDL0ShaderNode n = TexShader;
                        n._parent = model._shadGroup;
                        model._shadList.Add(n);
                        tex = n;
                    }
 
                    mn.ShaderNode = tex;
                }
                else if (spaRef != null)
                {
                    if (colorSpa == null)
                    {
                        MDL0ShaderNode n = ColorSpaShader;
                        n._parent = model._shadGroup;
                        model._shadList.Add(n);
                        colorSpa = n;
                    }
 
                    mn.ShaderNode = colorSpa;
                }
                else
                {
                    if (color == null)
                    {
                        MDL0ShaderNode n = ColorShader;
                        n._parent = model._shadGroup;
                        model._shadList.Add(n);
                        color = n;
                    }
 
                    mn.ShaderNode = color;
                }
 
                mn._parent = model._matGroup;
                model._matList.Add(mn);
            }
 
            model._numTriangles = 0;
            model._numFacepoints = 0;
 
            int x = 0;
            int offset = 0;
            foreach (ModelMaterial m in _materials)
            {
                PrimitiveManager manager = new PrimitiveManager {_pointCount = (int) m._faceVertCount};
                MDL0ObjectNode p = new MDL0ObjectNode
                {
                    _manager = manager,
                    _drawCalls = new System.ComponentModel.BindingList<DrawCall>()
                };
                p._drawCalls.Add(new DrawCall(p)
                {
                    MaterialNode = (MDL0MaterialNode) model._matList[x]
                });
                p._manager._vertices = new List<Vertex3>();
                p.Name = "polygon" + x++;
                p._parent = model._objGroup;
 
                model._numTriangles += p._numFaces = manager._faceCount = manager._pointCount / 3;
                model._numFacepoints += p._numFacepoints = manager._pointCount;
 
                p._manager._indices = new UnsafeBuffer((int) m._faceVertCount * 2);
                p._manager._faceData[0] = new UnsafeBuffer((int) m._faceVertCount * 12);
                p._manager._faceData[1] = new UnsafeBuffer((int) m._faceVertCount * 12);
                p._manager._faceData[4] = new UnsafeBuffer((int) m._faceVertCount * 8);
 
                p._manager._dirty[0] = true;
                p._manager._dirty[1] = true;
                p._manager._dirty[4] = true;
 
                ushort* Indices = (ushort*) p._manager._indices.Address;
                Vector3* Vertices = (Vector3*) p._manager._faceData[0].Address;
                Vector3* Normals = (Vector3*) p._manager._faceData[1].Address;
                Vector2* UVs = (Vector2*) p._manager._faceData[4].Address;
 
                manager._triangles = new GLPrimitive((int) m._faceVertCount, BeginMode.Triangles);
                uint[] pTriarr = manager._triangles._indices;
                uint pTri = 0;
 
                index = 0;
                List<int> usedVertices = new List<int>();
                List<int> vertexIndices = new List<int>();
                for (int s = offset, l = 0; l < (int) m._faceVertCount; l++, s++)
                {
                    ushort i = _faceIndices[s];
                    ModelVertex mv = _vertices[i];
                    ushort j = 0;
                    if (!usedVertices.Contains(i))
                    {
                        Influence inf;
                        BoneWeight weight1 = null, weight2 = null;
 
                        float weight = (mv._boneWeight / 100.0f).Clamp(0.0f, 1.0f);
 
                        if (weight > 0.0f && weight < 1.0f)
                        {
                            weight1 = new BoneWeight(BoneCache[mv._boneIndex[0]], weight);
                            weight2 = new BoneWeight(BoneCache[mv._boneIndex[1]], 1.0f - weight);
                        }
                        else if (weight == 0.0f)
                        {
                            weight1 = new BoneWeight(BoneCache[mv._boneIndex[1]]);
                        }
                        else
                        {
                            weight1 = new BoneWeight(BoneCache[mv._boneIndex[0]]);
                        }
 
                        if (weight2 != null)
                        {
                            inf = new Influence(new List<BoneWeight> {weight1, weight2});
                        }
                        else
                        {
                            inf = new Influence(new List<BoneWeight> {weight1});
                        }
 
                        Vector3 t = new Vector3();
                        Vertex3 v;
                        t._x = mv._position[0];
                        t._y = mv._position[1];
                        t._z = mv._position[2];
                        if (inf.Weights.Count > 1)
                        {
                            inf = model._influences.FindOrCreate(inf);
                            inf.CalcMatrix();
                            v = new Vertex3(t, inf);
                        }
                        else
                        {
                            MDL0BoneNode bone = inf.Weights[0].Bone as MDL0BoneNode;
                            v = new Vertex3(t * bone._inverseBindMatrix, bone);
                        }
 
                        p._manager._vertices.Add(v);
                        vertexIndices.Add(usedVertices.Count);
                        usedVertices.Add(i);
                        j = (ushort) (usedVertices.Count - 1);
                    }
                    else
                    {
                        j = (ushort) vertexIndices[usedVertices.IndexOf(i)];
                    }
 
                    *Indices++ = j;
                    pTriarr[pTri++] = (uint) l;
                    *Vertices++ = p._manager._vertices[j].Position;
                    *Normals++ = mv._normal;
                    *UVs++ = mv._texCoord;
                }
 
                model._objList.Add(p);
                offset += (int) m._faceVertCount;
            }
 
            //Check each polygon to see if it can be rigged to a single influence
            if (model._objList != null && model._objList.Count != 0)
            {
                foreach (MDL0ObjectNode p in model._objList)
                {
                    IMatrixNode node = null;
                    bool singlebind = true;
 
                    foreach (Vertex3 v in p._manager._vertices)
                    {
                        if (v.MatrixNode != null)
                        {
                            if (node == null)
                            {
                                node = v.MatrixNode;
                            }
 
                            if (v.MatrixNode != node)
                            {
                                singlebind = false;
                                break;
                            }
                        }
                    }
 
                    if (singlebind && p._matrixNode == null)
                    {
                        //Increase reference count ahead of time for rebuild
                        //p._manager._vertices[0].MatrixNode.ReferenceCount++;
                        p._manager._vertices[0].MatrixNode?.Users.Add(p);
 
                        foreach (Vertex3 v in p._manager._vertices)
                        {
                            //v.MatrixNode.ReferenceCount--;
                            v.MatrixNode?.Users.Remove(v);
                        }
 
                        p._nodeId = -2; //Continued on polygon rebuild
                    }
                }
            }
 
            //foreach (MDL0ObjectNode p in model._objList)
            //    foreach (MDL0MaterialNode m in model._matList)
            //    {
            //        MDL0MaterialNode m2 = p.OpaMaterialNode;
 
            //        if (m2 == null || m2.ShaderNode != m.ShaderNode || m2.Children.Count != m.Children.Count)
            //            continue;
 
            //        for (int i = 0; i < m.Children.Count; i++)
            //            if (m2.Children[i].Name != m.Children[i].Name)
            //                continue;
 
            //        p.OpaMaterialNode = m;
            //        break;
            //    }
            //for (int i = 0; i < model._matList.Count; i++)
            //    if (((MDL0MaterialNode)model._matList[i])._objects.Count == 0)
            //        model._matList.RemoveAt(i--);
 
            model.FinishImport();
            Collada.Collada.CurrentModel = null;
        }

Read()

static void BrawlLib.Modeling.PMDModel.Read ( BinaryReader  reader, CoordinateType  coordinate  )

inlinestatic

        {
            _coordinate = coordinate;
 
            _header = new ModelHeader();
            _header.Read(reader);
 
            //Read Vertices
            uint num_vertex = BitConverter.ToUInt32(reader.ReadBytes(4), 0);
            _vertices = new ModelVertex[num_vertex];
            for (uint i = 0; i < num_vertex; i++)
            {
                _vertices[i] = new ModelVertex();
                _vertices[i].Read(reader, CoordZ);
            }
 
            //Read Primitives
            uint face_vert_count = BitConverter.ToUInt32(reader.ReadBytes(4), 0);
            _faceIndices = new ushort[face_vert_count];
            for (uint i = 0; i < face_vert_count; i++)
            {
                _faceIndices[i] = BitConverter.ToUInt16(reader.ReadBytes(2), 0);
            }
 
            //Read Materials
            uint material_count = BitConverter.ToUInt32(reader.ReadBytes(4), 0);
            _materials = new ModelMaterial[material_count];
            for (uint i = 0; i < material_count; i++)
            {
                _materials[i] = new ModelMaterial();
                _materials[i].Read(reader);
            }
 
            //Read Bones
            ushort bone_count = BitConverter.ToUInt16(reader.ReadBytes(2), 0);
            _bones = new ModelBone[bone_count];
            for (ushort i = 0; i < bone_count; i++)
            {
                _bones[i] = new ModelBone();
                _bones[i].Read(reader, CoordZ);
            }
 
            //Read IK Bones
            ushort ik_count = BitConverter.ToUInt16(reader.ReadBytes(2), 0);
            _IKs = new ModelIK[ik_count];
            for (ushort i = 0; i < ik_count; i++)
            {
                _IKs[i] = new ModelIK();
                _IKs[i].Read(reader);
            }
 
            //Read Face Morphs
            ushort skin_count = BitConverter.ToUInt16(reader.ReadBytes(2), 0);
            _skins = new ModelSkin[skin_count];
            for (ushort i = 0; i < skin_count; i++)
            {
                _skins[i] = new ModelSkin();
                _skins[i].Read(reader, CoordZ);
            }
 
            //Read face morph indices
            byte skin_disp_count = reader.ReadByte();
            _skinIndex = new ushort[skin_disp_count];
            for (byte i = 0; i < _skinIndex.Length; i++)
            {
                _skinIndex[i] = BitConverter.ToUInt16(reader.ReadBytes(2), 0);
            }
 
            //Read bone morph names
            byte bone_disp_name_count = reader.ReadByte();
            _boneDispNames = new ModelBoneDispName[bone_disp_name_count];
            for (byte i = 0; i < _boneDispNames.Length; i++)
            {
                _boneDispNames[i] = new ModelBoneDispName();
                _boneDispNames[i].Read(reader);
            }
 
            //Read bone morphs
            uint bone_disp_count = BitConverter.ToUInt32(reader.ReadBytes(4), 0);
            _boneDisps = new ModelBoneDisp[bone_disp_count];
            for (uint i = 0; i < _boneDisps.Length; i++)
            {
                _boneDisps[i] = new ModelBoneDisp();
                _boneDisps[i].Read(reader);
            }
 
            //Read English strings, if there are any.
            try
            {
                _expansion = reader.ReadByte() != 0;
                if (_expansion)
                {
                    _header.ReadExpansion(reader);
                    for (ushort i = 0; i < bone_count; i++)
                    {
                        _bones[i].ReadExpansion(reader);
                    }
 
                    for (ushort i = 0; i < skin_count; i++)
                    {
                        if (_skins[i]._skinType != 0)
                        {
                            _skins[i].ReadExpansion(reader);
                        }
                    }
 
                    for (byte i = 0; i < _boneDispNames.Length; i++)
                    {
                        _boneDispNames[i].ReadExpansion(reader);
                    }
 
                    if (reader.BaseStream.Position >= reader.BaseStream.Length)
                    {
                        _toonExpansion = false;
                    }
                    else
                    {
                        _toonExpansion = true;
                        _toonFileNames = new string[_numToonFileName];
                        for (int i = 0; i < _toonFileNames.Length; i++)
                        {
                            _toonFileNames[i] = GetString(reader.ReadBytes(100));
                        }
                    }
 
                    if (reader.BaseStream.Position >= reader.BaseStream.Length)
                    {
                        _physicsExpansion = false;
                    }
                    else
                    {
                        _physicsExpansion = true;
                        uint rididbody_count = BitConverter.ToUInt32(reader.ReadBytes(4), 0);
                        _rigidBodies = new ModelRigidBody[rididbody_count];
                        for (uint i = 0; i < rididbody_count; i++)
                        {
                            _rigidBodies[i] = new ModelRigidBody();
                            _rigidBodies[i].ReadExpansion(reader, CoordZ);
                        }
 
                        uint joint_count = BitConverter.ToUInt32(reader.ReadBytes(4), 0);
                        _joints = new ModelJoint[joint_count];
                        for (uint i = 0; i < joint_count; i++)
                        {
                            _joints[i] = new ModelJoint();
                            _joints[i].ReadExpansion(reader, CoordZ);
                        }
                    }
                }
            }
            catch
            {
                Console.WriteLine("This file does not contain English strings.");
            }
        }

Write()

static void BrawlLib.Modeling.PMDModel.Write ( BinaryWriter  writer )

inlinestatic

        {
            _header?.Write(writer);
 
            if (_vertices == null)
            {
                writer.Write((uint) 0);
            }
            else
            {
                writer.Write((uint) _vertices.LongLength);
                for (uint i = 0; i < _vertices.LongLength; i++)
                {
                    if (_vertices[i] == null)
                    {
                        throw new ArgumentNullException("Vertexes[" + i + "] is null!");
                    }
 
                    _vertices[i].Write(writer, CoordZ);
                }
            }
 
            if (_faceIndices == null)
            {
                writer.Write((uint) 0);
            }
            else
            {
                writer.Write((uint) _faceIndices.LongLength);
                for (uint i = 0; i < _faceIndices.LongLength; i++)
                {
                    writer.Write(_faceIndices[i]);
                }
            }
 
            if (_materials == null)
            {
                writer.Write((uint) 0);
            }
            else
            {
                writer.Write((uint) _materials.LongLength);
                for (uint i = 0; i < _materials.LongLength; i++)
                {
                    if (_materials[i] == null)
                    {
                        throw new ArgumentNullException("Materials[" + i + "] is null!");
                    }
 
                    _materials[i].Write(writer);
                }
            }
 
            if (_bones == null)
            {
                writer.Write((ushort) 0);
            }
            else
            {
                writer.Write((ushort) _bones.Length);
                for (ushort i = 0; i < _bones.Length; i++)
                {
                    if (_bones[i] == null)
                    {
                        throw new ArgumentNullException("Bones[" + i + "] is null!");
                    }
 
                    _bones[i].Write(writer, CoordZ);
                }
            }
 
            if (_IKs == null)
            {
                writer.Write((ushort) 0);
            }
            else
            {
                writer.Write((ushort) _IKs.Length);
                for (ushort i = 0; i < _IKs.Length; i++)
                {
                    if (_IKs[i] == null)
                    {
                        throw new ArgumentNullException("IKs[" + i + "] is null!");
                    }
 
                    _IKs[i].Write(writer);
                }
            }
 
            if (_skins == null)
            {
                writer.Write((ushort) 0);
            }
            else
            {
                writer.Write((ushort) _skins.Length);
                for (ushort i = 0; i < _skins.Length; i++)
                {
                    if (_skins[i] == null)
                    {
                        throw new ArgumentNullException("Skins[" + i + "] is null!");
                    }
 
                    _skins[i].Write(writer, CoordZ);
                }
            }
 
            if (_skinIndex == null)
            {
                writer.Write((byte) 0);
            }
            else
            {
                writer.Write((byte) _skinIndex.Length);
 
                for (byte i = 0; i < _skinIndex.Length; i++)
                {
                    writer.Write(_skinIndex[i]);
                }
            }
 
            if (_boneDispNames == null)
            {
                writer.Write((byte) 0);
            }
            else
            {
                writer.Write((byte) _boneDispNames.Length);
                for (byte i = 0; i < _boneDispNames.Length; i++)
                {
                    if (_boneDispNames[i] == null)
                    {
                        throw new ArgumentNullException("BoneDispNames[" + i + "] is null!");
                    }
 
                    _boneDispNames[i].Write(writer);
                }
            }
 
            if (_boneDisps == null)
            {
                writer.Write((uint) 0);
            }
            else
            {
                writer.Write((uint) _boneDisps.Length);
                for (uint i = 0; i < _boneDisps.Length; i++)
                {
                    if (_boneDisps[i] == null)
                    {
                        throw new ArgumentNullException("BoneDisps[" + i + "] is null!");
                    }
 
                    _boneDisps[i].Write(writer);
                }
            }
 
            writer.Write((byte) (_expansion ? 1 : 0));
            if (_expansion)
            {
                _header.WriteExpansion(writer);
                if (_bones != null)
                {
                    for (ushort i = 0; i < _bones.Length; i++)
                    {
                        _bones[i].WriteExpansion(writer);
                    }
                }
 
                if (_skins != null)
                {
                    for (ushort i = 0; i < _skins.Length; i++)
                    {
                        if (_skins[i]._skinType != 0)
                        {
                            _skins[i].WriteExpansion(writer);
                        }
                    }
                }
 
                if (_boneDispNames != null)
                {
                    for (byte i = 0; i < _boneDispNames.Length; i++)
                    {
                        _boneDispNames[i].WriteExpansion(writer);
                    }
                }
 
                if (_toonExpansion)
                {
                    for (int i = 0; i < _toonFileNames.Length; i++)
                    {
                        writer.Write(GetBytes(_toonFileNames[i], 100));
                    }
 
                    if (_physicsExpansion)
                    {
                        if (_rigidBodies == null)
                        {
                            writer.Write((uint) 0);
                        }
                        else
                        {
                            writer.Write((uint) _rigidBodies.LongLength);
                            for (long i = 0; i < _rigidBodies.LongLength; i++)
                            {
                                if (_rigidBodies[i] == null)
                                {
                                    throw new ArgumentNullException("RididBodies[" + i + "] is null!");
                                }
 
                                _rigidBodies[i].WriteExpansion(writer, CoordZ);
                            }
                        }
 
                        if (_joints == null)
                        {
                            writer.Write((uint) 0);
                        }
                        else
                        {
                            writer.Write((uint) _joints.LongLength);
                            for (long i = 0; i < _joints.LongLength; i++)
                            {
                                if (_joints[i] == null)
                                {
                                    throw new ArgumentNullException("Joints[" + i + "] is null!");
                                }
 
                                _joints[i].WriteExpansion(writer, CoordZ);
                            }
                        }
                    }
                }
            }
        }

Member Data Documentation

_boneDispNames

ModelBoneDispName [] BrawlLib.Modeling.PMDModel._boneDispNames

static

_boneDisps

ModelBoneDisp [] BrawlLib.Modeling.PMDModel._boneDisps

static

_bones

ModelBone [] BrawlLib.Modeling.PMDModel._bones

static

_coordinate

CoordinateType BrawlLib.Modeling.PMDModel._coordinate

static

_expansion

bool BrawlLib.Modeling.PMDModel._expansion

static

_faceIndices

ushort [] BrawlLib.Modeling.PMDModel._faceIndices

static

_header

ModelHeader BrawlLib.Modeling.PMDModel._header

static

_IKs

ModelIK [] BrawlLib.Modeling.PMDModel._IKs

static

_joints

ModelJoint [] BrawlLib.Modeling.PMDModel._joints

static

_materials

ModelMaterial [] BrawlLib.Modeling.PMDModel._materials

static

_numToonFileName

const int BrawlLib.Modeling.PMDModel._numToonFileName = 10

static

_physicsExpansion

bool BrawlLib.Modeling.PMDModel._physicsExpansion

static

_rigidBodies

ModelRigidBody [] BrawlLib.Modeling.PMDModel._rigidBodies

static

_skinIndex

ushort [] BrawlLib.Modeling.PMDModel._skinIndex

static

_skins

ModelSkin [] BrawlLib.Modeling.PMDModel._skins

static

_toonExpansion

bool BrawlLib.Modeling.PMDModel._toonExpansion

static

_toonFileNames

string [] BrawlLib.Modeling.PMDModel._toonFileNames

static

_version

float BrawlLib.Modeling.PMDModel._version = 1.0f

static

_vertices

ModelVertex [] BrawlLib.Modeling.PMDModel._vertices

static

Property Documentation

ColorShader

MDL0ShaderNode BrawlLib.Modeling.PMDModel.ColorShader

staticget

        {
            get
            {
                MDL0ShaderNode shader = new MDL0ShaderNode();
 
                MDL0TEVStageNode s = new MDL0TEVStageNode();
                shader.AddChild(s);
 
                s._colorEnv = 0x28FFFA;
                s._alphaEnv = 0x8FFD0;
                s.ConstantColorSelection = TevKColorSel.ConstantColor0_RGB;
                s.ConstantAlphaSelection = TevKAlphaSel.ConstantColor0_Alpha;
                s.TextureMapID = TexMapID.TexMap7;
                s.TextureCoordID = TexCoordID.TexCoord7;
                s.TextureEnabled = false;
                s.RasterColor = ColorSelChan.LightChannel0;
 
                s = new MDL0TEVStageNode();
                shader.AddChild(s);
 
                s._colorEnv = 0x8FEB0;
                s._alphaEnv = 0x81FF0;
                s.ConstantColorSelection = TevKColorSel.ConstantColor1_RGB;
                s.ConstantAlphaSelection = TevKAlphaSel.ConstantColor0_Alpha;
                s.TextureMapID = TexMapID.TexMap7;
                s.TextureCoordID = TexCoordID.TexCoord7;
                s.TextureEnabled = false;
                s.RasterColor = ColorSelChan.LightChannel0;
 
                s = new MDL0TEVStageNode();
                shader.AddChild(s);
 
                s._colorEnv = 0x806EF;
                s._alphaEnv = 0x81FF0;
                s.ConstantColorSelection = TevKColorSel.ConstantColor0_RGB;
                s.ConstantAlphaSelection = TevKAlphaSel.ConstantColor0_Alpha;
                s.TextureMapID = TexMapID.TexMap7;
                s.TextureCoordID = TexCoordID.TexCoord7;
                s.TextureEnabled = false;
                s.RasterColor = ColorSelChan.Zero;
 
                return shader;
            }
        }

ColorSpaShader

MDL0ShaderNode BrawlLib.Modeling.PMDModel.ColorSpaShader

staticget

        {
            get
            {
                MDL0ShaderNode shader = new MDL0ShaderNode
                {
                    TextureRef0 = true
                };
 
                MDL0TEVStageNode s = new MDL0TEVStageNode();
                shader.AddChild(s);
 
                s._colorEnv = 0x8FFFA;
                s._alphaEnv = 0x8FFD0;
                s.ConstantColorSelection = TevKColorSel.ConstantColor3_RGB;
                s.ConstantAlphaSelection = TevKAlphaSel.ConstantColor3_Alpha;
                s.TextureMapID = TexMapID.TexMap7;
                s.TextureCoordID = TexCoordID.TexCoord7;
                s.TextureEnabled = false;
                s.RasterColor = ColorSelChan.LightChannel0;
 
                s = new MDL0TEVStageNode();
                shader.AddChild(s);
 
                s._colorEnv = 0x88E80;
                s._alphaEnv = 0x8FF80;
                s.ConstantColorSelection = TevKColorSel.Constant1_4;
                s.ConstantAlphaSelection = TevKAlphaSel.Constant1_4;
                s.TextureMapID = TexMapID.TexMap0;
                s.TextureCoordID = TexCoordID.TexCoord0;
                s.TextureEnabled = true;
                s.RasterColor = ColorSelChan.Zero;
 
                s = new MDL0TEVStageNode();
                shader.AddChild(s);
 
                s._colorEnv = 0x28F0AF;
                s._alphaEnv = 0x8FF80;
                s.ConstantColorSelection = TevKColorSel.ConstantColor0_RGB;
                s.ConstantAlphaSelection = TevKAlphaSel.ConstantColor0_Alpha;
                s.TextureMapID = TexMapID.TexMap7;
                s.TextureCoordID = TexCoordID.TexCoord7;
                s.TextureEnabled = false;
                s.RasterColor = ColorSelChan.LightChannel0;
 
                s = new MDL0TEVStageNode();
                shader.AddChild(s);
 
                s._colorEnv = 0x8FEB0;
                s._alphaEnv = 0x81FF0;
                s.ConstantColorSelection = TevKColorSel.ConstantColor1_RGB;
                s.ConstantAlphaSelection = TevKAlphaSel.ConstantColor0_Alpha;
                s.TextureMapID = TexMapID.TexMap7;
                s.TextureCoordID = TexCoordID.TexCoord7;
                s.TextureEnabled = false;
                s.RasterColor = ColorSelChan.LightChannel0;
 
                s = new MDL0TEVStageNode();
                shader.AddChild(s);
 
                s._colorEnv = 0x806EF;
                s._alphaEnv = 0x81FF0;
                s.ConstantColorSelection = TevKColorSel.ConstantColor0_RGB;
                s.ConstantAlphaSelection = TevKAlphaSel.ConstantColor0_Alpha;
                s.TextureMapID = TexMapID.TexMap7;
                s.TextureCoordID = TexCoordID.TexCoord7;
                s.TextureEnabled = true;
                s.RasterColor = ColorSelChan.Zero;
 
                return shader;
            }
        }

CoordZ

float BrawlLib.Modeling.PMDModel.CoordZ

staticget

TexShader

MDL0ShaderNode BrawlLib.Modeling.PMDModel.TexShader

staticget

        {
            get
            {
                MDL0ShaderNode shader = new MDL0ShaderNode
                {
                    TextureRef0 = true
                };
 
                MDL0TEVStageNode s = new MDL0TEVStageNode();
                shader.AddChild(s);
 
                s._colorEnv = 0x28FFF8;
                s._alphaEnv = 0x8FFC0;
                s.ConstantColorSelection = TevKColorSel.ConstantColor0_RGB;
                s.ConstantAlphaSelection = TevKAlphaSel.ConstantColor0_Alpha;
                s.TextureMapID = TexMapID.TexMap0;
                s.TextureCoordID = TexCoordID.TexCoord0;
                s.TextureEnabled = true;
                s.RasterColor = ColorSelChan.Zero;
 
                s = new MDL0TEVStageNode();
                shader.AddChild(s);
 
                s._colorEnv = 0x8FEB0;
                s._alphaEnv = 0x81FF0;
                s.ConstantColorSelection = TevKColorSel.ConstantColor1_RGB;
                s.ConstantAlphaSelection = TevKAlphaSel.ConstantColor0_Alpha;
                s.TextureMapID = TexMapID.TexMap7;
                s.TextureCoordID = TexCoordID.TexCoord7;
                s.TextureEnabled = false;
                s.RasterColor = ColorSelChan.LightChannel0;
 
                s = new MDL0TEVStageNode();
                shader.AddChild(s);
 
                s._colorEnv = 0x806EF;
                s._alphaEnv = 0x81FF0;
                s.ConstantColorSelection = TevKColorSel.ConstantColor0_RGB;
                s.ConstantAlphaSelection = TevKAlphaSel.ConstantColor0_Alpha;
                s.TextureMapID = TexMapID.TexMap7;
                s.TextureCoordID = TexCoordID.TexCoord7;
                s.TextureEnabled = false;
                s.RasterColor = ColorSelChan.Zero;
 
                return shader;
            }
        }

TexSpaShader

MDL0ShaderNode BrawlLib.Modeling.PMDModel.TexSpaShader

staticget

        {
            get
            {
                MDL0ShaderNode shader = new MDL0ShaderNode
                {
                    TextureRef0 = true,
                    TextureRef1 = true
                };
 
                MDL0TEVStageNode s = new MDL0TEVStageNode();
                shader.AddChild(s);
 
                s._colorEnv = 0x8FFF8;
                s._alphaEnv = 0x8FFC0;
                s.ConstantColorSelection = TevKColorSel.ConstantColor3_RGB;
                s.ConstantAlphaSelection = TevKAlphaSel.ConstantColor3_Alpha;
                s.TextureMapID = TexMapID.TexMap0;
                s.TextureCoordID = TexCoordID.TexCoord0;
                s.TextureEnabled = true;
                s.RasterColor = ColorSelChan.Zero;
 
                s = new MDL0TEVStageNode();
                shader.AddChild(s);
 
                s._colorEnv = 0x88E80;
                s._alphaEnv = 0x8FF80;
                s.ConstantColorSelection = TevKColorSel.Constant1_4;
                s.ConstantAlphaSelection = TevKAlphaSel.Constant1_4;
                s.TextureMapID = TexMapID.TexMap1;
                s.TextureCoordID = TexCoordID.TexCoord1;
                s.TextureEnabled = true;
                s.RasterColor = ColorSelChan.Zero;
 
                s = new MDL0TEVStageNode();
                shader.AddChild(s);
 
                s._colorEnv = 0x28F0AF;
                s._alphaEnv = 0x8FF80;
                s.ConstantColorSelection = TevKColorSel.ConstantColor0_RGB;
                s.ConstantAlphaSelection = TevKAlphaSel.ConstantColor0_Alpha;
                s.TextureMapID = TexMapID.TexMap7;
                s.TextureCoordID = TexCoordID.TexCoord7;
                s.TextureEnabled = false;
                s.RasterColor = ColorSelChan.LightChannel0;
 
                s = new MDL0TEVStageNode();
                shader.AddChild(s);
 
                s._colorEnv = 0x8FEB0;
                s._alphaEnv = 0x81FF0;
                s.ConstantColorSelection = TevKColorSel.ConstantColor1_RGB;
                s.ConstantAlphaSelection = TevKAlphaSel.ConstantColor0_Alpha;
                s.TextureMapID = TexMapID.TexMap7;
                s.TextureCoordID = TexCoordID.TexCoord7;
                s.TextureEnabled = false;
                s.RasterColor = ColorSelChan.LightChannel0;
 
                s = new MDL0TEVStageNode();
                shader.AddChild(s);
 
                s._colorEnv = 0x806EF;
                s._alphaEnv = 0x81FF0;
                s.ConstantColorSelection = TevKColorSel.ConstantColor0_RGB;
                s.ConstantAlphaSelection = TevKAlphaSel.ConstantColor0_Alpha;
                s.TextureMapID = TexMapID.TexMap7;
                s.TextureCoordID = TexCoordID.TexCoord7;
                s.TextureEnabled = true;
                s.RasterColor = ColorSelChan.Zero;
 
                return shader;
            }
        }

---

The documentation for this class was generated from the following file:

• BrawlLib/Modeling/PMDModel.cs