TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-07-14 16:14:38 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

strip out unused pixspecular to cut down on sources of confusion

Browse source
This commit is contained in:
AzaezelX 2019-05-05 20:10:14 -05:00
parent 6326147fca
commit 57ee1882fa
22 changed files with 12 additions and 534 deletions
Download patch file Download diff file Expand all files Collapse all files

3
Engine/source/lighting/advanced/advancedLightingFeatures.cpp
View file

@ -60,7 +60,6 @@ void AdvancedLightingFeatures::registerFeatures( const GFXFormat &deferredTarget
FEATUREMGR->registerFeature(MFT_DeferredConditioner, cond); FEATUREMGR->registerFeature(MFT_DeferredConditioner, cond);
FEATUREMGR->registerFeature(MFT_RTLighting, new DeferredRTLightingFeatGLSL()); FEATUREMGR->registerFeature(MFT_RTLighting, new DeferredRTLightingFeatGLSL());
FEATUREMGR->registerFeature(MFT_NormalMap, new DeferredBumpFeatGLSL()); FEATUREMGR->registerFeature(MFT_NormalMap, new DeferredBumpFeatGLSL());
FEATUREMGR->registerFeature(MFT_PixSpecular, new DeferredPixelSpecularGLSL());
FEATUREMGR->registerFeature(MFT_MinnaertShading, new DeferredMinnaertGLSL()); FEATUREMGR->registerFeature(MFT_MinnaertShading, new DeferredMinnaertGLSL());
FEATUREMGR->registerFeature(MFT_SubSurface, new DeferredSubSurfaceGLSL()); FEATUREMGR->registerFeature(MFT_SubSurface, new DeferredSubSurfaceGLSL());
FEATUREMGR->registerFeature(MFT_ReflectionProbes, new ReflectionProbeFeatGLSL); FEATUREMGR->registerFeature(MFT_ReflectionProbes, new ReflectionProbeFeatGLSL);
@ -73,7 +72,6 @@ void AdvancedLightingFeatures::registerFeatures( const GFXFormat &deferredTarget
FEATUREMGR->registerFeature(MFT_DeferredConditioner, cond); FEATUREMGR->registerFeature(MFT_DeferredConditioner, cond);
FEATUREMGR->registerFeature(MFT_RTLighting, new DeferredRTLightingFeatHLSL()); FEATUREMGR->registerFeature(MFT_RTLighting, new DeferredRTLightingFeatHLSL());
FEATUREMGR->registerFeature(MFT_NormalMap, new DeferredBumpFeatHLSL()); FEATUREMGR->registerFeature(MFT_NormalMap, new DeferredBumpFeatHLSL());
FEATUREMGR->registerFeature(MFT_PixSpecular, new DeferredPixelSpecularHLSL());
FEATUREMGR->registerFeature(MFT_MinnaertShading, new DeferredMinnaertHLSL()); FEATUREMGR->registerFeature(MFT_MinnaertShading, new DeferredMinnaertHLSL());
FEATUREMGR->registerFeature(MFT_SubSurface, new DeferredSubSurfaceHLSL()); FEATUREMGR->registerFeature(MFT_SubSurface, new DeferredSubSurfaceHLSL());
FEATUREMGR->registerFeature(MFT_ReflectionProbes, new ReflectionProbeFeatHLSL); FEATUREMGR->registerFeature(MFT_ReflectionProbes, new ReflectionProbeFeatHLSL);
@ -96,7 +94,6 @@ void AdvancedLightingFeatures::unregisterFeatures()
FEATUREMGR->unregisterFeature(MFT_DeferredConditioner); FEATUREMGR->unregisterFeature(MFT_DeferredConditioner);
FEATUREMGR->unregisterFeature(MFT_RTLighting); FEATUREMGR->unregisterFeature(MFT_RTLighting);
FEATUREMGR->unregisterFeature(MFT_NormalMap); FEATUREMGR->unregisterFeature(MFT_NormalMap);
FEATUREMGR->unregisterFeature(MFT_PixSpecular);
FEATUREMGR->unregisterFeature(MFT_MinnaertShading); FEATUREMGR->unregisterFeature(MFT_MinnaertShading);
FEATUREMGR->unregisterFeature(MFT_SubSurface); FEATUREMGR->unregisterFeature(MFT_SubSurface);

111
Engine/source/lighting/advanced/glsl/advancedLightingFeaturesGLSL.cpp
View file

@ -388,7 +388,7 @@ void DeferredBumpFeatGLSL::processPix( Vector<ShaderComponent*> &componentList,
Parent::processPix( componentList, fd ); Parent::processPix( componentList, fd );
return; return;
} }
else if ( fd.features[MFT_PixSpecular] && !fd.features[MFT_SpecularMap] ) else if (!fd.features[MFT_SpecularMap] )
{ {
Var *bumpSample = (Var *)LangElement::find( "bumpSample" ); Var *bumpSample = (Var *)LangElement::find( "bumpSample" );
if( bumpSample == NULL ) if( bumpSample == NULL )
@ -463,8 +463,7 @@ void DeferredBumpFeatGLSL::setTexData( Material::StageData &stageDat,
} }
} }
else if (!fd.features[MFT_Parallax] && !fd.features[MFT_SpecularMap] && else if (!fd.features[MFT_Parallax] && !fd.features[MFT_SpecularMap] &&
( fd.features[MFT_DeferredConditioner] || ( fd.features[MFT_DeferredConditioner]) )
fd.features[MFT_PixSpecular] ) )
{ {
passData.mTexType[ texIndex ] = Material::Bump; passData.mTexType[ texIndex ] = Material::Bump;
passData.mSamplerNames[ texIndex ] = "bumpMap"; passData.mSamplerNames[ texIndex ] = "bumpMap";
@ -481,112 +480,6 @@ void DeferredBumpFeatGLSL::setTexData( Material::StageData &stageDat,
} }
void DeferredPixelSpecularGLSL::processVert( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd )
{
if( !fd.features[MFT_isDeferred] || !fd.features[MFT_RTLighting] )
{
Parent::processVert( componentList, fd );
return;
}
output = NULL;
}
void DeferredPixelSpecularGLSL::processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd )
{
if( !fd.features[MFT_isDeferred] || !fd.features[MFT_RTLighting] )
{
Parent::processPix( componentList, fd );
return;
}
MultiLine *meta = new MultiLine;
Var *specular = new Var;
specular->setType( "float" );
specular->setName( "specular" );
LangElement * specDecl = new DecOp( specular );
Var *pbrConfig = (Var*)LangElement::find( "pbrConfig" );
if(pbrConfig == NULL)
{
pbrConfig = new Var;
pbrConfig->setType( "vec4" );
pbrConfig->setName( "pbrConfig" );
pbrConfig->uniform = true;
pbrConfig->constSortPos = cspPotentialPrimitive;
}
Var *smoothness = (Var*)LangElement::find("smoothness");
if (!smoothness)
{
smoothness = new Var("smoothness", "float");
// If the gloss map flag is set, than the specular power is in the alpha
// channel of the specular map
if (fd.features[MFT_GlossMap])
meta->addStatement(new GenOp(" @ = @.a;\r\n", new DecOp(smoothness), pbrConfig));
else
{
smoothness->uniform = true;
smoothness->constSortPos = cspPotentialPrimitive;
}
}
Var *metalness = (Var*)LangElement::find("metalness");
if (!metalness)
{
metalness = new Var("metalness", "float");
metalness->uniform = true;
metalness->constSortPos = cspPotentialPrimitive;
}
Var *lightInfoSamp = (Var *)LangElement::find( "lightInfoSample" );
Var *d_specular = (Var*)LangElement::find( "d_specular" );
Var *d_NL_Att = (Var*)LangElement::find( "d_NL_Att" );
AssertFatal( lightInfoSamp && d_specular && d_NL_Att,
"DeferredPixelSpecularGLSL::processPix - Something hosed the deferred features!" );
if (fd.features[MFT_AccuMap]) {
// change specularity where the accu texture is applied
Var *accuPlc = (Var*)LangElement::find("plc");
Var *accuSpecular = (Var*)LangElement::find("accuSpecular");
if (accuPlc != NULL && accuSpecular != NULL)
//d_specular = clamp(lerp( d_specular, accuSpecular * d_specular, plc.a), 0, 1)
meta->addStatement(new GenOp(" @ = clamp( lerp( @, @ * @, @.a), 0, 1);\r\n", d_specular, d_specular, accuSpecular, d_specular, accuPlc));
}
// (a^m)^n = a^(m*n)
meta->addStatement( new GenOp( " @ = pow( abs(@), max((@ / AL_ConstantSpecularPower),1.0f)) * @;\r\n",
specDecl, d_specular, smoothness, metalness));
LangElement *specMul = new GenOp( "vec4( @.rgb, 0 ) * @", pbrConfig, specular );
LangElement *final = specMul;
// We we have a normal map then mask the specular
if( !fd.features[MFT_SpecularMap] && fd.features[MFT_NormalMap] )
{
Var *bumpSample = (Var*)LangElement::find( "bumpSample" );
final = new GenOp( "@ * @.a", final, bumpSample );
}
// add to color
meta->addStatement( new GenOp( " @;\r\n", assignColor( final, Material::Add ) ) );
output = meta;
}
ShaderFeature::Resources DeferredPixelSpecularGLSL::getResources( const MaterialFeatureData &fd )
{
if( !fd.features[MFT_isDeferred] || !fd.features[MFT_RTLighting] )
return Parent::getResources( fd );
Resources res;
return res;
}
ShaderFeature::Resources DeferredMinnaertGLSL::getResources( const MaterialFeatureData &fd ) ShaderFeature::Resources DeferredMinnaertGLSL::getResources( const MaterialFeatureData &fd )
{ {
Resources res; Resources res;

25
Engine/source/lighting/advanced/glsl/advancedLightingFeaturesGLSL.h
View file

@ -101,29 +101,6 @@ public:
} }
}; };
/// Generates specular highlights in the forward pass
/// from the light deferred buffer.
class DeferredPixelSpecularGLSL : public PixelSpecularGLSL
{
typedef PixelSpecularGLSL Parent;
public:
virtual void processVert( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
virtual void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
virtual Resources getResources( const MaterialFeatureData &fd );
virtual String getName()
{
return "Pixel Specular [Deferred]";
}
};
/// ///
class DeferredMinnaertGLSL : public ShaderFeatureGLSL class DeferredMinnaertGLSL : public ShaderFeatureGLSL
{ {
@ -167,4 +144,4 @@ public:
} }
}; };
#endif // _DEFERREDFEATURESGLSL_H_ #endif // _DEFERREDFEATURESGLSL_H_

