int EnumMtlTree(MtlBase *mb, int subMtl, MtlEnum &tenum)
{
for (int i=0; i<mb->NumSubTexmaps(); i++) {
Texmap *st = mb->GetSubTexmap(i);
if (st) {
if (!EnumMtlTree(st,subMtl, tenum)) {
return 0;
}
}
}
if (IsTex(mb)) {
if (!tenum.proc(mb,subMtl)) {
return 0;
}
}
if (IsMtl(mb)) {
Mtl *m = (Mtl *)mb;
for (i=0; i<m->NumSubMtls(); i++) {
Mtl *sm = m->GetSubMtl(i);
int subm = (mb->IsMultiMtl()&&subMtl<0)?i:subMtl;
if (sm) {
if (!EnumMtlTree(sm,subm,tenum)) {
return 0;
}
}
}
if (!tenum.proc(mb,subMtl)) {
return 0;
}
}
return 1;
}
void SceneExportUtil::getUsedMaterials( INode* node, Vector<Mtl*>& materials )
{
require( node );
Mtl* mat = node->GetMtl();
if ( mat )
{
materials.add( mat );
// get sub-materials (Multi/Sub-Object material)
for ( int k = 0 ; k < mat->NumSubMtls() ; ++k )
{
Mtl* submat = mat->GetSubMtl(k);
if ( submat )
materials.add( submat );
}
}
// remove duplicates
std::sort( materials.begin(), materials.end() );
std::unique( materials.begin(), materials.end() );
// sort to abc order
std::sort( materials.begin(), materials.end(), MtlNameLess() );
}
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;
}
static void extractTriangleGeometry( GmModel* gm, INode* node, Mesh* mesh, Mtl* material )
{
#ifdef SGEXPORT_PHYSIQUE
Modifier* phyMod = 0;
IPhysiqueExport* phyExport = 0;
IPhyContextExport* mcExport = 0;
#endif
Modifier* skinMod = 0;
ISkin* skin = 0;
String nodeName ( node->GetName() );
try
{
// vertex transform to left-handed system
Matrix3 pivot = TmUtil::getPivotTransform( node );
Matrix3 vertexTM = pivot * s_convtm;
bool insideOut = TmUtil::hasNegativeParity( pivot );
/*Matrix4x4 pm = TmUtil::toLH( vertexTM );
Debug::println( "Object {0} vertex local TM is", nodeName );
Debug::println( " {0,#.###} {1,#.###} {2,#.###} {3,#.###}", pm(0,0), pm(0,1), pm(0,2), pm(0,3) );
Debug::println( " {0,#.###} {1,#.###} {2,#.###} {3,#.###}", pm(1,0), pm(1,1), pm(1,2), pm(1,3) );
Debug::println( " {0,#.###} {1,#.###} {2,#.###} {3,#.###}", pm(2,0), pm(2,1), pm(2,2), pm(2,3) );
Debug::println( " {0,#.###} {1,#.###} {2,#.###} {3,#.###}", pm(3,0), pm(3,1), pm(3,2), pm(3,3) );*/
// add vertex positions
int vertices = mesh->getNumVerts();
for ( int vi = 0 ; vi < vertices ; ++vi )
{
Point3 v = vertexTM * mesh->verts[vi];
mb::Vertex* vert = gm->addVertex();
vert->setPosition( v.x, v.y, v.z );
}
// add vertex weights (from Physique modifier)
#ifdef SGEXPORT_PHYSIQUE
phyMod = PhyExportUtil::findPhysiqueModifier( node );
if ( phyMod )
{
Debug::println( " Found Physique modifier: {0}", gm->name );
// get (possibly shared) Physique export interface
phyExport = (IPhysiqueExport*)phyMod->GetInterface( I_PHYINTERFACE );
if( !phyExport )
throw Exception( Format("No Physique modifier export interface") );
// export from initial pose?
phyExport->SetInitialPose( false );
// get (unique) context dependent export inteface
mcExport = (IPhyContextExport*)phyExport->GetContextInterface( node );
if( !mcExport )
throw Exception( Format("No Physique modifier context export interface") );
// convert to rigid for time independent vertex assignment
mcExport->ConvertToRigid( true );
// allow blending to export multi-link assignments
mcExport->AllowBlending( true );
// list bones
Vector<INode*> bones( Allocator<INode*>(__FILE__,__LINE__) );
PhyExportUtil::listBones( mcExport, bones );
// add vertex weight maps
for ( int i = 0 ; i < bones.size() ; ++i )
{
INode* bone = bones[i];
String name = bone->GetName();
mb::VertexMap* vmap = gm->addVertexMap( 1, name, mb::VertexMapFormat::VERTEXMAP_WEIGHT );
PhyExportUtil::addWeights( vmap, bone, mcExport );
}
}
#endif // SGEXPORT_PHYSIQUE
// add vertex weights (from Skin modifier)
skinMod = SkinExportUtil::findSkinModifier( node );
if ( skinMod )
{
skin = (ISkin*)skinMod->GetInterface(I_SKIN);
require( skin );
ISkinContextData* skincx = skin->GetContextInterface( node );
require( skincx );
Debug::println( " Found Skin modifier: {0} ({1} bones, {2} points)", gm->name, skin->GetNumBones(), skincx->GetNumPoints() );
if ( skincx->GetNumPoints() != gm->vertices() )
throw Exception( Format("Only some vertices ({0}/{1}) of {2} are skinned", skincx->GetNumPoints(), gm->vertices(), gm->name) );
// list bones
Vector<INode*> bones( Allocator<INode*>(__FILE__,__LINE__) );
SkinExportUtil::listBones( skin, bones );
// add vertex weight maps
for ( int i = 0 ; i < bones.size() ; ++i )
{
INode* bone = bones[i];
String name = bone->GetName();
mb::VertexMap* vmap = gm->addVertexMap( 1, name, mb::VertexMapFormat::VERTEXMAP_WEIGHT );
SkinExportUtil::addWeights( vmap, bone, skin, skincx );
//Debug::println( " Bone {0} is affecting {1} vertices", name, vmap->size() );
}
// DEBUG: print skin node tm and initial object tm
/*Matrix3 tm;
int ok = skin->GetSkinInitTM( node, tm );
require( ok == SKIN_OK );
Debug::println( " NodeInitTM of {0}", nodeName );
TmUtil::println( tm, 4 );
ok = skin->GetSkinInitTM( node, tm, true );
require( ok == SKIN_OK );
Debug::println( " NodeObjectTM of {0}", nodeName );
TmUtil::println( tm, 4 );*/
// DEBUG: print bones
/*Debug::println( " bones of {0}:", nodeName );
for ( int i = 0 ; i < bones.size() ; ++i )
{
Debug::println( " bone ({0}): {1}", i, String(bones[i]->GetName()) );
skin->GetBoneInitTM( bones[i], tm );
Debug::println( " InitNodeTM:" );
TmUtil::println( tm, 6 );
skin->GetBoneInitTM( bones[i], tm, true );
Debug::println( " InitObjectTM:" );
TmUtil::println( tm, 6 );
}*/
// DEBUG: print bones used by the points
/*for ( int i = 0 ; i < skincx->GetNumPoints() ; ++i )
{
int bonec = skincx->GetNumAssignedBones(i);
Debug::println( " point {0} has {1} bones", i, bonec );
for ( int k = 0 ; k < bonec ; ++k )
{
int boneidx = skincx->GetAssignedBone( i, k );
float w = skincx->GetBoneWeight( i, k );
Debug::println( " point {0} boneidx ({1}): {2}, weight {3}", i, k, boneidx, w );
}
}*/
}
// ensure clockwise polygon vertex order
int vx[3] = {2,1,0};
if ( insideOut )
{
int tmp = vx[0];
vx[0] = vx[2];
vx[2] = tmp;
}
// list unique materials used by the triangles
Vector<ShellMaterial> usedMaterials( Allocator<ShellMaterial>(__FILE__,__LINE__) );
if ( material )
{
for ( int fi = 0 ; fi < mesh->getNumFaces() ; ++fi )
{
Face& face = mesh->faces[fi];
int mergesubmaterial = -1;
int originalsubmaterial = -1;
for ( int j = 0; j < material->NumSubMtls(); ++j)
{
// Get Sub Material Slot name
TSTR name = material->GetSubMtlSlotName(j);
// Light maps are stored in sub material slot named "Baked Material"
if ( strcmp( name, "Baked Material" ) == 0 )
mergesubmaterial = j;
else
originalsubmaterial = j;
}
if ( mergesubmaterial != -1 ) // A baked material was found, shell materials will be created
{
Mtl* mat = material->GetSubMtl( originalsubmaterial );
Mtl* bakedmtl = material->GetSubMtl( mergesubmaterial );
if ( mat->NumSubMtls() > 0 ) // Check for nested multi-material
{
for ( int j = 0; j < mat->NumSubMtls(); ++j)
usedMaterials.add( ShellMaterial( mat->GetSubMtl( face.getMatID() % mat->NumSubMtls() ), bakedmtl ) );
} else
usedMaterials.add( ShellMaterial( mat, bakedmtl ) );
}
else if ( material->NumSubMtls() > 0 ) // Multi-material without baked material
{
usedMaterials.add( ShellMaterial( material->GetSubMtl( face.getMatID() % material->NumSubMtls() ), 0 ) );
}
else // Single material without baked material
{
usedMaterials.add( ShellMaterial( material, 0 ) );
}
}
std::sort( usedMaterials.begin(), usedMaterials.end() );
usedMaterials.setSize( std::unique( usedMaterials.begin(), usedMaterials.end() ) - usedMaterials.begin() );
}
// create used materials
for ( int mi = 0 ; mi < usedMaterials.size() ; ++mi )
{
ShellMaterial shellmtl = usedMaterials[mi];
gm->materials.add( GmUtil::createGmMaterial( shellmtl.original, shellmtl.baked ) );
}
// add triangles
for ( int fi = 0 ; fi < mesh->getNumFaces() ; ++fi )
{
mb::Polygon* poly = gm->addPolygon();
// triangle indices
Face& face = mesh->faces[fi];
for ( int vxi = 0 ; vxi < 3 ; ++vxi )
{
int vi = face.v[ vx[vxi] ];
require( vi >= 0 && vi < gm->vertices() );
mb::Vertex* vert = gm->getVertex( vi );
poly->addVertex( vert );
}
// triangle material
int polyMaterialIndex = 0;
if ( material )
{
ShellMaterial mat( material, 0 );
int numsubmaterials = material->NumSubMtls();
if ( numsubmaterials > 0 )
{
mat.original = material->GetSubMtl( face.getMatID() % material->NumSubMtls() );
for ( int j = 0; j < numsubmaterials; ++j) // Is baked material present?
{
TSTR name = material->GetSubMtlSlotName(j);
if ( strcmp( name, "Baked Material" ) == 0 )
mat.baked = material->GetSubMtl( j );
if ( strcmp( name, "Original Material" ) == 0 )
mat.original = material->GetSubMtl( j );
}
if ( mat.original->NumSubMtls() > 0 ) // Is there a nested multi-material?
{
mat.original = mat.original->GetSubMtl( face.getMatID() % mat.original->NumSubMtls() );
}
}
for ( int mi = 0 ; mi < usedMaterials.size() ; ++mi )
{
if ( usedMaterials[mi] == mat )
{
polyMaterialIndex = mi;
break;
}
}
}
poly->setMaterial( polyMaterialIndex );
}
// add vertex colors
int mp = 0;
if ( mesh->mapSupport(mp) && mesh->getNumMapVerts(mp) > 0 )
{
mb::DiscontinuousVertexMap* vmad = gm->addDiscontinuousVertexMap( 3, "rgb", mb::VertexMapFormat::VERTEXMAP_RGB );
int tverts = mesh->getNumMapVerts( mp );
UVVert* tvert = mesh->mapVerts( mp );
TVFace* tface = mesh->mapFaces( mp );
//Debug::println( "Vertex colors:" );
for ( int fi = 0 ; fi < mesh->getNumFaces() ; ++fi )
{
Face& face = mesh->faces[fi];
mb::Polygon* poly = gm->getPolygon( fi );
for ( int vxi = 0 ; vxi < 3 ; ++vxi )
{
int vi = face.v[ vx[vxi] ];
mb::Vertex* vert = gm->getVertex( vi );
Point3 tc = tvert[ tface[fi].t[ vx[vxi] ] % tverts ];
float rgb[3] = {tc.x, tc.y, tc.z};
vmad->addValue( vert->index(), poly->index(), rgb, 3 );
//Debug::println( " vertex[{0}].rgb: {1} {2} {3}", vert->index(), rgb[0], rgb[1], rgb[2] );
}
}
}
// add texcoord layers
int lastCoords = MAX_MESHMAPS-2;
while ( lastCoords > 0 && (!mesh->mapSupport(lastCoords) || 0 == mesh->getNumMapVerts(lastCoords)) )
--lastCoords;
if ( lastCoords > 8 )
throw IOException( Format("Too many texture coordinate sets ({1}) in {0}", gm->name, lastCoords) );
for ( mp = 1 ; mp <= lastCoords ; ++mp )
{
mb::DiscontinuousVertexMap* vmad = gm->addDiscontinuousVertexMap( 2, "uv", mb::VertexMapFormat::VERTEXMAP_TEXCOORD );
if ( mesh->mapSupport(mp) && mesh->getNumMapVerts(mp) > 0 )
{
int tverts = mesh->getNumMapVerts( mp );
UVVert* tvert = mesh->mapVerts( mp );
TVFace* tface = mesh->mapFaces( mp );
for ( int fi = 0 ; fi < mesh->getNumFaces() ; ++fi )
{
Face& face = mesh->faces[fi];
mb::Polygon* poly = gm->getPolygon( fi );
for ( int vxi = 0 ; vxi < 3 ; ++vxi )
{
int vi = face.v[ vx[vxi] ];
mb::Vertex* vert = gm->getVertex( vi );
Point3 tc = tvert[ tface[fi].t[ vx[vxi] ] % tverts ];
float uv[2] = {tc.x, 1.f-tc.y};
vmad->addValue( vert->index(), poly->index(), uv, 2 );
}
}
}
}
// compute face vertex normals from smoothing groups
require( mesh->getNumFaces() == gm->polygons() );
mb::DiscontinuousVertexMap* vmad = gm->addDiscontinuousVertexMap( 3, "vnormals", mb::VertexMapFormat::VERTEXMAP_NORMALS );
for ( int fi = 0 ; fi < gm->polygons() ; ++fi )
{
mb::Polygon* poly = gm->getPolygon( fi );
require( poly );
require( poly->index() >= 0 && poly->index() < mesh->getNumFaces() );
Face& face = mesh->faces[ poly->index() ];
require( poly->vertices() == 3 );
for ( int j = 0 ; j < poly->vertices() ; ++j )
{
Vector3 vn(0,0,0);
mb::Vertex* vert = poly->getVertex( j );
// sum influencing normals
for ( int k = 0 ; k < vert->polygons() ; ++k )
{
mb::Polygon* vpoly = vert->getPolygon( k );
require( vpoly );
require( vpoly->index() >= 0 && vpoly->index() < mesh->getNumFaces() );
Face& vface = mesh->faces[ vpoly->index() ];
if ( 0 != (face.smGroup & vface.smGroup) || poly == vpoly )
{
Vector3 vpolyn;
vpoly->getNormal( &vpolyn.x, &vpolyn.y, &vpolyn.z );
vn += vpolyn;
}
}
// normalize
float lensqr = vn.lengthSquared();
if ( lensqr > Float::MIN_VALUE )
vn *= 1.f / Math::sqrt(lensqr);
else
vn = Vector3(0,0,0);
vmad->addValue( vert->index(), poly->index(), vn.begin(), 3 );
}
}
// re-export mesh points in non-deformed pose if Skin modifier present
// NOTE: 3ds Mesh must not be used after this, because collapsing can invalidate it
if ( skin )
{
// evaluate derived object before Skin modifier
TimeValue time = 0;
bool evalNext = false;
bool evalDone = false;
::ObjectState os;
::Object* obj = node->GetObjectRef();
while ( obj->SuperClassID() == GEN_DERIVOB_CLASS_ID && !evalDone )
{
IDerivedObject* derivedObj = static_cast<IDerivedObject*>(obj);
for ( int modStack = 0 ; modStack < derivedObj->NumModifiers() ; ++modStack )
{
if ( evalNext )
{
os = derivedObj->Eval( time, modStack );
evalDone = true;
break;
}
Modifier* mod = derivedObj->GetModifier(modStack);
if ( mod->ClassID() == SKIN_CLASSID )
evalNext = true;
}
obj = derivedObj->GetObjRef();
}
// evaluate possible non-derived object
if ( evalNext && !evalDone )
{
os = obj->Eval( time );
evalDone = true;
}
// convert to TriObject and get points
if ( evalDone && os.obj->CanConvertToType( Class_ID(TRIOBJ_CLASS_ID,0) ) )
{
Debug::println( " Evaluating object {0} before Skin modifier", nodeName );
// get TriObject
std::auto_ptr<TriObject> triAutoDel(0);
TriObject* tri = static_cast<TriObject*>( os.obj->ConvertToType( time, Class_ID(TRIOBJ_CLASS_ID,0) ) );
if ( tri != os.obj )
triAutoDel = std::auto_ptr<TriObject>( tri );
// get mesh points before Skin is applied
//Debug::println( " Original collapsed mesh has {0} points, before Skin modifier {1} points", mesh->getNumVerts(), tri->mesh.getNumVerts() );
require( gm->vertices() == tri->mesh.getNumVerts() );
Mesh* mesh = &tri->mesh;
int vertices = mesh->getNumVerts();
for ( int vi = 0 ; vi < vertices ; ++vi )
{
Point3 v = vertexTM * mesh->verts[vi];
mb::Vertex* vert = gm->getVertex( vi );
vert->setPosition( v.x, v.y, v.z );
}
}
}
// split vertices with discontinuous vertex map values
for ( int vmi = 0 ; vmi < gm->discontinuousVertexMaps() ; ++vmi )
{
mb::DiscontinuousVertexMap* vmad = gm->getDiscontinuousVertexMap( vmi );
gm->splitVertexDiscontinuities( vmad );
}
// find base texcoord layer
mb::DiscontinuousVertexMap* texcoords = 0;
for ( int i = 0 ; i < gm->discontinuousVertexMaps() ; ++i )
{
mb::DiscontinuousVertexMap* vmad = gm->getDiscontinuousVertexMap(i);
if ( vmad->dimensions() == 2 && vmad->format() == mb::VertexMapFormat::VERTEXMAP_TEXCOORD )
{
texcoords = vmad;
break;
}
}
if ( !texcoords )
Debug::printlnError( "Object {0} must have texture coordinates", gm->name );
// requires identification of footsteps in MySceneExport::isExportableGeometry
//throw IOException( Format("Object {0} must have texture coordinates", gm->name) );
// optimize
gm->removeUnusedVertices();
// cleanup export interfaces
#ifdef SGEXPORT_PHYSIQUE
if ( mcExport )
{
require( phyExport );
phyExport->ReleaseContextInterface( mcExport );
mcExport = 0;
}
if ( phyExport )
{
require( phyMod );
phyMod->ReleaseInterface( I_PHYINTERFACE, phyExport );
phyExport = 0;
}
#endif // SGEXPORT_PHYSIQUE
if ( skin )
{
skinMod->ReleaseInterface( I_SKIN, skin );
skin = 0;
skinMod = 0;
}
}
catch ( ... )
{
// cleanup export interfaces
#ifdef SGEXPORT_PHYSIQUE
if ( mcExport )
{
require( phyExport );
phyExport->ReleaseContextInterface( mcExport );
mcExport = 0;
}
if ( phyExport )
{
require( phyMod );
phyMod->ReleaseInterface( I_PHYINTERFACE, phyExport );
phyExport = 0;
}
#endif // SGEXPORT_PHYSIQUE
if ( skin )
{
skinMod->ReleaseInterface( I_SKIN, skin );
skin = 0;
skinMod = 0;
}
throw;
}
}
int DxStdMtl2::GetMatIndex(Mtl * m_Mtl)
{
int i;
Mtl *Std;
StdMat2 * Shader;
// MaxShader *Shader, *s;
if(m_Mtl->IsMultiMtl())
{
Shader = (StdMat2 *)GetRefTarg();
// I use the SubAnims here, as I do not want any NULL material introduced that are not visible to the user
// this can happen when you have N materials and you select N+1 mat ID - the material will add a NULL material
// to the list to compensate - this screws with the index into the paramblock
for(i=0; i < m_Mtl->NumSubs(); i++)
{
Std = (Mtl*)m_Mtl->SubAnim(i);
if(Std!=NULL)
{
if(Std->NumSubMtls()>0)
{
for(int j=0; j< Std->NumSubMtls();j++)
{
Mtl * subMtl = Std->GetSubMtl(j);
if(subMtl == Shader)
Std = subMtl;
}
}
MSPlugin* plugin = (MSPlugin*)((ReferenceTarget*)Std)->GetInterface(I_MAXSCRIPTPLUGIN);
ReferenceTarget * targ = NULL;
if(plugin){
targ = plugin->get_delegate();
Std = (Mtl*)targ;
}
if(Std == Shader)
{
int id=0;
// this gets interesting - the MatID are editable !! must get them from the PAramblock
IParamBlock2 * pblock = m_Mtl->GetParamBlock(0); // there is only one
if(pblock)
{
ParamBlockDesc2 * pd = pblock->GetDesc();
for(int j=0;j<pd->count;j++)
{
if(_tcsicmp(_T("materialIDList"),pd->paramdefs[j].int_name)==0) //not localised
{
//int id;
pblock->GetValue(j,0,id,FOREVER,i);
id = id+1; //for some reason this is stored as a zero index, when a 1's based index is used
}
}
pblock->ReleaseDesc();
}
return(id);
}
}
}
}
return(0);
}
//=================================================================
// Methods for DumpModelTEP
//
int DumpModelTEP::callback(INode *pnode)
{
Object* pobj;
int fHasMat = TRUE;
// clear physique export parameters
m_mcExport = NULL;
m_phyExport = NULL;
m_phyMod = NULL;
ASSERT_MBOX(!(pnode)->IsRootNode(), "Encountered a root node!");
if (::FNodeMarkedToSkip(pnode))
return TREE_CONTINUE;
int iNode = ::GetIndexOfINode(pnode);
TSTR strNodeName(pnode->GetName());
// The Footsteps node apparently MUST have a dummy mesh attached! Ignore it explicitly.
if (FStrEq((char*)strNodeName, "Bip01 Footsteps"))
return TREE_CONTINUE;
// Helper nodes don't have meshes
pobj = pnode->GetObjectRef();
if (pobj->SuperClassID() == HELPER_CLASS_ID)
return TREE_CONTINUE;
// The model's root is a child of the real "scene root"
INode *pnodeParent = pnode->GetParentNode();
BOOL fNodeIsRoot = pnodeParent->IsRootNode( );
// Get node's material: should be a multi/sub (if it has a material at all)
Mtl *pmtlNode = pnode->GetMtl();
if (pmtlNode == NULL)
{
return TREE_CONTINUE;
fHasMat = FALSE;
}
else if (!(pmtlNode->ClassID() == Class_ID(MULTI_CLASS_ID, 0) && pmtlNode->IsMultiMtl()))
{
// sprintf(st_szDBG, "ERROR--Material on node %s isn't a Multi/Sub-Object", (char*)strNodeName);
// ASSERT_AND_ABORT(FALSE, st_szDBG);
fHasMat = FALSE;
}
// Get Node's object, convert to a triangle-mesh object, so I can access the Faces
ObjectState os = pnode->EvalWorldState(m_tvToDump);
pobj = os.obj;
TriObject *ptriobj;
BOOL fConvertedToTriObject =
pobj->CanConvertToType(triObjectClassID) &&
(ptriobj = (TriObject*)pobj->ConvertToType(m_tvToDump, triObjectClassID)) != NULL;
if (!fConvertedToTriObject)
return TREE_CONTINUE;
Mesh *pmesh = &ptriobj->mesh;
// Shouldn't have gotten this far if it's a helper object
if (pobj->SuperClassID() == HELPER_CLASS_ID)
{
sprintf(st_szDBG, "ERROR--Helper node %s has an attached mesh, and it shouldn't.", (char*)strNodeName);
ASSERT_AND_ABORT(FALSE, st_szDBG);
}
// Ensure that the vertex normals are up-to-date
pmesh->buildNormals();
// We want the vertex coordinates in World-space, not object-space
Matrix3 mat3ObjectTM = pnode->GetObjectTM(m_tvToDump);
// initialize physique export parameters
m_phyMod = FindPhysiqueModifier(pnode);
if (m_phyMod)
{
// Physique Modifier exists for given Node
m_phyExport = (IPhysiqueExport *)m_phyMod->GetInterface(I_PHYINTERFACE);
if (m_phyExport)
{
// create a ModContext Export Interface for the specific node of the Physique Modifier
m_mcExport = (IPhyContextExport *)m_phyExport->GetContextInterface(pnode);
if (m_mcExport)
{
// convert all vertices to Rigid
m_mcExport->ConvertToRigid(TRUE);
}
}
}
// Dump the triangle face info
int cFaces = pmesh->getNumFaces();
for (int iFace = 0; iFace < cFaces; iFace++)
{
Face* pface = &pmesh->faces[iFace];
TVFace* ptvface = &pmesh->tvFace[iFace];
DWORD smGroupFace = pface->getSmGroup();
// Get face's 3 indexes into the Mesh's vertex array(s).
DWORD iVertex0 = pface->getVert(0);
DWORD iVertex1 = pface->getVert(1);
DWORD iVertex2 = pface->getVert(2);
ASSERT_AND_ABORT((int)iVertex0 < pmesh->getNumVerts(), "Bogus Vertex 0 index");
ASSERT_AND_ABORT((int)iVertex1 < pmesh->getNumVerts(), "Bogus Vertex 1 index");
ASSERT_AND_ABORT((int)iVertex2 < pmesh->getNumVerts(), "Bogus Vertex 2 index");
// Get the 3 Vertex's for this face
Point3 pt3Vertex0 = pmesh->getVert(iVertex0);
Point3 pt3Vertex1 = pmesh->getVert(iVertex1);
Point3 pt3Vertex2 = pmesh->getVert(iVertex2);
// Get the 3 RVertex's for this face
// NOTE: I'm using getRVertPtr instead of getRVert to work around a 3DSMax bug
RVertex *prvertex0 = pmesh->getRVertPtr(iVertex0);
RVertex *prvertex1 = pmesh->getRVertPtr(iVertex1);
RVertex *prvertex2 = pmesh->getRVertPtr(iVertex2);
// Find appropriate normals for each RVertex
// A vertex can be part of multiple faces, so the "smoothing group"
// is used to locate the normal for this face's use of the vertex.
Point3 pt3Vertex0Normal;
Point3 pt3Vertex1Normal;
Point3 pt3Vertex2Normal;
if (smGroupFace)
{
pt3Vertex0Normal = Pt3GetRVertexNormal(prvertex0, smGroupFace);
pt3Vertex1Normal = Pt3GetRVertexNormal(prvertex1, smGroupFace);
pt3Vertex2Normal = Pt3GetRVertexNormal(prvertex2, smGroupFace);
}
else
{
pt3Vertex0Normal = pmesh->getFaceNormal( iFace );
pt3Vertex1Normal = pmesh->getFaceNormal( iFace );
pt3Vertex2Normal = pmesh->getFaceNormal( iFace );
}
ASSERT_AND_ABORT( Length( pt3Vertex0Normal ) <= 1.1, "bogus orig normal 0" );
ASSERT_AND_ABORT( Length( pt3Vertex1Normal ) <= 1.1, "bogus orig normal 1" );
ASSERT_AND_ABORT( Length( pt3Vertex2Normal ) <= 1.1, "bogus orig normal 2" );
// Get Face's sub-material from node's material, to get the bitmap name.
// And no, there isn't a simpler way to get the bitmap name, you have to
// dig down through all these levels.
TCHAR szBitmapName[256] = "null.bmp";
if (fHasMat)
{
MtlID mtlidFace = pface->getMatID();
if (mtlidFace >= pmtlNode->NumSubMtls())
{
sprintf(st_szDBG, "ERROR--Bogus sub-material index %d in node %s; highest valid index is %d",
mtlidFace, (char*)strNodeName, pmtlNode->NumSubMtls()-1);
// ASSERT_AND_ABORT(FALSE, st_szDBG);
mtlidFace = 0;
}
Mtl *pmtlFace = pmtlNode->GetSubMtl(mtlidFace);
ASSERT_AND_ABORT(pmtlFace != NULL, "NULL Sub-material returned");
if ((pmtlFace->ClassID() == Class_ID(MULTI_CLASS_ID, 0) && pmtlFace->IsMultiMtl()))
{
// it's a sub-sub material. Gads.
pmtlFace = pmtlFace->GetSubMtl(mtlidFace);
ASSERT_AND_ABORT(pmtlFace != NULL, "NULL Sub-material returned");
}
if (!(pmtlFace->ClassID() == Class_ID(DMTL_CLASS_ID, 0)))
{
sprintf(st_szDBG,
"ERROR--Sub-material with index %d (used in node %s) isn't a 'default/standard' material [%x].",
mtlidFace, (char*)strNodeName, pmtlFace->ClassID());
ASSERT_AND_ABORT(FALSE, st_szDBG);
}
StdMat *pstdmtlFace = (StdMat*)pmtlFace;
Texmap *ptexmap = pstdmtlFace->GetSubTexmap(ID_DI);
// ASSERT_AND_ABORT(ptexmap != NULL, "NULL diffuse texture")
if (ptexmap != NULL)
{
if (!(ptexmap->ClassID() == Class_ID(BMTEX_CLASS_ID, 0)))
{
sprintf(st_szDBG,
"ERROR--Sub-material with index %d (used in node %s) doesn't have a bitmap as its diffuse texture.",
mtlidFace, (char*)strNodeName);
ASSERT_AND_ABORT(FALSE, st_szDBG);
}
BitmapTex *pbmptex = (BitmapTex*)ptexmap;
strcpy(szBitmapName, pbmptex->GetMapName());
TSTR strPath, strFile;
SplitPathFile(TSTR(szBitmapName), &strPath, &strFile);
strcpy(szBitmapName,strFile);
}
}
UVVert UVvertex0( 0, 0, 0 );
UVVert UVvertex1( 1, 0, 0 );
UVVert UVvertex2( 0, 1, 0 );
// All faces must have textures assigned to them
if (pface->flags & HAS_TVERTS)
{
// Get TVface's 3 indexes into the Mesh's TVertex array(s).
DWORD iTVertex0 = ptvface->getTVert(0);
DWORD iTVertex1 = ptvface->getTVert(1);
DWORD iTVertex2 = ptvface->getTVert(2);
ASSERT_AND_ABORT((int)iTVertex0 < pmesh->getNumTVerts(), "Bogus TVertex 0 index");
ASSERT_AND_ABORT((int)iTVertex1 < pmesh->getNumTVerts(), "Bogus TVertex 1 index");
ASSERT_AND_ABORT((int)iTVertex2 < pmesh->getNumTVerts(), "Bogus TVertex 2 index");
// Get the 3 TVertex's for this TVFace
// NOTE: I'm using getRVertPtr instead of getRVert to work around a 3DSMax bug
UVvertex0 = pmesh->getTVert(iTVertex0);
UVvertex1 = pmesh->getTVert(iTVertex1);
UVvertex2 = pmesh->getTVert(iTVertex2);
}
else
{
//sprintf(st_szDBG, "ERROR--Node %s has a textureless face. All faces must have an applied texture.", (char*)strNodeName);
//ASSERT_AND_ABORT(FALSE, st_szDBG);
}
/*
const char *szExpectedExtension = ".bmp";
if (stricmp(szBitmapName+strlen(szBitmapName)-strlen(szExpectedExtension), szExpectedExtension) != 0)
{
sprintf(st_szDBG, "Node %s uses %s, which is not a %s file", (char*)strNodeName, szBitmapName, szExpectedExtension);
ASSERT_AND_ABORT(FALSE, st_szDBG);
}
*/
// Determine owning bones for the vertices.
int iNodeV0, iNodeV1, iNodeV2;
if (m_mcExport)
{
// The Physique add-in allows vertices to be assigned to bones arbitrarily
iNodeV0 = InodeOfPhyVectex( iVertex0 );
iNodeV1 = InodeOfPhyVectex( iVertex1 );
iNodeV2 = InodeOfPhyVectex( iVertex2 );
}
else
{
// Simple 3dsMax model: the vertices are owned by the object, and hence the node
iNodeV0 = iNode;
iNodeV1 = iNode;
iNodeV2 = iNode;
}
// Rotate the face vertices out of object-space, and into world-space space
Point3 v0 = pt3Vertex0 * mat3ObjectTM;
Point3 v1 = pt3Vertex1 * mat3ObjectTM;
Point3 v2 = pt3Vertex2 * mat3ObjectTM;
Matrix3 mat3ObjectNTM = mat3ObjectTM;
mat3ObjectNTM.NoScale( );
ASSERT_AND_ABORT( Length( pt3Vertex0Normal ) <= 1.1, "bogus pre normal 0" );
pt3Vertex0Normal = VectorTransform(mat3ObjectNTM, pt3Vertex0Normal);
ASSERT_AND_ABORT( Length( pt3Vertex0Normal ) <= 1.1, "bogus post normal 0" );
ASSERT_AND_ABORT( Length( pt3Vertex1Normal ) <= 1.1, "bogus pre normal 1" );
pt3Vertex1Normal = VectorTransform(mat3ObjectNTM, pt3Vertex1Normal);
ASSERT_AND_ABORT( Length( pt3Vertex1Normal ) <= 1.1, "bogus post normal 1" );
ASSERT_AND_ABORT( Length( pt3Vertex2Normal ) <= 1.1, "bogus pre normal 2" );
pt3Vertex2Normal = VectorTransform(mat3ObjectNTM, pt3Vertex2Normal);
ASSERT_AND_ABORT( Length( pt3Vertex2Normal ) <= 1.1, "bogus post normal 2" );
// Finally dump the bitmap name and 3 lines of face info
fprintf(m_pfile, "%s\n", szBitmapName);
fprintf(m_pfile, "%3d %8.4f %8.4f %8.4f %8.4f %8.4f %8.4f %8.4f %8.4f\n",
iNodeV0, v0.x, v0.y, v0.z,
pt3Vertex0Normal.x, pt3Vertex0Normal.y, pt3Vertex0Normal.z,
UVvertex0.x, UVvertex0.y);
fprintf(m_pfile, "%3d %8.4f %8.4f %8.4f %8.4f %8.4f %8.4f %8.4f %8.4f\n",
iNodeV1, v1.x, v1.y, v1.z,
pt3Vertex1Normal.x, pt3Vertex1Normal.y, pt3Vertex1Normal.z,
UVvertex1.x, UVvertex1.y);
fprintf(m_pfile, "%3d %8.4f %8.4f %8.4f %8.4f %8.4f %8.4f %8.4f %8.4f\n",
iNodeV2, v2.x, v2.y, v2.z,
pt3Vertex2Normal.x, pt3Vertex2Normal.y, pt3Vertex2Normal.z,
UVvertex2.x, UVvertex2.y);
}
cleanup( );
return TREE_CONTINUE;
}
// --[ 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 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));
}
}
}
}
