/* ** Command & Conquer Renegade(tm) ** Copyright 2025 Electronic Arts Inc. ** ** This program is free software: you can redistribute it and/or modify ** it under the terms of the GNU General Public License as published by ** the Free Software Foundation, either version 3 of the License, or ** (at your option) any later version. ** ** This program is distributed in the hope that it will be useful, ** but WITHOUT ANY WARRANTY; without even the implied warranty of ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ** GNU General Public License for more details. ** ** You should have received a copy of the GNU General Public License ** along with this program. If not, see . */ /*********************************************************************************************** *** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S *** *********************************************************************************************** * * * Project Name : WDump * * * * $Archive:: /Commando/Code/Tools/W3DShellExt/External/chunk_d.cpp $* * * * $Author:: Moumine_ballo $* * * * $Modtime:: 1/02/02 1:22p $* * * * $Revision:: 66 $* * * *---------------------------------------------------------------------------------------------* * Functions: * * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ #include "w3d_file.h" #include "stdafx.h" #include "wdump.h" #include "Chunk_D.h" #include "rawfilem.h" #include "finddialog.h" #ifdef _DEBUG #undef THIS_FILE static char THIS_FILE[]=__FILE__; #define new DEBUG_NEW #endif static int Get_Bit(void const * array, int bit); static void Set_Bit(void * array, int bit, int value); ChunkTableClass ChunkItem::ChunkTable; ChunkTableClass::~ChunkTableClass() { ChunkType *chunktype; POSITION p = Types.GetStartPosition(); while(p) { void *key; Types.GetNextAssoc(p, key, (void *&) chunktype); delete chunktype; } } void ChunkTableClass::NewType(int ID, const char *name, void (*callback)(ChunkItem *item, CListCtrl *list), bool wrapper) { ChunkType *chunktype = new ChunkType(name, callback, wrapper); Types.SetAt((void *) ID, (void *) chunktype); } void ChunkTableClass::AddItem(CListCtrl *List, int &Counter, const char *Name, const char *Value, const char *Type) { if (List != NULL) { int list_item = List->InsertItem(Counter++, Name); List->SetItemText(list_item, 1, Type); List->SetItemText(list_item, 2, Value); } else { FindDialog::Compare (Value); } } void ChunkTableClass::AddItemVersion(CListCtrl *List,int &Counter,uint32 version) { char buf[64]; sprintf(buf,"%d.%d",W3D_GET_MAJOR_VERSION(version),W3D_GET_MINOR_VERSION(version)); AddItem(List,Counter,"Version",buf); } void ChunkTableClass::AddItem(CListCtrl *List, int &Counter, const char *Name, uint32 Value) { char buf[256]; sprintf(buf, "%d", Value); AddItem(List, Counter, Name, buf, "int32"); } void ChunkTableClass::AddItem(CListCtrl *List, int &Counter, const char *Name, uint16 Value) { char buf[256]; sprintf(buf, "%d", Value); AddItem(List, Counter, Name, buf, "int16"); } void ChunkTableClass::AddItem(CListCtrl *List, int &Counter, const char *Name, uint8 Value) { char buf[256]; sprintf(buf, "%d", Value); AddItem(List, Counter, Name, buf, "int8"); } void ChunkTableClass::AddItem(CListCtrl *List, int &Counter, const char *Name, uint8 *Value, int Count) { CString buffer; CString temp; int counter = 0; while(counter < Count) { temp.Format("%d ", Value[counter++]); buffer += temp; } char type[256]; sprintf(type, "int8[%d]", Count); AddItem(List, Counter, Name, (LPCTSTR) buffer, type); } void ChunkTableClass::AddItem(CListCtrl *List,int &Counter, const char *Name, float32 Value) { char buf[256]; sprintf(buf, "%f", Value); AddItem(List, Counter, Name, buf, "float"); } void ChunkTableClass::AddItem(CListCtrl *List, int &Counter, const char *Name, uint32 *Value, int Count) { CString buffer; CString temp; int counter = 0; while(counter < Count) { temp.Format("%d ", Value[counter++]); buffer += temp; } char type[256]; sprintf(type, "int32[%d]", Count); AddItem(List, Counter, Name, (LPCTSTR) buffer, type); } void ChunkTableClass::AddItem(CListCtrl *List, int &Counter, const char *Name, float32 *Value, int Count) { CString buffer; CString temp; int counter = 0; while(counter < Count) { temp.Format("%f ", Value[counter++]); buffer += temp; } char type[256]; sprintf(type, "float[%d]", Count); AddItem(List, Counter, Name, (LPCTSTR) buffer, type); } void ChunkTableClass::AddItem(CListCtrl *List, int &Counter, const char *Name, IOVector3Struct *Value) { char buf[256]; sprintf(buf, "%f %f %f", Value->X, Value->Y, Value->Z); AddItem(List, Counter, Name, buf, "vector"); } void ChunkTableClass::AddItem(CListCtrl *List, int &Counter, const char *Name, IOVector4Struct *Value) { char buf[256]; sprintf(buf, "%f %f %f %f", Value->X, Value->Y, Value->Z, Value->W); AddItem(List, Counter, Name, buf, "vector4"); } void ChunkTableClass::AddItem(CListCtrl *List, int &Counter, const char *Name, W3dQuaternionStruct *Value) { char buf[256]; sprintf(buf, "%f %f %f %f", Value->Q[0], Value->Q[1], Value->Q[2], Value->Q[3]); AddItem(List, Counter, Name, buf, "quaternion"); } void ChunkTableClass::AddItem(CListCtrl *List, int &Counter, const char *Name, W3dRGBStruct *Value) { CString buffer; buffer.Format( "(%d %d %d) ", Value->R, Value->G, Value->B); AddItem(List, Counter, Name, (LPCTSTR) buffer, "RGB"); } void ChunkTableClass::AddItem(CListCtrl *List, int &Counter, const char *Name, W3dRGBStruct *Value, int Count) { CString buffer; CString temp; int counter = 0; while(counter < Count) { temp.Format( "(%d %d %d) ", Value[counter].R, Value[counter].G, Value[counter].B); counter++; buffer += temp; } char type[256]; sprintf(type, "RGB[%d]", Count); AddItem(List, Counter, Name, (LPCTSTR) buffer, type); } void ChunkTableClass::AddItem(CListCtrl *List, int &Counter, const char *Name, W3dRGBAStruct *Value) { CString buffer; buffer.Format( "(%d %d %d %d) ", Value->R, Value->G, Value->B, Value->A); AddItem(List, Counter, Name, (LPCTSTR) buffer, "RGBA"); } void ChunkTableClass::AddItem(CListCtrl *List, int &Counter, const char *Name, W3dTexCoordStruct *Value, int Count) { CString temp; int counter = 0; while(counter < Count) { char type[256]; sprintf(type, "%s.TexCoord[%d]", Name, counter); AddItem(List, Counter, type, &Value[counter]); counter++; } } void ChunkTableClass::AddItem(CListCtrl *List, int &Counter, const char *Name, W3dTexCoordStruct *Value) { char buf[256]; sprintf(buf, "%f %f", Value->U, Value->V); AddItem(List, Counter, Name, buf, "UV"); } void ChunkTableClass::AddItem(CListCtrl *List, int &Counter, const char *name, W3dShaderStruct * shader) { static char * _depth_compare[] = { "Pass Never","Pass Less","Pass Equal","Pass Less or Equal", "Pass Greater","Pass Not Equal","Pass Greater or Equal","Pass Always" }; static char * _depth_mask[] = { "Write Disable", "Write Enable" }; static char * _color_mask[] = { "Write Disable", "Write Enable" }; static char * _destblend[] = { "Zero","One","Src Color","One Minus Src Color","Src Alpha","One Minus Src Alpha","Src Color Prefog" }; static char * _fogfunc[] = { "Disable","Enable","Scale Fragment","Replace Fragment" }; static char * _prigradient[] = { "Disable","Modulate","Add","Bump-Environment" }; static char * _secgradient[] = { "Disable","Enable" }; static char * _srcblend[] = { "Zero","One","Src Alpha","One Minus Src Alpha" }; static char * _texturing[] = { "Disable","Enable" }; static char * _detailcolor[] = { "Disable","Detail","Scale","InvScale","Add","Sub","SubR","Blend","DetailBlend" }; static char * _detailalpha[] = { "Disable","Detail","Scale","InvScale" }; static char * _dithermask[] = { "Disable", "Enable" }; static char * _shademodel[] = { "Smooth", "Flat" }; static char * _alphatest[] = { "Alpha Test Disable", "Alpha Test Enable" }; int counter = 0; char label[256]; sprintf(label,"%s.DepthCompare",name); AddItem(List, Counter, label, _depth_compare[W3d_Shader_Get_Depth_Compare(shader)]); sprintf(label,"%s.DepthMask",name); AddItem(List, Counter, label, _depth_mask[W3d_Shader_Get_Depth_Mask(shader)]); sprintf(label,"%s.DestBlend",name); AddItem(List, Counter, label, _destblend[W3d_Shader_Get_Dest_Blend_Func(shader)]); sprintf(label,"%s.PriGradient",name); AddItem(List, Counter, label, _prigradient[W3d_Shader_Get_Pri_Gradient(shader)]); sprintf(label,"%s.SecGradient",name); AddItem(List, Counter, label, _secgradient[W3d_Shader_Get_Sec_Gradient(shader)]); sprintf(label,"%s.SrcBlend",name); AddItem(List, Counter, label, _srcblend[W3d_Shader_Get_Src_Blend_Func(shader)]); sprintf(label,"%s.Texturing",name); AddItem(List, Counter, label, _texturing[W3d_Shader_Get_Texturing(shader)]); sprintf(label,"%s.DetailColor",name); AddItem(List, Counter, label, _detailcolor[W3d_Shader_Get_Detail_Color_Func(shader)]); sprintf(label,"%s.DetailAlpha",name); AddItem(List, Counter, label, _detailalpha[W3d_Shader_Get_Detail_Alpha_Func(shader)]); sprintf(label,"%s.AlphaTest",name); AddItem(List, Counter, label, _alphatest[W3d_Shader_Get_Alpha_Test(shader)]); counter++; shader++; } void ChunkTableClass::AddItem(CListCtrl *List, int &Counter, const char *name, W3dPS2ShaderStruct * shader) { static char * _depth_compare[] = { "Pass Never","Pass Less","Pass Always","Pass Less or Equal"}; static char * _depth_mask[] = { "Write Disable", "Write Enable" }; static char * _color_mask[] = { "Write Disable", "Write Enable" }; static char * _ablend[] = { "Src Color","Dest Color","Zero"}; static char * _cblend[] = { "Src Alpha","Dest Alpha","One"}; static char * _fogfunc[] = { "Disable","Enable","Scale Fragment","Replace Fragment" }; static char * _prigradient[] = { "Disable","Modulate","Highlight","Highlight2" }; static char * _secgradient[] = { "Disable","Enable" }; static char * _texturing[] = { "Disable","Enable" }; static char * _detailcolor[] = { "Disable","Detail","Scale","InvScale","Add","Sub","SubR","Blend","DetailBlend" }; static char * _detailalpha[] = { "Disable","Detail","Scale","InvScale" }; static char * _dithermask[] = { "Disable", "Enable" }; static char * _shademodel[] = { "Smooth", "Flat" }; int counter = 0; char label[256]; sprintf(label,"%s.DepthCompare",name); AddItem(List, Counter, label, _depth_compare[W3d_Shader_Get_Depth_Compare(shader)]); sprintf(label,"%s.DepthMask",name); AddItem(List, Counter, label, _depth_mask[W3d_Shader_Get_Depth_Mask(shader)]); sprintf(label,"%s.PriGradient",name); AddItem(List, Counter, label, _prigradient[W3d_Shader_Get_Pri_Gradient(shader)]); sprintf(label,"%s.Texturing",name); AddItem(List, Counter, label, _texturing[W3d_Shader_Get_Texturing(shader)]); sprintf(label,"%s.AParam",name); AddItem(List, Counter, label, _ablend[W3d_Shader_Get_PS2_Param_A(shader)]); sprintf(label,"%s.BParam",name); AddItem(List, Counter, label, _ablend[W3d_Shader_Get_PS2_Param_B(shader)]); sprintf(label,"%s.CParam",name); AddItem(List, Counter, label, _cblend[W3d_Shader_Get_PS2_Param_C(shader)]); sprintf(label,"%s.DParam",name); AddItem(List, Counter, label, _ablend[W3d_Shader_Get_PS2_Param_D(shader)]); counter++; shader++; } void ChunkTableClass::AddItem(CListCtrl *List, int &Counter, const char *Name, Vector3i *Value) { char buf[256]; sprintf(buf, "%d %d %d", Value->I, Value->J, Value->K); AddItem(List, Counter, Name, buf, "IJK"); } void ChunkTableClass::List_Subitems(ChunkItem *Item, CListCtrl *List) { int counter = 0; POSITION p = Item->Chunks.GetHeadPosition(); while(p) { ChunkItem *subitem = Item->Chunks.GetNext(p); if(subitem->Type) { AddItem(List, counter,subitem->Type->Name, "", "chunk"); } } } void ChunkTableClass::List_W3D_CHUNK_MESH(ChunkItem *Item, CListCtrl *List) { List_Subitems(Item, List); } void ChunkTableClass::List_W3D_CHUNK_MESH_HEADER(ChunkItem *Item, CListCtrl *List) { struct W3dMeshHeaderStruct *data; data = (W3dMeshHeaderStruct *) Item->Data; int Counter = 0; char buf[64]; sprintf(buf,"%d.%d",W3D_GET_MAJOR_VERSION(data->Version),W3D_GET_MINOR_VERSION(data->Version)); AddItem(List, Counter,"Version", buf); AddItem(List, Counter,"MeshName", data->MeshName); AddItem(List,Counter,"Attributes",data->Attributes); if (data->Attributes & W3D_MESH_FLAG_COLLISION_BOX) AddItem(List, Counter,"Attributes", "W3D_MESH_FLAG_COLLISION_BOX"); if (data->Attributes & W3D_MESH_FLAG_SKIN) AddItem(List, Counter,"Attributes", "W3D_MESH_FLAG_SKIN"); if (data->Attributes & W3D_MESH_FLAG_SHADOW) AddItem(List, Counter,"Attributes", "W3D_MESH_FLAG_SHADOW"); if (data->Attributes & W3D_MESH_FLAG_ALIGNED) AddItem(List, Counter,"Attributes", "W3D_MESH_FLAG_ALIGNED"); if (data->Attributes & W3D_MESH_FLAG_COLLISION_TYPE_PHYSICAL) AddItem(List, Counter,"Attributes", "W3D_MESH_FLAG_COLLISION_TYPE_PHYSICAL"); if (data->Attributes & W3D_MESH_FLAG_COLLISION_TYPE_PROJECTILE) AddItem(List, Counter,"Attributes", "W3D_MESH_FLAG_COLLISION_TYPE_PROJECTILE"); AddItem(List, Counter,"NumTris", data->NumTris); AddItem(List, Counter,"NumQuads", data->NumQuads); AddItem(List, Counter,"NumSrTris", data->NumSrTris); AddItem(List, Counter,"NumPovQuads", data->NumPovQuads); AddItem(List, Counter,"NumVertices", data->NumVertices); AddItem(List, Counter,"NumNormals", data->NumNormals); AddItem(List, Counter,"NumSrNormals", data->NumSrNormals); AddItem(List, Counter,"NumTexCoords", data->NumTexCoords); AddItem(List, Counter,"NumMaterials", data->NumMaterials); AddItem(List, Counter,"NumVertColors", data->NumVertColors); AddItem(List, Counter,"NumVertInfluences", data->NumVertInfluences); AddItem(List, Counter,"NumDamageStages", data->NumDamageStages); AddItem(List, Counter,"FutureCounts", data->FutureCounts, 5); AddItem(List, Counter,"LODMin", data->LODMin); AddItem(List, Counter,"LODMax", data->LODMax); AddItem(List, Counter,"Min", &data->Min); AddItem(List, Counter,"Max", &data->Max); AddItem(List, Counter,"SphCenter", &data->SphCenter); AddItem(List, Counter,"SphRadius", data->SphRadius); AddItem(List, Counter,"Translation", &data->Translation); AddItem(List, Counter,"Rotation", data->Rotation, 9); AddItem(List, Counter,"MassCenter", &data->MassCenter); AddItem(List, Counter,"Inertia", data->Inertia, 9); AddItem(List, Counter,"Volume", data->Volume); AddItem(List, Counter,"HierarchyTreeName", data->HierarchyTreeName); AddItem(List, Counter,"HierarchyModelName", data->HierarchyModelName); AddItem(List, Counter,"FutureUse", data->FutureUse, 24); } void ChunkTableClass::List_W3D_CHUNK_VERTICES(ChunkItem *Item, CListCtrl *List) { W3dVectorStruct *data; data = (W3dVectorStruct *) Item->Data; int Counter = 0; int index = 0; void *max = (char *) Item->Data + Item->Length; int counter = 0; char buf[256]; while(data < max) { sprintf(buf, "Vertex[%d]", counter++); AddItem(List, Counter,buf, data); data++; } } void ChunkTableClass::List_W3D_CHUNK_VERTEX_NORMALS(ChunkItem *Item, CListCtrl *List) { W3dVectorStruct *data; data = (W3dVectorStruct *) Item->Data; int Counter = 0; int index = 0; void *max = (char *) Item->Data + Item->Length; int counter = 0; char buf[256]; while(data < max) { sprintf(buf, "Normal[%d]", counter++); AddItem(List, Counter,buf, data); data++; } } void ChunkTableClass::List_W3D_CHUNK_SURRENDER_NORMALS(ChunkItem *Item, CListCtrl *List) { W3dVectorStruct *data; data = (W3dVectorStruct *) Item->Data; int Counter = 0; int index = 0; void *max = (char *) Item->Data + Item->Length; int counter = 0; char buf[256]; while(data < max) { sprintf(buf, "SRNormal[%d]", counter++); AddItem(List, Counter,buf, data); data++; } } void ChunkTableClass::List_W3D_CHUNK_TEXCOORDS(ChunkItem *Item, CListCtrl *List) { W3dTexCoordStruct *data; data = (W3dTexCoordStruct *) Item->Data; int Counter = 0; int index = 0; void *max = (char *) Item->Data + Item->Length; int counter = 0; char buf[256]; while(data < max) { sprintf(buf, "TexCoord[%d]", counter++); AddItem(List, Counter, buf, data); data++; } } void ChunkTableClass::List_O_W3D_CHUNK_MATERIALS(ChunkItem *Item, CListCtrl *List) { struct W3dMaterialStruct *data; data = (W3dMaterialStruct *) Item->Data; int Counter = 0; int index = 0; void *max = (char *) Item->Data + Item->Length; int counter = 0; char buf[256]; while(data < max) { sprintf(buf, "Material[%d].MaterialName", counter); AddItem(List, Counter,buf, data->MaterialName); sprintf(buf, "Material[%d].PrimaryName", counter); AddItem(List, Counter,buf, data->PrimaryName); sprintf(buf, "Material[%d].SecondaryName", counter); AddItem(List, Counter,buf, data->SecondaryName); sprintf(buf, "Material[%d].RenderFlags", counter); AddItem(List, Counter,buf, data->RenderFlags); sprintf(buf, "Material[%d].Red", counter); AddItem(List, Counter,buf, data->Red); sprintf(buf, "Material[%d].Green", counter); AddItem(List, Counter,buf, data->Green); sprintf(buf, "Material[%d].Blue", counter); AddItem(List, Counter,buf, data->Blue); counter++; data++; } } void ChunkTableClass::List_O_W3D_CHUNK_TRIANGLES(ChunkItem *Item, CListCtrl *List) { int Counter = 0; AddItem(List, Counter, "Obsolete structure", ""); } void ChunkTableClass::List_O_W3D_CHUNK_QUADRANGLES(ChunkItem *Item, CListCtrl *List) { int Counter = 0; AddItem(List, Counter, "Outdated structure", ""); } void ChunkTableClass::List_O_W3D_CHUNK_SURRENDER_TRIANGLES(ChunkItem *Item, CListCtrl *List) { struct W3dSurrenderTriStruct *data; data = (W3dSurrenderTriStruct *) Item->Data; int Counter = 0; int index = 0; void *max = (char *) Item->Data + Item->Length; int counter = 0; char buf[256]; while(data < max) { sprintf(buf, "Triangle[%d].Attributes", counter); AddItem(List, Counter,buf, data->Attributes); sprintf(buf, "Triangle[%d].Gouraud", counter); AddItem(List, Counter,buf, data->Gouraud, 3); sprintf(buf, "Triangle[%d].VertexIndices", counter); AddItem(List, Counter,buf, data->Vindex, 3); sprintf(buf, "Triangle[%d].MaterialIdx", counter); AddItem(List, Counter,buf, data->MaterialIdx); sprintf(buf, "Triangle[%d].Normal", counter); AddItem(List, Counter,buf, &data->Normal); sprintf(buf, "Triangle[%d].TexCoord", counter); AddItem(List, Counter,buf, data->TexCoord, 3); counter++; data++; } } void ChunkTableClass::List_O_W3D_CHUNK_POV_TRIANGLES(ChunkItem *Item, CListCtrl *List) { int Counter = 0; AddItem(List, Counter,"Contact Greg if you need to look at this!", "unsupported"); } void ChunkTableClass::List_O_W3D_CHUNK_POV_QUADRANGLES(ChunkItem *Item, CListCtrl *List) { int Counter = 0; AddItem(List, Counter,"Contact Greg if you need to look at this!", "unsupported"); } void ChunkTableClass::List_W3D_CHUNK_MESH_USER_TEXT(ChunkItem *Item, CListCtrl *List) { int Counter = 0; AddItem(List, Counter,"UserText", (char *) Item->Data); } void ChunkTableClass::List_W3D_CHUNK_VERTEX_COLORS(ChunkItem *Item, CListCtrl *List) { struct W3dRGBStruct *data; data = (W3dRGBStruct *) Item->Data; int Counter = 0; int index = 0; void *max = (char *) Item->Data + Item->Length; int counter = 0; char buf[256]; int sz = sizeof(W3dRGBStruct); while(data < max) { sprintf(buf, "Vertex[%d].RGB", counter); AddItem(List, Counter,buf, data); counter++; data++; } } void ChunkTableClass::List_W3D_CHUNK_VERTEX_INFLUENCES(ChunkItem *Item, CListCtrl *List) { struct W3dVertInfStruct *data; data = (W3dVertInfStruct *) Item->Data; int Counter = 0; int index = 0; void *max = (char *) Item->Data + Item->Length; int counter = 0; char buf[256]; while(data < max) { sprintf(buf, "VertexInfluence[%d].BoneIdx", counter); AddItem(List, Counter,buf, data->BoneIdx); sprintf(buf, "VertexInfluence[%d].Pad", counter); AddItem(List, Counter,buf, data->Pad, 6); counter++; data++; } } void ChunkTableClass::List_W3D_CHUNK_DAMAGE(ChunkItem *Item, CListCtrl *List) { List_Subitems(Item, List); } void ChunkTableClass::List_W3D_CHUNK_DAMAGE_HEADER(ChunkItem *Item, CListCtrl *List) { struct W3dMeshDamageStruct *data; data = (W3dMeshDamageStruct *) Item->Data; int Counter = 0; int index = 0; void *max = (char *) Item->Data + Item->Length; int counter = 0; char buf[256]; while(data < max) { sprintf(buf, "DamageStruct[%d].NumDamageMaterials", counter); AddItem(List, Counter,buf, data->NumDamageMaterials); sprintf(buf, "DamageStruct[%d].NumDamageVerts", counter); AddItem(List, Counter,buf, data->NumDamageVerts); sprintf(buf, "DamageStruct[%d].NumDamageColors", counter); AddItem(List, Counter,buf, data->NumDamageColors); sprintf(buf, "DamageStruct[%d].DamageIndex", counter); AddItem(List, Counter,buf, data->DamageIndex); counter++; data++; } } void ChunkTableClass::List_W3D_CHUNK_DAMAGE_VERTICES(ChunkItem *Item, CListCtrl *List) { struct W3dMeshDamageVertexStruct *data; data = (W3dMeshDamageVertexStruct *) Item->Data; int Counter = 0; int index = 0; void *max = (char *) Item->Data + Item->Length; int counter = 0; char buf[256]; while(data < max) { sprintf(buf, "DamageVertexStruct[%d].VertexIndex", counter); AddItem(List, Counter,buf, data->VertexIndex); sprintf(buf, "DamageVertexStruct[%d].NewVertex", counter); AddItem(List, Counter,buf, data->VertexIndex); counter++; data++; } } void ChunkTableClass::List_W3D_CHUNK_DAMAGE_COLORS(ChunkItem *Item, CListCtrl *List) { struct W3dMeshDamageColorStruct *data; data = (W3dMeshDamageColorStruct *) Item->Data; int Counter = 0; int index = 0; void *max = (char *) Item->Data + Item->Length; int counter = 0; char buf[256]; while(data < max) { sprintf(buf, "DamageColorStruct[%d].VertexIndex", counter); AddItem(List, Counter,buf, data->VertexIndex); sprintf(buf, "DamageColorStruct[%d].NewColor", counter); AddItem(List, Counter,buf, &data->NewColor); counter++; data++; } } void ChunkTableClass::List_O_W3D_CHUNK_MATERIALS2(ChunkItem *Item, CListCtrl *List) { struct W3dMaterial2Struct *data; data = (W3dMaterial2Struct *) Item->Data; int Counter = 0; int index = 0; void *max = (char *) Item->Data + Item->Length; int counter = 0; char buf[256]; while(data < max) { sprintf(buf, "Material[%d].MaterialName", counter); AddItem(List, Counter,buf, data->MaterialName); sprintf(buf, "Material[%d].PrimaryName", counter); AddItem(List, Counter,buf, data->PrimaryName); sprintf(buf, "Material[%d].SecondaryName", counter); AddItem(List, Counter,buf, data->SecondaryName); sprintf(buf, "Material[%d].RenderFlags", counter); AddItem(List, Counter,buf, data->RenderFlags); sprintf(buf, "Material[%d].Red", counter); AddItem(List, Counter,buf, data->Red); sprintf(buf, "Material[%d].Green", counter); AddItem(List, Counter,buf, data->Green); sprintf(buf, "Material[%d].Blue", counter); AddItem(List, Counter,buf, data->Blue); sprintf(buf, "Material[%d].Alpha", counter); AddItem(List, Counter,buf, data->Alpha); sprintf(buf, "Material[%d].PrimaryNumFrames", counter); AddItem(List, Counter,buf, data->PrimaryNumFrames); sprintf(buf, "Material[%d].SecondaryNumFrames", counter); AddItem(List, Counter,buf, data->SecondaryNumFrames); counter++; data++; } } void ChunkTableClass::List_W3D_CHUNK_MATERIALS3(ChunkItem *Item, CListCtrl *List) { List_Subitems(Item, List); } void ChunkTableClass::List_W3D_CHUNK_MATERIAL3(ChunkItem *Item, CListCtrl *List) { List_Subitems(Item, List); } void ChunkTableClass::List_W3D_CHUNK_MATERIAL3_NAME(ChunkItem *Item, CListCtrl *List) { int Counter = 0; char * data = (char *)Item->Data; AddItem(List, Counter,"Material Name:", data); } void ChunkTableClass::List_W3D_CHUNK_MATERIAL3_INFO(ChunkItem *Item, CListCtrl *List) { int Counter = 0; struct W3dMaterial3Struct *data; data = (W3dMaterial3Struct *) Item->Data; AddItem(List,Counter,"Attributes",data->Attributes); if (data->Attributes & W3DMATERIAL_USE_ALPHA) AddItem(List,Counter,"Attributes","W3DMATERIAL_USE_ALPHA"); if (data->Attributes & W3DMATERIAL_USE_SORTING) AddItem(List,Counter,"Attributes","W3DMATERIAL_USE_SORTING"); if (data->Attributes & W3DMATERIAL_HINT_DIT_OVER_DCT) AddItem(List,Counter,"Attributes","W3DMATERIAL_HINT_DIT_OVER_DCT"); if (data->Attributes & W3DMATERIAL_HINT_SIT_OVER_SCT) AddItem(List,Counter,"Attributes","W3DMATERIAL_HINT_SIT_OVER_SCT"); if (data->Attributes & W3DMATERIAL_HINT_DIT_OVER_DIG) AddItem(List,Counter,"Attributes","W3DMATERIAL_HINT_DIT_OVER_DIG"); if (data->Attributes & W3DMATERIAL_HINT_SIT_OVER_SIG) AddItem(List,Counter,"Attributes","W3DMATERIAL_HINT_SIT_OVER_SIG"); if (data->Attributes & W3DMATERIAL_HINT_FAST_SPECULAR_AFTER_ALPHA) AddItem(List,Counter,"Attributes","W3DMATERIAL_HINT_FAST_SPECULAR_AFTER_ALPHA"); if (data->Attributes & W3DMATERIAL_PSX_TRANS_100) AddItem(List,Counter,"Attributes","W3DMATERIAL_PSX_TRANS_100"); if (data->Attributes & W3DMATERIAL_PSX_TRANS_50) AddItem(List,Counter,"Attributes","W3DMATERIAL_PSX_TRANS_50"); if (data->Attributes & W3DMATERIAL_PSX_TRANS_25) AddItem(List,Counter,"Attributes","W3DMATERIAL_PSX_TRANS_25"); if (data->Attributes & W3DMATERIAL_PSX_TRANS_MINUS_100) AddItem(List,Counter,"Attributes","W3DMATERIAL_PSX_TRANS_MINUS_100"); if (data->Attributes & W3DMATERIAL_PSX_NO_RT_LIGHTING) AddItem(List,Counter,"Attributes","W3DMATERIAL_PSX_NO_RT_LIGHTING"); AddItem(List, Counter,"Diffuse Color", &data->DiffuseColor); AddItem(List, Counter,"Specular Color", &data->SpecularColor); AddItem(List, Counter,"Emissive Coefficients", &data->EmissiveCoefficients); AddItem(List, Counter,"Ambient Coefficients", &data->AmbientCoefficients); AddItem(List, Counter,"Diffuse Coefficients", &data->DiffuseCoefficients); AddItem(List, Counter,"Specular Coefficients", &data->SpecularCoefficients); AddItem(List, Counter,"Shininess", data->Shininess); AddItem(List, Counter,"Opacity", data->Opacity); AddItem(List, Counter,"Translucency", data->Translucency); AddItem(List, Counter,"Fog Coefficient", data->FogCoeff); } void ChunkTableClass::List_W3D_CHUNK_MAP3_FILENAME(ChunkItem * Item,CListCtrl * List) { int Counter = 0; char * data = (char *)Item->Data; AddItem(List, Counter, "Texture Filename:", data); } void ChunkTableClass::List_W3D_CHUNK_MAP3_INFO(ChunkItem * Item,CListCtrl * List) { int Counter = 0; struct W3dMap3Struct * data; data = (W3dMap3Struct *)Item->Data; AddItem(List, Counter, "Mapping Type",data->MappingType); AddItem(List, Counter, "Frame Count",data->FrameCount); AddItem(List, Counter, "Frame Rate",data->FrameRate); } void ChunkTableClass::List_W3D_CHUNK_MATERIAL3_DC_MAP(ChunkItem *Item, CListCtrl *List) { List_Subitems(Item, List); } void ChunkTableClass::List_W3D_CHUNK_MATERIAL3_DI_MAP(ChunkItem *Item, CListCtrl *List) { List_Subitems(Item,List); } void ChunkTableClass::List_W3D_CHUNK_MATERIAL3_SC_MAP(ChunkItem *Item, CListCtrl *List) { List_Subitems(Item,List); } void ChunkTableClass::List_W3D_CHUNK_MATERIAL3_SI_MAP(ChunkItem *Item, CListCtrl *List) { List_Subitems(Item,List); } void ChunkTableClass::List_W3D_CHUNK_MESH_HEADER3(ChunkItem *Item, CListCtrl *List) { struct W3dMeshHeader3Struct *data; data = (W3dMeshHeader3Struct *) Item->Data; int Counter = 0; char buf[64]; sprintf(buf,"%d.%d",W3D_GET_MAJOR_VERSION(data->Version),W3D_GET_MINOR_VERSION(data->Version)); AddItem(List, Counter,"Version", buf); AddItem(List, Counter,"MeshName", data->MeshName); AddItem(List, Counter,"ContainerName", data->ContainerName); AddItem(List, Counter,"Attributes",data->Attributes); switch(data->Attributes & W3D_MESH_FLAG_GEOMETRY_TYPE_MASK) { case W3D_MESH_FLAG_GEOMETRY_TYPE_NORMAL: AddItem(List, Counter,"Attributes", "W3D_MESH_FLAG_GEOMETRY_TYPE_NORMAL_MESH","flag"); break; case W3D_MESH_FLAG_GEOMETRY_TYPE_CAMERA_ALIGNED: AddItem(List, Counter,"Attributes", "W3D_MESH_FLAG_GEOMETRY_TYPE_CAMERA_ALIGNED","flag"); break; case W3D_MESH_FLAG_GEOMETRY_TYPE_SKIN: AddItem(List, Counter,"Attributes", "W3D_MESH_FLAG_GEOMETRY_TYPE_SKIN","flag"); break; case W3D_MESH_FLAG_GEOMETRY_TYPE_AABOX: AddItem(List, Counter,"Attributes", "W3D_MESH_FLAG_GEOMETRY_TYPE_AABOX","flag"); break; case W3D_MESH_FLAG_GEOMETRY_TYPE_OBBOX: AddItem(List, Counter,"Attributes", "W3D_MESH_FLAG_GEOMETRY_TYPE_OBBOX","flag"); break; }; if (data->Attributes & W3D_MESH_FLAG_COLLISION_TYPE_PHYSICAL) AddItem(List, Counter,"Attributes", "W3D_MESH_FLAG_COLLISION_TYPE_PHYSICAL","flag"); if (data->Attributes & W3D_MESH_FLAG_COLLISION_TYPE_PROJECTILE) AddItem(List, Counter,"Attributes", "W3D_MESH_FLAG_COLLISION_TYPE_PROJECTILE","flag"); if (data->Attributes & W3D_MESH_FLAG_COLLISION_TYPE_VIS) AddItem(List, Counter,"Attributes", "W3D_MESH_FLAG_COLLISION_TYPE_VIS","flag"); if (data->Attributes & W3D_MESH_FLAG_COLLISION_TYPE_CAMERA) AddItem(List, Counter,"Attributes", "W3D_MESH_FLAG_COLLISION_TYPE_CAMERA","flag"); if (data->Attributes & W3D_MESH_FLAG_COLLISION_TYPE_VEHICLE) AddItem(List, Counter,"Attributes", "W3D_MESH_FLAG_COLLISION_TYPE_VEHICLE","flag"); if (data->Attributes & W3D_MESH_FLAG_HIDDEN) AddItem(List, Counter,"Attributes", "W3D_MESH_FLAG_HIDDEN","flag"); if (data->Attributes & W3D_MESH_FLAG_TWO_SIDED) AddItem(List, Counter,"Attributes", "W3D_MESH_FLAG_TWO_SIDED","flag"); if (data->Attributes & W3D_MESH_FLAG_CAST_SHADOW) AddItem(List, Counter,"Attributes", "W3D_MESH_FLAG_CAST_SHADOW"); if (data->Attributes & W3D_MESH_FLAG_SHATTERABLE) AddItem(List, Counter,"Attributes", "W3D_MESH_FLAG_SHATTERABLE"); if (data->Attributes & W3D_MESH_FLAG_NPATCHABLE) AddItem(List, Counter,"Attributes", "W3D_MESH_FLAG_NPATCHABLE"); if (data->Attributes & W3D_MESH_FLAG_PRELIT_UNLIT) AddItem(List, Counter,"Attributes", "W3D_MESH_FLAG_PRELIT_UNLIT","flag"); if (data->Attributes & W3D_MESH_FLAG_PRELIT_VERTEX) AddItem(List, Counter,"Attributes", "W3D_MESH_FLAG_PRELIT_VERTEX","flag"); if (data->Attributes & W3D_MESH_FLAG_PRELIT_LIGHTMAP_MULTI_PASS) AddItem(List, Counter,"Attributes", "W3D_MESH_FLAG_PRELIT_LIGHTMAP_MULTI_PASS","flag"); if (data->Attributes & W3D_MESH_FLAG_PRELIT_LIGHTMAP_MULTI_TEXTURE) AddItem(List, Counter,"Attributes", "W3D_MESH_FLAG_PRELIT_LIGHTMAP_MULTI_TEXTURE","flag"); AddItem(List, Counter,"NumTris", data->NumTris); AddItem(List, Counter,"NumVertices", data->NumVertices); AddItem(List, Counter,"NumMaterials", data->NumMaterials); AddItem(List, Counter,"NumDamageStages", data->NumDamageStages); if (data->SortLevel == SORT_LEVEL_NONE) { AddItem(List, Counter, "SortLevel", "NONE"); } else { AddItem(List, Counter, "SortLevel", (uint8)data->SortLevel); } if ((data->Attributes & W3D_MESH_FLAG_PRELIT_MASK) != 0x0) { if (data->PrelitVersion != 0) { sprintf (buf, "%d.%d", W3D_GET_MAJOR_VERSION (data->PrelitVersion), W3D_GET_MINOR_VERSION (data->PrelitVersion)); } else { sprintf (buf, "UNKNOWN"); } } else { sprintf (buf, "N/A"); } AddItem (List, Counter, "PrelitVersion", buf); AddItem(List, Counter, "FutureCounts", data->FutureCounts, 1); AddItem(List, Counter, "VertexChannels", data->VertexChannels); if (data->VertexChannels & W3D_VERTEX_CHANNEL_LOCATION) AddItem(List,Counter,"VertexChannels","W3D_VERTEX_CHANNEL_LOCATION","flag"); if (data->VertexChannels & W3D_VERTEX_CHANNEL_NORMAL) AddItem(List,Counter,"VertexChannels","W3D_VERTEX_CHANNEL_NORMAL","flag"); if (data->VertexChannels & W3D_VERTEX_CHANNEL_TEXCOORD) AddItem(List,Counter,"VertexChannels","W3D_VERTEX_CHANNEL_TEXCOORD","flag"); if (data->VertexChannels & W3D_VERTEX_CHANNEL_COLOR) AddItem(List,Counter,"VertexChannels","W3D_VERTEX_CHANNEL_COLOR","flag"); if (data->VertexChannels & W3D_VERTEX_CHANNEL_BONEID) AddItem(List,Counter,"VertexChannels","W3D_VERTEX_CHANNEL_BONEID","flag"); AddItem(List, Counter,"FaceChannels", data->FaceChannels); if (data->FaceChannels & W3D_FACE_CHANNEL_FACE) AddItem(List,Counter,"FaceChannels","W3D_FACE_CHANNEL_FACE","flag"); AddItem(List, Counter,"Min", &data->Min); AddItem(List, Counter,"Max", &data->Max); AddItem(List, Counter,"SphCenter", &data->SphCenter); AddItem(List, Counter,"SphRadius", data->SphRadius); } void ChunkTableClass::List_W3D_CHUNK_TRIANGLES(ChunkItem *Item, CListCtrl *List) { struct W3dTriStruct *data; data = (W3dTriStruct *) Item->Data; int Counter = 0; int index = 0; void *max = (char *) Item->Data + Item->Length; int counter = 0; char buf[256]; while(data < max) { sprintf(buf, "Triangle[%d].VertexIndices", counter); AddItem(List, Counter,buf, data->Vindex, 3); sprintf(buf, "Triangle[%d].Attributes", counter); AddItem(List, Counter,buf, data->Attributes); sprintf(buf, "Triangle[%d].Normal", counter); AddItem(List, Counter,buf, &data->Normal); sprintf(buf, "Triangle[%d].Dist", counter); AddItem(List, Counter,buf, data->Dist); counter++; data++; } } void ChunkTableClass::List_W3D_CHUNK_PER_TRI_MATERIALS(ChunkItem * Item,CListCtrl *List) { unsigned short *data; data = (unsigned short *) Item->Data; int Counter = 0; int index = 0; void *max = (char *) Item->Data + Item->Length; int counter = 0; char buf[256]; while(data < max) { sprintf(buf, "Triangle[%d].MaterialIdx", counter); AddItem(List, Counter,buf, *data); counter++; data++; } } void ChunkTableClass::List_W3D_CHUNK_VERTEX_SHADE_INDICES(ChunkItem * Item,CListCtrl *List) { uint32 * data = (uint32 *) Item->Data; int Counter = 0; int index = 0; void *max = (char *) Item->Data + Item->Length; int counter = 0; char buf[256]; while(data < max) { sprintf(buf, "Index[%d]", counter); AddItem(List, Counter, buf, *data); counter++; data++; } } void ChunkTableClass::List_W3D_CHUNK_MATERIAL_INFO(ChunkItem * Item,CListCtrl *List) { W3dMaterialInfoStruct * matinfo = (W3dMaterialInfoStruct *)Item->Data; int counter = 0; AddItem(List, counter,"PassCount", matinfo->PassCount); AddItem(List, counter,"VertexMaterialCount", matinfo->VertexMaterialCount); AddItem(List, counter,"ShaderCount", matinfo->ShaderCount); AddItem(List, counter,"TextureCount",matinfo->TextureCount); } void ChunkTableClass::List_W3D_CHUNK_VERTEX_MATERIALS(ChunkItem *Item,CListCtrl *List) { List_Subitems(Item,List); } void ChunkTableClass::List_W3D_CHUNK_VERTEX_MATERIAL(ChunkItem *Item,CListCtrl *List) { List_Subitems(Item,List); } void ChunkTableClass::List_W3D_CHUNK_VERTEX_MATERIAL_NAME(ChunkItem * Item,CListCtrl *List) { int Counter = 0; char * data = (char *)Item->Data; AddItem(List, Counter,"Material Name:", data); } void ChunkTableClass::List_W3D_CHUNK_VERTEX_MATERIAL_INFO(ChunkItem * Item,CListCtrl *List) { struct W3dVertexMaterialStruct *data = (W3dVertexMaterialStruct *)Item->Data; int Counter = 0; if (data->Attributes & W3DVERTMAT_USE_DEPTH_CUE) AddItem (List, Counter, "Material.Attributes", "W3DVERTMAT_USE_DEPTH_CUE", "flag"); if (data->Attributes & W3DVERTMAT_ARGB_EMISSIVE_ONLY) AddItem (List, Counter, "Material.Attributes", "W3DVERTMAT_ARGB_EMISSIVE_ONLY", "flag"); if (data->Attributes & W3DVERTMAT_COPY_SPECULAR_TO_DIFFUSE) AddItem (List, Counter, "Material.Attributes", "W3DVERTMAT_COPY_SPECULAR_TO_DIFFUSE", "flag"); if (data->Attributes & W3DVERTMAT_DEPTH_CUE_TO_ALPHA) AddItem (List, Counter, "Material.Attributes", "W3DVERTMAT_DEPTH_CUE_TO_ALPHA", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE0_MAPPING_MASK) == W3DVERTMAT_STAGE0_MAPPING_UV) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE0_MAPPING_UV", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE0_MAPPING_MASK) == W3DVERTMAT_STAGE0_MAPPING_ENVIRONMENT) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE0_MAPPING_ENVIRONMENT", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE0_MAPPING_MASK) == W3DVERTMAT_STAGE0_MAPPING_CHEAP_ENVIRONMENT) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE0_MAPPING_CHEAP_ENVIRONMENT", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE0_MAPPING_MASK) == W3DVERTMAT_STAGE0_MAPPING_SCREEN) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE0_MAPPING_SCREEN", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE0_MAPPING_MASK) == W3DVERTMAT_STAGE0_MAPPING_LINEAR_OFFSET) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE0_MAPPING_LINEAR_OFFSET", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE0_MAPPING_MASK) == W3DVERTMAT_STAGE0_MAPPING_SILHOUETTE) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE0_MAPPING_SILHOUETTE", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE0_MAPPING_MASK) == W3DVERTMAT_STAGE0_MAPPING_SCALE) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE0_MAPPING_SCALE", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE0_MAPPING_MASK) == W3DVERTMAT_STAGE0_MAPPING_GRID) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE0_MAPPING_GRID", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE0_MAPPING_MASK) == W3DVERTMAT_STAGE0_MAPPING_ROTATE) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE0_MAPPING_ROTATE", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE0_MAPPING_MASK) == W3DVERTMAT_STAGE0_MAPPING_SINE_LINEAR_OFFSET) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE0_MAPPING_SINE_LINEAR_OFFSET", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE0_MAPPING_MASK) == W3DVERTMAT_STAGE0_MAPPING_STEP_LINEAR_OFFSET) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE0_MAPPING_STEP_LINEAR_OFFSET", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE0_MAPPING_MASK) == W3DVERTMAT_STAGE0_MAPPING_ZIGZAG_LINEAR_OFFSET) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE0_MAPPING_ZIGZAG_LINEAR_OFFSET", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE0_MAPPING_MASK) == W3DVERTMAT_STAGE0_MAPPING_WS_CLASSIC_ENV) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE0_MAPPING_WS_CLASSIC_ENV", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE0_MAPPING_MASK) == W3DVERTMAT_STAGE0_MAPPING_WS_ENVIRONMENT) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE0_MAPPING_WS_ENVIRONMENT", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE0_MAPPING_MASK) == W3DVERTMAT_STAGE0_MAPPING_GRID_CLASSIC_ENV) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE0_MAPPING_GRID_CLASSIC_ENV", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE0_MAPPING_MASK) == W3DVERTMAT_STAGE0_MAPPING_GRID_ENVIRONMENT) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE0_MAPPING_GRID_ENVIRONMENT", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE0_MAPPING_MASK) == W3DVERTMAT_STAGE0_MAPPING_RANDOM) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE0_MAPPING_RANDOM", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE0_MAPPING_MASK) == W3DVERTMAT_STAGE0_MAPPING_BUMPENV) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE0_MAPPING_BUMPENV", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE1_MAPPING_MASK) == W3DVERTMAT_STAGE1_MAPPING_UV) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE1_MAPPING_UV", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE1_MAPPING_MASK) == W3DVERTMAT_STAGE1_MAPPING_ENVIRONMENT) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE1_MAPPING_ENVIRONMENT", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE1_MAPPING_MASK) == W3DVERTMAT_STAGE1_MAPPING_CHEAP_ENVIRONMENT) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE1_MAPPING_CHEAP_ENVIRONMENT", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE1_MAPPING_MASK) == W3DVERTMAT_STAGE1_MAPPING_SCREEN) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE1_MAPPING_SCREEN", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE1_MAPPING_MASK) == W3DVERTMAT_STAGE1_MAPPING_LINEAR_OFFSET) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE1_MAPPING_LINEAR_OFFSET", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE1_MAPPING_MASK) == W3DVERTMAT_STAGE1_MAPPING_SILHOUETTE) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE1_MAPPING_SILHOUETTE", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE1_MAPPING_MASK) == W3DVERTMAT_STAGE1_MAPPING_SCALE) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE1_MAPPING_SCALE", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE1_MAPPING_MASK) == W3DVERTMAT_STAGE1_MAPPING_GRID) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE1_MAPPING_GRID", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE1_MAPPING_MASK) == W3DVERTMAT_STAGE1_MAPPING_ROTATE) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE1_MAPPING_ROTATE", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE1_MAPPING_MASK) == W3DVERTMAT_STAGE1_MAPPING_SINE_LINEAR_OFFSET) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE1_MAPPING_SINE_LINEAR_OFFSET", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE1_MAPPING_MASK) == W3DVERTMAT_STAGE1_MAPPING_STEP_LINEAR_OFFSET) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE1_MAPPING_STEP_LINEAR_OFFSET", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE1_MAPPING_MASK) == W3DVERTMAT_STAGE1_MAPPING_ZIGZAG_LINEAR_OFFSET) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE1_MAPPING_ZIGZAG_LINEAR_OFFSET", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE1_MAPPING_MASK) == W3DVERTMAT_STAGE1_MAPPING_WS_CLASSIC_ENV) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE1_MAPPING_WS_CLASSIC_ENV", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE1_MAPPING_MASK) == W3DVERTMAT_STAGE1_MAPPING_WS_ENVIRONMENT) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE1_MAPPING_WS_ENVIRONMENT", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE1_MAPPING_MASK) == W3DVERTMAT_STAGE1_MAPPING_GRID_CLASSIC_ENV) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE1_MAPPING_GRID_CLASSIC_ENV", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE1_MAPPING_MASK) == W3DVERTMAT_STAGE1_MAPPING_GRID_ENVIRONMENT) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE1_MAPPING_GRID_ENVIRONMENT", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE1_MAPPING_MASK) == W3DVERTMAT_STAGE1_MAPPING_RANDOM) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE1_MAPPING_RANDOM", "flag"); if ((data->Attributes & W3DVERTMAT_STAGE1_MAPPING_MASK) == W3DVERTMAT_STAGE1_MAPPING_BUMPENV) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_STAGE1_MAPPING_BUMPENV", "flag"); if (data->Attributes & W3DVERTMAT_PSX_MASK) { if (data->Attributes & W3DVERTMAT_PSX_NO_RT_LIGHTING) { AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_PSX_NO_RT_LIGHTING", "flag"); } else { if ((data->Attributes & W3DVERTMAT_PSX_TRANS_MASK) == W3DVERTMAT_PSX_TRANS_NONE) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_PSX_TRANS_NONE", "flag"); if ((data->Attributes & W3DVERTMAT_PSX_TRANS_MASK) == W3DVERTMAT_PSX_TRANS_100) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_PSX_TRANS_100", "flag"); if ((data->Attributes & W3DVERTMAT_PSX_TRANS_MASK) == W3DVERTMAT_PSX_TRANS_50) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_PSX_TRANS_50", "flag"); if ((data->Attributes & W3DVERTMAT_PSX_TRANS_MASK) == W3DVERTMAT_PSX_TRANS_25) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_PSX_TRANS_25", "flag"); if ((data->Attributes & W3DVERTMAT_PSX_TRANS_MASK) == W3DVERTMAT_PSX_TRANS_MINUS_100) AddItem(List, Counter, "Material.Attributes", "W3DVERTMAT_PSX_TRANS_MINUS_100", "flag"); } } AddItem(List, Counter, "Material.Attributes", data->Attributes); AddItem(List, Counter, "Material.Ambient", &(data->Ambient)); AddItem(List, Counter, "Material.Diffuse", &(data->Diffuse)); AddItem(List, Counter, "Material.Specular", &(data->Specular)); AddItem(List, Counter, "Material.Emissive", &(data->Emissive)); AddItem(List, Counter, "Material.Shininess", data->Shininess); AddItem(List, Counter, "Material.Opacity", data->Opacity); AddItem(List, Counter, "Material.Translucency", data->Translucency); } void ChunkTableClass::List_W3D_CHUNK_VERTEX_MAPPER_ARGS0(ChunkItem *Item, CListCtrl *List) { int Counter = 0; char * data = (char *)Item->Data; AddItem(List, Counter, "Stage0 Mapper Args:", data); } void ChunkTableClass::List_W3D_CHUNK_VERTEX_MAPPER_ARGS1(ChunkItem *Item, CListCtrl *List) { int Counter = 0; char * data = (char *)Item->Data; AddItem(List, Counter, "Stage1 Mapper Args:", data); } void ChunkTableClass::List_W3D_CHUNK_SHADERS(ChunkItem * Item,CListCtrl *List) { struct W3dShaderStruct *shader = (W3dShaderStruct *)Item->Data; void *max = (char *)Item->Data + Item->Length; int counter = 0; char label[256]; while(shader < max) { sprintf(label,"shader[%d]",counter); int counter2 = 0; AddItem(List,counter2,label,shader); counter++; shader++; } } void ChunkTableClass::List_W3D_CHUNK_PS2_SHADERS(ChunkItem * Item,CListCtrl *List) { struct W3dPS2ShaderStruct *shader = (W3dPS2ShaderStruct *)Item->Data; void *max = (char *)Item->Data + Item->Length; int counter = 0; char label[256]; while(shader < max) { sprintf(label,"shader[%d]",counter); int counter2 = 0; AddItem(List,counter2,label,shader); counter++; shader++; } } void ChunkTableClass::List_W3D_CHUNK_TEXTURES(ChunkItem * Item,CListCtrl *List) { List_Subitems(Item,List); } void ChunkTableClass::List_W3D_CHUNK_TEXTURE(ChunkItem * Item,CListCtrl *List) { List_Subitems(Item,List); } void ChunkTableClass::List_W3D_CHUNK_TEXTURE_NAME(ChunkItem * Item,CListCtrl *List) { int Counter = 0; char * data = (char *)Item->Data; AddItem(List, Counter,"Texture Name:", data); } void ChunkTableClass::List_W3D_CHUNK_TEXTURE_INFO(ChunkItem * Item,CListCtrl *List) { struct W3dTextureInfoStruct *data = (W3dTextureInfoStruct *)Item->Data; int Counter = 0; AddItem(List, Counter, "Texture.Attributes", data->Attributes); if (data->Attributes & W3DTEXTURE_PUBLISH) AddItem(List, Counter,"Attributes", "W3DTEXTURE_PUBLISH","flag"); if (data->Attributes & W3DTEXTURE_NO_LOD) AddItem(List, Counter,"Attributes", "W3DTEXTURE_NO_LOD","flag"); if (data->Attributes & W3DTEXTURE_CLAMP_U) AddItem(List, Counter,"Attributes", "W3DTEXTURE_CLAMP_U","flag"); if (data->Attributes & W3DTEXTURE_CLAMP_V) AddItem(List, Counter,"Attributes", "W3DTEXTURE_CLAMP_V","flag"); if (data->Attributes & W3DTEXTURE_ALPHA_BITMAP) AddItem(List, Counter,"Attributes", "W3DTEXTURE_ALPHA_BITMAP","flag"); AddItem(List, Counter, "Texture.FrameCount", data->FrameCount); AddItem(List, Counter, "Texture.FrameRate", data->FrameRate); } void ChunkTableClass::List_W3D_CHUNK_MATERIAL_PASS(ChunkItem * Item,CListCtrl *List) { List_Subitems(Item,List); } void ChunkTableClass::List_W3D_CHUNK_VERTEX_MATERIAL_IDS(ChunkItem * Item,CListCtrl *List) { int Counter = 0; int counter = 0; uint32 *data = (uint32 *)Item->Data; void *max = (char *) Item->Data + Item->Length; char buf[256]; while(data < max) { sprintf(buf, "Vertex[%d] Vertex Material Index", counter); AddItem(List, Counter,buf, *data); counter++; data++; } } void ChunkTableClass::List_W3D_CHUNK_SHADER_IDS(ChunkItem * Item,CListCtrl *List) { int Counter = 0; int counter = 0; uint32 *data = (uint32 *)Item->Data; void *max = (char *) Item->Data + Item->Length; char buf[256]; while(data < max) { sprintf(buf, "Face[%d] Shader Index", counter); AddItem(List, Counter, buf, *data); counter++; data++; } } void ChunkTableClass::List_W3D_CHUNK_DCG(ChunkItem * Item,CListCtrl *List) { W3dRGBAStruct *data = (W3dRGBAStruct *) Item->Data; int Counter = 0; int index = 0; void *max = (char *) Item->Data + Item->Length; int counter = 0; char buf[256]; while(data < max) { sprintf(buf, "Vertex[%d].DCG", counter); AddItem(List, Counter,buf, data); counter++; data++; } } void ChunkTableClass::List_W3D_CHUNK_DIG(ChunkItem * Item,CListCtrl *List) { W3dRGBStruct *data = (W3dRGBStruct *)Item->Data; int Counter = 0; int index = 0; void *max = (char *) Item->Data + Item->Length; int counter = 0; char buf[256]; while(data < max) { sprintf(buf, "Vertex[%d].DIG", counter); AddItem(List, Counter,buf, data); counter++; data++; } } void ChunkTableClass::List_W3D_CHUNK_SCG(ChunkItem * Item,CListCtrl *List) { W3dRGBStruct *data = (W3dRGBStruct *)Item->Data; int Counter = 0; int index = 0; void *max = (char *) Item->Data + Item->Length; int counter = 0; char buf[256]; while(data < max) { sprintf(buf, "Vertex[%d].SCG", counter); AddItem(List, Counter,buf, data); counter++; data++; } } void ChunkTableClass::List_W3D_CHUNK_TEXTURE_STAGE(ChunkItem * Item,CListCtrl *List) { List_Subitems(Item,List); } void ChunkTableClass::List_W3D_CHUNK_TEXTURE_IDS(ChunkItem * Item,CListCtrl *List) { int Counter = 0; int counter = 0; uint32 *data = (uint32 *)Item->Data; void *max = (char *) Item->Data + Item->Length; char buf[256]; while(data < max) { sprintf(buf, "Face[%d] Texture Index", counter); AddItem(List, Counter, buf, *data); counter++; data++; } } void ChunkTableClass::List_W3D_CHUNK_STAGE_TEXCOORDS(ChunkItem * Item,CListCtrl *List) { W3dTexCoordStruct *data = (W3dTexCoordStruct *)Item->Data; int Counter = 0; int index = 0; void *max = (char *) Item->Data + Item->Length; int counter = 0; char buf[256]; while(data < max) { sprintf(buf, "Vertex[%d].UV", counter); AddItem(List, Counter, buf, data); counter++; data++; } } void ChunkTableClass::List_W3D_CHUNK_PER_FACE_TEXCOORD_IDS(ChunkItem * Item,CListCtrl *List) { int Counter = 0; int counter = 0; Vector3i *data = (Vector3i *)Item->Data; void *max = (char *) Item->Data + Item->Length; char buf[256]; while(data < max) { sprintf(buf, "Face[%d] UV Indices", counter); AddItem(List, Counter, buf, data); counter++; data++; } } void ChunkTableClass::List_W3D_CHUNK_AABTREE(ChunkItem * Item,CListCtrl *List) { List_Subitems(Item, List); } void ChunkTableClass::List_W3D_CHUNK_AABTREE_HEADER(ChunkItem * Item,CListCtrl *List) { W3dMeshAABTreeHeader * data = (W3dMeshAABTreeHeader*)Item->Data; int Counter = 0; AddItem(List, Counter, "NodeCount", data->NodeCount); AddItem(List, Counter, "PolyCount", data->PolyCount); } void ChunkTableClass::List_W3D_CHUNK_AABTREE_POLYINDICES(ChunkItem * Item,CListCtrl *List) { int Counter = 0; int counter = 0; uint32 *data = (uint32 *)Item->Data; void *max = (char *) Item->Data + Item->Length; char buf[256]; while(data < max) { sprintf(buf, "Polygon Index[%d]", counter); AddItem(List, Counter, buf, *data); counter++; data++; } } void ChunkTableClass::List_W3D_CHUNK_AABTREE_NODES(ChunkItem * Item,CListCtrl *List) { W3dMeshAABTreeNode * data = (W3dMeshAABTreeNode *)Item->Data; int Counter = 0; int index = 0; void *max = (char *)Item->Data + Item->Length; int counter = 0; char buf[256]; while(data < max) { sprintf(buf, "Node[%d].Min", counter); AddItem(List, Counter,buf, &data->Min); sprintf(buf, "Node[%d].Max", counter); AddItem(List, Counter,buf, &data->Max); if (data->FrontOrPoly0 & 0x80000000) { sprintf(buf, "Node[%d].Poly0",counter); AddItem(List, Counter, buf, data->FrontOrPoly0 & 0x7FFFFFFF); sprintf(buf, "Node[%d].PolyCount",counter); AddItem(List, Counter, buf, data->BackOrPolyCount); } else { sprintf(buf, "Node[%d].Front",counter); AddItem(List, Counter, buf, data->FrontOrPoly0); sprintf(buf, "Node[%d].Back",counter); AddItem(List, Counter, buf, data->BackOrPolyCount); } counter++; data++; } } void ChunkTableClass::List_W3D_CHUNK_HIERARCHY(ChunkItem *Item, CListCtrl *List) { List_Subitems(Item, List); } void ChunkTableClass::List_W3D_CHUNK_HIERARCHY_HEADER(ChunkItem *Item, CListCtrl *List) { struct W3dHierarchyStruct *data; data = (W3dHierarchyStruct *) Item->Data; int Counter = 0; char buf[64]; sprintf(buf,"%d.%d",W3D_GET_MAJOR_VERSION(data->Version),W3D_GET_MINOR_VERSION(data->Version)); AddItem(List, Counter,"Version", buf); AddItem(List, Counter, "Name", data->Name); AddItem(List, Counter, "NumPivots", data->NumPivots); AddItem(List, Counter, "Center", &data->Center); } void ChunkTableClass::List_W3D_CHUNK_PIVOTS(ChunkItem *Item, CListCtrl *List) { struct W3dPivotStruct *data; data = (W3dPivotStruct *) Item->Data; int Counter = 0; int index = 0; void *max = (char *) Item->Data + Item->Length; int counter = 0; char buf[256]; while(data < max) { sprintf(buf, "Pivot[%d].Name", counter); AddItem(List, Counter,buf, data->Name); sprintf(buf, "Pivot[%d].ParentIdx", counter); AddItem(List, Counter,buf, data->ParentIdx); sprintf(buf, "Pivot[%d].Translation", counter); AddItem(List, Counter,buf, &data->Translation); sprintf(buf, "Pivot[%d].EulerAngles", counter); AddItem(List, Counter,buf, &data->EulerAngles); sprintf(buf, "Pivot[%d].Rotation", counter); AddItem(List, Counter,buf, &data->Rotation); counter++; data++; } } void ChunkTableClass::List_W3D_CHUNK_PIVOT_FIXUPS(ChunkItem *Item, CListCtrl *List) { W3dPivotFixupStruct *data = (W3dPivotFixupStruct *) Item->Data; int Counter = 0; int pivot_counter = 0; while ((char*)data < (char*)Item->Data + Item->Length) { char tmp[256]; for (int i=0;i<4;i++) { sprintf(tmp,"Transform %d, Row[%d]", pivot_counter,i); AddItem(List, Counter, tmp, data->TM[i], 3); } data++; pivot_counter++; } } void ChunkTableClass::List_W3D_CHUNK_ANIMATION(ChunkItem *Item, CListCtrl *List) { List_Subitems(Item, List); } void ChunkTableClass::List_W3D_CHUNK_ANIMATION_HEADER(ChunkItem *Item, CListCtrl *List) { W3dAnimHeaderStruct *data = (W3dAnimHeaderStruct *) Item->Data; int Counter = 0; char buf[64]; sprintf(buf,"%d.%d",W3D_GET_MAJOR_VERSION(data->Version),W3D_GET_MINOR_VERSION(data->Version)); AddItem(List, Counter,"Version", buf); AddItem(List, Counter, "Name", data->Name); AddItem(List, Counter, "HierarchyName", data->HierarchyName); AddItem(List, Counter, "NumFrames", data->NumFrames); AddItem(List, Counter, "FrameRate", data->FrameRate); } void ChunkTableClass::List_W3D_CHUNK_ANIMATION_CHANNEL(ChunkItem *Item, CListCtrl *List) { static char * _chntypes[] = { "X Translation", "Y Translation", "Z Translation", "X Rotation", "Y Rotation", "Z Rotation", "Quaternion" }; W3dAnimChannelStruct *data = (W3dAnimChannelStruct *) Item->Data; int Counter = 0; AddItem(List, Counter, "FirstFrame", data->FirstFrame); AddItem(List, Counter, "LastFrame", data->LastFrame); if ((data->Flags >= ANIM_CHANNEL_X)&&(data->Flags <= ANIM_CHANNEL_Q)) { AddItem(List, Counter, "ChannelType",_chntypes[data->Flags]); } else { AddItem(List, Counter, "ChannelType",data->Flags); } AddItem(List, Counter, "Pivot", data->Pivot); AddItem(List, Counter, "VectorLen", data->VectorLen); CString name; for (int frameidx=0; frameidx <= data->LastFrame - data->FirstFrame; frameidx++) { for (int vidx = 0; vidx < data->VectorLen; vidx++) { name.Format("Data[%d][%d]", frameidx, vidx); AddItem(List, Counter, name, data->Data[frameidx * data->VectorLen + vidx]); } } } void ChunkTableClass::List_W3D_CHUNK_BIT_CHANNEL(ChunkItem *Item, CListCtrl *List) { static char * _chntypes[] = { "Visibility", }; W3dBitChannelStruct *data = (W3dBitChannelStruct *) Item->Data; int Counter = 0; unsigned char * bits = &(data->Data[0]); AddItem(List, Counter, "FirstFrame", data->FirstFrame); AddItem(List, Counter, "LastFrame", data->LastFrame); if ((data->Flags >= BIT_CHANNEL_VIS)&&(data->Flags <= BIT_CHANNEL_VIS)) { AddItem(List, Counter, "ChannelType",_chntypes[data->Flags]); } else { AddItem(List, Counter, "ChannelType",data->Flags); } AddItem(List, Counter, "Pivot", data->Pivot); AddItem(List, Counter, "Default Value", data->DefaultVal); CString name; for (int frameidx=0; frameidx <= data->LastFrame - data->FirstFrame; frameidx++) { name.Format("Data[%d]",frameidx + data->FirstFrame); AddItem(List, Counter, name, (uint8)Get_Bit(bits,frameidx)); } } void ChunkTableClass::List_W3D_CHUNK_HMODEL(ChunkItem *Item, CListCtrl *List) { List_Subitems(Item, List); } void ChunkTableClass::List_W3D_CHUNK_HMODEL_HEADER(ChunkItem *Item, CListCtrl *List) { W3dHModelHeaderStruct *data = (W3dHModelHeaderStruct *) Item->Data; int Counter = 0; char buf[64]; sprintf(buf,"%d.%d",W3D_GET_MAJOR_VERSION(data->Version),W3D_GET_MINOR_VERSION(data->Version)); AddItem(List, Counter,"Version", buf); AddItem(List, Counter, "Name", data->Name); AddItem(List, Counter, "HierarchyName", data->HierarchyName); AddItem(List, Counter, "NumConnections", data->NumConnections); } void ChunkTableClass::List_W3D_CHUNK_NODE(ChunkItem *Item, CListCtrl *List) { W3dHModelNodeStruct *data = (W3dHModelNodeStruct *) Item->Data; int Counter = 0; AddItem(List, Counter, "RenderObjName", data->RenderObjName); AddItem(List, Counter, "PivotIdx", data->PivotIdx); } void ChunkTableClass::List_W3D_CHUNK_COLLISION_NODE(ChunkItem *Item, CListCtrl *List) { W3dHModelNodeStruct *data = (W3dHModelNodeStruct *) Item->Data; int Counter = 0; AddItem(List, Counter, "CollisionMeshName", data->RenderObjName); AddItem(List, Counter, "PivotIdx", data->PivotIdx); } void ChunkTableClass::List_W3D_CHUNK_SKIN_NODE(ChunkItem *Item, CListCtrl *List) { W3dHModelNodeStruct *data = (W3dHModelNodeStruct *) Item->Data; int Counter = 0; AddItem(List, Counter, "SkinMeshName", data->RenderObjName); AddItem(List, Counter, "PivotIdx", data->PivotIdx); } void ChunkTableClass::List_W3D_CHUNK_HMODEL_AUX_DATA(ChunkItem *Item, CListCtrl *List) { W3dHModelAuxDataStruct *data = (W3dHModelAuxDataStruct *) Item->Data; int Counter = 0; AddItem(List, Counter, "Attributes", data->Attributes); AddItem(List, Counter, "MeshCount", data->MeshCount); AddItem(List, Counter, "CollisionCount", data->CollisionCount); AddItem(List, Counter, "SkinCount", data->SkinCount); AddItem(List, Counter, "FutureCounts", data->FutureCounts, 8); AddItem(List, Counter, "LODMin", data->LODMin); AddItem(List, Counter, "LODMax", data->LODMax); AddItem(List, Counter, "FutureUse", data->FutureUse, 32); } void ChunkTableClass::List_W3D_CHUNK_SHADOW_NODE(ChunkItem *Item, CListCtrl *List) { W3dHModelNodeStruct *data = (W3dHModelNodeStruct *) Item->Data; int Counter = 0; AddItem(List, Counter, "ShadowMeshName", data->RenderObjName); AddItem(List, Counter, "PivotIdx", data->PivotIdx); } void ChunkTableClass::List_W3D_CHUNK_LODMODEL(ChunkItem *Item, CListCtrl *List) { List_Subitems(Item, List); } void ChunkTableClass::List_W3D_CHUNK_LODMODEL_HEADER(ChunkItem *Item, CListCtrl *List) { W3dLODModelHeaderStruct *data = (W3dLODModelHeaderStruct *) Item->Data; int Counter = 0; char buf[64]; sprintf(buf,"%d.%d",W3D_GET_MAJOR_VERSION(data->Version),W3D_GET_MINOR_VERSION(data->Version)); AddItem(List, Counter,"Version", buf); AddItem(List, Counter, "Name", data->Name); AddItem(List, Counter, "NumLODs", data->NumLODs); } void ChunkTableClass::List_W3D_CHUNK_LOD(ChunkItem * Item,CListCtrl * List) { W3dLODStruct *data = (W3dLODStruct *) Item->Data; int Counter = 0; AddItem(List, Counter, "Render Object Name", data->RenderObjName); AddItem(List, Counter, "LOD Min Distance", data->LODMin); AddItem(List, Counter, "LOD Max Distance", data->LODMax); } void ChunkTableClass::List_W3D_CHUNK_COLLECTION(ChunkItem * Item,CListCtrl * List) { List_Subitems(Item, List); } void ChunkTableClass::List_W3D_CHUNK_COLLECTION_HEADER(ChunkItem * Item,CListCtrl * List) { W3dCollectionHeaderStruct *data = (W3dCollectionHeaderStruct *) Item->Data; int Counter = 0; char buf[64]; sprintf(buf,"%d.%d",W3D_GET_MAJOR_VERSION(data->Version),W3D_GET_MINOR_VERSION(data->Version)); AddItem(List, Counter,"Version", buf); AddItem(List, Counter, "Name", data->Name); AddItem(List, Counter, "RenderObjectCount", data->RenderObjectCount); } void ChunkTableClass::List_W3D_CHUNK_COLLECTION_OBJ_NAME(ChunkItem * Item,CListCtrl * List) { char * name = (char *)Item->Data; int Counter = 0; AddItem(List,Counter,"Render Object Name",name); } void ChunkTableClass::List_W3D_CHUNK_PLACEHOLDER(ChunkItem * Item,CListCtrl * List) { W3dPlaceholderStruct * data = (W3dPlaceholderStruct *)(Item->Data); int Counter = 0; AddItemVersion(List,Counter,data->version); AddItem(List,Counter,"Transform",&(data->transform[0][0]),3); AddItem(List,Counter,"Transform",&(data->transform[1][0]),3); AddItem(List,Counter,"Transform",&(data->transform[2][0]),3); AddItem(List,Counter,"Transform",&(data->transform[3][0]),3); AddItem(List,Counter,"Name",(char *)(data + 1)); } void ChunkTableClass::List_W3D_CHUNK_TRANSFORM_NODE(ChunkItem * Item,CListCtrl * List) { W3dTransformNodeStruct * data = (W3dTransformNodeStruct *)(Item->Data); int Counter = 0; AddItemVersion(List,Counter,data->version); AddItem(List,Counter,"Transform",&(data->transform[0][0]),3); AddItem(List,Counter,"Transform",&(data->transform[1][0]),3); AddItem(List,Counter,"Transform",&(data->transform[2][0]),3); AddItem(List,Counter,"Transform",&(data->transform[3][0]),3); AddItem(List,Counter,"Name",(char *)(data + 1)); } void ChunkTableClass::List_W3D_CHUNK_POINTS(ChunkItem * Item,CListCtrl * List) { W3dVectorStruct *data; data = (W3dVectorStruct *) Item->Data; int Counter = 0; void *max = (char *) Item->Data + Item->Length; int counter = 0; char buf[256]; while (data < max) { sprintf(buf, "Point[%d]", counter++); AddItem(List, Counter,buf, data); data++; } } void ChunkTableClass::List_W3D_CHUNK_LIGHT(ChunkItem * Item,CListCtrl * List) { List_Subitems(Item, List); } void ChunkTableClass::List_W3D_CHUNK_LIGHT_INFO(ChunkItem * Item,CListCtrl * List) { W3dLightStruct * data = (W3dLightStruct *)Item->Data; int counter = 0; if ((data->Attributes & W3D_LIGHT_ATTRIBUTE_TYPE_MASK) == W3D_LIGHT_ATTRIBUTE_POINT) AddItem (List, counter, "Attributes", "W3D_LIGHT_ATTRIBUTE_POINT"); if ((data->Attributes & W3D_LIGHT_ATTRIBUTE_TYPE_MASK) == W3D_LIGHT_ATTRIBUTE_SPOT) AddItem (List, counter, "Attributes", "W3D_LIGHT_ATTRIBUTE_SPOT"); if ((data->Attributes & W3D_LIGHT_ATTRIBUTE_TYPE_MASK) == W3D_LIGHT_ATTRIBUTE_DIRECTIONAL) AddItem (List, counter, "Attributes", "W3D_LIGHT_ATTRIBUTE_DIRECTIONAL"); if (data->Attributes & W3D_LIGHT_ATTRIBUTE_CAST_SHADOWS) AddItem (List, counter, "Attributes", "W3D_LIGHT_ATTRIBUTE_CAST_SHADOWS", "flag"); AddItem(List,counter,"Ambient",&(data->Ambient),1); AddItem(List,counter,"Diffuse",&(data->Diffuse),1); AddItem(List,counter,"Specular",&(data->Specular),1); AddItem(List,counter,"Intensity",data->Intensity); } void ChunkTableClass::List_W3D_CHUNK_SPOT_LIGHT_INFO(ChunkItem * Item,CListCtrl * List) { W3dSpotLightStruct * data = (W3dSpotLightStruct*)Item->Data; int counter = 0; AddItem(List,counter,"SpotDirection",&(data->SpotDirection)); AddItem(List,counter,"SpotAngle",data->SpotAngle); AddItem(List,counter,"SpotExponent",data->SpotExponent); } void ChunkTableClass::List_W3D_CHUNK_NEAR_ATTENUATION(ChunkItem * Item,CListCtrl * List) { W3dLightAttenuationStruct * data = (W3dLightAttenuationStruct *)Item->Data; int counter = 0; AddItem(List,counter,"Near Atten Start",data->Start); AddItem(List,counter,"Near Atten End",data->End); } void ChunkTableClass::List_W3D_CHUNK_FAR_ATTENUATION(ChunkItem * Item,CListCtrl * List) { W3dLightAttenuationStruct * data = (W3dLightAttenuationStruct *)Item->Data; int counter = 0; AddItem(List,counter,"Far Atten Start",data->Start); AddItem(List,counter,"Far Atten End",data->End); } void ChunkTableClass::List_W3D_CHUNK_EMITTER(ChunkItem * Item,CListCtrl * List) { List_Subitems(Item, List); } void ChunkTableClass::List_W3D_CHUNK_EMITTER_HEADER(ChunkItem * Item,CListCtrl * List) { W3dEmitterHeaderStruct * data = (W3dEmitterHeaderStruct*)Item->Data; int counter = 0; AddItem(List,counter,"Version",data->Version); AddItem(List,counter,"Name",data->Name); } void ChunkTableClass::List_W3D_CHUNK_EMITTER_USER_DATA(ChunkItem * Item,CListCtrl * List) { char * data = (char *)Item->Data; int counter = 0; AddItem(List,counter,"User Data",data); } void ChunkTableClass::List_W3D_CHUNK_EMITTER_INFO(ChunkItem * Item,CListCtrl * List) { W3dEmitterInfoStruct * data = (W3dEmitterInfoStruct *)Item->Data; int counter = 0; AddItem(List,counter,"Texture Name",data->TextureFilename); AddItem(List,counter,"StartSize", data->StartSize); AddItem(List,counter,"EndSize",data->EndSize); AddItem(List,counter,"Lifetime",data->Lifetime); AddItem(List,counter,"EmissionRate",data->EmissionRate); AddItem(List,counter,"MaxEmissions",data->MaxEmissions); AddItem(List,counter,"VelocityRandom",data->VelocityRandom); AddItem(List,counter,"PositionRandom",data->PositionRandom); AddItem(List,counter,"FadeTime",data->FadeTime); AddItem(List,counter,"Gravity",data->Gravity); AddItem(List,counter,"Elasticity",data->Elasticity); AddItem(List,counter,"Velocity",&(data->Velocity)); AddItem(List,counter,"Acceleration",&(data->Acceleration)); AddItem(List,counter,"StartColor",&(data->StartColor)); AddItem(List,counter,"EndColor",&(data->EndColor)); } void ChunkTableClass::List_W3D_CHUNK_EMITTER_INFOV2(ChunkItem * Item,CListCtrl * List) { W3dEmitterInfoStructV2 * data = (W3dEmitterInfoStructV2 *)(Item->Data); int counter = 0; AddItem(List,counter,"BurstSize",data->BurstSize); AddItem(List,counter,"CreationVolume.ClassID",data->CreationVolume.ClassID); AddItem(List,counter,"CreationVolume.Value1",data->CreationVolume.Value1); AddItem(List,counter,"CreationVolume.Value2",data->CreationVolume.Value2); AddItem(List,counter,"CreationVolume.Value3",data->CreationVolume.Value3); AddItem(List,counter,"VelRandom.ClassID",data->VelRandom.ClassID); AddItem(List,counter,"VelRandom.Value1",data->VelRandom.Value1); AddItem(List,counter,"VelRandom.Value2",data->VelRandom.Value2); AddItem(List,counter,"VelRandom.Value3",data->VelRandom.Value3); AddItem(List,counter,"OutwardVel",data->OutwardVel); AddItem(List,counter,"VelInherit",data->VelInherit); AddItem(List,counter,"Shader",&(data->Shader)); AddItem(List,counter,"RenderMode",data->RenderMode); } void ChunkTableClass::List_W3D_CHUNK_EMITTER_PROPS(ChunkItem * Item,CListCtrl * List) { W3dEmitterPropertyStruct * data = (W3dEmitterPropertyStruct *)(Item->Data); int counter = 0; AddItem(List,counter,"ColorKeyframes",data->ColorKeyframes); AddItem(List,counter,"OpacityKeyframes",data->OpacityKeyframes); AddItem(List,counter,"SizeKeyframes",data->SizeKeyframes); AddItem(List,counter,"ColorRandom",&(data->ColorRandom)); AddItem(List,counter,"OpacityRandom",data->OpacityRandom); AddItem(List,counter,"SizeRandom",data->SizeRandom); } void ChunkTableClass::List_W3D_CHUNK_EMITTER_COLOR_KEYFRAME(ChunkItem * Item,CListCtrl * List) { W3dEmitterColorKeyframeStruct * data = (W3dEmitterColorKeyframeStruct *)(Item->Data); int counter = 0; AddItem(List,counter,"Time",data->Time); AddItem(List,counter,"Color",&(data->Color)); } void ChunkTableClass::List_W3D_CHUNK_EMITTER_OPACITY_KEYFRAME(ChunkItem * Item,CListCtrl * List) { W3dEmitterOpacityKeyframeStruct * data = (W3dEmitterOpacityKeyframeStruct *)(Item->Data); int counter = 0; AddItem(List,counter,"Time",data->Time); AddItem(List,counter,"Opacity",data->Opacity); } void ChunkTableClass::List_W3D_CHUNK_EMITTER_SIZE_KEYFRAME(ChunkItem * Item,CListCtrl * List) { W3dEmitterSizeKeyframeStruct * data = (W3dEmitterSizeKeyframeStruct *)(Item->Data); int counter = 0; AddItem(List,counter,"Time",data->Time); AddItem(List,counter,"Size",data->Size); } void ChunkTableClass::List_W3D_CHUNK_EMITTER_ROTATION_KEYFRAMES(ChunkItem * Item,CListCtrl * List) { W3dEmitterRotationHeaderStruct * header = (W3dEmitterRotationHeaderStruct*)(Item->Data); int counter = 0; AddItem(List,counter,"KeyframeCount",header->KeyframeCount); AddItem(List,counter,"Random",header->Random); W3dEmitterRotationKeyframeStruct * key = (W3dEmitterRotationKeyframeStruct *)((char*)Item->Data + sizeof(W3dEmitterRotationHeaderStruct)); char buf[256]; for (unsigned int i=0; iKeyframeCount+1; i++) { sprintf(buf,"Time[%d]",i); AddItem(List,counter,buf,key[i].Time); sprintf(buf,"Rotation[%d]",i); AddItem(List,counter,buf,key[i].Rotation); } } void ChunkTableClass::List_W3D_CHUNK_EMITTER_FRAME_KEYFRAMES(ChunkItem * Item,CListCtrl * List) { W3dEmitterFrameHeaderStruct * header = (W3dEmitterFrameHeaderStruct*)(Item->Data); int counter = 0; AddItem(List,counter,"KeyframeCount",header->KeyframeCount); AddItem(List,counter,"Random",header->Random); W3dEmitterFrameKeyframeStruct * key = (W3dEmitterFrameKeyframeStruct *)((char *)Item->Data + sizeof(W3dEmitterFrameHeaderStruct)); char buf[256]; for (unsigned int i=0; iKeyframeCount+1; i++) { sprintf(buf,"Time[%d]",i); AddItem(List,counter,buf,key[i].Time); sprintf(buf,"Frame[%d]",i); AddItem(List,counter,buf,key[i].Frame); } } void ChunkTableClass::List_W3D_CHUNK_EMITTER_BLUR_TIME_KEYFRAMES(ChunkItem * Item,CListCtrl * List) { W3dEmitterBlurTimeHeaderStruct * header = (W3dEmitterBlurTimeHeaderStruct*)(Item->Data); int counter = 0; AddItem(List,counter,"KeyframeCount",header->KeyframeCount); AddItem(List,counter,"Random",header->Random); W3dEmitterBlurTimeKeyframeStruct * key = (W3dEmitterBlurTimeKeyframeStruct *)((char *)Item->Data + sizeof(W3dEmitterBlurTimeHeaderStruct)); char buf[256]; for (unsigned int i=0; iKeyframeCount+1; i++) { sprintf(buf,"Time[%d]",i); AddItem(List,counter,buf,key[i].Time); sprintf(buf,"BlurTime[%d]",i); AddItem(List,counter,buf,key[i].BlurTime); } } void ChunkTableClass::List_W3D_CHUNK_AGGREGATE(ChunkItem * Item,CListCtrl * List) { List_Subitems(Item, List); } void ChunkTableClass::List_W3D_CHUNK_AGGREGATE_HEADER(ChunkItem * Item,CListCtrl * List) { W3dAggregateHeaderStruct * data = (W3dAggregateHeaderStruct*)Item->Data; int counter = 0; AddItem(List,counter,"Version",data->Version); AddItem(List,counter,"Name",data->Name); } void ChunkTableClass::List_W3D_CHUNK_AGGREGATE_INFO(ChunkItem * Item,CListCtrl * List) { W3dAggregateInfoStruct * info = (W3dAggregateInfoStruct *)Item->Data; int counter = 0; AddItem(List,counter,"BaseModelName",info->BaseModelName); AddItem(List,counter,"SubobjectCount",info->SubobjectCount); char label[256]; W3dAggregateSubobjectStruct * defs = (W3dAggregateSubobjectStruct *)((char*)Item->Data + sizeof(W3dAggregateInfoStruct)); for (unsigned int subobj=0; subobjSubobjectCount; subobj++) { counter = 0; sprintf(label,"SubObject[%d].SubobjectName",subobj); AddItem(List,counter,label,defs[subobj].SubobjectName); sprintf(label,"SubObject[%d].BoneName",subobj); AddItem(List,counter,label,defs[subobj].BoneName); } } void ChunkTableClass::List_W3D_CHUNK_TEXTURE_REPLACER_INFO(ChunkItem * Item,CListCtrl * List) { W3dTextureReplacerHeaderStruct * header = (W3dTextureReplacerHeaderStruct *)(Item->Data); int counter = 0; AddItem(List,counter,"ReplacedTexturesCount",header->ReplacedTexturesCount); W3dTextureReplacerStruct * data = (W3dTextureReplacerStruct *)(header + 1); for (uint32 replaceidx=0; replaceidxReplacedTexturesCount; replaceidx++) { int pathidx = 0; char label[256]; for (pathidx=0; pathidxMeshPath[pathidx]); } for (pathidx=0; pathidxBonePath[pathidx]); } AddItem(List,counter,"OldTextureName",data->OldTextureName); AddItem(List,counter,"NewTextureName",data->NewTextureName); AddItem(List,counter,"TextureParams.Attributes", data->TextureParams.Attributes); AddItem(List,counter,"TextureParams.FrameCount", data->TextureParams.FrameCount); AddItem(List,counter,"TextureParams.FrameRate", data->TextureParams.FrameRate); data++; } } void ChunkTableClass::List_W3D_CHUNK_AGGREGATE_CLASS_INFO(ChunkItem * Item,CListCtrl * List) { W3dAggregateMiscInfo * data = (W3dAggregateMiscInfo *)(Item->Data); int counter = 0; AddItem(List,counter,"OriginalClassID",data->OriginalClassID); AddItem(List,counter,"Flags",data->Flags); } void ChunkTableClass::List_W3D_CHUNK_HLOD(ChunkItem * Item,CListCtrl * List) { List_Subitems(Item, List); } void ChunkTableClass::List_W3D_CHUNK_HLOD_HEADER(ChunkItem * Item,CListCtrl * List) { W3dHLodHeaderStruct * header = (W3dHLodHeaderStruct *)Item->Data; int counter = 0; AddItem(List,counter,"Version",header->Version); AddItem(List,counter,"LodCount", header->LodCount); AddItem(List,counter,"Name",header->Name); AddItem(List,counter,"HTree Name", header->HierarchyName); } void ChunkTableClass::List_W3D_CHUNK_HLOD_LOD_ARRAY(ChunkItem * Item,CListCtrl * List) { List_Subitems(Item, List); } void ChunkTableClass::List_W3D_CHUNK_HLOD_LOD_ARRAY_HEADER(ChunkItem * Item,CListCtrl * List) { W3dHLodArrayHeaderStruct * header = (W3dHLodArrayHeaderStruct *)Item->Data; int counter = 0; AddItem(List,counter,"ModelCount",header->ModelCount); AddItem(List,counter,"MaxScreenSize",header->MaxScreenSize); } void ChunkTableClass::List_W3D_CHUNK_HLOD_SUB_OBJECT(ChunkItem * Item,CListCtrl * List) { W3dHLodSubObjectStruct * data = (W3dHLodSubObjectStruct *)Item->Data; int counter = 0; AddItem(List,counter,"Name",data->Name); AddItem(List,counter,"BoneIndex",data->BoneIndex); } void ChunkTableClass::List_W3D_CHUNK_BOX(ChunkItem * Item,CListCtrl * List) { W3dBoxStruct * box = (W3dBoxStruct *)Item->Data; int counter = 0; AddItem(List,counter,"Version",box->Version); AddItem(List,counter,"Attributes",box->Attributes); if (box->Attributes & W3D_BOX_ATTRIBUTE_ORIENTED) { AddItem(List,counter,"Attributes","W3D_BOX_ATTRIBUTE_ORIENTED","flag"); } if (box->Attributes & W3D_BOX_ATTRIBUTE_ALIGNED) { AddItem(List,counter,"Attributes","W3D_BOX_ATTRIBUTE_ALIGNED","flag"); } if (box->Attributes & W3D_BOX_ATTRIBTUE_COLLISION_TYPE_PHYSICAL) { AddItem(List,counter,"Attributes","W3D_BOX_ATTRIBTUE_COLLISION_TYPE_PHYSICAL","flag"); } if (box->Attributes & W3D_BOX_ATTRIBTUE_COLLISION_TYPE_PROJECTILE) { AddItem(List,counter,"Attributes","W3D_BOX_ATTRIBTUE_COLLISION_TYPE_PROJECTILE","flag"); } if (box->Attributes & W3D_BOX_ATTRIBTUE_COLLISION_TYPE_VIS) { AddItem(List,counter,"Attributes","W3D_BOX_ATTRIBTUE_COLLISION_TYPE_VIS","flag"); } if (box->Attributes & W3D_BOX_ATTRIBTUE_COLLISION_TYPE_CAMERA) { AddItem(List,counter,"Attributes","W3D_BOX_ATTRIBTUE_COLLISION_TYPE_CAMERA","flag"); } if (box->Attributes & W3D_BOX_ATTRIBTUE_COLLISION_TYPE_VEHICLE) { AddItem(List,counter,"Attributes","W3D_BOX_ATTRIBTUE_COLLISION_TYPE_VEHICLE","flag"); } AddItem(List,counter,"Name",box->Name); AddItem(List,counter,"Color",&(box->Color)); AddItem(List,counter,"Center",&(box->Center)); AddItem(List,counter,"Extent",&(box->Extent)); } void ChunkTableClass::List_W3D_CHUNK_NULL_OBJECT(ChunkItem * Item,CListCtrl * List) { W3dNullObjectStruct * null = (W3dNullObjectStruct *)Item->Data; int counter = 0; AddItemVersion(List,counter,null->Version); AddItem(List,counter,"Attributes",null->Attributes); // No attributes are currently used AddItem(List,counter,"Name",null->Name); } void ChunkTableClass::List_W3D_CHUNK_PRELIT_UNLIT(ChunkItem *Item, CListCtrl *List) { List_Subitems(Item, List); } void ChunkTableClass::List_W3D_CHUNK_PRELIT_VERTEX(ChunkItem *Item, CListCtrl *List) { List_Subitems(Item, List); } void ChunkTableClass::List_W3D_CHUNK_PRELIT_LIGHTMAP_MULTI_PASS(ChunkItem *Item, CListCtrl *List) { List_Subitems(Item, List); } void ChunkTableClass::List_W3D_CHUNK_PRELIT_LIGHTMAP_MULTI_TEXTURE(ChunkItem *Item, CListCtrl *List) { List_Subitems(Item, List); } void ChunkTableClass::List_W3D_CHUNK_LIGHTSCAPE(ChunkItem *Item, CListCtrl *List) { List_Subitems(Item, List); } void ChunkTableClass::List_W3D_CHUNK_LIGHTSCAPE_LIGHT(ChunkItem *Item, CListCtrl *List) { List_Subitems(Item, List); } void ChunkTableClass::List_W3D_CHUNK_LIGHT_TRANSFORM(ChunkItem *Item, CListCtrl *List) { W3dLightTransformStruct *data = (W3dLightTransformStruct*) (Item->Data); int counter = 0; AddItem (List, counter, "Transform", &(data->Transform [0][0]), 4); AddItem (List, counter, "Transform", &(data->Transform [1][0]), 4); AddItem (List, counter, "Transform", &(data->Transform [2][0]), 4); } void ChunkTableClass::List_W3D_CHUNK_DAZZLE(ChunkItem *Item, CListCtrl *List) { List_Subitems(Item, List); } void ChunkTableClass::List_W3D_CHUNK_DAZZLE_NAME(ChunkItem *Item, CListCtrl *List) { int counter = 0; AddItem (List, counter, "Dazzle Name", (char *)(Item->Data)); } void ChunkTableClass::List_W3D_CHUNK_DAZZLE_TYPENAME(ChunkItem *Item, CListCtrl *List) { int counter = 0; AddItem (List, counter, "Dazzle Type Name", (char *)(Item->Data)); } ChunkTableClass::ChunkTableClass() { NewType( W3D_CHUNK_MESH, "CHUNK_MESH", List_W3D_CHUNK_MESH, true); NewType( W3D_CHUNK_MESH_HEADER, "W3D_CHUNK_MESH_HEADER", List_W3D_CHUNK_MESH_HEADER); NewType( W3D_CHUNK_VERTICES, "W3D_CHUNK_VERTICES", List_W3D_CHUNK_VERTICES); NewType( W3D_CHUNK_VERTEX_NORMALS, "W3D_CHUNK_VERTEX_NORMALS", List_W3D_CHUNK_VERTEX_NORMALS); NewType( W3D_CHUNK_SURRENDER_NORMALS, "W3D_CHUNK_SURRENDER_NORMALS", List_W3D_CHUNK_SURRENDER_NORMALS); NewType( W3D_CHUNK_TEXCOORDS, "W3D_CHUNK_TEXCOORDS", List_W3D_CHUNK_TEXCOORDS); NewType( O_W3D_CHUNK_MATERIALS, "O_W3D_CHUNK_MATERIALS", List_O_W3D_CHUNK_MATERIALS); NewType( O_W3D_CHUNK_TRIANGLES, "O_W3D_CHUNK_TRIANGLES", List_O_W3D_CHUNK_TRIANGLES); NewType( O_W3D_CHUNK_QUADRANGLES, "O_W3D_CHUNK_QUADRANGLES", List_O_W3D_CHUNK_QUADRANGLES); NewType( O_W3D_CHUNK_SURRENDER_TRIANGLES, "O_W3D_CHUNK_SURRENDER_TRIANGLES", List_O_W3D_CHUNK_SURRENDER_TRIANGLES); NewType( O_W3D_CHUNK_POV_TRIANGLES, "O_W3D_CHUNK_POV_TRIANGLES", List_O_W3D_CHUNK_POV_TRIANGLES); NewType( O_W3D_CHUNK_POV_QUADRANGLES, "O_W3D_CHUNK_POV_QUADRANGLES", List_O_W3D_CHUNK_POV_QUADRANGLES); NewType( W3D_CHUNK_MESH_USER_TEXT, "W3D_CHUNK_MESH_USER_TEXT", List_W3D_CHUNK_MESH_USER_TEXT); NewType( W3D_CHUNK_VERTEX_COLORS, "W3D_CHUNK_VERTEX_COLORS", List_W3D_CHUNK_VERTEX_COLORS); NewType( W3D_CHUNK_VERTEX_INFLUENCES, "W3D_CHUNK_VERTEX_INFLUENCES", List_W3D_CHUNK_VERTEX_INFLUENCES); NewType( W3D_CHUNK_DAMAGE, "W3D_CHUNK_DAMAGE", List_W3D_CHUNK_DAMAGE, true); NewType( W3D_CHUNK_DAMAGE_HEADER, "W3D_CHUNK_DAMAGE_HEADER", List_W3D_CHUNK_DAMAGE_HEADER); NewType( W3D_CHUNK_DAMAGE_VERTICES, "W3D_CHUNK_DAMAGE_VERTICES", List_W3D_CHUNK_DAMAGE_VERTICES); NewType( W3D_CHUNK_DAMAGE_COLORS, "W3D_CHUNK_DAMAGE_COLORS", List_W3D_CHUNK_DAMAGE_COLORS); NewType( O_W3D_CHUNK_MATERIALS2, "O_W3D_CHUNK_MATERIALS2", List_O_W3D_CHUNK_MATERIALS2); NewType( W3D_CHUNK_MATERIALS3, "W3D_CHUNK_MATERIALS3", List_W3D_CHUNK_MATERIALS3, true); NewType( W3D_CHUNK_MATERIAL3, "W3D_CHUNK_MATERIAL3", List_W3D_CHUNK_MATERIAL3, true); NewType( W3D_CHUNK_MATERIAL3_NAME, "W3D_CHUNK_MATERIAL3_NAME", List_W3D_CHUNK_MATERIAL3_NAME); NewType( W3D_CHUNK_MATERIAL3_INFO, "W3D_CHUNK_MATERIAL3_INFO", List_W3D_CHUNK_MATERIAL3_INFO); NewType( W3D_CHUNK_MATERIAL3_DC_MAP, "W3D_CHUNK_MATERIAL3_DC_MAP", List_W3D_CHUNK_MATERIAL3_DC_MAP,true); NewType( W3D_CHUNK_MATERIAL3_DI_MAP, "W3D_CHUNK_MATERIAL3_DI_MAP", List_W3D_CHUNK_MATERIAL3_DI_MAP,true); NewType( W3D_CHUNK_MATERIAL3_SC_MAP, "W3D_CHUNK_MATERIAL3_SC_MAP", List_W3D_CHUNK_MATERIAL3_SC_MAP,true); NewType( W3D_CHUNK_MATERIAL3_SI_MAP, "W3D_CHUNK_MATERIAL3_SI_MAP", List_W3D_CHUNK_MATERIAL3_SI_MAP,true); NewType( W3D_CHUNK_MAP3_FILENAME, "W3D_CHUNK_MAP3_FILENAME", List_W3D_CHUNK_MAP3_FILENAME); NewType( W3D_CHUNK_MAP3_INFO, "W3D_CHUNK_MAP3_INFO", List_W3D_CHUNK_MAP3_INFO); NewType( W3D_CHUNK_MESH_HEADER3, "W3D_CHUNK_MESH_HEADER3",List_W3D_CHUNK_MESH_HEADER3); NewType( W3D_CHUNK_TRIANGLES, "W3D_CHUNK_TRIANGLES",List_W3D_CHUNK_TRIANGLES); NewType( W3D_CHUNK_PER_TRI_MATERIALS,"W3D_CHUNK_PER_TRI_MATERIALS",List_W3D_CHUNK_PER_TRI_MATERIALS); NewType( W3D_CHUNK_VERTEX_SHADE_INDICES, "W3D_CHUNK_VERTEX_SHADE_INDICES",List_W3D_CHUNK_VERTEX_SHADE_INDICES); NewType( W3D_CHUNK_MATERIAL_INFO,"W3D_CHUNK_MATERIAL_INFO",List_W3D_CHUNK_MATERIAL_INFO); NewType( W3D_CHUNK_SHADERS,"W3D_CHUNK_SHADERS",List_W3D_CHUNK_SHADERS); NewType( W3D_CHUNK_PS2_SHADERS,"W3D_CHUNK_PS2_SHADERS",List_W3D_CHUNK_PS2_SHADERS); NewType( W3D_CHUNK_VERTEX_MATERIALS, "W3D_CHUNK_VERTEX_MATERIALS",List_W3D_CHUNK_VERTEX_MATERIALS,true); NewType( W3D_CHUNK_VERTEX_MATERIAL, "W3D_CHUNK_VERTEX_MATERIAL",List_W3D_CHUNK_VERTEX_MATERIAL,true); NewType( W3D_CHUNK_VERTEX_MATERIAL_NAME, "W3D_CHUNK_VERTEX_MATERIAL_NAME",List_W3D_CHUNK_VERTEX_MATERIAL_NAME); NewType( W3D_CHUNK_VERTEX_MATERIAL_INFO, "W3D_CHUNK_VERTEX_MATERIAL_INFO",List_W3D_CHUNK_VERTEX_MATERIAL_INFO); NewType( W3D_CHUNK_VERTEX_MAPPER_ARGS0, "W3D_CHUNK_VERTEX_MAPPER_ARGS0",List_W3D_CHUNK_VERTEX_MAPPER_ARGS0); NewType( W3D_CHUNK_VERTEX_MAPPER_ARGS1, "W3D_CHUNK_VERTEX_MAPPER_ARGS1",List_W3D_CHUNK_VERTEX_MAPPER_ARGS1); NewType( W3D_CHUNK_TEXTURES, "W3D_CHUNK_TEXTURES", List_W3D_CHUNK_TEXTURES,true); NewType( W3D_CHUNK_TEXTURE, "W3D_CHUNK_TEXTURE", List_W3D_CHUNK_TEXTURE,true); NewType( W3D_CHUNK_TEXTURE_NAME, "W3D_CHUNK_TEXTURE_NAME", List_W3D_CHUNK_TEXTURE_NAME); NewType( W3D_CHUNK_TEXTURE_INFO, "W3D_CHUNK_TEXTURE_INFO", List_W3D_CHUNK_TEXTURE_INFO); NewType( W3D_CHUNK_MATERIAL_PASS, "W3D_CHUNK_MATERIAL_PASS", List_W3D_CHUNK_MATERIAL_PASS,true); NewType( W3D_CHUNK_VERTEX_MATERIAL_IDS, "W3D_CHUNK_VERTEX_MATERIAL_IDS", List_W3D_CHUNK_VERTEX_MATERIAL_IDS); NewType( W3D_CHUNK_SHADER_IDS, "W3D_CHUNK_SHADER_IDS", List_W3D_CHUNK_SHADER_IDS); NewType( W3D_CHUNK_DCG, "W3D_CHUNK_DCG", List_W3D_CHUNK_DCG); NewType( W3D_CHUNK_DIG, "W3D_CHUNK_DIG", List_W3D_CHUNK_DIG); NewType( W3D_CHUNK_SCG, "W3D_CHUNK_SCG", List_W3D_CHUNK_SCG); NewType( W3D_CHUNK_TEXTURE_STAGE, "W3D_CHUNK_TEXTURE_STAGE", List_W3D_CHUNK_TEXTURE_STAGE,true); NewType( W3D_CHUNK_TEXTURE_IDS, "W3D_CHUNK_TEXTURE_IDS", List_W3D_CHUNK_TEXTURE_IDS); NewType( W3D_CHUNK_STAGE_TEXCOORDS, "W3D_CHUNK_STAGE_TEXCOORDS", List_W3D_CHUNK_STAGE_TEXCOORDS); NewType( W3D_CHUNK_PER_FACE_TEXCOORD_IDS, "W3D_CHUNK_PER_FACE_TEXCOORD_IDS", List_W3D_CHUNK_PER_FACE_TEXCOORD_IDS); NewType( W3D_CHUNK_AABTREE, "W3D_CHUNK_AABTREE", List_W3D_CHUNK_AABTREE,true); NewType( W3D_CHUNK_AABTREE_HEADER, "W3D_CHUNK_AABTREE_HEADER", List_W3D_CHUNK_AABTREE_HEADER); NewType( W3D_CHUNK_AABTREE_POLYINDICES, "W3D_CHUNK_AABTREE_POLYINDICES", List_W3D_CHUNK_AABTREE_POLYINDICES); NewType( W3D_CHUNK_AABTREE_NODES, "W3D_CHUNK_AABTREE_NODES", List_W3D_CHUNK_AABTREE_NODES); NewType( W3D_CHUNK_HIERARCHY, "W3D_CHUNK_HIERARCHY", List_W3D_CHUNK_HIERARCHY, true); NewType( W3D_CHUNK_HIERARCHY_HEADER, "W3D_CHUNK_HIERARCHY_HEADER", List_W3D_CHUNK_HIERARCHY_HEADER); NewType( W3D_CHUNK_PIVOTS, "W3D_CHUNK_PIVOTS", List_W3D_CHUNK_PIVOTS); NewType( W3D_CHUNK_PIVOT_FIXUPS, "W3D_CHUNK_PIVOT_FIXUPS", List_W3D_CHUNK_PIVOT_FIXUPS); NewType( W3D_CHUNK_ANIMATION, "W3D_CHUNK_ANIMATION", List_W3D_CHUNK_ANIMATION, true); NewType( W3D_CHUNK_ANIMATION_HEADER, "W3D_CHUNK_ANIMATION_HEADER", List_W3D_CHUNK_ANIMATION_HEADER); NewType( W3D_CHUNK_ANIMATION_CHANNEL, "W3D_CHUNK_ANIMATION_CHANNEL", List_W3D_CHUNK_ANIMATION_CHANNEL); NewType( W3D_CHUNK_BIT_CHANNEL, "W3D_CHUNK_BIT_CHANNEL", List_W3D_CHUNK_BIT_CHANNEL); NewType( W3D_CHUNK_HMODEL, "W3D_CHUNK_HMODEL", List_W3D_CHUNK_HMODEL,true); NewType( W3D_CHUNK_HMODEL_HEADER, "W3D_CHUNK_HMODEL_HEADER", List_W3D_CHUNK_HMODEL_HEADER); NewType( W3D_CHUNK_NODE, "W3D_CHUNK_NODE", List_W3D_CHUNK_NODE); NewType( W3D_CHUNK_COLLISION_NODE, "W3D_CHUNK_COLLISION_NODE", List_W3D_CHUNK_COLLISION_NODE); NewType( W3D_CHUNK_SKIN_NODE, "W3D_CHUNK_SKIN_NODE", List_W3D_CHUNK_SKIN_NODE); NewType( OBSOLETE_W3D_CHUNK_HMODEL_AUX_DATA, "W3D_CHUNK_HMODEL_AUX_DATA", List_W3D_CHUNK_HMODEL_AUX_DATA); NewType( OBSOLETE_W3D_CHUNK_SHADOW_NODE, "OBSOLETE_W3D_CHUNK_SHADOW_NODE", List_W3D_CHUNK_SHADOW_NODE); NewType( W3D_CHUNK_LODMODEL, "W3D_CHUNK_LODMODEL", List_W3D_CHUNK_LODMODEL,true); NewType( W3D_CHUNK_LODMODEL_HEADER, "W3D_CHUNK_LODMODEL_HEADER", List_W3D_CHUNK_LODMODEL_HEADER); NewType( W3D_CHUNK_LOD, "W3D_CHUNK_LOD", List_W3D_CHUNK_LOD); NewType( W3D_CHUNK_COLLECTION, "W3D_CHUNK_COLLECTION", List_W3D_CHUNK_COLLECTION,true); NewType( W3D_CHUNK_COLLECTION_HEADER, "W3D_CHUNK_COLLECTION_HEADER", List_W3D_CHUNK_COLLECTION_HEADER); NewType( W3D_CHUNK_COLLECTION_OBJ_NAME, "W3D_CHUNK_COLLECTION_OBJ_NAME", List_W3D_CHUNK_COLLECTION_OBJ_NAME); NewType( W3D_CHUNK_PLACEHOLDER,"W3D_CHUNK_PLACEHOLDER", List_W3D_CHUNK_PLACEHOLDER); NewType( W3D_CHUNK_TRANSFORM_NODE,"W3D_CHUNK_TRANSFORM_NODE", List_W3D_CHUNK_TRANSFORM_NODE); NewType( W3D_CHUNK_POINTS, "W3D_CHUNK_POINTS", List_W3D_CHUNK_POINTS); NewType( W3D_CHUNK_LIGHT, "W3D_CHUNK_LIGHT", List_W3D_CHUNK_LIGHT,true); NewType( W3D_CHUNK_LIGHT_INFO, "W3D_CHUNK_LIGHT_INFO",List_W3D_CHUNK_LIGHT_INFO); NewType( W3D_CHUNK_SPOT_LIGHT_INFO, "W3D_CHUNK_SPOT_LIGHT_INFO",List_W3D_CHUNK_SPOT_LIGHT_INFO); NewType( W3D_CHUNK_NEAR_ATTENUATION, "W3D_CHUNK_NEAR_ATTENUATION", List_W3D_CHUNK_NEAR_ATTENUATION); NewType( W3D_CHUNK_FAR_ATTENUATION, "W3D_CHUNK_FAR_ATTENUATION", List_W3D_CHUNK_FAR_ATTENUATION); NewType( W3D_CHUNK_EMITTER, "W3D_CHUNK_EMITTER", List_W3D_CHUNK_EMITTER,true); NewType( W3D_CHUNK_EMITTER_HEADER, "W3D_CHUNK_EMITTER_HEADER",List_W3D_CHUNK_EMITTER_HEADER); NewType( W3D_CHUNK_EMITTER_USER_DATA, "W3D_CHUNK_EMITTER_USER_DATA", List_W3D_CHUNK_EMITTER_USER_DATA); NewType( W3D_CHUNK_EMITTER_INFO, "W3D_CHUNK_EMITTER_INFO", List_W3D_CHUNK_EMITTER_INFO); NewType( W3D_CHUNK_EMITTER_INFOV2, "W3D_CHUNK_EMITTER_INFOV2",List_W3D_CHUNK_EMITTER_INFOV2); NewType( W3D_CHUNK_EMITTER_PROPS, "W3D_CHUNK_EMITTER_PROPS", List_W3D_CHUNK_EMITTER_PROPS); NewType( OBSOLETE_W3D_CHUNK_EMITTER_COLOR_KEYFRAME, "OBSOLETE_W3D_CHUNK_EMITTER_COLOR_KEYFRAME", List_W3D_CHUNK_EMITTER_COLOR_KEYFRAME); NewType( OBSOLETE_W3D_CHUNK_EMITTER_OPACITY_KEYFRAME, "OBSOLETE_W3D_CHUNK_EMITTER_OPACITY_KEYFRAME", List_W3D_CHUNK_EMITTER_OPACITY_KEYFRAME); NewType( OBSOLETE_W3D_CHUNK_EMITTER_SIZE_KEYFRAME, "OBSOLETE_W3D_CHUNK_EMITTER_SIZE_KEYFRAME", List_W3D_CHUNK_EMITTER_SIZE_KEYFRAME); NewType( W3D_CHUNK_EMITTER_ROTATION_KEYFRAMES, "W3D_CHUNK_EMITTER_ROTATION_KEYFRAMES", List_W3D_CHUNK_EMITTER_ROTATION_KEYFRAMES); NewType( W3D_CHUNK_EMITTER_FRAME_KEYFRAMES, "W3D_CHUNK_EMITTER_FRAME_KEYFRAMES", List_W3D_CHUNK_EMITTER_FRAME_KEYFRAMES); NewType( W3D_CHUNK_EMITTER_BLUR_TIME_KEYFRAMES, "W3D_CHUNK_EMITTER_BLUR_TIME_KEYFRAMES", List_W3D_CHUNK_EMITTER_BLUR_TIME_KEYFRAMES); NewType( W3D_CHUNK_AGGREGATE, "W3D_CHUNK_AGGREGATE", List_W3D_CHUNK_AGGREGATE,true); NewType( W3D_CHUNK_AGGREGATE_HEADER, "W3D_CHUNK_AGGREGATE_HEADER", List_W3D_CHUNK_AGGREGATE_HEADER); NewType( W3D_CHUNK_AGGREGATE_INFO, "W3D_CHUNK_AGGREGATE_INFO",List_W3D_CHUNK_AGGREGATE_INFO); NewType( W3D_CHUNK_TEXTURE_REPLACER_INFO, "W3D_CHUNK_TEXTURE_REPLACER_INFO", List_W3D_CHUNK_TEXTURE_REPLACER_INFO); NewType( W3D_CHUNK_AGGREGATE_CLASS_INFO, "W3D_CHUNK_AGGREGATE_CLASS_INFO", List_W3D_CHUNK_AGGREGATE_CLASS_INFO); NewType( W3D_CHUNK_HLOD, "W3D_CHUNK_HLOD", List_W3D_CHUNK_HLOD, true); NewType( W3D_CHUNK_HLOD_HEADER, "W3D_CHUNK_HLOD_HEADER", List_W3D_CHUNK_HLOD_HEADER); NewType( W3D_CHUNK_HLOD_LOD_ARRAY, "W3D_CHUNK_HLOD_LOD_ARRAY", List_W3D_CHUNK_HLOD_LOD_ARRAY, true); NewType( W3D_CHUNK_HLOD_SUB_OBJECT_ARRAY_HEADER, "W3D_CHUNK_HLOD_LOD_ARRAY_HEADER", List_W3D_CHUNK_HLOD_LOD_ARRAY_HEADER); NewType( W3D_CHUNK_HLOD_SUB_OBJECT, "W3D_CHUNK_HLOD_SUB_OBJECT", List_W3D_CHUNK_HLOD_SUB_OBJECT); NewType( W3D_CHUNK_HLOD_AGGREGATE_ARRAY, "W3D_CHUNK_HLOD_AGGREGATE_ARRAY", List_W3D_CHUNK_HLOD_LOD_ARRAY, true); NewType( W3D_CHUNK_HLOD_PROXY_ARRAY, "W3D_CHUNK_HLOD_PROXY_ARRAY", List_W3D_CHUNK_HLOD_LOD_ARRAY, true); NewType( W3D_CHUNK_BOX, "W3D_CHUNK_BOX", List_W3D_CHUNK_BOX); NewType( W3D_CHUNK_NULL_OBJECT, "W3D_CHUNK_NULL_OBJECT", List_W3D_CHUNK_NULL_OBJECT); NewType( W3D_CHUNK_PRELIT_UNLIT, "W3D_CHUNK_PRELIT_UNLIT", List_W3D_CHUNK_PRELIT_UNLIT, true); NewType( W3D_CHUNK_PRELIT_VERTEX, "W3D_CHUNK_PRELIT_VERTEX", List_W3D_CHUNK_PRELIT_VERTEX, true); NewType( W3D_CHUNK_PRELIT_LIGHTMAP_MULTI_PASS, "W3D_CHUNK_PRELIT_LIGHTMAP_MULTI_PASS", List_W3D_CHUNK_PRELIT_LIGHTMAP_MULTI_PASS, true); NewType( W3D_CHUNK_PRELIT_LIGHTMAP_MULTI_TEXTURE, "W3D_CHUNK_PRELIT_LIGHTMAP_MULTI_TEXTURE", List_W3D_CHUNK_PRELIT_LIGHTMAP_MULTI_TEXTURE, true); NewType( W3D_CHUNK_LIGHTSCAPE, "W3D_CHUNK_LIGHTSCAPE", List_W3D_CHUNK_LIGHTSCAPE, true); NewType( W3D_CHUNK_LIGHTSCAPE_LIGHT, "W3D_CHUNK_LIGHTSCAPE_LIGHT", List_W3D_CHUNK_LIGHTSCAPE_LIGHT, true); NewType( W3D_CHUNK_LIGHT_TRANSFORM, "W3D_CHUNK_LIGHT_TRANSFORM", List_W3D_CHUNK_LIGHT_TRANSFORM); NewType( W3D_CHUNK_DAZZLE, "W3D_CHUNK_DAZZLE", List_W3D_CHUNK_DAZZLE, true); NewType( W3D_CHUNK_DAZZLE_NAME, "W3D_CHUNK_DAZZLE_NAME" , List_W3D_CHUNK_DAZZLE_NAME); NewType( W3D_CHUNK_DAZZLE_TYPENAME, "W3D_CHUNK_DAZZLE_TYPENAME" , List_W3D_CHUNK_DAZZLE_TYPENAME); } ChunkType *ChunkTableClass::Lookup(int ID) { ChunkType *chunktype; if(Types.Lookup((void *) ID, (void *&) chunktype)) return chunktype; return 0; } ChunkItem::ChunkItem(ChunkLoadClass &cload) { ID = cload.Cur_Chunk_ID(); Length = cload.Cur_Chunk_Length(); Type = ChunkTable.Lookup(ID); // if the chunktype indicates that it has member chunks then do not load this chunk's data. Have the external caller do that. if(Type != 0 && Type->Wrapper) { Data = 0; return; } if(Type != 0) { TRACE("%s %d\n", Type->Name, Length); } if(Length == 0) { Data = 0; } else { Data = new char[Length]; cload.Read(Data, Length); } } ChunkItem::~ChunkItem() { if(Data != 0) delete [] Data; while(!Chunks.IsEmpty()) { ChunkItem *item = Chunks.RemoveHead(); delete item; } } ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// ChunkData::ChunkData() { } ChunkData::~ChunkData() { while(!Chunks.IsEmpty()) { ChunkItem *item = Chunks.RemoveHead(); delete item; } } bool ChunkData::Load(const char *filename) { Release_Data(); RawFileMClass chunk_file; if (!chunk_file.Open(filename)) { return false; } ChunkLoadClass cload(&chunk_file); while (cload.Open_Chunk()) { Add_Chunk(cload); cload.Close_Chunk(); } /* switch (cload.Cur_Chunk_ID()) { case W3D_CHUNK_MESH: MeshManager.Load_Mesh(cload); break; case W3D_CHUNK_HIERARCHY: HTreeManager.Load_Tree(cload); break; case W3D_CHUNK_ANIMATION: HAnimManager.Load_Anim(cload); break; case W3D_CHUNK_MESH_CONNECTIONS: HModelManager.Load_Model_Definition(cload); break; } cload.Close_Chunk(); } */ chunk_file.Close(); return true; } void ChunkData::Add_Chunk(ChunkLoadClass & cload, ChunkItem *Parent) { ChunkItem *item = new ChunkItem(cload); if(Parent) Parent->Chunks.AddTail(item); else Chunks.AddTail(item); //Moumine 1/2/2002 1:21:26 PM #if ! defined _W3DSHELLEXT if(theApp.DumpTextures) { if(item->ID == W3D_CHUNK_TEXTURE_NAME) { static CMapStringToString existing; char * data = (char *)item->Data; CString value; if(existing.Lookup(data, value) == FALSE) { existing.SetAt(data, data); if(theApp.TextureDumpFile != 0) fprintf(theApp.TextureDumpFile, "%s,%s\n", theApp.Filename, data); TRACE("%s,%s\n", theApp.Filename, data); } } } #endif if((item->Type != 0) && item->Type->Wrapper) { while(cload.Open_Chunk()) { Add_Chunk(cload, item); cload.Close_Chunk(); } } } void ChunkData::Release_Data() { while(Chunks.IsEmpty() == 0) { ChunkItem *item = Chunks.RemoveHead(); delete item; } } int Get_Bit(void const * array, int bit) { unsigned char mask = (unsigned char)(1 << (bit % 8)); return((*((unsigned char *)array + (bit/8)) & mask) != 0); } void Set_Bit(void * array, int bit, int value) { unsigned char mask = (unsigned char)(1 << (bit % 8)); if (value != 0) { *((unsigned char *)array + (bit/8)) |= mask; } else { *((unsigned char *)array + (bit/8)) &= (unsigned char)~mask; } }