114
Engine/source/lighting/advanced/hlsl/advancedLightingFeaturesHLSL.cpp
View file

@ -419,7 +419,7 @@ void DeferredBumpFeatHLSL::processPix( Vector<ShaderComponent*> &componentList,
Parent::processPix( componentList, fd ); Parent::processPix( componentList, fd );
return; return;
} }
else if ( fd.features[MFT_PixSpecular] && !fd.features[MFT_SpecularMap] ) else if (!fd.features[MFT_SpecularMap] )
{ {
Var *bumpSample = (Var *)LangElement::find( "bumpSample" ); Var *bumpSample = (Var *)LangElement::find( "bumpSample" );
if( bumpSample == NULL ) if( bumpSample == NULL )
@ -496,8 +496,7 @@ void DeferredBumpFeatHLSL::setTexData( Material::StageData &stageDat,
} }
} }
else if ( !fd.features[MFT_Parallax] && !fd.features[MFT_SpecularMap] && else if ( !fd.features[MFT_Parallax] && !fd.features[MFT_SpecularMap] &&
( fd.features[MFT_DeferredConditioner] || ( fd.features[MFT_DeferredConditioner]) )
fd.features[MFT_PixSpecular] ) )
{ {
passData.mTexType[ texIndex ] = Material::Bump; passData.mTexType[ texIndex ] = Material::Bump;
passData.mSamplerNames[ texIndex ] = "bumpMap"; passData.mSamplerNames[ texIndex ] = "bumpMap";
@ -513,115 +512,6 @@ void DeferredBumpFeatHLSL::setTexData( Material::StageData &stageDat,
} }
} }
void DeferredPixelSpecularHLSL::processVert( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd )
{
if( !fd.features[MFT_isDeferred] || !fd.features[MFT_RTLighting] )
{
Parent::processVert( componentList, fd );
return;
}
output = NULL;
}
void DeferredPixelSpecularHLSL::processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd )
{
if( !fd.features[MFT_isDeferred] || !fd.features[MFT_RTLighting] )
{
Parent::processPix( componentList, fd );
return;
}
MultiLine *meta = new MultiLine;
Var *specular = new Var;
specular->setType( "float" );
specular->setName( "specular" );
LangElement * specDecl = new DecOp( specular );
Var *pbrConfig = (Var*)LangElement::find( "pbrConfig" );
if(pbrConfig == NULL)
{
pbrConfig = new Var;
pbrConfig->setType( "float4" );
pbrConfig->setName( "pbrConfig" );
pbrConfig->uniform = true;
pbrConfig->constSortPos = cspPotentialPrimitive;
}
Var *smoothness = (Var*)LangElement::find("smoothness");
if (!smoothness)
{
smoothness = new Var("smoothness", "float");
// If the gloss map flag is set, than the specular power is in the alpha
// channel of the specular map
if (fd.features[MFT_GlossMap])
meta->addStatement(new GenOp(" @ = @.a;\r\n", new DecOp(smoothness), pbrConfig));
else
{
smoothness->uniform = true;
smoothness->constSortPos = cspPotentialPrimitive;
}
}
Var *metalness = (Var*)LangElement::find("metalness");
if (!metalness)
{
metalness = new Var("metalness", "float");
metalness->uniform = true;
metalness->constSortPos = cspPotentialPrimitive;
}
Var *lightInfoSamp = (Var *)LangElement::find( "lightInfoSample" );
Var *d_specular = (Var*)LangElement::find( "d_specular" );
Var *d_NL_Att = (Var*)LangElement::find( "d_NL_Att" );
AssertFatal( lightInfoSamp && d_specular && d_NL_Att,
"DeferredPixelSpecularHLSL::processPix - Something hosed the deferred features!" );
if (fd.features[ MFT_AccuMap ])
{
// change specularity where the accu texture is applied
Var *accuPlc = (Var*) LangElement::find( "plc" );
Var *accuSpecular = (Var*)LangElement::find( "accuSpecular" );
if(accuPlc != NULL && accuSpecular != NULL)
//d_specular = clamp(lerp( d_specular, accuSpecular * d_specular, plc.a), 0, 1)
meta->addStatement( new GenOp( " @ = clamp( lerp( @, @ * @, @.a), 0, 1);\r\n", d_specular, d_specular, accuSpecular, d_specular, accuPlc ) );
}
// (a^m)^n = a^(m*n)
meta->addStatement( new GenOp( " @ = pow( abs(@), max((@ / AL_ConstantSpecularPower),1.0f)) * @;\r\n",
specDecl, d_specular, smoothness, metalness));
LangElement *specMul = new GenOp( "float4( @.rgb, 0 ) * @", pbrConfig, specular );
LangElement *final = specMul;
// We we have a normal map then mask the specular
if( !fd.features[MFT_SpecularMap] && fd.features[MFT_NormalMap] )
{
Var *bumpSample = (Var*)LangElement::find( "bumpSample" );
final = new GenOp( "@ * @.a", final, bumpSample );
}
// add to color
meta->addStatement( new GenOp( " @;\r\n", assignColor( final, Material::Add ) ) );
output = meta;
}
ShaderFeature::Resources DeferredPixelSpecularHLSL::getResources( const MaterialFeatureData &fd )
{
if( !fd.features[MFT_isDeferred] || !fd.features[MFT_RTLighting] )
return Parent::getResources( fd );
Resources res;
return res;
}
ShaderFeature::Resources DeferredMinnaertHLSL::getResources( const MaterialFeatureData &fd ) ShaderFeature::Resources DeferredMinnaertHLSL::getResources( const MaterialFeatureData &fd )
{ {
Resources res; Resources res;

24
Engine/source/lighting/advanced/hlsl/advancedLightingFeaturesHLSL.h
View file

@ -102,28 +102,6 @@ public:
}; };
/// Generates specular highlights in the forward pass
/// from the light deferred buffer.
class DeferredPixelSpecularHLSL : public PixelSpecularHLSL
{
typedef PixelSpecularHLSL Parent;
public:
virtual void processVert( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
virtual void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
virtual Resources getResources( const MaterialFeatureData &fd );
virtual String getName()
{
return "Pixel Specular [Deferred]";
}
};
/// ///
class DeferredMinnaertHLSL : public ShaderFeatureHLSL class DeferredMinnaertHLSL : public ShaderFeatureHLSL
{ {
@ -167,4 +145,4 @@ public:
} }
}; };
#endif // _DEFERREDFEATURESHLSL_H_ #endif // _DEFERREDFEATURESHLSL_H_

