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;
}
bool sMaterial::ConvertMTL(Mtl *mtl)
{
char filename[64];
char file_ext[16];
char filename_with_ext[128];
m_EmissiveColor = mtl->GetSelfIllumColor();
m_AmbientColor = mtl->GetAmbient();
m_DiffuseColor = mtl->GetDiffuse();
m_SpecularColor = mtl->GetSpecular();
m_fShininess = mtl->GetShininess();
m_iNumTextures = 0;
m_BlendMode = "replace";
if ( mtl->ClassID()==Class_ID(DMTL_CLASS_ID, 0) )
{
StdMat* std = (StdMat*)mtl;
float fOpacity = std->GetOpacity(0);
if ( fOpacity < 1.0f )
{
switch (std->GetTransparencyType())
{
case TRANSP_FILTER:
m_BlendMode = "blend";
break;
case TRANSP_SUBTRACTIVE:
m_BlendMode = "subtract";
break;
case TRANSP_ADDITIVE:
m_BlendMode = "add";
break;
default:
m_BlendMode = "replace";
break;
}
}
m_bCullFace = !std->GetTwoSided();
}
for (int i=0; i<mtl->NumSubTexmaps(); i++)
{
Texmap *tex = mtl->GetSubTexmap(i);
if ( tex && tex->ClassID() == Class_ID(BMTEX_CLASS_ID, 0x00) )
{
bool valid_channel = false;
int texture_type = -1;
switch(i)
{
case 0: // ambientmap/lightmap
texture_type = TEXTURE_LIGHTMAP;
break;
case 1: // diffusemap
texture_type = TEXTURE_DIFFUSE;
break;
case 9: // environment
texture_type = TEXTURE_ENVIRONMENT;
break;
default:
// not supported by fixed pipeline 3D rendering
break;
}
if ( texture_type >= 0 )
{
TSTR mapName = ((BitmapTex *)tex)->GetMapName();
_splitpath(mapName, NULL, NULL, filename, file_ext);
sprintf(filename_with_ext, "%s%s", filename, file_ext);
m_Textures[texture_type] = filename_with_ext;
m_MapChannel[texture_type] = tex->GetMapChannel()-1;
}
}
}
return true;
}
//----------------------------------------------------------------------------------
void DumpMaterial(IGameMaterial *pGMaxMat)
{
m_material *pMat = NULL;
if (!pGMaxMat->IsMultiType()) // check not a mix material
{
pMat = new m_material;
// set the name of the material...
pMat->name = pGMaxMat->GetMaterialName();
// add the new material to the TOC(Table Of Contants) and set its id...
pMat->id = ExporterMAX::GetExporter()->AddMaterial(pGMaxMat, pMat);
Mtl *pMaxMaterial = pGMaxMat->GetMaxMaterial();
if (pMaxMaterial->ClassID() == Class_ID(DMTL_CLASS_ID, 0))
{
StdMat *pStandardMaterial = (StdMat*)pMaxMaterial;
Color col;
// diffuse color...
col = pStandardMaterial->GetDiffuse(ExporterMAX::GetExporter()->GetStaticFrame());
pMat->diffuse = Vector4f(col.r, col.g, col.b, 1.f);
// ambient color...
col = pStandardMaterial->GetAmbient(ExporterMAX::GetExporter()->GetStaticFrame());
pMat->ambient = Vector4f(col.r, col.g, col.b, 1.f);
// specular color...
col = pStandardMaterial->GetSpecular(ExporterMAX::GetExporter()->GetStaticFrame());
pMat->specular = Vector4f(col.r, col.g, col.b, 1.f);
// emissive color...
pMat->emission = Vector4f(0.f, 0.f, 0.f, 1.f);
// level of transparency
pMat->transparent = pStandardMaterial->GetOpacity(ExporterMAX::GetExporter()->GetStaticFrame());
// specular exponent...
pMat->shininess = pStandardMaterial->GetShininess(ExporterMAX::GetExporter()->GetStaticFrame());
// transparency
if (pMat->transparent < 1.f){
pMat->diffuse.z = pMat->transparent;
}
}// 3dsmax6 HLSL Material support. (IDxMaterial)
else if (IsDynamicDxMaterial((MtlBase*)pMaxMaterial))
{
IDxMaterial *idxm = (IDxMaterial*)pMaxMaterial->GetInterface(IDXMATERIAL_INTERFACE);
int lightParams = idxm->GetNumberOfLightParams();
for (int i = 0; i < lightParams; ++i)
{
INode *pNode = idxm->GetLightNode(i);
if (pNode){
TCHAR *paramName = idxm->GetLightParameterName(i);
}
}
// Other attributes are located in paramblk 0...
IParamBlock2 *pParamBlk2 = (IParamBlock2*)(pMaxMaterial->GetParamBlock(0));
TimeValue t0 = ExporterMAX::GetExporter()->GetIGame()->GetSceneStartTime();
TimeValue t1 = ExporterMAX::GetExporter()->GetIGame()->GetSceneEndTime();
TimeValue DeltaTime = ExporterMAX::GetExporter()->GetIGame()->GetSceneTicks();
const int SamplingRate = 1;
int numkeys = (t1 - t0) / (DeltaTime * SamplingRate) + 1;
for (int i = 0; i < pParamBlk2->NumParams(); ++i)
{
ParamID id = pParamBlk2->IndextoID(i);
ParamDef paramDef = pParamBlk2->GetParamDef(id);
// we want the variable name not the UI Name...
OutputDebugString(paramDef.int_name);
}
}
//do the textures if they are there
DumpTexture(pMat, pGMaxMat);
}
}
