public static unsafe void PMD2MDL0(MDL0Node model)
{
model._version = 9;
model._isImport = true;
Collada._importOptions = BrawlLib.Properties.Settings.Default.ColladaImportOptions;
Collada._importOptions._forceCCW = true;
Collada._importOptions._fltVerts = true;
Collada._importOptions._fltNrms = true;
Collada._importOptions._fltUVs = true;
model.InitGroups();
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();
}
BoneCache.Add(bone);
}
MDL0ShaderNode texSpa = null, tex = null, colorSpa = null, color = null;
index = 0;
foreach (ModelMaterial m in _materials)
{
MDL0MaterialNode mn = new MDL0MaterialNode();
mn.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();
texRef.Name = names[0].Substring(0, names[0].IndexOf('.'));
}
if (!String.IsNullOrEmpty(names[1]))
{
spaRef = new MDL0MaterialRefNode();
spaRef.Name = names[1].Substring(0, names[1].IndexOf('.'));
spaRef.MapMode = MDL0MaterialRefNode.MappingMethod.EnvCamera;
spaRef.UWrapMode = MDL0MaterialRefNode.WrapMode.Clamp;
spaRef.VWrapMode = MDL0MaterialRefNode.WrapMode.Clamp;
spaRef.Projection = Wii.Graphics.TexProjection.STQ;
spaRef.InputForm = Wii.Graphics.TexInputForm.ABC1;
spaRef.Coordinates = Wii.Graphics.TexSourceRow.Normals;
spaRef.Normalize = true;
}
}
else
{
texRef = new MDL0MaterialRefNode();
texRef.Name = m._textureFileName.Substring(0, m._textureFileName.IndexOf('.'));
texRef.Coordinates = Wii.Graphics.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._numFaces = 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, _opaMaterial = (MDL0MaterialNode)model._matList[x] };
p._opaMaterial._objects.Add(p);
p._manager._vertices = new List<Vertex3>();
p.Name = "polygon" + x++;
p._parent = model._objGroup;
model._numFaces += 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 NewPrimitive((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 = ((float)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, true);
inf.CalcMatrix();
v = new Vertex3(t, inf);
}
else
{
MDL0BoneNode bone = inf._weights[0].Bone;
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
if (p._manager._vertices[0]._matrixNode != null)
p._manager._vertices[0]._matrixNode.ReferenceCount++;
foreach (Vertex3 v in p._manager._vertices)
if (v._matrixNode != null)
v._matrixNode.ReferenceCount--;
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.CleanGroups();
model.BuildFromScratch(null);
}
public MDL0Node ImportModel(string filePath)
{
MDL0Node model = new MDL0Node() { _name = Path.GetFileNameWithoutExtension(filePath) };
model.InitGroups();
if (_importOptions._setOrigPath)
model._originalPath = filePath;
//Parse the collada file and use the data to create an MDL0
using (DecoderShell shell = DecoderShell.Import(filePath))
try
{
model._version = _importOptions._modelVersion;
Error = "There was a problem reading the model.";
//Extract images, removing duplicates
foreach (ImageEntry img in shell._images)
{
string name;
MDL0TextureNode tex;
if (img._path != null)
name = Path.GetFileNameWithoutExtension(img._path);
else
name = img._name != null ? img._name : img._id;
tex = model.FindOrCreateTexture(name);
img._node = tex;
}
//Extract materials and create shaders
int tempNo = -1;
foreach (MaterialEntry mat in shell._materials)
{
tempNo += 1;
MDL0MaterialNode matNode = new MDL0MaterialNode();
matNode._parent = model._matGroup;
matNode._name = mat._name != null ? mat._name : mat._id;
if (tempNo == 0)
{
MDL0ShaderNode shadNode = new MDL0ShaderNode();
shadNode._parent = model._shadGroup;
shadNode._name = "Shader" + tempNo;
model._shadList.Add(shadNode);
}
matNode.Shader = "Shader0";
matNode.ShaderNode = (MDL0ShaderNode)model._shadGroup.Children[0];
mat._node = matNode;
matNode._cull = _importOptions._culling;
//Find effect
if (mat._effect != null)
foreach (EffectEntry eff in shell._effects)
if (eff._id == mat._effect) //Attach textures and effects to material
if (eff._shader != null)
foreach (LightEffectEntry l in eff._shader._effects)
if (l._type == LightEffectType.diffuse && l._texture != null)
{
string path = l._texture;
foreach (EffectNewParam p in eff._newParams)
if (p._sid == l._texture)
{
path = p._sampler2D._url;
if (!String.IsNullOrEmpty(p._sampler2D._source))
{
foreach (EffectNewParam p2 in eff._newParams)
if (p2._sid == p._sampler2D._source)
path = p2._path;
}
}
foreach (ImageEntry img in shell._images)
if (img._id == path)
{
MDL0MaterialRefNode mr = new MDL0MaterialRefNode();
(mr._texture = img._node as MDL0TextureNode)._references.Add(mr);
mr._name = mr._texture.Name;
matNode._children.Add(mr);
mr._parent = matNode;
mr._minFltr = mr._magFltr = 1;
mr._index1 = mr._index2 = mr.Index;
mr._uWrap = mr._vWrap = (int)_importOptions._wrap;
break;
}
}
matNode._numTextures = (byte)matNode.Children.Count;
model._matList.Add(matNode);
}
Say("Extracting scenes...");
//Extract scenes
foreach (SceneEntry scene in shell._scenes)
{
//Parse joints first
NodeEntry[] joints = scene._nodes.Where(x => x._type == NodeType.JOINT).ToArray();
NodeEntry[] nodes = scene._nodes.Where(x => x._type != NodeType.JOINT).ToArray();
foreach (NodeEntry node in joints)
EnumNode(node, model._boneGroup, scene, model, shell);
foreach (NodeEntry node in nodes)
EnumNode(node, model._boneGroup, scene, model, shell);
}
//If there are no bones, rig all objects to a single bind.
if (model._boneGroup._children.Count == 0)
{
for (int i = 0; i < 2; i++)
{
MDL0BoneNode bone = new MDL0BoneNode();
bone.Scale = new Vector3(1);
bone._bindMatrix =
bone._inverseBindMatrix =
Matrix.Identity;
switch (i)
{
case 0:
bone._name = "TopN";
model._boneGroup._children.Add(bone);
bone._parent = model._boneGroup;
break;
case 1:
bone._name = "TransN";
model._boneGroup._children[0]._children.Add(bone);
bone._parent = model._boneGroup._children[0];
bone.ReferenceCount = model._objList.Count;
break;
}
}
if (model._objList != null && model._objList.Count != 0)
foreach (MDL0ObjectNode poly in model._objList)
{
poly._nodeId = 0;
poly.MatrixNode = (MDL0BoneNode)model._boneGroup._children[0]._children[0];
}
}
else
{
//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
if (p._manager._vertices[0]._matrixNode != null)
p._manager._vertices[0]._matrixNode.ReferenceCount++;
foreach (Vertex3 v in p._manager._vertices)
if (v._matrixNode != null)
v._matrixNode.ReferenceCount--;
p._nodeId = -2; //Continued on polygon rebuild
}
}
}
//Remove original color buffers if option set
if (_importOptions._ignoreColors)
{
if (model._objList != null && model._objList.Count != 0)
foreach (MDL0ObjectNode p in model._objList)
for (int x = 2; x < 4; x++)
if (p._manager._faceData[x] != null)
{
p._manager._faceData[x].Dispose();
p._manager._faceData[x] = null;
}
}
//Add color buffers if option set
if (_importOptions._addClrs)
{
RGBAPixel pixel = _importOptions._dfltClr;
//Add a color buffer to objects that don't have one
if (model._objList != null && model._objList.Count != 0)
foreach (MDL0ObjectNode p in model._objList)
if (p._manager._faceData[2] == null)
{
RGBAPixel* pIn = (RGBAPixel*)(p._manager._faceData[2] = new UnsafeBuffer(4 * p._manager._pointCount)).Address;
for (int i = 0; i < p._manager._pointCount; i++)
*pIn++ = pixel;
}
}
//Apply defaults to materials
if (model._matList != null)
foreach (MDL0MaterialNode p in model._matList)
{
if (_importOptions._mdlType == 0)
{
p._lSet = 20;
p._fSet = 4;
p._ssc = 3;
p.C1ColorEnabled = true;
p.C1AlphaMaterialSource = GXColorSrc.Vertex;
p.C1ColorMaterialSource = GXColorSrc.Vertex;
p.C1ColorDiffuseFunction = GXDiffuseFn.Clamped;
p.C1ColorAttenuation = GXAttnFn.Spotlight;
p.C1AlphaEnabled = true;
p.C1AlphaDiffuseFunction = GXDiffuseFn.Clamped;
p.C1AlphaAttenuation = GXAttnFn.Spotlight;
p.C2ColorDiffuseFunction = GXDiffuseFn.Disabled;
p.C2ColorAttenuation = GXAttnFn.None;
p.C2AlphaDiffuseFunction = GXDiffuseFn.Disabled;
p.C2AlphaAttenuation = GXAttnFn.None;
}
else
{
p._lSet = 0;
p._fSet = 0;
p._ssc = 1;
p._chan1.Color = new LightChannelControl(1795);
p._chan1.Alpha = new LightChannelControl(1795);
p._chan2.Color = new LightChannelControl(1795);
p._chan2.Alpha = new LightChannelControl(1795);
}
}
//Set materials to use register color if option set
if (_importOptions._useReg && model._objList != null)
foreach (MDL0ObjectNode p in model._objList)
{
MDL0MaterialNode m = p.OpaMaterialNode;
if (m != null && p._manager._faceData[2] == null && p._manager._faceData[3] == null)
{
m.C1MaterialColor = _importOptions._dfltClr;
m.C1ColorMaterialSource = GXColorSrc.Register;
m.C1AlphaMaterialSource = GXColorSrc.Register;
}
}
//Remap materials if option set
if (_importOptions._rmpMats && model._matList != null && model._objList != null)
{
foreach (MDL0ObjectNode p in model._objList)
foreach (MDL0MaterialNode m in model._matList)
if (m.Children.Count > 0 &&
m.Children[0] != null &&
p.OpaMaterialNode != null &&
p.OpaMaterialNode.Children.Count > 0 &&
p.OpaMaterialNode.Children[0] != null &&
m.Children[0].Name == p.OpaMaterialNode.Children[0].Name &&
m.C1ColorMaterialSource == p.OpaMaterialNode.C1ColorMaterialSource)
{
p.OpaMaterialNode = m;
break;
}
//Remove unused materials
for (int i = 0; i < model._matList.Count; i++)
if (((MDL0MaterialNode)model._matList[i])._objects.Count == 0)
model._matList.RemoveAt(i--);
}
Error = "There was a problem writing the model.";
//Clean the model and then build it!
if (model != null)
{
model.CleanGroups();
model.BuildFromScratch(this);
}
}
catch (Exception x)
{
MessageBox.Show("Cannot continue importing this model.\n" + Error + "\n\nException:\n" + x.ToString());
model = null;
Close();
}
finally
{
//Clean up the mess we've made
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
}
return model;
}