Value* reload_texture_cf (Value** arg_list, int count)
{
// Make sure we have the correct number of arguments (1)
check_arg_count(reload_texture, 1, count);
char *message = "NelReloadTexture [BitmapTex]";
//type_check (arg_list[0], TextureMap, message);
// Get a good interface pointer
Interface *ip = MAXScript_interface;
theCNelExport.init (false, false, ip, true);
// The 2 filenames
Texmap *texmap = arg_list[0]->to_texmap ();
// BitmapTex ?
if (texmap->ClassID() == Class_ID (BMTEX_CLASS_ID, 0))
{
// Cast
BitmapTex *bitmap = (BitmapTex*)texmap;
// Reload
bitmap->ReloadBitmapAndUpdate ();
// Tell the bitmap has changed
BroadcastNotification (NOTIFY_BITMAP_CHANGED, (void *)bitmap->GetMapName());
return &true_value;
}
return &false_value;
}
BitmapTex* SceneExportUtil::getStdMatBitmapTex( StdMat* stdmat, int id )
{
StdMat2* stdmat2 = 0;
int channel = id;
if ( stdmat->SupportsShaders() )
{
stdmat2 = static_cast<StdMat2*>( stdmat );
channel = stdmat2->StdIDToChannel( id );
}
if ( stdmat->MapEnabled(channel) )
{
Texmap* tex = stdmat->GetSubTexmap(channel);
if ( tex && tex->ClassID() == Class_ID(BMTEX_CLASS_ID,0) &&
(!stdmat2 || 2 == stdmat2->GetMapState(channel)) )
{
BitmapTex* bmptex = static_cast<BitmapTex*>(tex);
if ( bmptex->GetMapName() )
{
return bmptex;
}
}
}
return 0;
}
static void BitmapDimensions(int &width, int &height, Texmap * map)
{
// int h=dim; w=dim;
if(map == NULL){
//NH 05-Dec-05 This can happen when submaps are not assigned - in this case simply bail and let
//the parent texture deal with it.
// height = width = 0;
return;
}
if(map->ClassID() == GNORMAL_CLASS_ID)
{
Texmap * bmap;
map->GetParamBlock(0)->GetValue(2,0,bmap,FOREVER); // normal map
BitmapDimensions(width,height,bmap);
return;
}
else if(map->ClassID() == Class_ID(BMTEX_CLASS_ID, 0))
{
BitmapTex *pBT;
Bitmap *pTex;
pBT = static_cast<BitmapTex *>(map);
pTex = pBT->GetBitmap(0);
if (pTex)
{
width = getClosestPowerOf2(pTex->Width());
height = getClosestPowerOf2(pTex->Height());
}
return;
}
else{
}
}
Texmap* M2Importer::createTexture(LPCTSTR fileName)
{
BitmapManager* bmpMgr = TheManager;
size_t pathSlashPos = m_modelName.find_last_of('\\');
string pathName = m_modelName.substr(0, pathSlashPos + 1);
// 将贴图文件名改为当前目录下的tga文件
string origFileName = fileName;
size_t dotPos = origFileName.find_last_of('.');
if (dotPos != string::npos)
origFileName = origFileName.substr(0, dotPos);
size_t slashPos = origFileName.find_last_of('\\');
if (slashPos != string::npos)
{
++slashPos;
origFileName = origFileName.substr(slashPos, origFileName.length() - slashPos);
}
pathName += string("texture\\");
pathName += origFileName;
pathName.append(".tga");
m_logStream << "Model Texture Name: " << pathName << endl;
TSTR newFileName = pathName.c_str();
if (origFileName.length())
{
// 改成用系统的检查文件是否存在的API
ifstream testStream(newFileName, ios::binary | ios::in);
if (testStream.fail())
{
string errstr = string("Load texture error. filename: ") + string(newFileName);
errstr += string("\n\nOriginal file: ");
errstr += string(fileName);
MessageBox(NULL, errstr.c_str(), "TBD: Error.", MB_OK);
m_logStream << errstr << endl;
}
else
testStream.close();
}
if (bmpMgr->CanImport(newFileName))
{
BitmapTex* bmpTex = NewDefaultBitmapTex();
bmpTex->SetName(newFileName);
bmpTex->SetMapName(newFileName);
bmpTex->SetAlphaAsMono(TRUE);
bmpTex->SetAlphaSource(ALPHA_FILE);
return bmpTex;
}
return 0;
}
//----------------------------------------------------------------------------
// Material parsing
//----------------------------------------------------------------------------
BOOL CEditableObject::ExtractTexName(Texmap *src, LPSTR dest)
{
if( src->ClassID() != Class_ID(BMTEX_CLASS_ID,0) )
return FALSE;
BitmapTex *bmap = (BitmapTex*)src;
_splitpath( bmap->GetMapName(), 0, 0, dest, 0 );
EFS.AppendFolderToName(dest,1,TRUE);
return TRUE;
}
//------------------------------
void MaterialCreator::createAndAssignTexture( Mtl* material,
const COLLADAFW::EffectCommon& effectCommon,
const COLLADAFW::ColorOrTexture& (COLLADAFW::EffectCommon::*f)() const,
int slot,
unsigned char mapChannel)
{
const COLLADAFW::ColorOrTexture& colorOrTexture = (effectCommon.*f)();
if ( colorOrTexture.isTexture() )
{
BitmapTex* texture = createTexture( effectCommon, colorOrTexture.getTexture() );
texture->GetUVGen()->SetMapChannel( mapChannel );
assignTextureToMaterial(material, slot, texture);
}
}
//------------------------------
BitmapTex* MaterialCreator::createTexture( const COLLADAFW::EffectCommon& effectCommon, const COLLADAFW::Texture& texture )
{
BitmapTex* bitmapTexture = NewDefaultBitmapTex();
COLLADAFW::SamplerID samplerId = texture.getSamplerId();
const COLLADAFW::Sampler* sampler = effectCommon.getSamplerPointerArray()[ samplerId ];
const COLLADAFW::UniqueId& imageUniqueId = sampler->getSourceImage();
const COLLADAFW::Image* image = getFWImageByUniqueId( imageUniqueId );
if ( !image )
return 0;
COLLADABU::URI imageUri( getFileInfo().absoluteFileUri, image->getImageURI().getURIString() );
COLLADABU::NativeString imageFileName( imageUri.toNativePath().c_str(), COLLADABU::NativeString::ENCODING_UTF8 );
bitmapTexture->SetMapName(const_cast<char*>(imageFileName.c_str()));
bitmapTexture->LoadMapFiles(0);
UVGen* uvGen = bitmapTexture->GetTheUVGen();
StdUVGen* stdUVGen = (StdUVGen*)uvGen;
// reset all flags
//stdUVGen->SetFlag(U_WRAP|V_WRAP, 1);
//stdUVGen->SetFlag(U_MIRROR|V_MIRROR, 0);
int tiling = 0;
if ( sampler->getWrapS() == COLLADAFW::Sampler::WRAP_MODE_WRAP )
{
tiling += 1<<0;
}
else if ( sampler->getWrapS() == COLLADAFW::Sampler::WRAP_MODE_MIRROR )
{
tiling += 1<<2;
}
if ( sampler->getWrapT() == COLLADAFW::Sampler::WRAP_MODE_WRAP )
{
tiling += 1<<1;
}
else if ( sampler->getWrapT() == COLLADAFW::Sampler::WRAP_MODE_MIRROR )
{
tiling += 1<<3;
}
stdUVGen->SetTextureTiling(tiling);
return bitmapTexture;
}
bool SGP_MaxInterface::GetStdMtlChannelBitmapFileName( StdMat* pStdMat, int nChannel, TCHAR szFileName[] )
{
if( !pStdMat )
{
assert( false );
return false;
}
Texmap *tx = pStdMat->GetSubTexmap(nChannel);
if( !tx )
return false;
if(tx->ClassID() != Class_ID(BMTEX_CLASS_ID,0))
return false;
BitmapTex *bmt = (BitmapTex*)tx;
_tcscpy( szFileName, bmt->GetMapName() );
return true;
}
void UtilTest::SetEnvironmentMap()
{
// Make a bitmap texture map.
BitmapTex *map = NewDefaultBitmapTex();
// Get the UVGen
StdUVGen *uvGen = map->GetUVGen();
// Set up the coords. to be screen environment.
uvGen->SetCoordMapping(UVMAP_SCREEN_ENV);
// Set the bitmap file.
map->SetMapName(_T("A_MAX.TGA"));
// Make this the new environment map.
ip->SetEnvironmentMap(map);
}
Texmap* NifImporter::CreateTexture(const string& filename)
{
if (filename.empty())
return NULL;
BitmapManager *bmpMgr = TheManager;
if (bmpMgr->CanImport(filename.c_str())){
BitmapTex *bmpTex = NewDefaultBitmapTex();
string name = filename;
if (name.empty()) {
TCHAR buffer[MAX_PATH];
_tcscpy(buffer, PathFindFileName(filename.c_str()));
PathRemoveExtension(buffer);
name = buffer;
}
bmpTex->SetName(name.c_str());
bmpTex->SetMapName(const_cast<TCHAR*>(FindImage(filename).c_str()));
bmpTex->SetAlphaAsMono(TRUE);
bmpTex->SetAlphaSource(ALPHA_DEFAULT);
bmpTex->SetFilterType(FILTER_PYR);
if (showTextures) {
bmpTex->SetMtlFlag(MTL_TEX_DISPLAY_ENABLED, TRUE);
bmpTex->ActivateTexDisplay(TRUE);
bmpTex->NotifyDependents(FOREVER, PART_ALL, REFMSG_CHANGE);
}
if (UVGen *uvGen = bmpTex->GetTheUVGen()){
uvGen->SetTextureTiling(0);
}
return bmpTex;
}
return NULL;
}
P(GmMaterial) GmUtil::createGmMaterial( Mtl* material, Mtl* bakedmaterial )
{
require( material );
P(GmMaterial) s = new GmMaterial;
// get name
static int unnamedCount = 0;
if ( material->GetName().data() )
s->name = material->GetName().data();
else
s->name = "noname #"+String::valueOf( ++unnamedCount );
// Standard material (+Diffuse) (+ Reflection)
if ( material->ClassID() == Class_ID(DMTL_CLASS_ID,0) )
{
StdMat* stdmat = static_cast<StdMat*>(material);
StdMat* bakedmat = static_cast<StdMat*>(bakedmaterial);
// StdMat2?
StdMat2* stdmat2 = 0;
if ( stdmat->SupportsShaders() )
stdmat2 = static_cast<StdMat2*>( stdmat );
// uniform transparency
s->opacity = stdmat->GetOpacity(0);
// self illumination
s->selfIllum = stdmat->GetSelfIllum(0);
// two-sided material?
s->twosided = ( 0 != stdmat->GetTwoSided() );
// blending mode
s->blend = GmMaterial::BLEND_COPY;
if ( s->opacity < 1.f )
s->blend = GmMaterial::BLEND_MULTIPLY;
if ( stdmat->GetTransparencyType() == TRANSP_ADDITIVE )
s->blend = GmMaterial::BLEND_ADD;
// diffuse color
s->diffuseColor = toColorf( stdmat->GetDiffuse(0) );
// specular highlights
float shinStr = stdmat->GetShinStr(0);
s->specular = (shinStr > 0.f);
if ( s->specular )
{
float shininess = stdmat->GetShininess(0);
s->specularExponent = Math::pow( 2.f, shininess*10.f + 2.f );
s->specularColor = toColorf( stdmat->GetSpecular(0) ) * shinStr;
}
if ( bakedmat )
{
shinStr = bakedmat->GetShinStr(0);
s->specular = (shinStr > 0.f);
if ( s->specular )
{
float shininess = bakedmat->GetShininess(0);
s->specularExponent = Math::pow( 2.f, shininess*10.f + 2.f );
s->specularColor = toColorf( bakedmat->GetSpecular(0) ) * shinStr;
}
}
// diffuse texture layer
BitmapTex* tex = SceneExportUtil::getStdMatBitmapTex( stdmat, ID_DI );
if ( tex )
{
GmMaterial::TextureLayer& layer = s->diffuseLayer;
setLayerTex( layer, tex, s->name );
}
// opacity texture layer
tex = SceneExportUtil::getStdMatBitmapTex( stdmat, ID_OP );
if ( tex )
{
GmMaterial::TextureLayer& layer = s->opacityLayer;
setLayerTex( layer, tex, s->name );
// check alpha channel validity
Bitmap* bmp = tex->GetBitmap(0);
if ( bmp && !bmp->HasAlpha() )
Debug::printlnError( "Material \"{0}\" opacity map \"{1}\" must have image alpha channel.", s->name, tex->GetMapName() );
//throw IOException( Format("Material \"{0}\" opacity map \"{1}\" must have image alpha channel.", s->name, tex->GetMapName()) );
s->blend = GmMaterial::BLEND_MULTIPLY;
// check that opacity map is the same as diffuse map
if ( s->opacityLayer.filename != s->diffuseLayer.filename )
throw IOException( Format("Material \"{0}\" diffuse bitmap needs to be the same in opacity map.(diffuse map is \"{1}\" and opacity map is \"{2}\")", s->name, s->diffuseLayer.filename, s->opacityLayer.filename) );
if ( s->opacityLayer.coordset != s->diffuseLayer.coordset )
throw IOException( Format("Material \"{0}\" diffuse map texture coordinate set needs to be the same in opacity map.", s->name) );
if ( s->opacityLayer.env != s->diffuseLayer.env )
throw IOException( Format("Material \"{0}\" diffuse map texture coordinate generator needs to be the same in opacity map.", s->name) );
}
// reflection texture layer
tex = SceneExportUtil::getStdMatBitmapTex( stdmat, ID_RL );
if ( tex )
{
GmMaterial::TextureLayer& layer = s->reflectionLayer;
setLayerTex( layer, tex, s->name );
}
// glossiness (shininess strength, SS) texture layer
tex = SceneExportUtil::getStdMatBitmapTex( stdmat, ID_SS );
if ( tex )
{
GmMaterial::TextureLayer& layer = s->glossinessLayer;
setLayerTex( layer, tex, s->name );
// check alpha channel validity
Bitmap* bmp = tex->GetBitmap(0);
//if ( bmp && !bmp->HasAlpha() )
// throw IOException( Format("Material \"{0}\" glossiness map \"{1}\" must have image alpha channel.", s->name, tex->GetMapName()) );
if ( bmp && !bmp->HasAlpha() )
Debug::printlnError("Material \"{0}\" glossiness map \"{1}\" must have image alpha channel.", s->name, tex->GetMapName() );
// check that glossiness map is the same as diffuse map
if ( s->glossinessLayer.filename != s->diffuseLayer.filename )
throw IOException( Format("Material \"{0}\" diffuse bitmap needs to be the same in glossiness map.(diffuse map is \"{1}\" and glossiness map is \"{2}\")", s->name, s->diffuseLayer.filename, s->glossinessLayer.filename) );
if ( s->glossinessLayer.coordset != s->diffuseLayer.coordset )
throw IOException( Format("Material \"{0}\" diffuse map texture coordinate set needs to be the same in glossiness map.", s->name) );
if ( s->glossinessLayer.env != s->diffuseLayer.env )
throw IOException( Format("Material \"{0}\" diffuse map texture coordinate generator needs to be the same in glossiness map.", s->name) );
// check that reflection map has been set
if ( s->reflectionLayer.filename.length() == 0 )
throw IOException( Format("Material \"{0}\" glossiness map requires reflection map to be set.", s->name) );
}
// bump texture layer
tex = SceneExportUtil::getStdMatBitmapTex( stdmat, ID_BU );
if ( tex )
{
GmMaterial::TextureLayer& layer = s->bumpLayer;
setLayerTex( layer, tex, s->name );
}
// specular color texture layer
tex = SceneExportUtil::getStdMatBitmapTex( stdmat, ID_SP );
if ( tex )
{
GmMaterial::TextureLayer& layer = s->specularColorLayer;
setLayerTex( layer, tex, s->name );
}
// specular level texture layer
tex = SceneExportUtil::getStdMatBitmapTex( stdmat, ID_SH );
if ( tex )
{
GmMaterial::TextureLayer& layer = s->specularLevelLayer;
setLayerTex( layer, tex, s->name );
}
// lightmap texture layer ( from self-illumination map of baked material )
tex = SceneExportUtil::getStdMatBitmapTex( stdmat, ID_SI );
BitmapTex* tex2 = 0;
if ( bakedmat )
tex2 = SceneExportUtil::getStdMatBitmapTex( bakedmat, ID_SI );
if ( tex || tex2 )
{
GmMaterial::TextureLayer& layer = s->lightMapLayer;
if ( tex && !tex2 )
setLayerTex( layer, tex, s->name );
else if ( tex2 )
setLayerTex( layer, tex2, s->name );
}
}
return s;
}
//=================================================================
// 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;
}
bool SGP_MaxInterface::GetMtlAnim( StdMat* pStdMtl, ColorTrack& track, int nChannel )
{
if( pStdMtl == NULL )
{
assert( false && "std mtl is NULL" );
return false;
}
int nFrameCount = 0;
TimeValue nStartTick = GetStartTick();
TimeValue nEndTick = GetEndTick();
int nTickPerFrame = GetTickPerFrame();
track.bTiling = false;
StdUVGen *uv = NULL;
Texmap *tx = pStdMtl->GetSubTexmap(nChannel);
if( tx )
{
if( tx->ClassID() == Class_ID( BMTEX_CLASS_ID, 0 ) )
{
BitmapTex *bmt = (BitmapTex*)tx;
uv = bmt->GetUVGen();
if( uv )
{
track.nUTile = (int)uv->GetUScl(0);
track.nVTile = (int)uv->GetVScl(0);
if( track.nUTile == 1 && track.nVTile == 1 )
track.bTiling = false;
else
track.bTiling = true;
track.nStartFrame = bmt->GetStartTime();
track.fPlaybackRate = bmt->GetPlaybackRate();
track.nLoopMode = bmt->GetEndCondition();
if( uv->GetUAng( 0 ) != 0.0f ||
uv->GetVAng( 0 ) != 0.0f )
{
track.fUSpeed = uv->GetUAng( 0 ) / piOver180;
track.fVSpeed = uv->GetVAng( 0 ) / piOver180;
track.bUVMoving = true;
}
else
track.bUVMoving = false;
}
}
}
TimeValue t;
for( t = nStartTick; t <= nEndTick; t += nTickPerFrame )
nFrameCount++;
track.ColorKeyFrame.resize( nFrameCount );
t = nStartTick;
for( int i = 0; i < nFrameCount; i++, t += nTickPerFrame )
{
SGP_ColorKey key;
memset( &key, 0x00, sizeof( key ) );
Color diffuse = pStdMtl->GetDiffuse( t );
Color ambient = pStdMtl->GetAmbient( t );
Color specular = pStdMtl->GetSpecular( t );
Color filter = pStdMtl->GetFilter( t );
float alpha = pStdMtl->GetOpacity( t );
float shinstr = pStdMtl->GetShinStr(t);
float selfillum = pStdMtl->GetSelfIllum( t );
float uoffset = 0;
float voffset = 0;
if( uv )
{
uoffset = uv->GetUOffs( t );
voffset = uv->GetVOffs( t );
}
/*
int nTransparencyType = pStdMtl->GetTransparencyType();
key.dwBlendMode = 0;
switch( nTransparencyType )
{
case TRANSP_SUBTRACTIVE:
key.dwBlendMode |= HR3D_MDX2_MODULATE;
break;
case TRANSP_ADDITIVE:
key.dwBlendMode |= HR3D_MDX2_ADD;
break;
case TRANSP_FILTER:
key.dwBlendMode |= HR3D_MDX2_MODULATE2X;
break;
default:
break;
};
*/
key.dr = diffuse.r;
key.dg = diffuse.g;
key.db = diffuse.b;
key.da = alpha;
if( uv )
{
key.uoffset = uv->GetUOffs( t );
key.voffset = uv->GetVOffs( t );
}
else
{
key.uoffset = 0;
key.voffset = 0;
}
track.ColorKeyFrame.getReference(i) = key;
}
return true;
}
void Import::LoadMaterials (dScene& scene, MaterialCache& materialCache)
{
dScene::Iterator iter (scene);
for (iter.Begin(); iter; iter ++) {
dScene::dTreeNode* const materialNode = iter.GetNode();
dNodeInfo* const info = scene.GetInfoFromNode(materialNode);
if (info->IsType(dMaterialNodeInfo::GetRttiType())) {
MaterialProxi material;
material.m_mtl = NewDefaultStdMat();
StdMat* const stdMtl = (StdMat*)material.m_mtl;
dMaterialNodeInfo* const materialInfo = (dMaterialNodeInfo*) info;
stdMtl->SetName(materialInfo->GetName());
dVector ambient (materialInfo->GetAmbientColor());
dVector difusse (materialInfo->GetDiffuseColor());
dVector specular (materialInfo->GetSpecularColor());
float shininess (materialInfo->GetShininess());
//float shininessStr (materialInfo->GetShinStr());
float transparency (materialInfo->GetOpacity());
stdMtl->SetAmbient(*((Point3*)&ambient), 0);
stdMtl->SetDiffuse(*((Point3*)&difusse), 0);
stdMtl->SetSpecular(*((Point3*)&specular), 0);
stdMtl->SetShinStr(shininess / 100.0f, 0);
stdMtl->SetOpacity(transparency, 0);
if (materialInfo->GetDiffuseTextId() != -1) {
dScene::dTreeNode* textNode = scene.FindTextureByTextId(materialNode, materialInfo->GetDiffuseTextId());
if (textNode) {
_ASSERTE (textNode);
// BitmapTex* bmtex;
// const TCHAR* txtName;
dTextureNodeInfo* textureInfo = (dTextureNodeInfo*) scene.GetInfoFromNode(textNode);
TCHAR txtNameBuffer[256];
sprintf (txtNameBuffer, "%s/%s", m_path, textureInfo->GetPathName());
const TCHAR* txtName = txtNameBuffer;
BitmapTex* bmtex = (BitmapTex*)NewDefaultBitmapTex();
bmtex->SetMapName((TCHAR*)txtName);
txtName = textureInfo->GetPathName();
bmtex->SetName (txtName);
bmtex->GetUVGen()->SetMapChannel(1);
stdMtl->SetSubTexmap(ID_DI, bmtex);
stdMtl->SetTexmapAmt(ID_DI, 1.0f, 0);
stdMtl->EnableMap(ID_DI, TRUE);
// const char* materialOpanacity = segment.m_opacityTextureName;
// if (materialOpanacity[0]) {
// BitmapTex* bmtex;
// const TCHAR* txtName;
//
// txtName = segment.m_opacityPathName;
// bmtex = (BitmapTex*)NewDefaultBitmapTex();
// bmtex->SetMapName((TCHAR*)txtName);
//
// txtName = materialName;
// bmtex->SetName (txtName);
// bmtex->GetUVGen()->SetMapChannel(2);
//
// stdMtl->SetSubTexmap(ID_OP, bmtex);
// stdMtl->SetTexmapAmt(ID_OP, 1.0f, 0);
// stdMtl->EnableMap(ID_OP, TRUE);
// }
// materialCache.AddMaterial(material, segment.m_textureName);
}
}
materialCache.AddMaterial(material, materialInfo->GetId());
}
}
}
//----------------------------------------------------------------------------------
// dump material textures
void DumpTexture(m_material *pMat, IGameMaterial *pGMaxMat)
{
std::vector<tex_channel> bk_tex_channel;
std::vector<unsigned int> bk_tex_idx;
std::vector<MatTextureInfo> TexInfos;
int texCount = pGMaxMat->GetNumberOfTextureMaps();
for (int i = 0; i < texCount; ++i)
{
IGameTextureMap * pGMaxTex = pGMaxMat->GetIGameTextureMap(i);
int tex_type = pGMaxTex->GetStdMapSlot();
if (pGMaxTex->IsEntitySupported() && tex_type >= 0) //its a bitmap texture
{
MatTextureInfo TexInfo;
tex_channel tc;
TexInfo.mat_id = pMat->id;
m_texture * pTex = new m_texture;
std::string pathname = pGMaxTex->GetBitmapFileName();
int idx = (int)pathname.rfind('\\');
if (idx == INDEX_NONE){
idx = (int)pathname.rfind('/');
}
std::string filename = pathname.substr(idx + 1, INDEX_NONE);
pTex->name = filename;
// set the texture xform...
IGameUVGen *pUVGen = pGMaxTex->GetIGameUVGen();
GMatrix UVMat = pUVGen->GetUVTransform();
TexInfo.tex_mat = pTex->tex_mat = (scalar*)UVMat.GetAddr(); // save mapping matrix
// get the uv channel to use...
Texmap *pTMap = pGMaxTex->GetMaxTexmap();
BitmapTex *pBTex = (BitmapTex*)pTMap;
StdUVGen *pStdUVGen = pBTex->GetUVGen();
if (pStdUVGen){
tc.channel = pStdUVGen->GetMapChannel() - 1;
}
IParamBlock2 *pUVWCropParam = (IParamBlock2*)(pBTex->GetReference(1));
if (pUVWCropParam)
{
pUVWCropParam->GetValue(0, ExporterMAX::GetExporter()->GetStaticFrame(), TexInfo.uv_offset.x, FOREVER);
pUVWCropParam->GetValue(1, ExporterMAX::GetExporter()->GetStaticFrame(), TexInfo.uv_offset.y, FOREVER);
pUVWCropParam->GetValue(2, ExporterMAX::GetExporter()->GetStaticFrame(), TexInfo.uv_scale.x, FOREVER);
pUVWCropParam->GetValue(3, ExporterMAX::GetExporter()->GetStaticFrame(), TexInfo.uv_scale.y, FOREVER);
}
// set the type of texture...
pTex->type = texture_type[tex_type];
// if we have a bump map, we create a normal map with the convention
// that the filename will be the same name as the bump map + "_normal"
// appended to it.
if (pTex->type == m_texture::BUMP)
{
std::string normal_map = pTex->name;
std::string::size_type pos = normal_map.rfind(".");
normal_map.insert(pos, "_normal");
m_texture *pTexNormal = new m_texture;
*pTexNormal = *pTex;
pTexNormal->name = normal_map;
pTexNormal->type = m_texture::NORMAL;
tc.pTex = pTexNormal;
bk_tex_channel.push_back(tc); // add the new texture to the local TOC
TexInfos.push_back(TexInfo);
}
tc.pTex = pTex;
bk_tex_channel.push_back(tc); // add the new texture to the local TOC
TexInfos.push_back(TexInfo);
}
}
// lets check if we don't have them already in our global TOC...
for (size_t index = 0; index < bk_tex_channel.size(); ++index)
{
m_texture * pTex = bk_tex_channel[index].pTex;
unsigned int idx = ExporterMAX::GetExporter()->FindTexture(pTex);
if (idx == INDEX_NONE){
idx = ExporterMAX::GetExporter()->AddTexture(pTex); // add the new texture to the TOC
}
bk_tex_idx.push_back(idx);
pMat->tex_channel.push_back(bk_tex_channel[index].channel);
TexInfos[index].base_channel = bk_tex_channel[index].channel;
bk_texs.insert(IdxBKTexMapPair(idx, TexInfos[index]));
}
// set the texture indices...
for (size_t index = 0; index < bk_tex_idx.size(); ++index){
pMat->textures.push_back(bk_tex_idx[index]);
}
}
Texmap* NifImporter::CreateTexture(TexDesc& desc)
{
BitmapManager *bmpMgr = TheManager;
if (NiSourceTextureRef texSrc = desc.source){
string filename = texSrc->GetTextureFileName();
if (bmpMgr->CanImport(filename.c_str())){
BitmapTex *bmpTex = NewDefaultBitmapTex();
string name = texSrc->GetName();
if (name.empty()) {
TCHAR buffer[MAX_PATH];
_tcscpy(buffer, PathFindFileName(filename.c_str()));
PathRemoveExtension(buffer);
name = buffer;
}
bmpTex->SetName(name.c_str());
bmpTex->SetMapName(const_cast<TCHAR*>(FindImage(filename).c_str()));
bmpTex->SetAlphaAsMono(TRUE);
bmpTex->SetAlphaSource(ALPHA_DEFAULT);
switch (desc.filterMode)
{
case FILTER_TRILERP: bmpTex->SetFilterType(FILTER_PYR); break;
case FILTER_BILERP: bmpTex->SetFilterType(FILTER_SAT); break;
case FILTER_NEAREST: bmpTex->SetFilterType(FILTER_NADA); break;
}
if (UVGen *uvGen = bmpTex->GetTheUVGen()){
if (uvGen && uvGen->IsStdUVGen()) {
StdUVGen *uvg = (StdUVGen*)uvGen;
uvg->SetMapChannel(desc.uvSet + 1);
}
switch (desc.clampMode)
{
case WRAP_S_WRAP_T : uvGen->SetTextureTiling(3); break;
case WRAP_S_CLAMP_T: uvGen->SetTextureTiling(1); break;
case CLAMP_S_WRAP_T: uvGen->SetTextureTiling(2); break;
case CLAMP_S_CLAMP_T:uvGen->SetTextureTiling(0); break;
}
if (desc.hasTextureTransform) {
if (RefTargetHandle ref = uvGen->GetReference(0)){
TexCoord trans = desc.translation;
TexCoord tiling = desc.tiling;
float wangle = TODEG(desc.wRotation);
setMAXScriptValue(ref, "U_Offset", 0, trans.u);
setMAXScriptValue(ref, "V_Offset", 0, trans.v);
setMAXScriptValue(ref, "U_Tiling", 0, tiling.u);
setMAXScriptValue(ref, "V_Tiling", 0, tiling.v);
setMAXScriptValue(ref, "W_Angle", 0, wangle);
}
}
}
if (showTextures) {
bmpTex->SetMtlFlag(MTL_TEX_DISPLAY_ENABLED, TRUE);
bmpTex->ActivateTexDisplay(TRUE);
bmpTex->NotifyDependents(FOREVER, PART_ALL, REFMSG_CHANGE);
}
return bmpTex;
}
}
return NULL;
}
//----------------------------------------------------------------------------
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));
}
}
}
}
AWDTexture *
AWDExporter::ExportTexture(AWD *awd, awd_ncache *ncache,Texmap* tex, Class_ID cid, int subNo, AWDMaterial * mat ) {
AWDTexture *awd_tex;
const char* name;
int name_len;
bool hasAlpha = false;
MSTR path;
awd_uint8 * buf;
int buf_len;
if (!tex) return NULL;
if (tex->ClassID() != Class_ID(BMTEX_CLASS_ID, 0x00) ) return NULL;
// texture already exist in cache
awd_tex = (AWDTexture *)awd_ncache_get( ncache, tex );
if( awd_tex ) return awd_tex;
BitmapTex *bmptex = (BitmapTex*)tex;
MaxSDK::AssetManagement::AssetUser asset = bmptex->GetMap();
hasAlpha = bmptex->GetBitmap( GetStaticFrame() )->HasAlpha();
if( !asset.GetFullFilePath(path) ) {
fprintf( logfile, " export !asset.GetFullFilePath(path) : %i \n", asset.GetType() );
fflush( logfile );
//return NULL;
}
fprintf( logfile, " export : %s \n", path );
fflush( logfile );
AWD_tex_type textype = EXTERNAL;
if( GetIncludeMaps() &&
asset.GetType() == MaxSDK::AssetManagement::kBitmapAsset
) {
const char * dot;
dot = strrchr(path,'.');
if( !strcmp(dot, ".jpg")||
!strcmp(dot, ".JPG")||
!strcmp(dot, ".jpeg")||
!strcmp(dot, ".JPEG")
) {
textype = EMBEDDED_JPEG;
} else if (
!strcmp(dot, ".png")||
!strcmp(dot, ".PNG")
) {
textype = EMBEDDED_PNG;
}
if( textype == 0 ) {
fprintf( logfile, " export texture : %s \n", path );
fflush( logfile );
// try to extract data
Bitmap *bmp = bmptex->GetBitmap( GetStaticFrame() );
BitmapInfo bi;
MaxSDK::Util::Path *temppath;
bi.SetWidth( bmp->Width() );
bi.SetHeight( bmp->Height() );
if( hasAlpha ) {
bi.SetType( BMM_TRUE_32 );
bi.SetFlags( MAP_HAS_ALPHA );
path = "C:\\Users\\lepersp\\Desktop\\temp\\awdexporttempjpg.png";
textype = EMBEDDED_PNG;
} else {
bi.SetType( BMM_TRUE_24 );
path = "C:\\Users\\lepersp\\Desktop\\temp\\awdexporttempjpg.jpg";
textype = EMBEDDED_JPEG;
}
temppath = new MaxSDK::Util::Path( path );
bi.SetPath( *temppath );
bmp->OpenOutput( & bi );
bmp->Write( & bi );
bmp->Close(& bi);
}
if( path != NULL ) {
size_t result;
int fd;
errno_t err = _sopen_s( &fd, path, _O_RDONLY|_O_BINARY, _SH_DENYNO, _S_IREAD );
if( err == 0 ) {
struct stat *s;
s = (struct stat *)malloc(sizeof(struct stat));
fstat(fd, s);
buf_len = s->st_size;
buf = (awd_uint8 *) malloc (buf_len * sizeof( awd_uint8 ) );
lseek(fd, 0, SEEK_SET);
result = read(fd, buf, buf_len);
if (result != buf_len) {
textype = EXTERNAL;
}
_close( fd );
} else {
textype = EXTERNAL;
}
}
}
name = tex->GetName();
name_len = strlen( name );
char* namecpy = (char*) malloc( name_len*sizeof( char ) ) ;
strcpy( namecpy, name );
awd_tex = new AWDTexture( textype, namecpy, name_len );
if( textype != 0 ) {
awd_tex->set_embed_data(buf, buf_len);
}
char * pathcpy = (char *) malloc( (path.length()+1) * sizeof( char ) );
strcpy( pathcpy, path.data() );
awd_tex->set_url( pathcpy, strlen( pathcpy ) );
awd->add_texture( awd_tex );
awd_ncache_add( ncache, tex, awd_tex );
if( subNo == ID_DI ) {
mat->set_texture( awd_tex );
mat->alpha_blending = hasAlpha;
}
return awd_tex;
}
