public void Copy(ref MODEL_NODE nc)
{
nc.Name = Name;
nc.NextSiblingNode = NextSiblingNode;
nc.NextChildNode = NextChildNode;
nc.ParentNode = ParentNode;
nc.Translation[0] = Translation[0];
nc.Translation[1] = Translation[1];
nc.Translation[2] = Translation[2];
nc.Rotation[0] = Rotation[0];
nc.Rotation[1] = Rotation[1];
nc.Rotation[2] = Rotation[2];
nc.Rotation[3] = Rotation[3];
nc.DistanceFromParent = DistanceFromParent;
}
public void InitializeAnimationProcessing()
{
m_AniNodes = new MODEL_NODE[m_header.Nodes.Count];
m_NodeTransforms = new MODEL_NODE_TRANSFORM[m_header.Nodes.Count];
for (int x = 0; x < m_header.Nodes.Count; x++)
{
m_AniNodes[x] = new MODEL_NODE();
m_Nodes[x].Copy(ref m_AniNodes[x]);
m_NodeTransforms[x] = new MODEL_NODE_TRANSFORM();
}
this.ProcessNodeOrientation(0);
//Process the node and vertex transformations to initialize everything
this.InverseTransformModel();
m_bAnimationEnabled = true;
}
public void LoadTagData()
{
m_bModelLoaded = false;
BinaryReader br = new BinaryReader(m_stream);
// Load the header
m_header.Load(ref br);
// Load the nodes and allocate the node transforms
br.BaseStream.Seek(m_header.Nodes.Offset, SeekOrigin.Begin);
m_Nodes = new MODEL_NODE[m_header.Nodes.Count];
for (int x = 0; x < m_Nodes.Length; x++)
{
m_Nodes[x] = new MODEL_NODE();
m_Nodes[x].LoadPc(ref br);
}
// Load the regions
br.BaseStream.Seek(m_header.Regions.Offset, SeekOrigin.Begin);
m_regions = new MODEL_REGION[m_header.Regions.Count];
for (int x = 0; x < m_regions.Length; x++)
{
m_regions[x] = new MODEL_REGION();
m_regions[x].Load(ref br);
}
// Load child permutations
for (int x = 0; x < m_regions.Length; x++)
{
br.BaseStream.Seek(m_regions[x].Permutations.Offset, SeekOrigin.Begin);
for (int y = 0; y < m_regions[x].Permutations.Count; y++)
{
m_regions[x].PERMUTATIONS[y] = new MODEL_REGION_PERMUTATION();
m_regions[x].PERMUTATIONS[y].Load(ref br);
}
}
// Load the Geometries
br.BaseStream.Seek(m_header.Geometries.Offset, SeekOrigin.Begin);
m_geometries = new MODEL_GEOMETRY_HEADER[m_header.Geometries.Count];
for (int x = 0; x < m_geometries.Length; x++)
{
m_geometries[x] = new MODEL_GEOMETRY_HEADER();
m_geometries[x].Load(ref br, this.Header.GameVersion);
}
// Load child Submesh Headers
for (int g = 0; g < m_geometries.Length; g++)
{
for (int s = 0; s < m_geometries[g].SubmeshHeaders.Count; s++)
{
if (this.Header.GameVersion == MapfileVersion.XHALO1)
{
m_geometries[g].XSUBMESHHEADERS[s] = new XBOXMODEL_SUBMESH_HEADER();
m_geometries[g].XSUBMESHHEADERS[s].UScale = m_header.u_scale;
m_geometries[g].XSUBMESHHEADERS[s].VScale = m_header.v_scale;
m_geometries[g].XSUBMESHHEADERS[s].Load(br);
}
else
{
m_geometries[g].SUBMESHHEADERS[s] = new PCMODEL_SUBMESH_HEADER();
m_geometries[g].SUBMESHHEADERS[s].UScale = m_header.u_scale;
m_geometries[g].SUBMESHHEADERS[s].VScale = m_header.v_scale;
m_geometries[g].SUBMESHHEADERS[s].Load(ref br);
}
}
for (int s = 0; s < m_geometries[g].SubmeshHeaders.Count; s++)
{
if (this.Header.GameVersion == MapfileVersion.XHALO1)
{
m_geometries[g].XSUBMESHHEADERS[s].LoadRawData(ref br, this.m_Buffer);
}
else
{
m_geometries[g].SUBMESHHEADERS[s].LoadRawData(ref br, this.m_Buffer);
}
}
}
// Load the shaders
br.BaseStream.Seek(m_header.Shaders.Offset, SeekOrigin.Begin);
m_shaders = new MODEL_SHADER[m_header.Shaders.Count];
for (int x = 0; x < m_shaders.Length; x++)
{
m_shaders[x] = new MODEL_SHADER();
m_shaders[x].Load(ref br);
}
// Now load all of the strings
for (int x = 0; x < m_shaders.Length; x++)
{
m_shaders[x].Shader.ReadString(ref br);
}
for (int x = 0; x < m_shaders.Length; x++)
{
string tagclass = new string(m_shaders[x].Shader.tag);
m_shaders[x].ShaderManagerIndex = MdxRender.SM.RegisterShader(new TagFileName(m_shaders[x].Shader.data, tagclass, this.m_PromHeader.GameVersion));
}
//Sync up submesh ShaderManagerIndex with global shader manager
for (int g = 0; g < m_geometries.Length; g++)
{
for (int s = 0; s < m_geometries[g].SubmeshHeaders.Count; s++)
{
if (this.Header.GameVersion == MapfileVersion.XHALO1)
{
string tag_type = new string(m_shaders[m_geometries[g].XSUBMESHHEADERS[s].ShaderIndex].Shader.tag);
TagFileName shader_filename = new TagFileName(m_shaders[m_geometries[g].XSUBMESHHEADERS[s].ShaderIndex].Shader.data,
tag_type, this.m_PromHeader.GameVersion);
m_geometries[g].XSUBMESHHEADERS[s].m_Mesh.RegisterShader(shader_filename);
}
else
{
string tag_type = new string(m_shaders[m_geometries[g].SUBMESHHEADERS[s].ShaderIndex].Shader.tag);
TagFileName shader_filename = new TagFileName(m_shaders[m_geometries[g].SUBMESHHEADERS[s].ShaderIndex].Shader.data,
tag_type, this.m_PromHeader.GameVersion);
m_geometries[g].SUBMESHHEADERS[s].m_Mesh.RegisterShader(shader_filename);
}
}
}
//determine bounding box for camera viewer
if (this.Header.GameVersion == MapfileVersion.XHALO1)
{
for (int g = 0; g < m_header.Geometries.Count; g++)
{
for (int s = 0; s < m_geometries[g].SubmeshHeaders.Count; s++)
{
m_geometries[g].XSUBMESHHEADERS[s].m_Mesh.UpdateBoundingBox(ref m_BoundingBox);
}
}
}
else
{
for (int g = 0; g < m_header.Geometries.Count; g++)
{
for (int s = 0; s < m_geometries[g].SubmeshHeaders.Count; s++)
{
m_geometries[g].SUBMESHHEADERS[s].m_Mesh.UpdateBoundingBox(ref m_BoundingBox);
}
}
}
m_bModelLoaded = true;
}
