GFXTexHandle ProcessedMaterial::_createTexture( const char* filename, GFXTextureProfile *profile)
{
return GFXTexHandle( _getTexturePath(filename), profile, avar("%s() - NA (line %d)", __FUNCTION__, __LINE__) );
}
void ProcessedMaterial::_setStageData()
{
// Only do this once
if ( mHasSetStageData )
return;
mHasSetStageData = true;
U32 i;
// Load up all the textures for every possible stage
for( i=0; i<Material::MAX_STAGES; i++ )
{
// DiffuseMap
if( mMaterial->mDiffuseMapFilename[i].isNotEmpty() )
{
mStages[i].setTex( MFT_DiffuseMap, _createTexture( mMaterial->mDiffuseMapFilename[i], &GFXDefaultStaticDiffuseProfile ) );
if (!mStages[i].getTex( MFT_DiffuseMap ))
{
mMaterial->logError("Failed to load diffuse map %s for stage %i", _getTexturePath(mMaterial->mDiffuseMapFilename[i]).c_str(), i);
// Load a debug texture to make it clear to the user
// that the texture for this stage was missing.
mStages[i].setTex( MFT_DiffuseMap, _createTexture( GFXTextureManager::getMissingTexturePath().c_str(), &GFXDefaultStaticDiffuseProfile ) );
}
}
// OverlayMap
if( mMaterial->mOverlayMapFilename[i].isNotEmpty() )
{
mStages[i].setTex( MFT_OverlayMap, _createTexture( mMaterial->mOverlayMapFilename[i], &GFXDefaultStaticDiffuseProfile ) );
if(!mStages[i].getTex( MFT_OverlayMap ))
mMaterial->logError("Failed to load overlay map %s for stage %i", _getTexturePath(mMaterial->mOverlayMapFilename[i]).c_str(), i);
}
// LightMap
if( mMaterial->mLightMapFilename[i].isNotEmpty() )
{
mStages[i].setTex( MFT_LightMap, _createTexture( mMaterial->mLightMapFilename[i], &GFXDefaultStaticDiffuseProfile ) );
if(!mStages[i].getTex( MFT_LightMap ))
mMaterial->logError("Failed to load light map %s for stage %i", _getTexturePath(mMaterial->mLightMapFilename[i]).c_str(), i);
}
// ToneMap
if( mMaterial->mToneMapFilename[i].isNotEmpty() )
{
mStages[i].setTex( MFT_ToneMap, _createTexture( mMaterial->mToneMapFilename[i], &GFXDefaultStaticDiffuseProfile ) );
if(!mStages[i].getTex( MFT_ToneMap ))
mMaterial->logError("Failed to load tone map %s for stage %i", _getTexturePath(mMaterial->mToneMapFilename[i]).c_str(), i);
}
// DetailMap
if( mMaterial->mDetailMapFilename[i].isNotEmpty() )
{
mStages[i].setTex( MFT_DetailMap, _createTexture( mMaterial->mDetailMapFilename[i], &GFXDefaultStaticDiffuseProfile ) );
if(!mStages[i].getTex( MFT_DetailMap ))
mMaterial->logError("Failed to load detail map %s for stage %i", _getTexturePath(mMaterial->mDetailMapFilename[i]).c_str(), i);
}
// NormalMap
if( mMaterial->mNormalMapFilename[i].isNotEmpty() )
{
mStages[i].setTex( MFT_NormalMap, _createTexture( mMaterial->mNormalMapFilename[i], &GFXDefaultStaticNormalMapProfile ) );
if(!mStages[i].getTex( MFT_NormalMap ))
mMaterial->logError("Failed to load normal map %s for stage %i", _getTexturePath(mMaterial->mNormalMapFilename[i]).c_str(), i);
}
// Detail Normal Map
if( mMaterial->mDetailNormalMapFilename[i].isNotEmpty() )
{
mStages[i].setTex( MFT_DetailNormalMap, _createTexture( mMaterial->mDetailNormalMapFilename[i], &GFXDefaultStaticNormalMapProfile ) );
if(!mStages[i].getTex( MFT_DetailNormalMap ))
mMaterial->logError("Failed to load normal map %s for stage %i", _getTexturePath(mMaterial->mDetailNormalMapFilename[i]).c_str(), i);
}
// SpecularMap
if( mMaterial->mSpecularMapFilename[i].isNotEmpty() )
{
mStages[i].setTex( MFT_SpecularMap, _createTexture( mMaterial->mSpecularMapFilename[i], &GFXDefaultStaticDiffuseProfile ) );
if(!mStages[i].getTex( MFT_SpecularMap ))
mMaterial->logError("Failed to load specular map %s for stage %i", _getTexturePath(mMaterial->mSpecularMapFilename[i]).c_str(), i);
}
//Sahara
// AccuMap
if( mMaterial->mAccuMapFilename[i].isNotEmpty() )
{
mStages[i].setTex( MFT_AccuMap, _createTexture( mMaterial->mAccuMapFilename[i], &GFXDefaultStaticDiffuseProfile ) );
if(!mStages[i].getTex( MFT_AccuMap ))
mMaterial->logError("Failed to load accu map %s for stage %i", _getTexturePath(mMaterial->mAccuMapFilename[i]).c_str(), i);
}
//Sahara
// EnironmentMap
if( mMaterial->mEnvMapFilename[i].isNotEmpty() )
{
mStages[i].setTex( MFT_EnvMap, _createTexture( mMaterial->mEnvMapFilename[i], &GFXDefaultStaticDiffuseProfile ) );
if(!mStages[i].getTex( MFT_EnvMap ))
mMaterial->logError("Failed to load environment map %s for stage %i", _getTexturePath(mMaterial->mEnvMapFilename[i]).c_str(), i);
}
}
mMaterial->mCubemapData = dynamic_cast<CubemapData*>(Sim::findObject( mMaterial->mCubemapName ));
if( !mMaterial->mCubemapData )
mMaterial->mCubemapData = NULL;
// If we have a cubemap put it on stage 0 (cubemaps only supported on stage 0)
if( mMaterial->mCubemapData )
{
mMaterial->mCubemapData->createMap();
mStages[0].setCubemap( mMaterial->mCubemapData->mCubemap );
if ( !mStages[0].getCubemap() )
mMaterial->logError("Failed to load cubemap");
}
}
void ProcessedCustomMaterial::_setStageData()
{
// Only do this once
if ( mHasSetStageData )
return;
mHasSetStageData = true;
ShaderRenderPassData* rpd = _getRPD(0);
mConditionerMacros.clear();
// Loop through all the possible textures, set the right flags, and load them if needed
for(U32 i=0; i<CustomMaterial::MAX_TEX_PER_PASS; i++ )
{
rpd->mTexType[i] = Material::NoTexture; // Set none as the default in case none of the cases below catch it.
String filename = mCustomMaterial->mTexFilename[i];
if(filename.isEmpty())
continue;
if(filename.equal(String("$dynamiclight"), String::NoCase))
{
rpd->mTexType[i] = Material::DynamicLight;
mMaxTex = i+1;
continue;
}
if(filename.equal(String("$dynamiclightmask"), String::NoCase))
{
rpd->mTexType[i] = Material::DynamicLightMask;
mMaxTex = i+1;
continue;
}
if(filename.equal(String("$lightmap"), String::NoCase))
{
rpd->mTexType[i] = Material::Lightmap;
mMaxTex = i+1;
continue;
}
if(filename.equal(String("$cubemap"), String::NoCase))
{
if( mCustomMaterial->mCubemapData )
{
rpd->mTexType[i] = Material::Cube;
mMaxTex = i+1;
}
else
{
mCustomMaterial->logError( "Could not find CubemapData - %s", mCustomMaterial->mCubemapName.c_str());
}
continue;
}
if(filename.equal(String("$dynamicCubemap"), String::NoCase))
{
rpd->mTexType[i] = Material::SGCube;
mMaxTex = i+1;
continue;
}
if(filename.equal(String("$backbuff"), String::NoCase))
{
rpd->mTexType[i] = Material::BackBuff;
mMaxTex = i+1;
continue;
}
if(filename.equal(String("$reflectbuff"), String::NoCase))
{
rpd->mTexType[i] = Material::ReflectBuff;
mMaxTex = i+1;
continue;
}
if(filename.equal(String("$miscbuff"), String::NoCase))
{
rpd->mTexType[i] = Material::Misc;
mMaxTex = i+1;
continue;
}
// Check for a RenderTexTargetBin assignment
if (filename.substr( 0, 1 ).equal("#"))
{
String texTargetBufferName = filename.substr(1, filename.length() - 1);
NamedTexTarget *texTarget = NamedTexTarget::find( texTargetBufferName );
rpd->mTexSlot[i].texTarget = texTarget;
// Get the conditioner macros.
if ( texTarget )
texTarget->getShaderMacros( &mConditionerMacros );
rpd->mTexType[i] = Material::TexTarget;
mMaxTex = i+1;
continue;
}
rpd->mTexSlot[i].texObject = _createTexture( filename, &GFXDefaultStaticDiffuseProfile );
if ( !rpd->mTexSlot[i].texObject )
{
mMaterial->logError("Failed to load texture %s", _getTexturePath(filename).c_str());
continue;
}
rpd->mTexType[i] = Material::Standard;
mMaxTex = i+1;
}
// We only get one cubemap
if( mCustomMaterial->mCubemapData )
{
mCustomMaterial->mCubemapData->createMap();
rpd->mCubeMap = mMaterial->mCubemapData->mCubemap; // BTRTODO ?
if ( !rpd->mCubeMap )
mMaterial->logError("Failed to load cubemap");
}
// If this has a output target defined, it may be writing
// to a tex target bin with a conditioner, so search for
// one and add its macros.
if ( mCustomMaterial->mOutputTarget.isNotEmpty() )
{
NamedTexTarget *texTarget = NamedTexTarget::find( mCustomMaterial->mOutputTarget );
if ( texTarget )
texTarget->getShaderMacros( &mConditionerMacros );
}
// Copy the glow state over.
mHasGlow = mCustomMaterial->mGlow[0];
}