2
Engine/source/lighting/basic/basicLightManager.cpp
View file

@ -167,7 +167,6 @@ void BasicLightManager::activate( SceneManager *sceneManager )
FEATUREMGR->registerFeature( MFT_ToneMap, new TonemapFeatGLSL ); FEATUREMGR->registerFeature( MFT_ToneMap, new TonemapFeatGLSL );
FEATUREMGR->registerFeature( MFT_NormalMap, new BumpFeatGLSL ); FEATUREMGR->registerFeature( MFT_NormalMap, new BumpFeatGLSL );
FEATUREMGR->registerFeature( MFT_RTLighting, new RTLightingFeatGLSL ); FEATUREMGR->registerFeature( MFT_RTLighting, new RTLightingFeatGLSL );
FEATUREMGR->registerFeature( MFT_PixSpecular, new PixelSpecularGLSL );
FEATUREMGR->registerFeature(MFT_ReflectionProbes, new ReflectionProbeFeatGLSL); FEATUREMGR->registerFeature(MFT_ReflectionProbes, new ReflectionProbeFeatGLSL);
#endif #endif
} }
@ -178,7 +177,6 @@ void BasicLightManager::activate( SceneManager *sceneManager )
FEATUREMGR->registerFeature( MFT_ToneMap, new TonemapFeatHLSL ); FEATUREMGR->registerFeature( MFT_ToneMap, new TonemapFeatHLSL );
FEATUREMGR->registerFeature( MFT_NormalMap, new BumpFeatHLSL ); FEATUREMGR->registerFeature( MFT_NormalMap, new BumpFeatHLSL );
FEATUREMGR->registerFeature( MFT_RTLighting, new RTLightingFeatHLSL ); FEATUREMGR->registerFeature( MFT_RTLighting, new RTLightingFeatHLSL );
FEATUREMGR->registerFeature( MFT_PixSpecular, new PixelSpecularHLSL );
FEATUREMGR->registerFeature(MFT_ReflectionProbes, new ReflectionProbeFeatHLSL); FEATUREMGR->registerFeature(MFT_ReflectionProbes, new ReflectionProbeFeatHLSL);
#endif #endif
} }

