void plMultipassMtlDlg::UpdateLayerDisplay()
{
int numlayers = fPBlock->GetInt(kMultCount);
fNumTexSpin->SetValue(numlayers, FALSE);
int i;
for (i = 0; i < numlayers && i < NSUBMTLS; i++)
{
Mtl *m = fPBlock->GetMtl(kMultPasses, curTime, i);
TSTR nm;
if (m)
nm = m->GetName();
else
nm = "None";
fLayerBtns[i]->SetText(nm.data());
ShowWindow(GetDlgItem(fhRollup, kLayerID[i].layerID), SW_SHOW);
ShowWindow(GetDlgItem(fhRollup, kLayerID[i].activeID), SW_SHOW);
SetCheckBox(fhRollup, kLayerID[i].activeID, fPBlock->GetInt(kMultOn, curTime, i));
}
for (i = numlayers; i < NSUBMTLS; i++)
{
ShowWindow(GetDlgItem(fhRollup, kLayerID[i].layerID), SW_HIDE);
ShowWindow(GetDlgItem(fhRollup, kLayerID[i].activeID), SW_HIDE);
}
}
void IInit(HWND hWnd, IParamBlock2* pb)
{
Mtl* mtl = pb->GetMtl(kMarkerMtl);
if (mtl)
{
SetDlgItemText(hWnd, IDC_MTL_BUTTON, mtl->GetName());
plNotetrackAnim anim(mtl, nil);
ILoadCombo(hWnd, IDC_ANIM_RED_COMBO, kMarkerRedAnim, pb, anim);
ILoadCombo(hWnd, IDC_ANIM_GREEN_COMBO, kMarkerGreenAnim, pb, anim);
ILoadCombo(hWnd, IDC_ANIM_OPEN_COMBO, kMarkerOpenAnim, pb, anim);
}
if (pb->GetINode(kMarkerMtlNode))
SetDlgItemText(hWnd, IDC_MTL_NODE_BUTTON, pb->GetINode(kMarkerMtlNode)->GetName());
else
SetDlgItemText(hWnd, IDC_MTL_NODE_BUTTON, "(none)");
if (pb->GetINode(kMarkerBounceNode))
SetDlgItemText(hWnd, IDC_BOUNCE_BUTTON, pb->GetINode(kMarkerBounceNode)->GetName());
else
SetDlgItemText(hWnd, IDC_BOUNCE_BUTTON, "(none)");
if (pb->GetINode(kMarkerSndPlace))
SetDlgItemText(hWnd, IDC_PLACE_BUTTON, pb->GetINode(kMarkerSndPlace)->GetName());
else
SetDlgItemText(hWnd, IDC_PLACE_BUTTON, "(none)");
if (pb->GetINode(kMarkerSndHit))
SetDlgItemText(hWnd, IDC_HIT_BUTTON, pb->GetINode(kMarkerSndHit)->GetName());
else
SetDlgItemText(hWnd, IDC_HIT_BUTTON, "(none)");
}
//+--------------------------------------------------------------------------+
//| From IPViewItem |
//+--------------------------------------------------------------------------+
bool PFOperatorMaterialStatic::HasDynamicName(TSTR& nameSuffix)
{
bool assign = (pblock()->GetInt(kMaterialStatic_assignMaterial, 0) != 0);
if (!assign) return false;
Mtl* mtl = GetMaterial();
if (mtl == NULL) {
nameSuffix = GetString(IDS_NONE);
} else {
nameSuffix = mtl->GetName();
}
return true;
}
void plMtlAnimProc::IUpdateMtlButton(HWND hWnd, IParamBlock2* pb)
{
HWND hMtl = GetDlgItem(hWnd, fMtlButtonID);
// Get the saved material
Mtl *savedMtl = IGetMtl(pb);
if (savedMtl)
SetWindowText(hMtl, savedMtl->GetName());
else
SetWindowText(hMtl, "(none)");
// Enable the node button if a material is selected
EnableWindow(GetDlgItem(hWnd, fNodeButtonID), (savedMtl != nil));
// Update the dependencies of this
IUpdateNodeButton(hWnd, pb);
}
void GmodelExp::ExportMaterial(void)
{
PrintSpace(); fprintf(m_pFile, "Begin Material\n");
PrintSpace(); fprintf(m_pFile, "{\n");
PushSpace();
m_iNumMaterials = m_MaterialTable.size();
PrintSpace(); fprintf(m_pFile, "Materials %d\n", m_iNumMaterials);
for ( int i=0; i<m_iNumMaterials; i++ )
{
PrintSpace(); fprintf(m_pFile, "{ // material %d\n", i);
PushSpace();
Mtl *mtl = m_MaterialTable[i];
sMaterial dxMaterial;
dxMaterial.ConvertMTL(mtl);
const char *name = mtl->GetName();
PrintSpace(); fprintf(m_pFile, "name = \"%s\"\n", name ? name : "unknown");
PrintSpace(); fprintf(m_pFile, "emissive = %f,%f,%f\n", dxMaterial.m_EmissiveColor.r, dxMaterial.m_EmissiveColor.g, dxMaterial.m_EmissiveColor.b);
PrintSpace(); fprintf(m_pFile, "ambient = %f,%f,%f\n", dxMaterial.m_AmbientColor.r, dxMaterial.m_AmbientColor.g, dxMaterial.m_AmbientColor.b);
PrintSpace(); fprintf(m_pFile, "diffuse = %f,%f,%f\n", dxMaterial.m_DiffuseColor.r, dxMaterial.m_DiffuseColor.g, dxMaterial.m_DiffuseColor.b);
PrintSpace(); fprintf(m_pFile, "specular = %f,%f,%f\n", dxMaterial.m_SpecularColor.r, dxMaterial.m_SpecularColor.g, dxMaterial.m_SpecularColor.b);
PrintSpace(); fprintf(m_pFile, "shininess = %f\n", dxMaterial.m_fShininess);
PrintSpace(); fprintf(m_pFile, "blendmode = %s\n", dxMaterial.m_BlendMode.c_str());
PrintSpace(); fprintf(m_pFile, "CullFace = %s\n", dxMaterial.m_bCullFace ? "on" : "off");
PrintSpace(); fprintf(m_pFile, "diffuseMap = \"%s\" MapChannel = %d\n", dxMaterial.m_Textures[0].length() ? dxMaterial.m_Textures[0].c_str() : "None", dxMaterial.m_MapChannel[0]);
PrintSpace(); fprintf(m_pFile, "lightMap = \"%s\" MapChannel = %d\n", dxMaterial.m_Textures[1].length() ? dxMaterial.m_Textures[1].c_str() : "None", dxMaterial.m_MapChannel[1]);
PrintSpace(); fprintf(m_pFile, "environmentMap = \"%s\"\n", dxMaterial.m_Textures[2].length() ? dxMaterial.m_Textures[2].c_str() : "None");
PopSpace();
PrintSpace(); fprintf(m_pFile, "}\n");
}
PopSpace();
PrintSpace(); fprintf(m_pFile, "}\n");
PrintSpace(); fprintf(m_pFile, "End Material\n");
}
/*
====================
GatherMesh
====================
*/
void G3DMExport::GatherMesh(INode* i_node)
{
// convert to the triangle type
Mesh* i_mesh = NULL;
Object* obj = i_node->EvalWorldState(mTime).obj;
if(obj && ( obj->SuperClassID() == GEOMOBJECT_CLASS_ID ))
{
if(obj->CanConvertToType(Class_ID(TRIOBJ_CLASS_ID, 0)))
{
TriObject *tri_obj = (TriObject*)obj->ConvertToType(mTime, Class_ID(TRIOBJ_CLASS_ID, 0)); MAX_CHECK(tri_obj);
i_mesh = &tri_obj->mesh;
}
}
if(i_mesh==NULL||i_mesh->getNumFaces()==0||i_mesh->getNumVerts()==0) return;
MESH mesh;
// get the mesh name
mesh.name = i_node->GetName();
// get the material
mesh.texture = "textures/default.tga";
Mtl* mtl = i_node->GetMtl();
if(mtl && (mtl->ClassID()==Class_ID(DMTL_CLASS_ID, 0)) && ((StdMat*)mtl)->MapEnabled(ID_DI))
{
Texmap *texmap = mtl->GetSubTexmap(ID_DI);
if(texmap && texmap->ClassID() == Class_ID(BMTEX_CLASS_ID, 0x00))
{
mesh.texture = UnifySlashes(((BitmapTex *)texmap)->GetMapName());
if( !strstr( mesh.texture.c_str(), mPath.c_str() ) )
{
G3DAssert("The material(%s) is error : the texture path(%s) is illegal!",mtl->GetName(), mesh.texture.c_str());
return;
}
else
{
mesh.texture = strstr(mesh.texture.c_str(),mPath.c_str()) + strlen(mPath.c_str());
}
}
}
// if it has uvs
int map_count = i_mesh->getNumMaps();
bool has_uvs = i_mesh->getNumTVerts() && i_mesh->tvFace;
if(!(has_uvs&&map_count)) return;
// get the transform
Matrix3 transform = i_node->GetObjectTM(mTime);
// get the points
mesh.points.assign(i_mesh->verts, i_mesh->verts+i_mesh->getNumVerts());
// get the triangles
for(int i = 0; i < i_mesh->getNumFaces(); i++)
{
Face& face = i_mesh->faces[i];
TRIANGLE tri;
tri.smoothing = face.smGroup;
for(int j = 0; j < 3; j++)
{
VTNIS v;
v.pos = transform * i_mesh->verts[face.v[j]];
// get the uv
UVVert * map_verts = i_mesh->mapVerts(1);
TVFace * map_faces = i_mesh->mapFaces(1);
v.uv = reinterpret_cast<Point2&>(map_verts[map_faces[i].t[j]]);
v.uv.y = 1 - v.uv.y;
// initialize the normal
v.normal = Point3::Origin;
// get the vertex index
v.index = face.v[j];
// get the smoothing group
v.smoothing = face.smGroup;
// set the index for the triangle
tri.index0[j] = v.index;
// reassemble the vertex list
tri.index1[j] = AddVertex(mesh, v);
}
// add the triangle to the table
mesh.triangles.push_back(tri);
}
// build the index map
for( int i = 0; i < mesh.vertexes.size(); i++ )
{
mesh.vertex_index_map[mesh.vertexes[i].index].push_back(i);
}
// build the normal space
BuildNormal(mesh);
// calculate the bounding box
mesh.box.Init();
for(int i = 0; i < mesh.vertexes.size(); i++)
{
mesh.box += mesh.vertexes[i].pos;
}
// add the mesh to the table
mMeshes.push_back(mesh);
}
void Exporter::DumpMaterial(MaxMaterial *maxm,Mtl* mtl, int mtlID, int subNo, int indentLevel)
{
int i;
TimeValue t = GetStaticFrame();
if (!mtl) return;
// for(i=0;i<indentLevel;i++) { log(" "); }
// log("material %s adding. type : ",mtl->GetName());
// We know the Standard material, so we can get some extra info
if (mtl->ClassID() == Class_ID(DMTL_CLASS_ID, 0)) { // top level & standard material
// log("standard \n");
StdMat* std = (StdMat*)mtl;
MaxStdMaterial *stdm=new MaxStdMaterial;
strcpy(stdm->name,mtl->GetName());
stdm->Ambient=rvector(std->GetAmbient(t));
stdm->Ambient.x=-stdm->Ambient.x;
stdm->Diffuse=rvector(std->GetDiffuse(t));
stdm->Diffuse.x=-stdm->Diffuse.x;
stdm->Specular=rvector(std->GetSpecular(t));
stdm->Specular.x=-stdm->Specular.x; // 축의 바뀜때문에 만들어 놓은.. 으흑..
stdm->TwoSide=std->GetTwoSided();
if(std->GetTransparencyType()==TRANSP_ADDITIVE)
stdm->ShadeMode=RSSHADEMODE_ADD;
else stdm->ShadeMode=RSSHADEMODE_NORMAL;
if(rsm->MaxStdMaterialList.GetByName(stdm->name)==-1) // 이미 있는 standard material 이면 더하지 않음.
{
rsm->MaxStdMaterialList.Add(stdm);
stdm->RMLIndex=rsm->MaxStdMaterialList.GetCount()-1;
for (i=0; i<mtl->NumSubTexmaps(); i++) {
Texmap* subTex = mtl->GetSubTexmap(i);
float amt = 1.0f;
if (subTex) {
// If it is a standard material we can see if the map is enabled.
if (mtl->ClassID() == Class_ID(DMTL_CLASS_ID, 0)) {
if (!((StdMat*)mtl)->MapEnabled(i))
continue;
amt = ((StdMat*)mtl)->GetTexmapAmt(i, 0);
}
DumpTexture(stdm, subTex, mtl->ClassID(), i, amt, indentLevel+1);
}
}
}
else
{
delete stdm;
}
maxm->nSubMaterial=1;
maxm->SubMaterials=new int[1];
maxm->SubMaterials[0]=rsm->MaxStdMaterialList.GetByName(mtl->GetName());
}
if (mtl->NumSubMtls() > 0) {
// log("multi/sub ( count : %d )\n",mtl->NumSubMtls());
maxm->nSubMaterial=mtl->NumSubMtls();
maxm->SubMaterials=new int[maxm->nSubMaterial];
maxm->pSubMaterials=new MaxMaterial*[maxm->nSubMaterial];
for (i=0; i<mtl->NumSubMtls(); i++) {
Mtl* subMtl = mtl->GetSubMtl(i);
if (subMtl) {
maxm->pSubMaterials[i]=new MaxMaterial;
DumpMaterial(maxm->pSubMaterials[i],subMtl, 0, i, indentLevel+1);
if(subMtl->ClassID() == Class_ID(DMTL_CLASS_ID, 0))
{
maxm->SubMaterials[i]= rsm->MaxStdMaterialList.GetByName(subMtl->GetName());
}
else
maxm->SubMaterials[i]= maxm->pSubMaterials[i]->SubMaterials[0];
}
else
{
maxm->pSubMaterials[i]=NULL;
maxm->SubMaterials[i]=-1;
}
}
}
}
int ExportQuake3Model(const TCHAR *filename, ExpInterface *ei, Interface *gi, int start_time, std::list<ExportNode> lTags, std::list<ExportNode> lMeshes)
{
FILE *file;
int i, j, totalTags, totalMeshes, current_time = 0;
long pos_current, totalTris = 0, totalVerts = 0;
std::list<FrameRange>::iterator range_i;
std::vector<Point3> lFrameBBoxMin;
std::vector<Point3> lFrameBBoxMax;
long pos_tagstart;
long pos_tagend;
long pos_filesize;
long pos_framestart;
int lazynamesfixed = 0;
const Point3 x_axis(1, 0, 0);
const Point3 z_axis(0, 0, 1);
SceneEnumProc checkScene(ei->theScene, start_time, gi);
totalTags = (int)lTags.size();
if (g_tag_for_pivot)
totalTags++;
totalMeshes = (int)lMeshes.size();
// open file
file = _tfopen(filename, _T("wb"));
if (!file)
{
ExportError("Cannot open file '%s'.", filename);
return FALSE;
}
ExportDebug("%s:", filename);
// sync pattern and version
putChars("IDP3", 4, file);
put32(15, file);
putChars("Darkplaces MD3 Exporter", 64, file);
put32(0, file); // flags
// MD3 header
ExportState("Writing MD3 header");
put32(g_total_frames, file); // how many frames
put32(totalTags, file); // tagsnum
put32(totalMeshes, file); // meshnum
put32(1, file); // maxskinnum
put32(108, file); // headersize
pos_tagstart = ftell(file); put32(0, file); // tagstart
pos_tagend = ftell(file); put32(256, file); // tagend
pos_filesize = ftell(file); put32(512, file); // filesize
ExportDebug(" %i frames, %i tags, %i meshes", g_total_frames, totalTags, totalMeshes);
// frame info
// bbox arrays get filled while exported mesh and written back then
ExportState("Writing frame info");
pos_framestart = ftell(file);
lFrameBBoxMin.resize(g_total_frames);
lFrameBBoxMax.resize(g_total_frames);
for (i = 0; i < g_total_frames; i++)
{
// init frame data
lFrameBBoxMin[i].Set(0, 0, 0);
lFrameBBoxMax[i].Set(0, 0, 0);
// put data
putFloat(-1.0f, file); // bbox min vector
putFloat(-1.0f, file);
putFloat(-1.0f, file);
putFloat( 1.0f, file); // bbox max vector
putFloat(1.0f, file);
putFloat(1.0f, file);
putFloat(0.0f, file); // local origin (usually 0 0 0)
putFloat(0.0f, file);
putFloat(0.0f, file);
putFloat(1.0f, file); // radius of bounding sphere
putChars("", 16, file);
}
// tags
pos_current = ftell(file);
fseek(file, pos_tagstart, SEEK_SET);
put32(pos_current, file);
fseek(file, pos_current, SEEK_SET);
// for each frame range cycle all frames and write out each tag
long pos_tags = pos_current;
if (totalTags)
{
long current_frame = 0;
ExportState("Writing %i tags", totalTags);
for (range_i = g_frame_ranges.begin(); range_i != g_frame_ranges.end(); range_i++)
{
for (i = (*range_i).first; i <= (int)(*range_i).last; i++, current_frame++)
{
SceneEnumProc current_scene(ei->theScene, i * g_ticks_per_frame, gi);
current_time = current_scene.time;
// write out tags
if (lTags.size())
{
for (std::list<ExportNode>::iterator tag_i = lTags.begin(); tag_i != lTags.end(); tag_i++)
{
INode *node = current_scene[tag_i->i]->node;
Matrix3 tm = node->GetObjTMAfterWSM(current_time);
ExportState("Writing '%s' frame %i of %i", tag_i->name, i, g_total_frames);
// tagname
putChars(tag_i->name, 64, file);
// origin, rotation matrix
Point3 row = tm.GetRow(3);
putFloat(row.x, file);
putFloat(row.y, file);
putFloat(row.z, file);
row = tm.GetRow(0);
putFloat(row.x, file);
putFloat(row.y, file);
putFloat(row.z, file);
row = tm.GetRow(1);
putFloat(row.x, file);
putFloat(row.y, file);
putFloat(row.z, file);
row = tm.GetRow(2);
putFloat(row.x, file);
putFloat(row.y, file);
putFloat(row.z, file);
}
}
// write the center of mass tag_pivot which is avg of all objects's pivots
if (g_tag_for_pivot)
{
ExportState("Writing 'tag_pivot' frame %i of %i", i, g_total_frames);
// write the null data as tag_pivot need to be written after actual geometry
// (it needs information on frame bound boxes to get proper blendings)
putChars("tag_pivot", 64, file);
putFloat(0, file);
putFloat(0, file);
putFloat(0, file);
putFloat(1, file);
putFloat(0, file);
putFloat(0, file);
putFloat(0, file);
putFloat(1, file);
putFloat(0, file);
putFloat(0, file);
putFloat(0, file);
putFloat(1, file);
}
}
}
}
// write the tag object offsets
pos_current = ftell(file);
fseek(file, pos_tagend, SEEK_SET);
put32(pos_current, file);
fseek(file, pos_current, SEEK_SET);
// allocate the structs used to calculate tag_pivot
std::vector<Point3> tag_pivot_origin;
std::vector<double> tag_pivot_volume;
if (g_tag_for_pivot)
{
tag_pivot_origin.resize(g_total_frames);
tag_pivot_volume.resize(g_total_frames);
}
// mesh objects
// for each mesh object write uv and frames
SceneEnumProc scratch(ei->theScene, start_time, gi);
ExportState("Writing %i meshes", (int)lMeshes.size());
for (std::list<ExportNode>::iterator mesh_i = lMeshes.begin(); mesh_i != lMeshes.end(); mesh_i++)
{
bool needsDel;
ExportState("Start mesh #%i", mesh_i);
INode *node = checkScene[mesh_i->i]->node;
Matrix3 tm = node->GetObjTMAfterWSM(start_time);
TriObject *tri = GetTriObjectFromNode(node, start_time, needsDel);
if (!tri)
continue;
// get mesh, compute normals
Mesh &mesh = tri->GetMesh();
MeshNormalSpec *meshNormalSpec = mesh.GetSpecifiedNormals();
if (meshNormalSpec)
{
if (!meshNormalSpec->GetNumFaces())
meshNormalSpec = NULL;
else
{
meshNormalSpec->SetParent(&mesh);
meshNormalSpec->CheckNormals();
}
}
mesh.checkNormals(TRUE);
// fix lazy object names
ExportState("Attempt to fix mesh name '%s'", mesh_i->name);
char meshname[64];
size_t meshnamelen = min(63, strlen(mesh_i->name));
memset(meshname, 0, 64);
strncpy(meshname, mesh_i->name, meshnamelen);
meshname[meshnamelen] = 0;
if (!strncmp("Box", meshname, 3) || !strncmp("Sphere", meshname, 6) || !strncmp("Cylinder", meshname, 8) ||
!strncmp("Torus", meshname, 5) || !strncmp("Cone", meshname, 4) || !strncmp("GeoSphere", meshname, 9) ||
!strncmp("Tube", meshname, 4) || !strncmp("Pyramid", meshname, 7) || !strncmp("Plane", meshname, 5) ||
!strncmp("Teapot", meshname, 6) || !strncmp("Object", meshname, 6))
{
name_conflict:
lazynamesfixed++;
if (lazynamesfixed == 1)
strcpy(meshname, "base");
else
sprintf(meshname, "base%i", lazynamesfixed);
// check if it's not used by another mesh
for (std::list<ExportNode>::iterator m_i = lMeshes.begin(); m_i != lMeshes.end(); m_i++)
if (!strncmp(m_i->name, meshname, strlen(meshname)))
goto name_conflict;
// approve name
ExportWarning("Lazy object name '%s' (mesh renamed to '%s').", node->GetName(), meshname);
}
// special mesh check
bool shadow_or_collision = false;
if (g_mesh_special)
if (!strncmp("collision", meshname, 9) || !strncmp("shadow", meshname, 6))
shadow_or_collision = true;
// get material
const char *shadername = NULL;
Texmap *tex = 0;
Mtl *mtl = 0;
if (!shadow_or_collision)
{
mtl = node->GetMtl();
if (mtl)
{
// check for multi-material
if (mtl->IsMultiMtl())
{
// check if it's truly multi material
// we do support multi-material with only one texture (some importers set it)
bool multi_material = false;
MtlID matId = mesh.faces[0].getMatID();
for (i = 1; i < mesh.getNumFaces(); i++)
if (mesh.faces[i].getMatID() != matId)
multi_material = true;
if (multi_material)
if (g_mesh_multimaterials == MULTIMATERIALS_NONE)
ExportWarning("Object '%s' is multimaterial and using multiple materials on its faces, that case is not yet supported (truncating to first submaterial).", node->GetName());
// switch to submaterial
mtl = mtl->GetSubMtl(matId);
}
// get shader from material if supplied
char *materialname = GetChar(mtl->GetName());
if (g_mesh_materialasshader && (strstr(materialname, "/") != NULL || strstr(materialname, "\\") != NULL))
shadername = GetChar(mtl->GetName());
else
{
// get texture
tex = mtl->GetSubTexmap(ID_DI);
if (tex)
{
if (tex->ClassID() == Class_ID(BMTEX_CLASS_ID, 0x00))
{
shadername = GetChar(((BitmapTex *)tex)->GetMapName());
if (shadername == NULL || !shadername[0])
ExportWarning("Object '%s' material '%s' has no bitmap.", tex->GetName(), node->GetName());
}
else
{
tex = NULL;
ExportWarning("Object '%s' has material with wrong texture type (only Bitmap are supported).", node->GetName());
}
}
else
ExportWarning("Object '%s' has material but no texture.", node->GetName());
}
}
else
ExportWarning("Object '%s' has no material.", node->GetName());
}
long pos_meshstart = ftell(file);
// surface object
ExportState("Writing mesh '%s' header", meshname);
putChars("IDP3", 4, file);
putChars(meshname, 64, file);
put32(0, file); // flags
put32(g_total_frames, file); // framecount
put32(1, file); // skincount
long pos_vertexnum = ftell(file); put32(0, file); // vertexcount
put32(mesh.getNumFaces(), file); // trianglecount
long pos_trianglestart = ftell(file); put32(0, file); // start triangles
put32(108, file); // header size
long pos_texvecstart = ftell(file); put32(0, file); // texvecstart
long pos_vertexstart = ftell(file); put32(16, file); // vertexstart
long pos_meshsize = ftell(file); put32(32, file); // meshsize
// write out a single 'skin'
ExportState("Writing mesh %s texture", meshname);
if (shadow_or_collision)
putChars(meshname, 64, file);
else if (shadername)
putMaterial(shadername, mtl, tex, file);
else
putChars("noshader", 64, file);
put32(0, file); // flags
// build geometry
ExportState("Building vertexes/triangles");
std::vector<ExportVertex>vVertexes;
std::vector<ExportTriangle>vTriangles;
vVertexes.resize(mesh.getNumVerts());
int vExtraVerts = mesh.getNumVerts();
for (i = 0; i < mesh.getNumVerts(); i++)
{
vVertexes[i].vert = i;
vVertexes[i].normalfilled = false;
// todo: check for coincident verts
}
int vNumExtraVerts = 0;
// check normals
if (!mesh.normalsBuilt && !shadow_or_collision)
ExportWarning("Object '%s' does not have normals contructed.", node->GetName());
// get info for triangles
const float normal_epsilon = 0.01f;
vTriangles.resize(mesh.getNumFaces());
for (i = 0; i < mesh.getNumFaces(); i++)
{
DWORD smGroup = mesh.faces[i].getSmGroup();
ExportState("Mesh %s: checking normals for face %i of %i", meshname, i, mesh.getNumFaces());
for (j = 0; j < 3; j++)
{
int vert = mesh.faces[i].getVert(j);
vTriangles[i].e[j] = vert;
// find a right normal for this vertex and save its 'address'
int vni;
Point3 vn;
if (!mesh.normalsBuilt || shadow_or_collision)
{
vn.Set(0, 0, 0);
vni = 0;
}
else
{
int numNormals;
RVertex *rv = mesh.getRVertPtr(vert);
if (meshNormalSpec)
{
ExportState("face %i vert %i have normal specified", i, j);
// mesh have explicit normals (i.e. Edit Normals modifier)
vn = meshNormalSpec->GetNormal(i, j);
vni = meshNormalSpec->GetNormalIndex(i, j);
}
else if (rv && rv->rFlags & SPECIFIED_NORMAL)
{
ExportState("face %i vert %i have SPECIFIED_NORMAL flag", i, j);
// SPECIFIED_NORMAL flag
vn = rv->rn.getNormal();
vni = 0;
}
else if (rv && (numNormals = rv->rFlags & NORCT_MASK) && smGroup)
{
// If there is only one vertex is found in the rn member.
if (numNormals == 1)
{
ExportState("face %i vert %i have solid smooth group", i, j);
vn = rv->rn.getNormal();
vni = 0;
}
else
{
ExportState("face %i vert %i have mixed smoothing groups", i, j);
// If two or more vertices are there you need to step through them
// and find the vertex with the same smoothing group as the current face.
// You will find multiple normals in the ern member.
for (int k = 0; k < numNormals; k++)
{
if (rv->ern[k].getSmGroup() & smGroup)
{
vn = rv->ern[k].getNormal();
vni = 1 + k;
}
}
}
}
else
{
ExportState("face %i vert %i flat shaded", i, j);
// Get the normal from the Face if no smoothing groups are there
vn = mesh.getFaceNormal(i);
vni = 0 - (i + 1);
}
}
// subdivide to get all normals right
if (!vVertexes[vert].normalfilled)
{
vVertexes[vert].normal = vn;
vVertexes[vert].normalindex = vni;
vVertexes[vert].normalfilled = true;
}
else if ((vVertexes[vert].normal - vn).Length() >= normal_epsilon)
{
// current vertex not matching normal - it was already filled by different smoothing group
// find a vert in extra verts in case it was already created
bool vert_found = false;
for (int ev = vExtraVerts; ev < (int)vVertexes.size(); ev++)
{
if (vVertexes[ev].vert == vert && (vVertexes[ev].normal - vn).Length() < normal_epsilon)
{
vert_found = true;
vTriangles[i].e[j] = ev;
break;
}
}
// we havent found a vertex, create new
if (!vert_found)
{
ExportVertex NewVert;
NewVert.vert = vVertexes[vert].vert;
NewVert.normal = vn;
NewVert.normalindex = vni;
NewVert.normalfilled = true;
vTriangles[i].e[j] = (int)vVertexes.size();
vVertexes.push_back(NewVert);
vNumExtraVerts++;
}
}
}
}
int vNumExtraVertsForSmoothGroups = vNumExtraVerts;
// generate UV map
// VorteX: use direct maps reading since getNumTVerts()/getTVert is deprecated
// max sets two default mesh maps: 0 - vertex color, 1 : UVW, 2 & up are custom ones
ExportState("Building UV map");
std::vector<ExportUV>vUVMap;
vUVMap.resize(vVertexes.size());
int meshMap = 1;
if (!mesh.mapSupport(meshMap) || !mesh.getNumMapVerts(meshMap) || shadow_or_collision)
{
for (i = 0; i < mesh.getNumVerts(); i++)
{
vUVMap[i].u = 0.5;
vUVMap[i].v = 0.5;
}
if (!shadow_or_collision)
ExportWarning("No UV mapping was found on object '%s'.", node->GetName());
}
else
{
UVVert *meshUV = mesh.mapVerts(meshMap);
for (i = 0; i < (int)vTriangles.size(); i++)
{
ExportState("Mesh %s: converting tvert for face %i of %i", meshname, i, (int)vTriangles.size());
// for 3 face vertexes
for (j = 0; j < 3; j++)
{
int vert = vTriangles[i].e[j];
int tv = mesh.tvFace[i].t[j];
UVVert &UV = meshUV[tv];
if (!vUVMap[vert].filled)
{
// fill uvMap vertex
vUVMap[vert].u = UV.x;
vUVMap[vert].v = UV.y;
vUVMap[vert].filled = true;
vUVMap[vert].tvert = tv;
}
else if (tv != vUVMap[vert].tvert)
{
// uvMap slot for this vertex has been filled
// we should arrange triangle to other vertex, which not filled and having same shading and uv
// check if any of the extra vertices can fit
bool vert_found = false;
for (int ev = vExtraVerts; ev < (int)vVertexes.size(); ev++)
{
if (vVertexes[ev].vert == vert && vUVMap[vert].u == UV.x &&vUVMap[vert].v == UV.y && (vVertexes[ev].normal - vVertexes[vert].normal).Length() < normal_epsilon)
{
vert_found = true;
vTriangles[i].e[j] = vVertexes[ev].vert;
break;
}
}
if (!vert_found)
{
// create new vert
ExportVertex NewVert;
NewVert.vert = vVertexes[vert].vert;
NewVert.normal = vVertexes[vert].normal;
NewVert.normalindex = vVertexes[vert].normalindex;
NewVert.normalfilled = vVertexes[vert].normalfilled;
vTriangles[i].e[j] = (int)vVertexes.size();
vVertexes.push_back(NewVert);
vNumExtraVerts++;
// create new TVert
ExportUV newUV;
newUV.filled = true;
newUV.u = UV.x;
newUV.v = UV.y;
newUV.tvert = tv;
vUVMap.push_back(newUV);
}
}
}
}
}
int vNumExtraVertsForUV = (vNumExtraVerts - vNumExtraVertsForSmoothGroups);
// print some debug stats
ExportDebug(" mesh %s: %i vertexes +%i %s +%i UV, %i triangles", meshname, ((int)vVertexes.size() - vNumExtraVerts), vNumExtraVertsForSmoothGroups, meshNormalSpec ? "EditNormals" : "SmoothGroups", vNumExtraVertsForUV, (int)vTriangles.size());
// fill in triangle start
pos_current = ftell(file);
fseek(file, pos_trianglestart, SEEK_SET);
put32(pos_current - pos_meshstart, file);
fseek(file, pos_current, SEEK_SET);
// detect if object have negative scale (mirrored)
// in this canse we should rearrange triangles counterclockwise
// so stuff will not be inverted
ExportState("Mesh %s: writing %i triangles", meshname, (int)vTriangles.size());
if (DotProd(CrossProd(tm.GetRow(0), tm.GetRow(1)), tm.GetRow(2)) < 0.0)
{
ExportWarning("Object '%s' is mirrored (having negative scale on it's transformation)", node->GetName());
for (i = 0; i < (int)vTriangles.size(); i++)
{
put32(vTriangles[i].b, file); // vertex index
put32(vTriangles[i].c, file); // for 3 vertices
put32(vTriangles[i].a, file); // of triangle
}
}
else
{
for (i = 0; i < (int)vTriangles.size(); i++)
{
put32(vTriangles[i].a, file); // vertex index
put32(vTriangles[i].c, file); // for 3 vertices
put32(vTriangles[i].b, file); // of triangle
}
}
// fill in texvecstart
// write out UV mapping coords.
ExportState("Mesh %s: writing %i UV vertexes", meshname, (int)vUVMap.size());
pos_current = ftell(file);
fseek(file, pos_texvecstart, SEEK_SET);
put32(pos_current - pos_meshstart, file);
fseek(file, pos_current, SEEK_SET);
for (i = 0; i < (int)vUVMap.size(); i++)
{
putFloat(vUVMap[i].u, file); // texture coord u,v
putFloat(1.0f - vUVMap[i].v, file); // for vertex
}
vUVMap.clear();
// fill in vertexstart
pos_current = ftell(file);
fseek(file, pos_vertexstart, SEEK_SET);
put32(pos_current - pos_meshstart, file);
fseek(file, pos_current, SEEK_SET);
// fill in vertexnum
pos_current = ftell(file);
fseek(file, pos_vertexnum, SEEK_SET);
put32((int)vVertexes.size(), file);
fseek(file, pos_current, SEEK_SET);
// write out for each frame the position of each vertex
long current_frame = 0;
ExportState("Mesh %s: writing %i frames", meshname, g_total_frames);
for (range_i = g_frame_ranges.begin(); range_i != g_frame_ranges.end(); range_i++)
{
for (i = (*range_i).first; i <= (int)(*range_i).last; i++, current_frame++)
{
bool _needsDel;
// get triobject for current frame
SceneEnumProc current_scene(ei->theScene, i * g_ticks_per_frame, gi);
current_time = current_scene.time;
INode *_node = current_scene[mesh_i->i]->node;
TriObject *_tri = GetTriObjectFromNode(_node, current_time, _needsDel);
if (!_tri)
continue;
// get mesh, compute normals
Mesh &_mesh = _tri->GetMesh();
MeshNormalSpec *_meshNormalSpec = _mesh.GetSpecifiedNormals();
if (_meshNormalSpec)
{
if (!_meshNormalSpec->GetNumFaces())
_meshNormalSpec = NULL;
else
{
_meshNormalSpec->SetParent(&_mesh);
_meshNormalSpec->CheckNormals();
}
}
_mesh.checkNormals(TRUE);
// get transformations for current frame
Matrix3 _tm = _node->GetObjTMAfterWSM(current_time);
ExportState("Mesh %s: writing frame %i of %i", meshname, current_frame, g_total_frames);
Point3 BoxMin(0, 0, 0);
Point3 BoxMax(0, 0, 0);
for (j = 0; j < (int)vVertexes.size(); j++) // number of vertices
{
ExportState("Mesh %s: transform vertex %i of %i", meshname, j, (int)vVertexes.size());
int vert = vVertexes[j].vert;
Point3 &v = _tm.PointTransform(_mesh.getVert(vert));
// populate bbox data
if (!shadow_or_collision)
{
BoxMin.x = min(BoxMin.x, v.x);
BoxMin.y = min(BoxMin.y, v.y);
BoxMin.z = min(BoxMin.z, v.z);
BoxMax.x = max(BoxMax.x, v.x);
BoxMax.y = max(BoxMax.y, v.y);
BoxMax.z = max(BoxMax.z, v.z);
}
// write vertex
double f;
f = v.x * 64.0f; if (f < -32768.0) f = -32768.0; if (f > 32767.0) f = 32767.0; put16((short)f, file);
f = v.y * 64.0f; if (f < -32768.0) f = -32768.0; if (f > 32767.0) f = 32767.0; put16((short)f, file);
f = v.z * 64.0f; if (f < -32768.0) f = -32768.0; if (f > 32767.0) f = 32767.0; put16((short)f, file);
// get normal
ExportState("Mesh %s: transform vertex normal %i of %i", meshname, j, (int)vVertexes.size());
Point3 n;
if (_meshNormalSpec) // mesh have explicit normals (i.e. Edit Normals modifier)
n = _meshNormalSpec->Normal(vVertexes[j].normalindex);
else if (!vVertexes[j].normalfilled || !_mesh.normalsBuilt)
n = _mesh.getNormal(vert);
else
{
RVertex *rv = _mesh.getRVertPtr(vert);
if (vVertexes[j].normalindex < 0)
n = _mesh.getFaceNormal((0 - vVertexes[j].normalindex) - 1);
else if (vVertexes[j].normalindex == 0)
n = rv->rn.getNormal();
else
n = rv->ern[vVertexes[j].normalindex - 1].getNormal();
}
// transform normal
Point3 &nt = _tm.VectorTransform(n).Normalize();
// encode a normal vector into a 16-bit latitude-longitude value
double lng = acos(nt.z) * 255 / (2 * pi);
double lat = atan2(nt.y, nt.x) * 255 / (2 * pi);
put16((((int)lat & 0xFF) << 8) | ((int)lng & 0xFF), file);
}
// blend the pivot positions for tag_pivot using mesh's volumes for blending power
if (g_tag_for_pivot && !shadow_or_collision)
{
ExportState("Mesh %s: writing tag_pivot", meshname);
Point3 Size = BoxMax - BoxMin;
double BoxVolume = pow(Size.x * Size.y * Size.z, 0.333f);
// blend matrices
float blend = (float)(BoxVolume / (BoxVolume + tag_pivot_volume[current_frame]));
float iblend = 1 - blend;
tag_pivot_volume[current_frame] = tag_pivot_volume[current_frame] + BoxVolume;
Point3 row = _tm.GetRow(3) - _node->GetObjOffsetPos();
tag_pivot_origin[current_frame].x = tag_pivot_origin[current_frame].x * iblend + row.x * blend;
tag_pivot_origin[current_frame].y = tag_pivot_origin[current_frame].y * iblend + row.y * blend;
tag_pivot_origin[current_frame].z = tag_pivot_origin[current_frame].z * iblend + row.z * blend;
}
// populate bbox data for frames
lFrameBBoxMin[current_frame].x = min(lFrameBBoxMin[current_frame].x, BoxMin.x);
lFrameBBoxMin[current_frame].y = min(lFrameBBoxMin[current_frame].y, BoxMin.y);
lFrameBBoxMin[current_frame].z = min(lFrameBBoxMin[current_frame].z, BoxMin.z);
lFrameBBoxMax[current_frame].x = max(lFrameBBoxMax[current_frame].x, BoxMax.x);
lFrameBBoxMax[current_frame].y = max(lFrameBBoxMax[current_frame].y, BoxMax.y);
lFrameBBoxMax[current_frame].z = max(lFrameBBoxMax[current_frame].z, BoxMax.z);
// delete the working object, if necessary.
if (_needsDel)
delete _tri;
}
}
// delete if necessary
if (needsDel)
delete tri;
// fill in meshsize
pos_current = ftell(file);
fseek(file, pos_meshsize, SEEK_SET);
put32(pos_current - pos_meshstart, file);
fseek(file, pos_current, SEEK_SET);
// reset back to first frame
SceneEnumProc scratch(ei->theScene, start_time, gi);
totalTris += (long)vTriangles.size();
totalVerts += (long)vVertexes.size();
vTriangles.clear();
vVertexes.clear();
}
// write tag_pivot
ExportState("Writing tag_pivot positions");
if (g_tag_for_pivot)
{
pos_current = ftell(file);
long current_frame = 0;
for (range_i = g_frame_ranges.begin(); range_i != g_frame_ranges.end(); range_i++)
{
for (i = (*range_i).first; i <= (int)(*range_i).last; i++, current_frame++)
{
fseek(file, pos_tags + totalTags*112*current_frame + (int)lTags.size()*112 + 64, SEEK_SET);
// origin
putFloat(tag_pivot_origin[current_frame].x, file);
putFloat(tag_pivot_origin[current_frame].y, file);
putFloat(tag_pivot_origin[current_frame].z, file);
}
}
fseek(file, pos_current, SEEK_SET);
}
tag_pivot_volume.clear();
tag_pivot_origin.clear();
// write frame data
ExportState("Writing culling info");
long current_frame = 0;
pos_current = ftell(file);
for (range_i = g_frame_ranges.begin(); range_i != g_frame_ranges.end(); range_i++)
{
for (i = (*range_i).first; i <= (int)(*range_i).last; i++, current_frame++)
{
fseek(file, pos_framestart + current_frame*56, SEEK_SET);
putFloat(lFrameBBoxMin[current_frame].x, file); // bbox min vector
putFloat(lFrameBBoxMin[current_frame].y, file);
putFloat(lFrameBBoxMin[current_frame].z, file);
putFloat(lFrameBBoxMax[current_frame].x, file); // bbox max vector
putFloat(lFrameBBoxMax[current_frame].y, file);
putFloat(lFrameBBoxMax[current_frame].z, file);
putFloat(0, file); // local origin (usually 0 0 0)
putFloat(0, file);
putFloat(0, file);
putFloat(max(lFrameBBoxMin[current_frame].Length(), lFrameBBoxMax[current_frame].Length()) , file); // radius of bounding sphere
}
}
fseek(file, pos_current, SEEK_SET);
lFrameBBoxMin.clear();
lFrameBBoxMax.clear();
// fill in filesize
pos_current = ftell(file);
fseek(file, pos_filesize, SEEK_SET);
put32(pos_current, file);
fseek(file, pos_current, SEEK_SET);
fclose(file);
ExportDebug(" total: %i vertexes, %i triangles", totalVerts, totalTris);
return TRUE;
}
void plTextureSearch::IUpdateTextures(plTextureSearch::Update update)
{
MtlSet mtls;
plMtlCollector::GetMtls(&mtls, nil, plMtlCollector::kPlasmaOnly | plMtlCollector::kNoMultiMtl);
char searchStr[256];
GetDlgItemText(fDlg, IDC_FIND_EDIT, searchStr, sizeof(searchStr));
strlwr(searchStr);
HWND hList = GetDlgItem(fDlg, IDC_TEXTURE_LIST);
ListView_DeleteAllItems(hList);
int sizeX = -1, sizeY = -1;
HWND hCombo = GetDlgItem(fDlg, IDC_SIZE_COMBO);
// If we're updating the size, get whatever the user selected
if (update == kUpdateSetSize)
{
int sel = ComboBox_GetCurSel(hCombo);
uint32_t data = ComboBox_GetItemData(hCombo, sel);
sizeX = LOWORD(data);
sizeY = HIWORD(data);
}
MtlSet::iterator it = mtls.begin();
for (; it != mtls.end(); it++)
{
Mtl *mtl = (*it);
LayerSet layers;
plMtlCollector::GetMtlLayers(mtl, layers);
LayerSet::iterator layerIt = layers.begin();
for (; layerIt != layers.end(); layerIt++)
{
plPlasmaMAXLayer *layer = (*layerIt);
int numBitmaps = layer->GetNumBitmaps();
for (int i = 0; i < numBitmaps; i++)
{
PBBitmap *pbbm = layer->GetPBBitmap(i);
if (pbbm)
{
const char *name = pbbm->bi.Filename();
if (name && *name != '\0')
{
char buf[256];
strncpy(buf, name, sizeof(buf));
strlwr(buf);
// If we don't have a search string, or we do and it was
// found in the texture name, add the texture to the list.
if (searchStr[0] == '\0' || strstr(buf, searchStr))
{
if (update == kUpdateLoadList)
{
LVITEM item = {0};
item.mask = LVIF_TEXT | LVIF_PARAM;
item.pszText = mtl->GetName();
item.lParam = (LPARAM)mtl; // A little dangerous, since the user could delete this
int idx = ListView_InsertItem(hList, &item);
ListView_SetItemText(hList, idx, 1, layer->GetName());
ListView_SetItemText(hList, idx, 2, (char*)name);
// If size is uninitialized or the same as the last, keep size
if ((sizeX == -1 && sizeY == -1) || (sizeX == pbbm->bi.Width() && sizeY == pbbm->bi.Height()))
{
sizeX = pbbm->bi.Width();
sizeY = pbbm->bi.Height();
}
// Otherwise clear it
else
{
sizeX = sizeY = 0;
}
}
else if (update == kUpdateReplace)
{
#ifdef MAXASS_AVAILABLE
layer->SetBitmapAssetId(gAssetID, i);
#endif
BitmapInfo info;
info.SetName(fFileName);
layer->SetBitmap(&info, i);
}
else if (update == kUpdateSetSize)
{
layer->SetExportSize(sizeX, sizeY);
}
}
}
}
}
}
}
if (update == kUpdateLoadList)
{
HWND hButton = GetDlgItem(fDlg, IDC_SET_ALL_BUTTON);
ComboBox_ResetContent(hCombo);
// If all bitmaps are the same size, enable resizing
if (sizeX != -1 && sizeX != 0)
{
sizeX = FloorPow2(sizeX);
sizeY = FloorPow2(sizeY);
char buf[256];
while (sizeX >= 4 && sizeY >= 4)
{
sprintf(buf, "%d x %d", sizeX, sizeY);
int idx = ComboBox_AddString(hCombo, buf);
ComboBox_SetItemData(hCombo, idx, MAKELPARAM(sizeX, sizeY));
sizeX >>= 1;
sizeY >>= 1;
}
ComboBox_SetCurSel(hCombo, 0);
EnableWindow(hCombo, TRUE);
EnableWindow(hButton, TRUE);
}
BOOL DlgProc(TimeValue t, IParamMap2 *map, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
int selection;
HWND cbox = NULL;
HWND hList = GetDlgItem(hWnd, IDC_COMP_LOD_AVATAR_BONELIST);
switch (msg)
{
case WM_INITDIALOG:
{
int LodBeginState = map->GetParamBlock()->GetInt(plLODAvatarComponent::kLODState);
HWND LODCombo = GetDlgItem(hWnd, IDC_COMP_LOD_AVATAR_STATE);
fMstrDlg = hWnd;
fPB = map->GetParamBlock();
fComp = (plLODAvatarComponent*) fPB->GetOwner();
VCharArray Nilptr;
ILoadComboBox(LODCombo, fComp->fLODLevels);
SendMessage(LODCombo, CB_SETCURSEL, LodBeginState, 0); // select the right one
int i;
for (i = 0; i < plClothingMgr::kMaxGroup; i++)
{
cbox = GetDlgItem(hWnd, IDC_COMP_AVATAR_CLOTHING_GROUP);
SendMessage(cbox, CB_ADDSTRING, 0, (LPARAM)plClothingMgr::GroupStrings[i]);
}
selection = fPB->GetInt(ParamID(plLODAvatarComponent::kClothingGroup));
SendMessage(cbox, CB_SETCURSEL, selection, 0);
for (i = 0; i < plArmatureMod::kMaxBoneBase; i++)
{
cbox = GetDlgItem(hWnd, IDC_COMP_AVATAR_SKELETON);
SendMessage(cbox, CB_ADDSTRING, 0, (LPARAM)plArmatureMod::BoneStrings[i]);
}
selection = fPB->GetInt(ParamID(plLODAvatarComponent::kSkeleton));
SendMessage(cbox, CB_SETCURSEL, selection, 0);
Mtl *mat = fPB->GetMtl(plLODAvatarComponent::kMaterial);
Button_SetText(GetDlgItem(hWnd, IDC_COMP_LOD_AVATAR_MTL), (mat ? mat->GetName() : "(none)"));
UpdateBoneDisplay(map);
return true;
}
case WM_COMMAND:
if (LOWORD(wParam) == IDC_COMP_AVATAR_CLOTHING_GROUP)
{
selection = SendMessage(GetDlgItem(hWnd, IDC_COMP_AVATAR_CLOTHING_GROUP), CB_GETCURSEL, 0, 0);
fPB->SetValue(ParamID(plLODAvatarComponent::kClothingGroup), t, selection);
return TRUE;
}
else if (LOWORD(wParam) == IDC_COMP_AVATAR_SKELETON)
{
selection = SendMessage(GetDlgItem(hWnd, IDC_COMP_AVATAR_SKELETON), CB_GETCURSEL, 0, 0);
fPB->SetValue(ParamID(plLODAvatarComponent::kSkeleton), t, selection);
return TRUE;
}
else if (HIWORD(wParam) == BN_CLICKED)
{
if (LOWORD(wParam) == IDC_COMP_LOD_AVATAR_BONE_ADD)
{
std::vector<Class_ID> cids;
cids.push_back(Class_ID(TRIOBJ_CLASS_ID, 0));
cids.push_back(Class_ID(EDITTRIOBJ_CLASS_ID, 0));
if (plPick::NodeRefKludge(fPB, plLODAvatarComponent::kLastPick, &cids, true, false))
fComp->AddSelectedBone();
return TRUE;
}
// Remove the currently selected material
else if (LOWORD(wParam) == IDC_COMP_LOD_AVATAR_BONE_REMOVE)
{
int curSel = SendMessage(hList, LB_GETCURSEL, 0, 0);
if (curSel >= 0)
fComp->RemoveBone(curSel);
return TRUE;
}
else if (LOWORD(wParam) == IDC_COMP_LOD_AVATAR_MTL)
{
Mtl *pickedMtl = plPickMaterialMap::PickMaterial(plMtlCollector::kPlasmaOnly);
fPB->SetValue(plLODAvatarComponent::kMaterial, 0, pickedMtl);
Button_SetText(GetDlgItem(hWnd, IDC_COMP_LOD_AVATAR_MTL), (pickedMtl ? pickedMtl->GetName() : "(none)"));
return TRUE;
}
}
else
{
int LodBeginState = map->GetParamBlock()->GetInt(plLODAvatarComponent::kLODState);
if(fPB->GetINode(plLODAvatarComponent::kMeshNodeAddBtn,t))
fPB->SetValue(plLODAvatarComponent::kMeshNodeTab, t, fPB->GetINode(plLODAvatarComponent::kMeshNodeAddBtn,t), LodBeginState);
if(LOWORD(wParam) == IDC_COMP_LOD_AVATAR_STATE && HIWORD(wParam) == CBN_SELCHANGE)
{
int idx = SendMessage((HWND)lParam, CB_GETCURSEL, 0, 0);
fPB->SetValue(plLODAvatarComponent::kLODState, 0, idx);
if(fPB->GetINode(plLODAvatarComponent::kMeshNodeTab, t, idx))
fPB->SetValue(plLODAvatarComponent::kMeshNodeAddBtn, t, fPB->GetINode(plLODAvatarComponent::kMeshNodeTab,t, idx));
else
fPB->Reset(plLODAvatarComponent::kMeshNodeAddBtn);
return true;
}
}
break;
case WM_CLOSE:
{
int LodBeginState = map->GetParamBlock()->GetInt(plLODAvatarComponent::kLODState);
if(fPB->GetINode(plLODAvatarComponent::kMeshNodeAddBtn,t))
fPB->SetValue(plLODAvatarComponent::kMeshNodeTab, t, fPB->GetINode(plLODAvatarComponent::kMeshNodeAddBtn,t), LodBeginState);
return false;
}
}
return false;
}
// --[ Method ]---------------------------------------------------------------
//
// - Class : CStravaganzaMaxTools
//
// - prototype : bool BuildShaders()
//
// - Purpose : Builds the shader list from MAX's materials.
// Preview mode requires texture files to be stored with full
// path in order to load them. When we export, we only store the
// filename. Another thing is that in the export mode, we copy
// all textures into the path specified by the user if that
// option is checked.
//
// -----------------------------------------------------------------------------
bool CStravaganzaMaxTools::BuildShaders()
{
std::vector<Mtl*>::iterator it;
assert(m_vecShaders.empty());
if(!m_bPreview && m_bCopyTextures && m_strTexturePath == "")
{
CLogger::NotifyWindow("Textures won't be copied\nSpecify a valid output texture path first");
}
LOG.Write("\n\n-Building shaders: ");
for(it = m_vecMaterials.begin(); it != m_vecMaterials.end(); ++it)
{
Mtl* pMaxMaterial = *it;
assert(pMaxMaterial);
LOG.Write("\n %s", pMaxMaterial->GetName().data());
CShaderStandard* pShaderStd = new CShaderStandard;
pShaderStd->SetName(pMaxMaterial->GetName().data());
// Properties
StdMat2 *pMaxStandardMtl = NULL;
StdMat2 *pMaxBakedMtl = NULL;
float fAlpha;
if(pMaxMaterial->ClassID() == Class_ID(DMTL_CLASS_ID, 0))
{
pMaxStandardMtl = (StdMat2 *)pMaxMaterial;
}
else if(pMaxMaterial->ClassID() == Class_ID(BAKE_SHELL_CLASS_ID, 0))
{
pMaxStandardMtl = (StdMat2 *)pMaxMaterial->GetSubMtl(0);
pMaxBakedMtl = (StdMat2 *)pMaxMaterial->GetSubMtl(1);
}
if(pMaxStandardMtl)
{
// Standard material
fAlpha = pMaxStandardMtl->GetOpacity(0);
Shader* pMaxShader = pMaxStandardMtl->GetShader();
CVector4 v4Specular = ColorToVector4(pMaxStandardMtl->GetSpecular(0), 0.0f) * pMaxShader->GetSpecularLevel(0, 0);
pShaderStd->SetAmbient (ColorToVector4(pMaxStandardMtl->GetAmbient(0), 0.0f));
pShaderStd->SetDiffuse (ColorToVector4(pMaxStandardMtl->GetDiffuse(0), fAlpha));
pShaderStd->SetSpecular (v4Specular);
pShaderStd->SetShininess(pMaxShader->GetGlossiness(0, 0) * 128.0f);
if(pMaxStandardMtl->GetTwoSided() == TRUE)
{
pShaderStd->SetTwoSided(true);
}
// Need to cast to StdMat2 in order to get access to IsFaceted().
// ¿Is StdMat2 always the interface for standard materials?
if(((StdMat2*)pMaxStandardMtl)->IsFaceted())
{
pShaderStd->SetFaceted(true);
}
if(pMaxStandardMtl->GetWire() == TRUE)
{
pShaderStd->SetPostWire(true);
pShaderStd->SetWireLineThickness(pMaxStandardMtl->GetWireSize(0));
}
}
else
{
// Material != Standard
fAlpha = 1.0f; // pMaxMaterial->GetXParency();
pShaderStd->SetAmbient (ColorToVector4(pMaxMaterial->GetAmbient(), 0.0f));
pShaderStd->SetDiffuse (ColorToVector4(pMaxMaterial->GetDiffuse(), fAlpha));
pShaderStd->SetSpecular (CVector4(0.0f, 0.0f, 0.0f, 0.0f));
pShaderStd->SetShininess(0.0f);
}
// Layers
if(!pMaxStandardMtl)
{
m_vecShaders.push_back(pShaderStd);
continue;
}
bool bDiffuseMap32Bits = false;
StdMat2 *pStandardMtl;
for(int i = 0; i < 3; i++)
{
int nMap;
pStandardMtl = pMaxStandardMtl;
// 0 = diffuse, 1 == bump, 2 = lightmap (self illumination slot) or envmap (reflection slot)
if(i == 0)
{
nMap = ID_DI;
}
else if(i == 1)
{
nMap = ID_BU;
// If its a baked material, get the bump map from there
if(pMaxBakedMtl)
{
pStandardMtl = pMaxBakedMtl;
}
}
else if(i == 2)
{
bool bBaked = false;
// If its a baked material, get the map2 (lightmap) from there
if(pMaxBakedMtl)
{
if(pMaxBakedMtl->GetMapState(ID_SI) == MAXMAPSTATE_ENABLED)
{
bBaked = true;
nMap = ID_SI;
pStandardMtl = pMaxBakedMtl;
}
}
if(!bBaked)
{
if(pStandardMtl->GetMapState(ID_SI) == MAXMAPSTATE_ENABLED)
{
nMap = ID_SI;
}
else
{
nMap = ID_RL;
}
}
}
// Check validity
if(pStandardMtl->GetMapState(nMap) != MAXMAPSTATE_ENABLED)
{
if(i == 0)
{
LOG.Write("\n No diffuse. Skipping.");
break;
}
continue;
}
Texmap* pMaxTexmap = pStandardMtl->GetSubTexmap(nMap);
if(!pMaxTexmap)
{
if(i == 0)
{
LOG.Write("\n No diffuse. Skipping.");
break;
}
continue;
}
// Get texmaps
std::vector<std::string> vecTextures, vecPaths;
CShaderStandard::SLayerInfo layerInfo;
CShaderStandard::SBitmapInfo bitmapInfo;
if(pMaxTexmap->ClassID() == Class_ID(BMTEX_CLASS_ID, 0))
{
BitmapTex* pMaxBitmapTex = (BitmapTex*)pMaxTexmap;
Bitmap* pMaxBitmap = pMaxBitmapTex->GetBitmap(SECONDS_TO_TICKS(m_fStartTime));
StdUVGen* pMaxUVGen = pMaxBitmapTex->GetUVGen();
if(!pMaxBitmap)
{
if(i == 0)
{
LOG.Write("\n Invalid diffuse. Skipping.");
break;
}
continue;
}
assert(pMaxUVGen);
BitmapInfo bi = pMaxBitmap->Storage()->bi;
// bi.Name() returns the full path
// bi.Filename() returns just the filename
vecTextures.push_back(bi.Filename());
vecPaths. push_back(bi.Name());
LOG.Write("\n Bitmap %s", vecTextures[0].data());
// Check if diffuse texture has alpha channel
if(i == 0)
{
CBitmap bitmap;
CInputFile bitmapFile;
if(!bitmapFile.Open(bi.Name(), false))
{
CLogger::NotifyWindow("WARNING - CStravaganzaMaxTools::BuildShaders():\nUnable to load file %s", bi.Name());
}
else
{
if(!bitmap.Load(&bitmapFile, GetFileExt(bi.Name())))
{
CLogger::NotifyWindow("WARNING - CStravaganzaMaxTools::BuildShaders():\nUnable to load bitmap %s", bi.Name());
}
else
{
if(bitmap.GetBpp() == 32)
{
bDiffuseMap32Bits = true;
LOG.Write(" (with alpha channel)");
}
bitmap.Free();
}
bitmapFile.Close();
}
}
// Ok, copy properties
layerInfo.texInfo.bLoop = false;
layerInfo.texInfo.eTextureType = UtilGL::Texturing::CTexture::TEXTURE2D;
bitmapInfo.strFile = m_bPreview ? bi.Name() : bi.Filename();
bitmapInfo.bTile = ((pMaxUVGen->GetTextureTiling() & (U_WRAP | V_WRAP)) == (U_WRAP | V_WRAP)) ? true : false;
bitmapInfo.fSeconds = 0.0f;
bitmapInfo.bForceFiltering = false;
bitmapInfo.eFilter = UtilGL::Texturing::FILTER_TRILINEAR; // won't be used (forcefiltering = false)
layerInfo.texInfo.m_vecBitmaps.push_back(bitmapInfo);
layerInfo.eTexEnv = nMap == ID_RL ? CShaderStandard::TEXENV_ADD : CShaderStandard::TEXENV_MODULATE;
layerInfo.eUVGen = pMaxUVGen->GetCoordMapping(0) == UVMAP_SPHERE_ENV ? CShaderStandard::UVGEN_ENVMAPPING : CShaderStandard::UVGEN_EXPLICITMAPPING;
layerInfo.uMapChannel = pMaxUVGen->GetMapChannel();
layerInfo.v3ScrollSpeed = CVector3(0.0f, 0.0f, 0.0f);
layerInfo.v3RotationSpeed = CVector3(0.0f, 0.0f, 0.0f);
layerInfo.v3ScrollOffset = CVector3(pMaxUVGen->GetUOffs(0), pMaxUVGen->GetVOffs(0), 0.0f);
layerInfo.v3RotationOffset = CVector3(pMaxUVGen->GetUAng(0), pMaxUVGen->GetVAng(0), pMaxUVGen->GetWAng(0));
}
else if(pMaxTexmap->ClassID() == Class_ID(ACUBIC_CLASS_ID, 0))
{
ACubic* pMaxCubic = (ACubic*)pMaxTexmap;
IParamBlock2* pBlock = pMaxCubic->pblock;
Interval validRange = m_pMaxInterface->GetAnimRange();
for(int nFace = 0; nFace < 6; nFace++)
{
int nMaxFace;
switch(nFace)
{
case 0: nMaxFace = 3; break;
case 1: nMaxFace = 2; break;
case 2: nMaxFace = 1; break;
case 3: nMaxFace = 0; break;
case 4: nMaxFace = 5; break;
case 5: nMaxFace = 4; break;
}
TCHAR *name;
pBlock->GetValue(acubic_bitmap_names, TICKS_TO_SECONDS(m_fStartTime), name, validRange, nMaxFace);
vecPaths.push_back(name);
CStr path, file, ext;
SplitFilename(CStr(name), &path, &file, &ext);
std::string strFile = std::string(file.data()) + ext.data();
vecTextures.push_back(strFile);
bitmapInfo.strFile = m_bPreview ? name : strFile;
bitmapInfo.bTile = false;
bitmapInfo.fSeconds = 0.0f;
bitmapInfo.bForceFiltering = false;
bitmapInfo.eFilter = UtilGL::Texturing::FILTER_TRILINEAR;
layerInfo.texInfo.m_vecBitmaps.push_back(bitmapInfo);
}
layerInfo.texInfo.bLoop = false;
layerInfo.texInfo.eTextureType = UtilGL::Texturing::CTexture::TEXTURECUBEMAP;
layerInfo.eTexEnv = nMap == ID_RL ? CShaderStandard::TEXENV_ADD : CShaderStandard::TEXENV_MODULATE;
layerInfo.eUVGen = CShaderStandard::UVGEN_ENVMAPPING;
layerInfo.uMapChannel = 0;
layerInfo.v3ScrollSpeed = CVector3(0.0f, 0.0f, 0.0f);
layerInfo.v3RotationSpeed = CVector3(0.0f, 0.0f, 0.0f);
layerInfo.v3ScrollOffset = CVector3(0.0f, 0.0f, 0.0f);
layerInfo.v3RotationOffset = CVector3(0.0f, 0.0f, 0.0f);
}
else
{
if(i == 0)
{
LOG.Write("\n No diffuse. Skipping.");
break;
}
continue;
}
if(!m_bPreview && m_bCopyTextures && m_strTexturePath != "")
{
for(int nTex = 0; nTex != vecTextures.size(); nTex++)
{
// Copy textures into the specified folder
std::string strDestPath = m_strTexturePath;
if(strDestPath[strDestPath.length() - 1] != '\\')
{
strDestPath.append("\\", 1);
}
strDestPath.append(vecTextures[nTex]);
if(!CopyFile(vecPaths[nTex].data(), strDestPath.data(), FALSE))
{
CLogger::NotifyWindow("Unable to copy %s to\n%s", vecPaths[i], strDestPath.data());
}
}
}
if(layerInfo.eUVGen == CShaderStandard::UVGEN_ENVMAPPING && i == 1)
{
CLogger::NotifyWindow("%s : Bump with spheremapping not supported", pShaderStd->GetName().data());
}
else
{
// Add layer
switch(i)
{
case 0: pShaderStd->SetLayer(CShaderStandard::LAYER_DIFF, layerInfo); break;
case 1: pShaderStd->SetLayer(CShaderStandard::LAYER_BUMP, layerInfo); break;
case 2: pShaderStd->SetLayer(CShaderStandard::LAYER_MAP2, layerInfo); break;
}
}
}
// ¿Do we need blending?
if(ARE_EQUAL(fAlpha, 1.0f) && !bDiffuseMap32Bits)
{
pShaderStd->SetBlendSrcFactor(UtilGL::States::BLEND_ONE);
pShaderStd->SetBlendDstFactor(UtilGL::States::BLEND_ZERO);
}
else
{
pShaderStd->SetBlendSrcFactor(UtilGL::States::BLEND_SRCALPHA);
pShaderStd->SetBlendDstFactor(UtilGL::States::BLEND_INVSRCALPHA);
}
// Add shader
m_vecShaders.push_back(pShaderStd);
}
return true;
}
void SkeletonExporter::export_particle_spray(INode *node)
{
char sval[50];
Interval range = ip->GetAnimRange();
ObjectState os = node->EvalWorldState(0);
if (!os.obj) return;
SimpleParticle *partsys;
Object *p; IDerivedObject *q; Modifier *m;
partsys=(SimpleParticle *)os.obj;
Point3 row;
Matrix3 mat;
Mtl *materiale;
INode *padre=node->GetParentNode();
int mod_names=0, k, mod_count=0;
char modNames[25][50], refname[50];
int sf, sm, mf, n;
if ((padre) && (strcmp(padre->GetName(), "Scene Root")!=0))
sf=strlen(padre->GetName())+1;
else sf=0;
materiale=node->GetMtl();
if (materiale) sm=strlen(materiale->GetName())+1;
else sm=0;
mf=0;
// trovo i modificatori Wind e Gravity con il loro
// nome
p=node->GetObjOrWSMRef();
if ((p->SuperClassID()==GEN_DERIVOB_CLASS_ID) &&
(p->ClassID()==Class_ID(WSM_DERIVOB_CLASS_ID, 0)))
{
q=(IDerivedObject *)p;
n=q->NumModifiers();
mod_names=mod_count=0;
for (k=0; k<n; k++)
{
m=q->GetModifier(k);
Class_ID cidd = m->ClassID();
if ((cidd==Class_ID(WINDMOD_CLASS_ID, 0)) ||
(cidd==Class_ID(GRAVITYMOD_CLASS_ID, 0)) ||
(cidd==Class_ID(BOMB_OBJECT_CLASS_ID, 0)))
{
SimpleWSMMod *wm=(SimpleWSMMod *)m;
strcpy(refname, wm->nodeRef->GetName());
strcpy(modNames[mod_count], refname);
mod_names+=(strlen(refname)+1);
mod_count++;
}
}
}
write_chunk_header(fA3D, SPRAY_PARTICLE_SYSTEM_ID, node->GetName(),
4+sf+4+sm+ // padre, materiale
12+48+ //pivot, matrice world(t=0)
4+mf+ // nome mesh/oggetto
4+4+4+4+ // emitter: width, height, speed , variation
4+4+4+4+ // life, startTime, stopTime, max_particles
4+mod_names // num WSM, nomi WSM
);
fprintf(fTXT, "Spray particle system found\n");
fprintf(fTXT, "Name : %s\n", node->GetName());
if (padre) fprintf(fTXT, "Parent name : %s\n", node->GetParentNode()->GetName());
if (materiale) fprintf(fTXT, "Material name : %s\n", materiale->GetName());
if (makeADP)
fprintf(fADP, " particle %c%s%c\n {\n", '"', node->GetName(), '"');
// ----------- scrivo il padre (flag, nome) ------------------
fwrite(&sf, sizeof(int), 1, fA3D);
if (sf>0)
{
write_string0(fA3D, padre->GetName());
if (makeADP) fprintf(fADP, " father=%c%s%c;\n", '"', padre->GetName(), '"');
}
else
if (makeADP) fprintf(fADP, " father=%cNONE%c;\n", '"', '"');
// --------- scrivo il materiale di base (flag, nome) ----------
fwrite(&sm, sizeof(int), 1, fA3D);
if (sm>0)
{
write_string0(fA3D, materiale->GetName());
//if (makeADP) fprintf(fADP, " material=%c%s%c;\n", '"', materiale->GetName(), '"');
}
else
//if (makeADP) fprintf(fADP, " material=%cNONE%c;\n", '"', '"');
// --------------- scrittura del punto di pivot ----------------
GetPivotOffset(node, &row);
fprintf(fTXT, "Pivot point : %f, %f, %f\n", row.x, row.y, row.z);
write_point3(&row, fA3D);
// ------------------- scrittura matrice -----------------------
mat = node->GetNodeTM(0);
write_matrix(&mat, fA3D);
// --------- scrittura dell'eventuale nome della mesh ----------
fwrite(&mf, sizeof(int), 1, fA3D);
if (mf>0)
{
write_string0(fA3D, "TO_DO");
if (makeADP) fprintf(fADP, " lod=%cTO_DO, 0, 99999.99%c;\n", '"', '"');
}
// ************* ESPORAZIONE DATI DEL PARTCLE SYSTEM *************
float initVel, var, width, height;
int count, life, start_time, stop_time;
partsys->pblock->GetValue(PB_EMITTERWIDTH, 0, width, FOREVER);
partsys->pblock->GetValue(PB_EMITTERHEIGHT, 0, height, FOREVER);
partsys->pblock->GetValue(PB_SPEED, 0, initVel, FOREVER);
partsys->pblock->GetValue(PB_VARIATION, 0, var, FOREVER);
partsys->pblock->GetValue(PB_LIFETIME, 0, life, FOREVER);
life=life/ GetTicksPerFrame();
partsys->pblock->GetValue(PB_STARTTIME, 0, start_time, FOREVER);
start_time=start_time / GetTicksPerFrame();
stop_time=range.End() / GetTicksPerFrame();
partsys->pblock->GetValue(PB_RNDPARTICLES, 0, count, FOREVER);
fprintf(fTXT, "Emitter width: %f\n", width);
fprintf(fTXT, "Emitter height: %f\n", height);
fprintf(fTXT, "Emitter speed (init vel): %f\n", initVel);
fprintf(fTXT, "Emitter variation: %f\n", var);
fprintf(fTXT, "Life: %d\n", life);
fprintf(fTXT, "Start time: %d\n", start_time);
fprintf(fTXT, "Stop time: %d\n", stop_time);
fprintf(fTXT, "Max particles: %d\n", count);
// informazioni in formato binario (.A3D)
fwrite(&width, sizeof(float), 1, fA3D);
fwrite(&height, sizeof(float), 1, fA3D);
fwrite(&initVel, sizeof(float), 1, fA3D);
fwrite(&var, sizeof(float), 1, fA3D);
fwrite(&life, sizeof(int), 1, fA3D);
fwrite(&start_time, sizeof(int), 1, fA3D);
fwrite(&stop_time, sizeof(int), 1, fA3D);
fwrite(&count, sizeof(int), 1, fA3D);
fwrite(&mod_count, sizeof(int), 1, fA3D);
fprintf(fTXT, "Modificatori (wind, gravity, bomb) collegati: %d\n", mod_count);
for (k=0; k<mod_count; k++)
{
fprintf(fTXT, "Modificatore %d: %s\n", k, modNames[k]);
write_string0(fA3D, modNames[k]);
//if (makeADP)
//fprintf(fADP, " modifier=%c%s, ON%c;\n", '"', modNames[k], '"');
}
//------------------------
// ESPORTAZIONE KEYFRAMER
//------------------------
Control *c;
int size_key;
// NB: per gli oggetti mesh e quant'altre tipologie di
// oggetti che possono essere linkati (ovvero dove e'
// possibile implmenetare gerarchie), esporto SEMPRE una key
// di posizione, una di rotazione ed una di scaling
// POSITION CONTROLLER
c=node->GetTMController()->GetPositionController();
if ((c) && (c->NumKeys()>0))
{
if (IsTCBControl(c)) size_key=36;
else
if (IsBezierControl(c)) size_key=40;
else size_key=16;
fprintf(fTXT, "Particle position track present.\n");
write_chunk_header(fA3D, POSITION_TRACK_ID,
node->GetName(), 1+2+4+c->NumKeys()*size_key);
export_point3_track(c, 1, fA3D);
}
else
{
fprintf(fTXT, "Particle position track present. (1 key case)\n");
if (!c) fprintf(fTXT, "c nullo !\n");
fflush(fTXT);
size_key=36;
write_chunk_header(fA3D, POSITION_TRACK_ID,
node->GetName(), 1+2+4+1*size_key);
export_1key_point3_track(c, 1, fA3D);
}
// ROTATION CONTROLLER
c=node->GetTMController()->GetRotationController();
if ((c) && (c->NumKeys()>0))
{
if (IsTCBControl(c)) size_key=40;
else size_key=20;
fprintf(fTXT, "Particle rotation track present.\n");
write_chunk_header(fA3D, ROTATION_TRACK_ID,
node->GetName(), 1+2+4+c->NumKeys()*size_key);
export_rot_track(c, fA3D);
}
else
{
fprintf(fTXT, "Particle rotation track present. (1 key case)\n");
fflush(fTXT);
size_key=40;
write_chunk_header(fA3D, ROTATION_TRACK_ID,
node->GetName(), 1+2+4+1*size_key);
export_1key_rot_track(c, fA3D);
}
// SCALE CONTROLLER
c=node->GetTMController()->GetScaleController();
if ((c) && (c->NumKeys()>0))
{
if (IsTCBControl(c)) size_key=36;
else
if (IsBezierControl(c)) size_key=40;
else size_key=16;
fprintf(fTXT, "Particle scaling track present.\n");
write_chunk_header(fA3D, SCALE_TRACK_ID,
node->GetName(), 1+2+4+c->NumKeys()*size_key);
export_scale_track(c, fA3D);
}
else
{
fprintf(fTXT, "Particle scaling track present. (1 key case)\n");
size_key=36;
write_chunk_header(fA3D, SCALE_TRACK_ID,
node->GetName(), 1+2+4+1*size_key);
export_1key_scale_track(c, fA3D);
}
// keyframer emitter width
c=partsys->pblock->GetController(PB_EMITTERWIDTH);
if ((c) && (c->NumKeys()>0))
{
if (IsTCBControl(c)) size_key=28;
else
if (IsBezierControl(c)) size_key=16;
else size_key=8;
fprintf(fTXT, "Particle emitter width track present.\n");
write_chunk_header(fA3D, PARTICLE_EMITTER_WIDTH_TRACK_ID,
node->GetName(), 1+2+4+c->NumKeys()*size_key);
export_float_track(c, 1, fA3D);
}
// keyframer emitter length
c=partsys->pblock->GetController(PB_EMITTERHEIGHT);
if ((c) && (c->NumKeys()>0))
{
if (IsTCBControl(c)) size_key=28;
else
if (IsBezierControl(c)) size_key=16;
else size_key=8;
fprintf(fTXT, "Particle emitter length track present.\n");
write_chunk_header(fA3D, PARTICLE_EMITTER_LENGTH_TRACK_ID,
node->GetName(), 1+2+4+c->NumKeys()*size_key);
export_float_track(c, 1, fA3D);
}
// keyframer particles speed
c=partsys->pblock->GetController(PB_SPEED);
if ((c) && (c->NumKeys()>0))
{
if (IsTCBControl(c)) size_key=28;
else
if (IsBezierControl(c)) size_key=16;
else size_key=8;
fprintf(fTXT, "Particle emitter speed track present.\n");
write_chunk_header(fA3D, PARTICLE_EMITTER_SPEED_TRACK_ID,
node->GetName(), 1+2+4+c->NumKeys()*size_key);
export_float_track(c, 1, fA3D);
}
// keyframer particles variations
c=partsys->pblock->GetController(PB_VARIATION);
if ((c) && (c->NumKeys()>0))
{
if (IsTCBControl(c)) size_key=28;
else
if (IsBezierControl(c)) size_key=16;
else size_key=8;
fprintf(fTXT, "Particle emitter variation track present.\n");
write_chunk_header(fA3D, PARTICLE_EMITTER_VARIATION_TRACK_ID,
node->GetName(), 1+2+4+c->NumKeys()*size_key);
export_float_track(c, 1, fA3D);
}
if (makeADP)
{
fprintf(fADP, " texture=%cNONE%c;\n", '"', '"');
my_ftoa(width, sval);
fprintf(fADP, " emitter_width=%c%s%c;\n", '"', sval, '"');
my_ftoa(height, sval);
fprintf(fADP, " emitter_height=%c%s%c;\n", '"', sval, '"');
fprintf(fADP, " faded_particles=%cOFF%c;\n", '"', '"');
fprintf(fADP, " max_particles=%c%d%c;\n", '"', count, '"');
fprintf(fADP, " start_time=%c%d%c;\n", '"', start_time, '"');
fprintf(fADP, " end_time=%c%d%c;\n", '"', stop_time, '"');
fprintf(fADP, " life=%c%d%c;\n", '"', life, '"');
my_ftoa(initVel, sval);
fprintf(fADP, " speed=%c%s%c;\n", '"', sval, '"');
my_ftoa(var, sval);
fprintf(fADP, " variation=%c%s%c;\n", '"', sval, '"');
fprintf(fADP, " size_attenuation=%c0.4, 1.0, 0.8, 0.1%c;\n", '"', '"');
fprintf(fADP, " }\n\n");
}
fprintf(fTXT, "\n\n");
}
//----------------------------------------------------------------------------
void SceneBuilder::ConvertMaterial (Mtl &mtl, MtlTree &mtlTree)
{
// 光照属性
PX2::Shine *shine = new0 PX2::Shine;
Color color = mtl.GetAmbient();
float alpha = 1.0f - mtl.GetXParency();
shine->Ambient = PX2::Float4(color.r, color.g, color.b, 1.0f);
color = mtl.GetDiffuse();
shine->Diffuse = PX2::Float4(color.r, color.g, color.b, alpha);
color = mtl.GetSpecular();
float shininess = mtl.GetShininess()*2.0f;
shine->Specular = PX2::Float4(color.r, color.g, color.b, shininess);
const char *name = (const char*)mtl.GetName();
shine->SetName(name);
mtlTree.SetShine(shine);
bool IsDirect9Shader = false;
if (mtl.ClassID() == Class_ID(CMTL_CLASS_ID, 0)
|| mtl.ClassID() == Class_ID(DMTL_CLASS_ID, 0))
{
StdMat2 *stdMat2 = (StdMat2*)(&mtl);
Interval valid = FOREVER;
stdMat2->Update(mTimeStart, valid);
std::string strName(stdMat2->GetName());
bool doubleSide = (stdMat2->GetTwoSided()==1);
char strBitMapName[256];
memset(strBitMapName, 0, 256*sizeof(char));
std::string resourcePath;
PX2::Shader::SamplerFilter filter = PX2::Shader::SF_LINEAR_LINEAR;
PX2::Shader::SamplerCoordinate uvCoord = PX2::Shader::SC_REPEAT;
PX2_UNUSED(uvCoord);
if (stdMat2->MapEnabled(ID_DI))
{
BitmapTex *tex = (BitmapTex*)stdMat2->GetSubTexmap(ID_DI);
BitmapInfo bI;
const char *mapName = tex->GetMapName();
TheManager->GetImageInfo(&bI, mapName);
strcpy(strBitMapName, bI.Name());
std::string fullName = std::string(strBitMapName);
std::string::size_type sizeT = fullName.find_first_not_of(mSettings->SrcRootDir);
resourcePath = std::string(strBitMapName).substr(sizeT);
StdUVGen* uvGen = tex->GetUVGen();
PX2_UNUSED(uvGen);
int filType = tex->GetFilterType();
switch (filType)
{
case FILTER_PYR:
filter = PX2::Shader::SF_LINEAR_LINEAR;
break;
case FILTER_SAT:
filter = PX2::Shader::SF_NEAREST;
break;
default:
break;
}
}
else
{
sprintf(strBitMapName, "%s/%s", mSettings->SrcRootDir, PX2_DEFAULT_TEXTURE);
resourcePath = PX2_DEFAULT_TEXTURE;
}
PX2::Texture2D *tex2d = PX2::DynamicCast<PX2::Texture2D>(
PX2::ResourceManager::GetSingleton().BlockLoad(strBitMapName));
tex2d->SetResourcePath(resourcePath);
if (tex2d)
{
PX2::Texture2DMaterial *tex2dMtl = new0 PX2::Texture2DMaterial(filter,
uvCoord, uvCoord);
if (doubleSide)
{
tex2dMtl->GetCullProperty(0, 0)->Enabled = false;
}
PX2::MaterialInstance *instance = tex2dMtl->CreateInstance(tex2d);
mtlTree.SetMaterialInstance(instance);
}
else
{
PX2::VertexColor4Material *vcMtl = new0 PX2::VertexColor4Material();
PX2::MaterialInstance *instance = vcMtl->CreateInstance();
mtlTree.SetMaterialInstance(instance);
}
}
else if (mtl.ClassID() == Class_ID(MULTI_CLASS_ID, 0))
{
}
else if (mtl.ClassID() == DIRECTX_9_SHADER_CLASS_ID)
{
IsDirect9Shader = true;
IDxMaterial* dxMtl = (IDxMaterial*)mtl.GetInterface(IDXMATERIAL_INTERFACE);
char *effectName = dxMtl->GetEffectFilename();
IParamBlock2 *paramBlock = mtl.GetParamBlock(0);
std::string outPath;
std::string outBaseName;
std::string outExtention;
PX2::StringHelp::SplitFullFilename(effectName, outPath, outBaseName,
outExtention);
PX2::ShinePtr shineStandard = new0 PX2::Shine();
bool alphaVertex = false;
PX2::Texture2DPtr diffTex;
bool normalEnable = false;
PX2::Texture2DPtr normalTex;
float normalScale = 0.0f;
bool specEnable = false;
PX2::Texture2DPtr specTex;
float specPower = 0.0f;
bool reflectEnable = false;
PX2::TextureCubePtr reflectTex;
float reflectPower = 0.0f;
bool doubleSide = false;
int blendMode = 2;
ParamBlockDesc2 *paramDesc = 0;
int numParam = 0;
if (paramBlock)
{
paramDesc = paramBlock->GetDesc();
numParam = paramBlock->NumParams();
ParamType2 paramType;
for (int i=0; i<numParam; i++)
{
std::string parmName;
PX2::Float4 color4 = PX2::Float4(0.0f, 0.0f, 0.0f, 0.0f);
PX2::Float3 color3 = PX2::Float3(0.0f, 0.0f, 0.0f);
float floatValue = 0.0f;
bool boolValue = false;
float *floatTable = 0;
int intValue = 0;
std::string str;
PX2::Texture2D *tex2d = 0;
paramType = paramBlock->GetParameterType((ParamID)i);
if (TYPE_STRING == paramType)
ConvertStringAttrib(paramBlock, i, parmName, str);
else if (TYPE_FLOAT == paramType)
ConvertFloatAttrib(paramBlock, i, parmName, floatValue);
else if (TYPE_INT == paramType)
ConvertIntAttrib(paramBlock, i, parmName, intValue);
else if (TYPE_RGBA == paramType)
ConvertColorAttrib(paramBlock, i, parmName, color4, i);
else if (TYPE_POINT3 == paramType)
ConvertPoint3Attrib(paramBlock, i, parmName, color3);
else if (TYPE_POINT4 == paramType)
ConvertPoint4Attrib(paramBlock, i, parmName, color4);
else if (TYPE_BOOL == paramType)
ConvertBoolAttrib(paramBlock, i, parmName, boolValue);
else if (TYPE_FLOAT_TAB == paramType)
ConvertFloatTabAttrib(paramBlock, i, parmName, floatTable);
else if (TYPE_BITMAP == paramType)
ConvertBitMapAttrib(paramBlock, i, parmName, tex2d);
else if (TYPE_FRGBA ==paramType)
ConvertFRGBAAttrib(paramBlock, i, parmName, color4);
// shine
if (parmName == "gBlendMode")
{
blendMode = intValue;
}
else if (parmName == "gShineEmissive")
{
shineStandard->Emissive = color4;
}
else if (parmName == "gShineAmbient")
{
shineStandard->Ambient = color4;
}
else if (parmName == "gShineDiffuse")
{
shineStandard->Diffuse = color4;
}
// alpha vertex
else if (parmName == "gAlphaVertex")
{
alphaVertex = boolValue;
}
// diffuse
else if (parmName == "gDiffuseTexture")
{
diffTex = tex2d;
}
// normal
else if (parmName == "gNormalEnable")
{
normalEnable = boolValue;
}
else if (parmName == "gNormalTexture")
{
normalTex = tex2d;
}
else if (parmName == "gNormalScale")
{
normalScale = floatValue;
}
// specular
else if (parmName == "gSpecularEnable")
{
specEnable = boolValue;
}
else if (parmName == "gSpecularTexture")
{
specTex = tex2d;
}
else if (parmName == "gSpecularPower")
{
specPower = floatValue;
}
// reflect
else if (parmName == "gReflectionEnable")
{
reflectEnable = boolValue;
}
else if (parmName == "gReflectTexture")
{
//reflectTex = tex2d;
}
else if (parmName == "gReflectPower")
{
reflectPower = floatValue;
}
// other
else if (parmName == "gDoubleSide")
{
doubleSide = boolValue;
}
}
}
PX2::MaterialInstance *inst = 0;
PX2::StandardMaterial *standardMtl = 0;
PX2::StandardESMaterial_Default *standardESMtl_D = 0;
PX2::StandardESMaterial_Specular *standardESMtl_S = 0;
if (outBaseName == "Standard")
{
char mtlName[256];
memset(mtlName, 0, 256*sizeof(char));
sprintf(mtlName, "%s/%s", mSettings->DstRootDir,
"Data/mtls/Standard.pxfx");
standardMtl = new0 PX2::StandardMaterial(mtlName);
}
else if (outBaseName == "StandardES")
{
if (false == specEnable)
{
standardESMtl_D = new0 PX2::StandardESMaterial_Default();
if (0 == blendMode)
{
standardESMtl_D->GetAlphaProperty(0, 0)->BlendEnabled = false;
standardESMtl_D->GetAlphaProperty(0, 0)->CompareEnabled = false;
}
else if (1 == blendMode)
{
standardESMtl_D->GetAlphaProperty(0, 0)->BlendEnabled = true;
}
else if (2 == blendMode)
{
standardESMtl_D->GetAlphaProperty(0, 0)->BlendEnabled = false;
standardESMtl_D->GetAlphaProperty(0, 0)->CompareEnabled = true;
standardESMtl_D->GetAlphaProperty(0, 0)->Compare = PX2::AlphaProperty::CM_GEQUAL;
standardESMtl_D->GetAlphaProperty(0, 0)->Reference = 0.2f;
}
}
else
{
char mtlName[256];
memset(mtlName, 0, 256*sizeof(char));
sprintf(mtlName, "%s/%s", mSettings->DstRootDir,
"Data/mtls/StandardES_Specular.pxfx");
standardESMtl_S = new0 PX2::StandardESMaterial_Specular(mtlName);
}
}
if (standardMtl && diffTex)
{
if (doubleSide)
{
standardMtl->GetCullProperty(0, 0)->Enabled = false;
}
inst = standardMtl->CreateInstance(diffTex, alphaVertex,
normalEnable, normalTex, normalScale, specEnable, specTex,
specPower, 0, shineStandard);
}
else if (standardESMtl_D && diffTex)
{
if (doubleSide)
{
standardESMtl_D->GetCullProperty(0, 0)->Enabled = false;
}
inst = standardESMtl_D->CreateInstance(diffTex, 0, shineStandard);
}
else if (standardESMtl_S && diffTex && specTex)
{
if (doubleSide)
{
standardESMtl_S->GetCullProperty(0, 0)->Enabled = false;
}
inst = standardESMtl_S->CreateInstance(diffTex, specTex, specPower,
0, shineStandard);
}
if (inst)
{
mtlTree.SetMaterialInstance(inst);
}
else
{
PX2::MaterialInstance *instance =
PX2::VertexColor4Material::CreateUniqueInstance();
mtlTree.SetMaterialInstance(instance);
}
}
else
{
PX2::VertexColor4Material *vcMtl = new0 PX2::VertexColor4Material();
PX2::MaterialInstance *instance = vcMtl->CreateInstance();
mtlTree.SetMaterialInstance(instance);
}
// 对子材质进行处理
if (IsDirect9Shader)
return;
int mQuantity = mtl.NumSubMtls(); // Class_ID(MULTI_CLASS_ID, 0)
if (mQuantity > 0)
{
mtlTree.SetMChildQuantity(mQuantity);
for (int i=0; i<mQuantity; i++)
{
Mtl *subMtl = 0;
subMtl = mtl.GetSubMtl(i);
if (subMtl)
{
ConvertMaterial(*subMtl, mtlTree.GetMChild(i));
}
}
}
}
/*
====================
GatherSkin
====================
*/
void G3DSExport::GatherSkin(INode* i_node)
{
SKIN skin;
// get the name of the node
skin.name = i_node->GetName();
// get the skin interface
Modifier *modifier = GetModifier(i_node,SKIN_CLASSID);
ISkin* i_skin = (ISkin*)modifier->GetInterface(I_SKIN);
MAX_CHECK(i_skin);
// convert to the triangle type
Mesh* i_mesh = NULL;
Object* obj = i_node->EvalWorldState(mTime).obj;
if(obj && ( obj->SuperClassID() == GEOMOBJECT_CLASS_ID ))
{
if(obj->CanConvertToType(Class_ID(TRIOBJ_CLASS_ID, 0)))
{
TriObject *tri_obj = (TriObject*)obj->ConvertToType(mTime, Class_ID(TRIOBJ_CLASS_ID, 0)); MAX_CHECK(tri_obj);
i_mesh = &tri_obj->mesh;
}
}
MAX_CHECK(i_mesh&&i_mesh->getNumFaces()&&i_mesh->getNumVerts());
// get the material
skin.texture = "textures/default.tga";
Mtl* mtl = i_node->GetMtl();
if(mtl && (mtl->ClassID()==Class_ID(DMTL_CLASS_ID, 0)) && ((StdMat*)mtl)->MapEnabled(ID_DI))
{
Texmap *texmap = mtl->GetSubTexmap(ID_DI);
if(texmap && texmap->ClassID() == Class_ID(BMTEX_CLASS_ID, 0x00))
{
skin.texture = UnifySlashes(((BitmapTex *)texmap)->GetMapName());
if( !strstr( skin.texture.c_str(), mPath.c_str() ) )
{
G3DAssert("The material(%s) is error : the texture path(%s) is illegal!",mtl->GetName(), skin.texture.c_str());
}
else
{
skin.texture = strstr(skin.texture.c_str(),mPath.c_str()) + strlen(mPath.c_str());
}
}
}
// if it has uvs
int map_count = i_mesh->getNumMaps();
bool has_uvs = i_mesh->getNumTVerts() && i_mesh->tvFace;
if(!(has_uvs&&map_count)) { G3DAssert("The skin(%s) has not the uv coordinates.",skin.name.c_str()); return; }
// get the transform
Matrix3 mesh_matrix = i_node->GetObjectTM(mTime);
Matrix3 node_matrix = i_node->GetNodeTM(mTime);
Matrix3 transform = mesh_matrix * Inverse(node_matrix);
// get the points
skin.points.assign(i_mesh->verts, i_mesh->verts+i_mesh->getNumVerts());
// get the triangles
for(int i = 0; i < i_mesh->getNumFaces(); i++)
{
Face& face = i_mesh->faces[i];
TRIANGLE tri;
tri.smoothing = face.smGroup;
for(int j = 0; j < 3; j++)
{
VPTNIS v;
v.pos = transform * i_mesh->verts[face.v[j]];
// get the uv
UVVert * map_verts = i_mesh->mapVerts(1);
TVFace * map_faces = i_mesh->mapFaces(1);
v.uv = reinterpret_cast<Point2&>(map_verts[map_faces[i].t[j]]);
v.uv.y = 1 - v.uv.y;
// initialize the normal
v.normal = Point3::Origin;
// get the vertex index
v.index = face.v[j];
// get the smoothing group
v.smoothing = face.smGroup;
// set the index for the triangle
tri.index0[j] = v.index;
// reassemble the vertex list
tri.index1[j] = AddVertex(skin, v);
}
// add the triangle to the table
skin.triangles.push_back(tri);
}
// build the index map
for( int i = 0; i < skin.vertexes.size(); i++ )
{
skin.vertex_index_map[skin.vertexes[i].index].push_back(i);
}
// get the skin context data
ISkinContextData* i_skin_context_data = i_skin->GetContextInterface(i_node);
if(i_skin_context_data == NULL) { G3DAssert("The skin(%s) has not the weight.",skin.name.c_str()); return; }
// gets the initial matrix of the skinned object
Matrix3 initial_object_transform;
i_skin->GetSkinInitTM(i_node, initial_object_transform, true);
// process the points
int num_points = i_skin_context_data->GetNumPoints();
for(int i = 0; i < num_points; i++)
{
MAX_CHECK(i < skin.points.size());
VPIW viw;
// get the initial point
viw.pos = initial_object_transform * skin.points[i];
// process the weights
std::multimap< float, int > weights;
// get the number of bones that control this vertex
int num_bones = i_skin_context_data->GetNumAssignedBones(i);
if(num_bones>0)
{
for (int j = 0; j < num_bones; j++)
{
Matrix3 transform;
// get the assigned bone of the point
INode* i_bone_node = i_skin->GetBone(i_skin_context_data->GetAssignedBone(i, j));
MAX_CHECK(i_bone_node != NULL);
// get the weight of the bone
float weight = i_skin_context_data->GetBoneWeight(i, j);
// add the weight to the table
weights.insert(std::make_pair(weight, AddBone(skin,i_bone_node)));
}
}
else
{
// add the weight to the table
weights.insert(std::make_pair(1.f, AddBone(skin,i_node)));
}
// recalculate the weights
float weight0 = 0.f, weight1 = 0.f, weight2 = 0.f;
int index0 = 0, index1 = 0, index2 = 0;
std::multimap< float, int >::iterator it = weights.end();
it--;
weight0 = it->first;
index0 = it->second;
if(it != weights.begin())
{
it--;
weight1 = it->first;
index1 = it->second;
if(it != weights.begin())
{
it--;
weight2 = it->first;
index2 = it->second;
}
}
float sum_weights = weight0 + weight1 + weight2;
// store the skin weights
viw.weight[0] = weight0/sum_weights;
viw.index[0] = index0;
viw.weight[1] = weight1/sum_weights;
viw.index[1] = index1;
viw.weight[2] = weight2/sum_weights;
viw.index[2] = index2;
skin.weights.push_back(viw);
}
// get the initial transforms
skin.transforms.resize(skin.bones.size());
for(int i = 0; i < skin.bones.size(); i++)
{
INode* node = skin.bones[i];
Matrix3 mat;
if (SKIN_INVALID_NODE_PTR == i_skin->GetBoneInitTM( node, mat ))
{
if (SKIN_INVALID_NODE_PTR == i_skin->GetSkinInitTM( node, mat ))
{
mat.IdentityMatrix();
}
}
skin.transforms[i] = Inverse(mat);
}
// there is a 75 bone limit for each skinned object.
if(skin.bones.size()>75)
{
G3DAssert("There are more %d bones in the skin(%s).",skin.bones.size(), i_node->GetName());
return;
}
// reset the skin vertex position
for(int i = 0; i < skin.vertexes.size(); i++)
{
VPTNIS& v0 = skin.vertexes[i];
VPIW& v1 = skin.weights[v0.index];
v0.pos = v1.pos;
}
// build the normal space
BuildNormal(skin);
// calculate the bounding box
skin.box.Init();
for(int i = 0; i < skin.vertexes.size(); i++)
{
Point3 pt = node_matrix * skin.vertexes[i].pos;
skin.box += pt;
}
// add the skin to the table
mSkins.push_back(skin);
}
BOOL plClothingComponentProc::DlgProc(TimeValue t, IParamMap2 *pm, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
IParamBlock2 *pb = pm->GetParamBlock();
HWND hList = GetDlgItem(hWnd, IDC_CLOTHING_LIST);
HWND hGroup = GetDlgItem(hWnd, IDC_CLOTHING_GROUP);
HWND hType = GetDlgItem(hWnd, IDC_CLOTHING_TYPE);
HWND hLOD = GetDlgItem(hWnd, IDC_COMP_LOD_CLOTHING_STATE);
switch (msg)
{
case WM_INITDIALOG:
{
ListBox_ResetContent(hList);
int i;
for (i = 0; i < pb->Count(plClothingComponent::kMaterials); i++)
ListBox_AddString(hList, pb->GetMtl(ParamID(plClothingComponent::kMaterials), 0, i)->GetName());
ListBox_SetCurSel(hList, -1);
for (i = 0; i < plClothingMgr::kMaxGroup; i++)
ComboBox_AddString(hGroup, plClothingMgr::GroupStrings[i]);
ComboBox_SetCurSel(hGroup, pb->GetInt(plClothingComponent::kGroup));
for (i = 0; i < plClothingMgr::kMaxType; i++)
ComboBox_AddString(hType, plClothingMgr::TypeStrings[i]);
ComboBox_SetCurSel(hType, pb->GetInt(plClothingComponent::kType));
ComboBox_AddString(hLOD, "High");
ComboBox_AddString(hLOD, "Medium");
ComboBox_AddString(hLOD, "Low");
ComboBox_SetCurSel(hLOD, pb->GetInt(plClothingComponent::kLODState));
}
return TRUE;
case WM_COMMAND:
if (HIWORD(wParam) == BN_CLICKED)
{
if (LOWORD(wParam) == IDC_CLOTHING_ADD)
{
Mtl *pickedMtl = plPickMaterialMap::PickMaterial(plMtlCollector::kClothingMtlOnly);
if (pickedMtl != nil)
{
LRESULT stringIdx = ListBox_FindStringExact(hList, -1, pickedMtl->GetName());
if (stringIdx == LB_ERR) // It's not already there, go and add it
{
pb->Append(ParamID(plClothingComponent::kMaterials), 1, &pickedMtl, 0);
ListBox_AddString(hList, pickedMtl->GetName());
}
}
return TRUE;
}
// Remove the currently selected material
else if (LOWORD(wParam) == IDC_CLOTHING_REMOVE)
{
int sel = ListBox_GetCurSel(hList);
if (sel != LB_ERR)
{
pb->Delete(plClothingComponent::kMaterials, sel, 1);
ListBox_DeleteString(hList, sel);
}
return TRUE;
}
else if( LOWORD( wParam ) == IDC_CLOTHING_CLEARMESH )
{
int state = pb->GetInt(plClothingComponent::kLODState);
pb->SetValue(plClothingComponent::kMeshNodeTab, 0, (INode*)nil, state );
pb->Reset(plClothingComponent::kMeshNodeAddBtn);
}
}
else if (LOWORD(wParam) == IDC_CLOTHING_GROUP)
{
int setIdx = ComboBox_GetCurSel(hGroup);
pb->SetValue(plClothingComponent::kGroup, 0, setIdx);
return TRUE;
}
else if (LOWORD(wParam) == IDC_CLOTHING_TYPE)
{
int setIdx = ComboBox_GetCurSel(hType);
pb->SetValue(plClothingComponent::kType, 0, setIdx);
return TRUE;
}
else
{
int state = pb->GetInt(plClothingComponent::kLODState);
INode *node = pb->GetINode(plClothingComponent::kMeshNodeAddBtn);
if (node)
pb->SetValue(plClothingComponent::kMeshNodeTab, 0, node, state);
if(LOWORD(wParam) == IDC_COMP_LOD_CLOTHING_STATE && HIWORD(wParam) == CBN_SELCHANGE)
{
int idx = SendMessage((HWND)lParam, CB_GETCURSEL, 0, 0);
pb->SetValue(plClothingComponent::kLODState, 0, idx);
node = pb->GetINode(plClothingComponent::kMeshNodeTab, 0, idx);
if (node)
pb->SetValue(plClothingComponent::kMeshNodeAddBtn, 0, node);
else
pb->Reset(plClothingComponent::kMeshNodeAddBtn);
return TRUE;
}
}
}
return FALSE;
}