1
Engine/source/materials/matInstance.cpp
View file

@ -583,6 +583,7 @@ void MatInstance::dumpShaderInfo() const
Con::printf( "Material Info for object %s - %s", mMaterial->getName(), mMaterial->mMapTo.c_str() ); Con::printf( "Material Info for object %s - %s", mMaterial->getName(), mMaterial->mMapTo.c_str() );
if ( mProcessedMaterial == NULL ) if ( mProcessedMaterial == NULL )
{ {
Con::printf( " [no processed material!]" ); Con::printf( " [no processed material!]" );

3
Engine/source/materials/materialDefinition.cpp
View file

@ -120,8 +120,7 @@ Material::Material()
mSmoothness[i] = 0.0f; mSmoothness[i] = 0.0f;
mMetalness[i] = 0.0f; mMetalness[i] = 0.0f;
mPixelSpecular[i] = false; mIsSRGb[i] = false;
mIsSRGb[i] = false;
mInvertSmoothness[i] = false; mInvertSmoothness[i] = false;
mSmoothnessChan[i] = 0; mSmoothnessChan[i] = 0;

4
Engine/source/materials/materialDefinition.h
View file

@ -237,9 +237,7 @@ public:
F32 mSmoothness[MAX_STAGES]; F32 mSmoothness[MAX_STAGES];
F32 mMetalness[MAX_STAGES]; F32 mMetalness[MAX_STAGES];
bool mPixelSpecular[MAX_STAGES];
bool mVertLit[MAX_STAGES]; bool mVertLit[MAX_STAGES];
/// If true for a stage, vertex colors are multiplied /// If true for a stage, vertex colors are multiplied

1
Engine/source/materials/materialFeatureTypes.cpp
View file

@ -56,7 +56,6 @@ ImplementFeatureType( MFT_RTLighting, MFG_Lighting, 2.0f, true );
ImplementFeatureType( MFT_LightMap, MFG_Lighting, 3.0f, true ); ImplementFeatureType( MFT_LightMap, MFG_Lighting, 3.0f, true );
ImplementFeatureType( MFT_ToneMap, MFG_Lighting, 4.0f, true ); ImplementFeatureType( MFT_ToneMap, MFG_Lighting, 4.0f, true );
ImplementFeatureType( MFT_VertLitTone, MFG_Lighting, 5.0f, false ); ImplementFeatureType( MFT_VertLitTone, MFG_Lighting, 5.0f, false );
ImplementFeatureType( MFT_PixSpecular, MFG_Lighting, 6.0f, true );
ImplementFeatureType( MFT_StaticCubemap, U32(-1), -1.0, true ); ImplementFeatureType( MFT_StaticCubemap, U32(-1), -1.0, true );
ImplementFeatureType( MFT_CubeMap, MFG_Lighting, 7.0f, true ); ImplementFeatureType( MFT_CubeMap, MFG_Lighting, 7.0f, true );
ImplementFeatureType( MFT_SubSurface, MFG_Lighting, 8.0f, true ); ImplementFeatureType( MFT_SubSurface, MFG_Lighting, 8.0f, true );

1
Engine/source/materials/materialFeatureTypes.h
View file

@ -124,7 +124,6 @@ DeclareFeatureType( MFT_VertLitTone );
DeclareFeatureType( MFT_StaticCubemap ); DeclareFeatureType( MFT_StaticCubemap );
DeclareFeatureType( MFT_CubeMap ); DeclareFeatureType( MFT_CubeMap );
DeclareFeatureType( MFT_PixSpecular );
DeclareFeatureType( MFT_InvertSmoothness ); DeclareFeatureType( MFT_InvertSmoothness );
DeclareFeatureType( MFT_SpecularMap ); DeclareFeatureType( MFT_SpecularMap );
DeclareFeatureType( MFT_GlossMap ); DeclareFeatureType( MFT_GlossMap );

8
Engine/source/materials/materialManager.cpp
View file

@ -84,8 +84,6 @@ MaterialManager::MaterialManager()
Con::NotifyDelegate callabck2( this, &MaterialManager::_onDisableMaterialFeature ); Con::NotifyDelegate callabck2( this, &MaterialManager::_onDisableMaterialFeature );
Con::setVariable( "$pref::Video::disableNormalMapping", "false" ); Con::setVariable( "$pref::Video::disableNormalMapping", "false" );
Con::addVariableNotify( "$pref::Video::disableNormalMapping", callabck2 ); Con::addVariableNotify( "$pref::Video::disableNormalMapping", callabck2 );
Con::setVariable( "$pref::Video::disablePixSpecular", "false" );
Con::addVariableNotify( "$pref::Video::disablePixSpecular", callabck2 );
Con::setVariable( "$pref::Video::disableCubemapping", "false" ); Con::setVariable( "$pref::Video::disableCubemapping", "false" );
Con::addVariableNotify( "$pref::Video::disableCubemapping", callabck2 ); Con::addVariableNotify( "$pref::Video::disableCubemapping", callabck2 );
Con::setVariable( "$pref::Video::disableParallaxMapping", "false" ); Con::setVariable( "$pref::Video::disableParallaxMapping", "false" );
@ -417,12 +415,6 @@ void MaterialManager::recalcFeaturesFromPrefs()
mExclusionFeatures.setFeature( MFT_NormalMap, mExclusionFeatures.setFeature( MFT_NormalMap,
Con::getBoolVariable( "$pref::Video::disableNormalMapping", false ) ); Con::getBoolVariable( "$pref::Video::disableNormalMapping", false ) );
mExclusionFeatures.setFeature( MFT_SpecularMap,
Con::getBoolVariable( "$pref::Video::disablePixSpecular", false ) );
mExclusionFeatures.setFeature( MFT_PixSpecular,
Con::getBoolVariable( "$pref::Video::disablePixSpecular", false ) );
mExclusionFeatures.setFeature( MFT_CubeMap, mExclusionFeatures.setFeature( MFT_CubeMap,
Con::getBoolVariable( "$pref::Video::disableCubemapping", false ) ); Con::getBoolVariable( "$pref::Video::disableCubemapping", false ) );

6
Engine/source/materials/processedFFMaterial.cpp
View file

@ -136,11 +136,7 @@ U32 ProcessedFFMaterial::getNumStages()
// stage is active. // stage is active.
if ( mStages[i].hasValidTex() ) if ( mStages[i].hasValidTex() )
stageActive = true; stageActive = true;
// If this stage has specular lighting, it's active
if ( mMaterial->mPixelSpecular[i] )
stageActive = true;
// If we have a Material that is vertex lit // If we have a Material that is vertex lit
// then it may not have a texture // then it may not have a texture
if( mMaterial->mVertLit[i] ) if( mMaterial->mVertLit[i] )

14
Engine/source/materials/processedShaderMaterial.cpp
View file

@ -267,11 +267,7 @@ U32 ProcessedShaderMaterial::getNumStages()
// stage is active. // stage is active.
if ( mStages[i].hasValidTex() ) if ( mStages[i].hasValidTex() )
stageActive = true; stageActive = true;
// If this stage has specular lighting, it's active
if ( mMaterial->mPixelSpecular[i] )
stageActive = true;
// If this stage has diffuse color, it's active // If this stage has diffuse color, it's active
if ( mMaterial->mDiffuse[i].alpha > 0 && if ( mMaterial->mDiffuse[i].alpha > 0 &&
mMaterial->mDiffuse[i] != LinearColorF::WHITE ) mMaterial->mDiffuse[i] != LinearColorF::WHITE )
@ -424,12 +420,6 @@ void ProcessedShaderMaterial::_determineFeatures( U32 stageNum,
if ( mMaterial->mParallaxScale[stageNum] > 0.0f && if ( mMaterial->mParallaxScale[stageNum] > 0.0f &&
fd.features[ MFT_NormalMap ] ) fd.features[ MFT_NormalMap ] )
fd.features.addFeature( MFT_Parallax ); fd.features.addFeature( MFT_Parallax );
// If not parallax then allow per-pixel specular if
// we have real time lighting enabled.
else if ( fd.features[MFT_RTLighting] &&
mMaterial->mPixelSpecular[stageNum] )
fd.features.addFeature( MFT_PixSpecular );
} }
// Without realtime lighting and on lower end // Without realtime lighting and on lower end
@ -441,8 +431,6 @@ void ProcessedShaderMaterial::_determineFeatures( U32 stageNum,
// have per-pixel specular enabled. // have per-pixel specular enabled.
if( fd.features[ MFT_SpecularMap ] ) if( fd.features[ MFT_SpecularMap ] )
{ {
fd.features.addFeature( MFT_PixSpecular );
// Check for an alpha channel on the specular map. If it has one (and it // Check for an alpha channel on the specular map. If it has one (and it
// has values less than 255) than the artist has put the gloss map into // has values less than 255) than the artist has put the gloss map into
// the alpha channel. // the alpha channel.

6
Engine/source/renderInstance/renderDeferredMgr.cpp
View file

@ -794,11 +794,7 @@ U32 ProcessedDeferredMaterial::getNumStages()
// stage is active. // stage is active.
if ( mStages[i].hasValidTex() ) if ( mStages[i].hasValidTex() )
stageActive = true; stageActive = true;
// If this stage has specular lighting, it's active
if ( mMaterial->mPixelSpecular[i] )
stageActive = true;
// If this stage has diffuse color, it's active // If this stage has diffuse color, it's active
if ( mMaterial->mDiffuse[i].alpha > 0 && if ( mMaterial->mDiffuse[i].alpha > 0 &&
mMaterial->mDiffuse[i] != LinearColorF::WHITE ) mMaterial->mDiffuse[i] != LinearColorF::WHITE )

82
Engine/source/shaderGen/GLSL/pixSpecularGLSL.cpp
View file

@ -29,88 +29,6 @@
#include "gfx/gfxStructs.h" #include "gfx/gfxStructs.h"
#include "shaderGen/shaderGen.h" #include "shaderGen/shaderGen.h"
PixelSpecularGLSL::PixelSpecularGLSL()
: mDep(ShaderGen::smCommonShaderPath + String("/gl/lighting.glsl" ))
{
addDependency( &mDep );
}
void PixelSpecularGLSL::processVert( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd )
{
AssertFatal( fd.features[MFT_RTLighting],
"PixelSpecularHLSL requires RTLighting to be enabled!" );
// Nothing to do here... MFT_RTLighting should have
// taken care of passing everything to the pixel shader.
}
void PixelSpecularGLSL::processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd )
{
AssertFatal( fd.features[MFT_RTLighting],
"PixelSpecularHLSL requires RTLighting to be enabled!" );
// RTLighting should have spit out the 4 specular
// powers for the 4 potential lights on this pass.
//
// This can sometimes be NULL if RTLighting skips out
// on us for lightmaps or missing normals.
Var *specular = (Var*)LangElement::find( "specular" );
if ( !specular )
return;
MultiLine *meta = new MultiLine;
LangElement *specMul = new GenOp( "@", specular );
LangElement *final = specMul;
// mask out with lightmap if present
if ( fd.features[MFT_LightMap] )
{
LangElement *lmColor = NULL;
// find lightmap color
lmColor = LangElement::find( "lmColor" );
if ( !lmColor )
{
LangElement * lightMap = LangElement::find( "lightMap" );
LangElement * lmCoord = LangElement::find( "texCoord2" );
lmColor = new GenOp( "texture(@, @)", lightMap, lmCoord );
}
final = new GenOp( "@ * vec4(@.rgb,0)", specMul, lmColor );
}
// If we have a normal map then mask the specular
if ( fd.features[MFT_SpecularMap] )
{
Var *pbrConfig = (Var*)LangElement::find( "PBRConfig" );
if (pbrConfig)
final = new GenOp( "@ * @", final, pbrConfig);
}
else if ( fd.features[MFT_NormalMap] && !fd.features[MFT_IsBC3nm] && !fd.features[MFT_IsBC5nm])
{
Var *bumpColor = (Var*)LangElement::find( "bumpNormal" );
final = new GenOp( "@ * @.a", final, bumpColor );
}
// Add the specular to the final color.
// search for color var
Var *color = (Var*)LangElement::find( "col" );
meta->addStatement( new GenOp( " @.rgb += ( @ ).rgb;\r\n", color, final ) );
output = meta;
}
ShaderFeature::Resources PixelSpecularGLSL::getResources( const MaterialFeatureData &fd )
{
Resources res;
return res;
}
void SpecularMapGLSL::processVert(Vector<ShaderComponent*> &componentList, const MaterialFeatureData &fd) void SpecularMapGLSL::processVert(Vector<ShaderComponent*> &componentList, const MaterialFeatureData &fd)
{ {
MultiLine *meta = new MultiLine; MultiLine *meta = new MultiLine;

26
Engine/source/shaderGen/GLSL/pixSpecularGLSL.h
View file

@ -27,32 +27,6 @@
#include "shaderGen/GLSL/shaderFeatureGLSL.h" #include "shaderGen/GLSL/shaderFeatureGLSL.h"
#endif #endif
/// A per-pixel specular feature.
class PixelSpecularGLSL : public ShaderFeatureGLSL
{
protected:
ShaderIncludeDependency mDep;
public:
PixelSpecularGLSL();
virtual void processVert( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
virtual void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
virtual Resources getResources( const MaterialFeatureData &fd );
virtual String getName()
{
return "Pixel Specular";
}
};
/// A texture source for the PixSpecular feature /// A texture source for the PixSpecular feature
class SpecularMapGLSL : public ShaderFeatureGLSL class SpecularMapGLSL : public ShaderFeatureGLSL
{ {

1
Engine/source/shaderGen/GLSL/shaderGenGLSLInit.cpp
View file

@ -65,7 +65,6 @@ void _initShaderGenGLSL( ShaderGen *shaderGen )
FEATUREMGR->registerFeature( MFT_DetailMap, new DetailFeatGLSL ); FEATUREMGR->registerFeature( MFT_DetailMap, new DetailFeatGLSL );
FEATUREMGR->registerFeature( MFT_StaticCubemap, new NamedFeatureGLSL( "Static Cubemap" ) ); FEATUREMGR->registerFeature( MFT_StaticCubemap, new NamedFeatureGLSL( "Static Cubemap" ) );
FEATUREMGR->registerFeature( MFT_CubeMap, new ReflectCubeFeatGLSL ); FEATUREMGR->registerFeature( MFT_CubeMap, new ReflectCubeFeatGLSL );
FEATUREMGR->registerFeature( MFT_PixSpecular, new PixelSpecularGLSL );
FEATUREMGR->registerFeature( MFT_InvertSmoothness, new NamedFeatureGLSL("Roughest = 1.0")); FEATUREMGR->registerFeature( MFT_InvertSmoothness, new NamedFeatureGLSL("Roughest = 1.0"));
FEATUREMGR->registerFeature( MFT_SpecularMap, new SpecularMapGLSL ); FEATUREMGR->registerFeature( MFT_SpecularMap, new SpecularMapGLSL );
FEATUREMGR->registerFeature( MFT_AccuMap, new AccuTexFeatGLSL ); FEATUREMGR->registerFeature( MFT_AccuMap, new AccuTexFeatGLSL );

86
Engine/source/shaderGen/HLSL/pixSpecularHLSL.cpp
View file

@ -29,92 +29,6 @@
#include "gfx/gfxStructs.h" #include "gfx/gfxStructs.h"
#include "shaderGen/shaderGen.h" #include "shaderGen/shaderGen.h"
PixelSpecularHLSL::PixelSpecularHLSL()
: mDep(ShaderGen::smCommonShaderPath + String("/lighting.hlsl" ))
{
addDependency( &mDep );
}
void PixelSpecularHLSL::processVert( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd )
{
AssertFatal( fd.features[MFT_RTLighting],
"PixelSpecularHLSL requires RTLighting to be enabled!" );
// Nothing to do here... MFT_RTLighting should have
// taken care of passing everything to the pixel shader.
}
void PixelSpecularHLSL::processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd )
{
AssertFatal( fd.features[MFT_RTLighting],
"PixelSpecularHLSL requires RTLighting to be enabled!" );
// RTLighting should have spit out the 4 specular
// powers for the 4 potential lights on this pass.
//
// This can sometimes be NULL if RTLighting skips out
// on us for lightmaps or missing normals.
Var *specular = (Var*)LangElement::find( "specular" );
if ( !specular )
return;
MultiLine *meta = new MultiLine;
LangElement *specMul = new GenOp( "@", specular );
LangElement *final = specMul;
// mask out with lightmap if present
if ( fd.features[MFT_LightMap] )
{
LangElement *lmColor = NULL;
// find lightmap color
lmColor = LangElement::find( "lmColor" );
if ( !lmColor )
{
LangElement * lightMap = LangElement::find( "lightMap" );
LangElement * lmCoord = LangElement::find( "texCoord2" );
LangElement * lightMapTex = LangElement::find("lightMapTex"); //used only DX11 shaders
if (lightMapTex)
lmColor = new GenOp("@.Sample(@, @)", lightMapTex, lightMap, lmCoord);
else
lmColor = new GenOp("tex2D(@, @)", lightMap, lmCoord);
}
final = new GenOp( "@ * float4(@.rgb,0)", specMul, lmColor );
}
// If we have a normal map then mask the specular
if ( fd.features[MFT_SpecularMap] )
{
Var *pbrConfig = (Var*)LangElement::find( "PBRConfig" );
if (pbrConfig)
final = new GenOp( "@ * @", final, pbrConfig);
}
else if ( fd.features[MFT_NormalMap] && !fd.features[MFT_IsBC3nm] && !fd.features[MFT_IsBC5nm])
{
Var *bumpColor = (Var*)LangElement::find( "bumpNormal" );
final = new GenOp( "@ * @.a", final, bumpColor );
}
// Add the specular to the final color.
// search for color var
Var *color = (Var*)LangElement::find( "col" );
meta->addStatement( new GenOp( " @.rgb += ( @ ).rgb;\r\n", color, final ) );
output = meta;
}
ShaderFeature::Resources PixelSpecularHLSL::getResources( const MaterialFeatureData &fd )
{
Resources res;
return res;
}
void SpecularMapHLSL::processVert(Vector<ShaderComponent*> &componentList, const MaterialFeatureData &fd) void SpecularMapHLSL::processVert(Vector<ShaderComponent*> &componentList, const MaterialFeatureData &fd)
{ {
MultiLine *meta = new MultiLine; MultiLine *meta = new MultiLine;

26
Engine/source/shaderGen/HLSL/pixSpecularHLSL.h
View file

@ -27,32 +27,6 @@
#include "shaderGen/HLSL/shaderFeatureHLSL.h" #include "shaderGen/HLSL/shaderFeatureHLSL.h"
#endif #endif
/// A per-pixel specular feature.
class PixelSpecularHLSL : public ShaderFeatureHLSL
{
protected:
ShaderIncludeDependency mDep;
public:
PixelSpecularHLSL();
virtual void processVert( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
virtual void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
virtual Resources getResources( const MaterialFeatureData &fd );
virtual String getName()
{
return "Pixel Specular";
}
};
/// A texture source for the PixSpecular feature /// A texture source for the PixSpecular feature
class SpecularMapHLSL : public ShaderFeatureHLSL class SpecularMapHLSL : public ShaderFeatureHLSL
{ {

1
Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
View file

@ -2952,7 +2952,6 @@ void ReflectionProbeFeatHLSL::processVert(Vector<ShaderComponent*>& componentLis
{ {
MultiLine* meta = new MultiLine; MultiLine* meta = new MultiLine;
output = meta; output = meta;
// Also output the worldToTanget transform which // Also output the worldToTanget transform which
// we use to create the world space normal. // we use to create the world space normal.
getOutWorldToTangent(componentList, meta, fd); getOutWorldToTangent(componentList, meta, fd);

1
Engine/source/shaderGen/HLSL/shaderGenHLSLInit.cpp
View file

@ -65,7 +65,6 @@ void _initShaderGenHLSL( ShaderGen *shaderGen )
FEATUREMGR->registerFeature( MFT_StaticCubemap, new NamedFeatureHLSL( "Static Cubemap" ) ); FEATUREMGR->registerFeature( MFT_StaticCubemap, new NamedFeatureHLSL( "Static Cubemap" ) );
FEATUREMGR->registerFeature( MFT_CubeMap, new ReflectCubeFeatHLSL ); FEATUREMGR->registerFeature( MFT_CubeMap, new ReflectCubeFeatHLSL );
FEATUREMGR->registerFeature( MFT_ReflectionProbes, new ReflectionProbeFeatHLSL); FEATUREMGR->registerFeature( MFT_ReflectionProbes, new ReflectionProbeFeatHLSL);
FEATUREMGR->registerFeature( MFT_PixSpecular, new PixelSpecularHLSL );
FEATUREMGR->registerFeature( MFT_InvertSmoothness, new NamedFeatureHLSL( "Roughest = 1.0" ) ); FEATUREMGR->registerFeature( MFT_InvertSmoothness, new NamedFeatureHLSL( "Roughest = 1.0" ) );
FEATUREMGR->registerFeature( MFT_IsTranslucent, new NamedFeatureHLSL( "Translucent" ) ); FEATUREMGR->registerFeature( MFT_IsTranslucent, new NamedFeatureHLSL( "Translucent" ) );
FEATUREMGR->registerFeature( MFT_IsTranslucentZWrite, new NamedFeatureHLSL( "Translucent ZWrite" ) ); FEATUREMGR->registerFeature( MFT_IsTranslucentZWrite, new NamedFeatureHLSL( "Translucent ZWrite" ) );