void CThermalMaterialProxy::OnBind( C_BaseEntity *pEntity )
{
// FIXME, enable this later
return;
if( !m_ThermalVar )
{
return;
}
float min, max, period, value;
// set default values if these variables don't exist.
min = m_ThermalMin ? m_ThermalMin->GetFloatValue() : 0.0f;
max = m_ThermalMax ? m_ThermalMax->GetFloatValue() : 1.0f;
period = m_ThermalPeriod ? m_ThermalPeriod->GetFloatValue() : 1.0f;
// get a value in [0,1]
value = ( sin( 2.0f * M_PI * gpGlobals->curtime / period ) * 0.5f ) + 0.5f;
// get a value in [min,max]
value = ( max - min ) * value + min;
Vector color;
HueToRGB( 360.f * value, color );
m_ThermalVar->SetVecValue( color[0], color[1], color[2] );
}
//------------------------------------------------------------------------------
// Purpose : Create leak effect if material requests it
// Input :
// Output :
//------------------------------------------------------------------------------
void LeakEffect( trace_t &tr )
{
Vector diffuseColor, baseColor;
Vector vTraceDir = (tr.endpos - tr.startpos);
VectorNormalize(vTraceDir);
Vector vTraceStart = tr.endpos - 0.1*vTraceDir;
Vector vTraceEnd = tr.endpos + 0.1*vTraceDir;
IMaterial* pTraceMaterial = engine->TraceLineMaterialAndLighting( vTraceStart, vTraceEnd, diffuseColor, baseColor );
if (!pTraceMaterial)
return;
bool found;
IMaterialVar *pLeakVar = pTraceMaterial->FindVar( "$leakamount", &found, false );
if( !found )
return;
C_Splash* pLeak = new C_Splash();
if (!pLeak)
return;
ClientEntityList().AddNonNetworkableEntity( pLeak->GetIClientUnknown() );
IMaterialVar* pLeakColorVar = pTraceMaterial->FindVar( "$leakcolor", &found );
if (found)
{
Vector color;
pLeakColorVar->GetVecValue(color.Base(),3);
pLeak->m_vStartColor = pLeak->m_vEndColor = color;
}
IMaterialVar* pLeakNoiseVar = pTraceMaterial->FindVar( "$leaknoise", &found );
if (found)
{
pLeak->m_flNoise = pLeakNoiseVar->GetFloatValue();
}
IMaterialVar* pLeakForceVar = pTraceMaterial->FindVar( "$leakforce", &found );
if (found)
{
float flForce = pLeakForceVar->GetFloatValue();
pLeak->m_flSpeed = flForce;
pLeak->m_flSpeedRange = pLeak->m_flNoise * flForce;
}
pLeak->m_flSpawnRate = pLeakVar->GetFloatValue();;
pLeak->m_flParticleLifetime = 10;
pLeak->m_flWidthMin = 1;
pLeak->m_flWidthMax = 5;
pLeak->SetLocalOrigin( tr.endpos );
QAngle angles;
VectorAngles( tr.plane.normal, angles );
pLeak->SetLocalAngles( angles );
pLeak->Start(&g_ParticleMgr, NULL);
pLeak->m_flStopEmitTime = gpGlobals->curtime+5.0;
pLeak->SetNextClientThink(gpGlobals->curtime+20.0);
}
void CBaseOES2Shader::SetTextureScaledTransform(int reg, int transformVar, int scaleVar)
{
Vector4D transformation[2];
IMaterialVar *pTransformationVar = s_ppParams[transformVar];
if (pTransformationVar && (pTransformationVar->GetType() == MATERIAL_VAR_TYPE_MATRIX))
{
const VMatrix &mat = pTransformationVar->GetMatrixValue();
transformation[0].Init(mat[0][0], mat[0][1], mat[0][2], mat[0][3]);
transformation[1].Init(mat[1][0], mat[1][1], mat[1][2], mat[1][3]);
}
else
{
transformation[0].Init(1.0f, 0.0f, 0.0f, 0.0f);
transformation[1].Init(0.0f, 1.0f, 0.0f, 0.0f);
}
float scale[2] = {1.0f, 1.0f};
IMaterialVar *pScaleVar = s_ppParams[scaleVar];
if (pScaleVar)
{
if (pScaleVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)
pScaleVar->GetVecValue(scale, 2);
else if (pScaleVar->IsDefined())
scale[0] = scale[1] = pScaleVar->GetFloatValue();
}
transformation[0][0] *= scale[0];
transformation[0][1] *= scale[1];
transformation[1][0] *= scale[0];
transformation[1][1] *= scale[1];
transformation[0][3] *= scale[0];
transformation[1][3] *= scale[1];
s_pShaderAPI->Uniform4fv(reg, 2, transformation[0].Base());
}
void CBaseVSShader::SetPixelShaderTextureScaledTransform( int pixelReg, int transformVar, int scaleVar )
{
Vector4D transformation[2];
IMaterialVar* pTransformationVar = s_ppParams[transformVar];
if (pTransformationVar && (pTransformationVar->GetType() == MATERIAL_VAR_TYPE_MATRIX))
{
const VMatrix &mat = pTransformationVar->GetMatrixValue();
transformation[0].Init( mat[0][0], mat[0][1], mat[0][2], mat[0][3] );
transformation[1].Init( mat[1][0], mat[1][1], mat[1][2], mat[1][3] );
}
else
{
transformation[0].Init( 1.0f, 0.0f, 0.0f, 0.0f );
transformation[1].Init( 0.0f, 1.0f, 0.0f, 0.0f );
}
Vector2D scale( 1, 1 );
IMaterialVar* pScaleVar = s_ppParams[scaleVar];
if (pScaleVar)
{
if (pScaleVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)
pScaleVar->GetVecValue( scale.Base(), 2 );
else if (pScaleVar->IsDefined())
scale[0] = scale[1] = pScaleVar->GetFloatValue();
}
// Apply the scaling
transformation[0][0] *= scale[0];
transformation[0][1] *= scale[1];
transformation[1][0] *= scale[0];
transformation[1][1] *= scale[1];
transformation[0][3] *= scale[0];
transformation[1][3] *= scale[1];
s_pShaderAPI->SetPixelShaderConstant( pixelReg, transformation[0].Base(), 2 );
}
void CBaseVSShader::SetPixelShaderConstantGammaToLinear( int pixelReg, int constantVar, int constantVar2 )
{
Assert( !IsSnapshotting() );
if ((!s_ppParams) || (constantVar == -1) || (constantVar2 == -1))
return;
IMaterialVar* pPixelVar = s_ppParams[constantVar];
Assert( pPixelVar );
IMaterialVar* pPixelVar2 = s_ppParams[constantVar2];
Assert( pPixelVar2 );
float val[4];
if (pPixelVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)
{
pPixelVar->GetVecValue( val, 3 );
}
else
{
val[0] = val[1] = val[2] = pPixelVar->GetFloatValue();
}
val[3] = pPixelVar2->GetFloatValue();
val[0] = val[0] > 1.0f ? val[0] : GammaToLinear( val[0] );
val[1] = val[1] > 1.0f ? val[1] : GammaToLinear( val[1] );
val[2] = val[2] > 1.0f ? val[2] : GammaToLinear( val[2] );
s_pShaderAPI->SetPixelShaderConstant( pixelReg, val );
}
//-----------------------------------------------------------------------------
// Sets the color + transparency
//-----------------------------------------------------------------------------
void CBaseShader::SetColorState( int colorVar, bool setAlpha )
{
Assert( !IsSnapshotting() );
if ( !s_ppParams )
return;
// Use tint instead of color if it was specified...
IMaterialVar* pColorVar = (colorVar != -1) ? s_ppParams[colorVar] : 0;
float color[4] = { 1.0, 1.0, 1.0, 1.0 };
if (pColorVar)
{
if (pColorVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)
{
pColorVar->GetVecValue( color, 3 );
}
else
{
color[0] = color[1] = color[2] = pColorVar->GetFloatValue();
}
// Clamp...
color[0] = clamp( color[0], 0.0f, 1.0f );
color[1] = clamp( color[1], 0.0f, 1.0f );
color[2] = clamp( color[2], 0.0f, 1.0f );
}
color[3] = setAlpha ? GetAlpha() : 1.0f;
s_pShaderAPI->Color4fv( color );
}
void CStatusEffectSkinProxy::OnBind( C_BaseEntity *pEnt )
{
float flEffectMagnitude;
if (pEnt->IsPlayer() && ToCFPlayer(pEnt))
{
C_CFPlayer* pPlayer = ToCFPlayer(pEnt);
flEffectMagnitude = pPlayer->m_pStats->GetEffectFromBitmask(STATUSEFFECT_SLOWNESS);
}
else if (pEnt->IsNPC() && dynamic_cast<C_CFActor*>(pEnt))
{
flEffectMagnitude = dynamic_cast<C_CFActor*>(pEnt)->m_flEffectMagnitude;
}
else
return;
if (m_pDetailBlend)
{
float flCurrent = m_pDetailBlend->GetFloatValue();
float flGoal = RemapValClamped(flEffectMagnitude, 0.0f, 1.0f, 0.3f, 1.0f );
if (flEffectMagnitude < 0.01)
flGoal = 0.0f;
m_pDetailBlend->SetFloatValue( Approach(flGoal, flCurrent, gpGlobals->frametime/10) );
}
}
//-----------------------------------------------------------------------------
// Helpers for dealing with envmap tint
//-----------------------------------------------------------------------------
// set alphaVar to -1 to ignore it.
void CBaseVSShader::SetEnvMapTintPixelShaderDynamicState( int pixelReg, int tintVar, int alphaVar, bool bConvertFromGammaToLinear )
{
float color[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
if( g_pConfig->bShowSpecular && mat_fullbright.GetInt() != 2 )
{
IMaterialVar* pAlphaVar = NULL;
if( alphaVar >= 0 )
{
pAlphaVar = s_ppParams[alphaVar];
}
if( pAlphaVar )
{
color[3] = pAlphaVar->GetFloatValue();
}
IMaterialVar* pTintVar = s_ppParams[tintVar];
#ifdef _DEBUG
pTintVar->GetVecValue( color, 3 );
float envmapTintOverride = mat_envmaptintoverride.GetFloat();
float envmapTintScaleOverride = mat_envmaptintscale.GetFloat();
if( envmapTintOverride != -1.0f )
{
color[0] = color[1] = color[2] = envmapTintOverride;
}
if( envmapTintScaleOverride != -1.0f )
{
color[0] *= envmapTintScaleOverride;
color[1] *= envmapTintScaleOverride;
color[2] *= envmapTintScaleOverride;
}
if( bConvertFromGammaToLinear )
{
color[0] = color[0] > 1.0f ? color[0] : GammaToLinear( color[0] );
color[1] = color[1] > 1.0f ? color[1] : GammaToLinear( color[1] );
color[2] = color[2] > 1.0f ? color[2] : GammaToLinear( color[2] );
}
#else
if( bConvertFromGammaToLinear )
{
pTintVar->GetLinearVecValue( color, 3 );
}
else
{
pTintVar->GetVecValue( color, 3 );
}
#endif
}
else
{
color[0] = color[1] = color[2] = color[3] = 0.0f;
}
s_pShaderAPI->SetPixelShaderConstant( pixelReg, color, 1 );
}
void CLessOrEqualProxy::OnBind( void *pC_BaseEntity )
{
Assert( m_pSrc1 && m_pSrc2 && m_pLessVar && m_pGreaterVar && m_pResult );
IMaterialVar *pSourceVar;
if (m_pSrc1->GetFloatValue() <= m_pSrc2->GetFloatValue())
{
pSourceVar = m_pLessVar;
}
else
{
pSourceVar = m_pGreaterVar;
}
int vecSize = 0;
MaterialVarType_t resultType = m_pResult->GetType();
if (resultType == MATERIAL_VAR_TYPE_VECTOR)
{
if (m_ResultVecComp >= 0)
resultType = MATERIAL_VAR_TYPE_FLOAT;
vecSize = m_pResult->VectorSize();
}
else if (resultType == MATERIAL_VAR_TYPE_UNDEFINED)
{
resultType = pSourceVar->GetType();
if (resultType == MATERIAL_VAR_TYPE_VECTOR)
{
vecSize = pSourceVar->VectorSize();
}
}
switch( resultType )
{
case MATERIAL_VAR_TYPE_VECTOR:
{
Vector src;
pSourceVar->GetVecValue( src.Base(), vecSize );
m_pResult->SetVecValue( src.Base(), vecSize );
}
break;
case MATERIAL_VAR_TYPE_FLOAT:
SetFloatResult( pSourceVar->GetFloatValue() );
break;
case MATERIAL_VAR_TYPE_INT:
m_pResult->SetFloatValue( pSourceVar->GetIntValue() );
break;
}
if ( ToolsEnabled() )
{
ToolFramework_RecordMaterialParams( GetMaterial() );
}
}
//-----------------------------------------------------------------------------
// Creates, destroys particles attached to an attachment
//-----------------------------------------------------------------------------
void C_EnvParticleScript::CreateParticle( const char *pAttachmentName, const char *pSpriteName )
{
// Find the attachment
int nAttachment = LookupAttachment( pAttachmentName );
if ( nAttachment <= 0 )
return;
// Get the sprite materials
PMaterialHandle hMat = m_ParticleEffect.FindOrAddMaterial( pSpriteName );
ParticleScriptParticle_t *pParticle =
(ParticleScriptParticle_t*)m_ParticleEffect.AddParticle(sizeof(ParticleScriptParticle_t), hMat);
if ( pParticle == NULL )
return;
// Get the sprite size from the material's materialvars
bool bFound = false;
IMaterialVar *pMaterialVar = NULL;
IMaterial *pMaterial = ParticleMgr()->PMaterialToIMaterial( hMat );
if ( pMaterial )
{
pMaterialVar = pMaterial->FindVar( "$spritesize", &bFound, false );
}
if ( bFound )
{
pParticle->m_flSize = pMaterialVar->GetFloatValue();
}
else
{
pParticle->m_flSize = 100.0f;
}
// Make sure the particle cull size reflects our particles
if ( pParticle->m_flSize > m_flMaxParticleSize )
{
m_flMaxParticleSize = pParticle->m_flSize;
m_ParticleEffect.SetParticleCullRadius( m_flMaxParticleSize );
}
// Place the particle on the attachment specified
pParticle->m_nAttachment = nAttachment;
QAngle vecAngles;
GetAttachment( nAttachment, pParticle->m_Pos, vecAngles );
if ( m_flSequenceScale != 1.0f )
{
pParticle->m_Pos -= GetAbsOrigin();
pParticle->m_Pos *= m_flSequenceScale;
pParticle->m_Pos += GetAbsOrigin();
}
}
inline void GetVecParam( int constantVar, float *val )
{
if( constantVar == -1 )
return;
IMaterialVar* pVar = s_ppParams[constantVar];
Assert( pVar );
if (pVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)
pVar->GetVecValue( val, 4 );
else
val[0] = val[1] = val[2] = val[3] = pVar->GetFloatValue();
}
void CBaseOES2Shader::SetTextureScale(int reg, int scaleVar)
{
float scale[2] = {1.0f, 1.0f};
IMaterialVar *pScaleVar = s_ppParams[scaleVar];
if (pScaleVar)
{
if (pScaleVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)
pScaleVar->GetVecValue(scale, 2);
else if (pScaleVar->IsDefined())
scale[0] = scale[1] = pScaleVar->GetFloatValue();
}
Vector4D scaleMatrix[2];
scaleMatrix[0].Init(scale[0], 0.0f, 0.0f, 0.0f);
scaleMatrix[1].Init(0.0f, scale[1], 0.0f, 0.0f);
s_pShaderAPI->Uniform4fv(reg, 2, scaleMatrix[0].Base());
}
void CBaseVSShader::SetVertexShaderConstant( int vertexReg, int constantVar )
{
Assert( !IsSnapshotting() );
if ((!s_ppParams) || (constantVar == -1))
return;
IMaterialVar* pVertexVar = s_ppParams[constantVar];
Assert( pVertexVar );
float val[4];
if (pVertexVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)
pVertexVar->GetVecValue( val, 4 );
else
val[0] = val[1] = val[2] = val[3] = pVertexVar->GetFloatValue();
s_pShaderAPI->SetVertexShaderConstant( vertexReg, val );
}
float CMaterial::GetDecalScale(void) const
{
const_cast<CMaterial*>(this)->Load();
IMaterialVar *decalScaleVar;
bool found;
decalScaleVar = m_pMaterial->FindVar( "$decalScale", &found, false );
if( !found )
{
return 1.0f;
}
else
{
return decalScaleVar->GetFloatValue();
}
}
void CBaseVSShader::SetPixelShaderConstant_W( int pixelReg, int constantVar, float fWValue )
{
Assert( !IsSnapshotting() );
if ((!s_ppParams) || (constantVar == -1))
return;
IMaterialVar* pPixelVar = s_ppParams[constantVar];
Assert( pPixelVar );
float val[4];
if (pPixelVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)
pPixelVar->GetVecValue( val, 4 );
else
val[0] = val[1] = val[2] = val[3] = pPixelVar->GetFloatValue();
val[3]=fWValue;
s_pShaderAPI->SetPixelShaderConstant( pixelReg, val );
}
void CPupilProxy::OnBind( C_BaseEntity *pBaseEntity )
{
if (!pBaseEntity || !m_pAnimatedTextureVar )
return;
if( m_pAnimatedTextureVar->GetType() != MATERIAL_VAR_TYPE_TEXTURE )
return;
ITexture *pTexture = m_pAnimatedTextureVar->GetTextureValue();
int nFrameCount = pTexture->GetNumAnimationFrames();
// Compute the lighting at the eye position of the entity; use it to dialate the pupil
Vector forward;
pBaseEntity->GetVectors( &forward, NULL, NULL );
Vector eyePt = pBaseEntity->EyePosition();
Vector color;
engine->ComputeLighting( eyePt, &forward, false, color );
// Compute the intensity...
float flIntensity = ( 0.299f * color[0] + 0.587f * color[1] + 0.114f * color[2] ) * 0.5;
flIntensity = clamp( flIntensity, 0, 1 );
float flLastIntensity = m_pLightingVar->GetFloatValue( );
if ( flIntensity > flLastIntensity )
{
float flMaxChange = m_flPupilCloseRate.GetFloat() * gpGlobals->frametime;
if ( flIntensity > (flMaxChange + flLastIntensity) )
{
flIntensity = flLastIntensity + flMaxChange;
}
}
else
{
float flMaxChange = m_flPupilOpenRate.GetFloat() * gpGlobals->frametime;
if ( flIntensity < (flLastIntensity - flMaxChange) )
{
flIntensity = flLastIntensity - flMaxChange;
}
}
int nFrame = nFrameCount * flIntensity;
nFrame = clamp( nFrame, 0, nFrameCount - 1 );
m_pAnimatedTextureFrameNumVar->SetIntValue( nFrame );
m_pLightingVar->SetFloatValue( flIntensity );
}
void CBaseVSShader::SetPixelShaderTextureScale( int pixelReg, int scaleVar )
{
float scale[2] = {1, 1};
IMaterialVar* pScaleVar = s_ppParams[scaleVar];
if (pScaleVar)
{
if (pScaleVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)
pScaleVar->GetVecValue( scale, 2 );
else if (pScaleVar->IsDefined())
scale[0] = scale[1] = pScaleVar->GetFloatValue();
}
Vector4D scaleMatrix[2];
scaleMatrix[0].Init( scale[0], 0.0f, 0.0f, 0.0f );
scaleMatrix[1].Init( 0.0f, scale[1], 0.0f, 0.0f );
s_pShaderAPI->SetPixelShaderConstant( pixelReg, scaleMatrix[0].Base(), 2 );
}
//-----------------------------------------------------------------------------
// Sets pixel shader texture transforms
//-----------------------------------------------------------------------------
void CBaseVSShader::SetPixelShaderTextureTranslation( int pixelReg, int translationVar )
{
float offset[2] = {0, 0};
IMaterialVar* pTranslationVar = s_ppParams[translationVar];
if (pTranslationVar)
{
if (pTranslationVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)
pTranslationVar->GetVecValue( offset, 2 );
else
offset[0] = offset[1] = pTranslationVar->GetFloatValue();
}
Vector4D translation[2];
translation[0].Init( 1.0f, 0.0f, 0.0f, offset[0] );
translation[1].Init( 0.0f, 1.0f, 0.0f, offset[1] );
s_pShaderAPI->SetPixelShaderConstant( pixelReg, translation[0].Base(), 2 );
}
void CTextureTransformProxy::OnBind( void *pC_BaseEntity )
{
Vector2D center( 0.5, 0.5 );
Vector2D translation( 0, 0 );
VMatrix mat, temp;
if (m_pCenterVar)
{
m_pCenterVar->GetVecValue( center.Base(), 2 );
}
MatrixBuildTranslation( mat, -center.x, -center.y, 0.0f );
if (m_pScaleVar)
{
Vector2D scale;
m_pScaleVar->GetVecValue( scale.Base(), 2 );
MatrixBuildScale( temp, scale.x, scale.y, 1.0f );
MatrixMultiply( temp, mat, mat );
}
if (m_pRotateVar)
{
float angle = m_pRotateVar->GetFloatValue( );
MatrixBuildRotateZ( temp, angle );
MatrixMultiply( temp, mat, mat );
}
MatrixBuildTranslation( temp, center.x, center.y, 0.0f );
MatrixMultiply( temp, mat, mat );
if (m_pTranslateVar)
{
m_pTranslateVar->GetVecValue( translation.Base(), 2 );
MatrixBuildTranslation( temp, translation.x, translation.y, 0.0f );
MatrixMultiply( temp, mat, mat );
}
m_pResult->SetMatrixValue( mat );
if ( ToolsEnabled() )
{
ToolFramework_RecordMaterialParams( GetMaterial() );
}
}
//-----------------------------------------------------------------------------
// Converts a color + alpha into a vector4
//-----------------------------------------------------------------------------
void CBaseVSShader::ColorVarsToVector( int colorVar, int alphaVar, Vector4D &color )
{
color.Init( 1.0, 1.0, 1.0, 1.0 );
if ( colorVar != -1 )
{
IMaterialVar* pColorVar = s_ppParams[colorVar];
if ( pColorVar->GetType() == MATERIAL_VAR_TYPE_VECTOR )
{
pColorVar->GetVecValue( color.Base(), 3 );
}
else
{
color[0] = color[1] = color[2] = pColorVar->GetFloatValue();
}
}
if ( alphaVar != -1 )
{
float flAlpha = s_ppParams[alphaVar]->GetFloatValue();
color[3] = clamp( flAlpha, 0.0f, 1.0f );
}
}
void CBaseShader::SetFixedFunctionTextureScaledTransform( MaterialMatrixMode_t textureTransform,
int transformVar, int scaleVar )
{
Assert( !IsSnapshotting() );
float mat[16];
IMaterialVar* pTransformationVar = s_ppParams[transformVar];
if (pTransformationVar && (pTransformationVar->GetType() == MATERIAL_VAR_TYPE_MATRIX))
{
Vector2D scale( 1, 1 );
IMaterialVar* pScaleVar = s_ppParams[scaleVar];
if (pScaleVar)
{
if (pScaleVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)
pScaleVar->GetVecValue( scale.Base(), 2 );
else if (pScaleVar->IsDefined())
scale[0] = scale[1] = pScaleVar->GetFloatValue();
}
s_pShaderAPI->MatrixMode( textureTransform );
const VMatrix &transformation = pTransformationVar->GetMatrixValue();
// only do the upper 3x3 since this is a 2D matrix
mat[0] = transformation[0][0] * scale[0]; mat[1] = transformation[1][0] * scale[0]; mat[2] = transformation[3][0] * scale[0];
mat[4] = transformation[0][1] * scale[1]; mat[5] = transformation[1][1] * scale[1]; mat[6] = transformation[3][1] * scale[1];
mat[8] = transformation[0][3]; mat[9] = transformation[1][3]; mat[10] = transformation[3][3];
// Better set the stuff we don't set with some sort of value!
mat[3] = mat[7] = mat[11] = 0;
mat[12] = mat[13] = mat[14] = 0;
mat[15] = 1;
s_pShaderAPI->LoadMatrix( mat );
}
else
{
SetFixedFunctionTextureScale( textureTransform, scaleVar );
}
}
void CBaseShader::ComputeModulationColor( float* color )
{
Assert( !IsSnapshotting() );
if (!s_ppParams)
return;
IMaterialVar* pColorVar = s_ppParams[COLOR];
if (pColorVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)
{
pColorVar->GetVecValue( color, 3 );
}
else
{
color[0] = color[1] = color[2] = pColorVar->GetFloatValue();
}
if( !g_pConfig->bShowDiffuse )
{
color[0] = color[1] = color[2] = 0.0f;
}
color[3] = GetAlpha();
}
IMaterial* CStudioRender::R_StudioSetupSkinAndLighting( IMatRenderContext *pRenderContext, int index, IMaterial **ppMaterials, int materialFlags,
void /*IClientRenderable*/ *pClientRenderable, ColorMeshInfo_t *pColorMeshes, StudioModelLighting_t &lighting )
{
VPROF( "R_StudioSetupSkin" );
IMaterial *pMaterial = NULL;
bool bCheckForConVarDrawTranslucentSubModels = false;
if( m_pRC->m_Config.bWireframe && !m_pRC->m_pForcedMaterial )
{
if ( m_pRC->m_Config.bDrawZBufferedWireframe )
pMaterial = m_pMaterialMRMWireframeZBuffer;
else
pMaterial = m_pMaterialMRMWireframe;
}
else if( m_pRC->m_Config.bShowEnvCubemapOnly )
{
pMaterial = m_pMaterialModelEnvCubemap;
}
else
{
if ( !m_pRC->m_pForcedMaterial && ( m_pRC->m_nForcedMaterialType != OVERRIDE_DEPTH_WRITE ) )
{
pMaterial = ppMaterials[index];
if ( !pMaterial )
{
Assert( 0 );
return 0;
}
}
else
{
materialFlags = 0;
pMaterial = m_pRC->m_pForcedMaterial;
if (m_pRC->m_nForcedMaterialType == OVERRIDE_BUILD_SHADOWS)
{
// Connect the original material up to the shadow building material
// Also bind the original material so its proxies are in the correct state
static unsigned int translucentCache = 0;
IMaterialVar* pOriginalMaterialVar = pMaterial->FindVarFast( "$translucent_material", &translucentCache );
Assert( pOriginalMaterialVar );
IMaterial *pOriginalMaterial = ppMaterials[index];
if ( pOriginalMaterial )
{
// Disable any alpha modulation on the original material that was left over from when it was last rendered
pOriginalMaterial->AlphaModulate( 1.0f );
pRenderContext->Bind( pOriginalMaterial, pClientRenderable );
if ( pOriginalMaterial->IsTranslucent() || pOriginalMaterial->IsAlphaTested() )
{
pOriginalMaterialVar->SetMaterialValue( pOriginalMaterial );
}
else
{
pOriginalMaterialVar->SetMaterialValue( NULL );
}
}
else
{
pOriginalMaterialVar->SetMaterialValue( NULL );
}
}
else if( m_pRC->m_nForcedMaterialType == OVERRIDE_DEPTH_WRITE )
{
// Disable any alpha modulation on the original material that was left over from when it was last rendered
ppMaterials[index]->AlphaModulate( 1.0f );
// Bail if the material is still considered translucent after setting the AlphaModulate to 1.0
if ( ppMaterials[index]->IsTranslucent() )
{
return NULL;
}
static unsigned int originalTextureVarCache = 0;
IMaterialVar *pOriginalTextureVar = ppMaterials[index]->FindVarFast( "$basetexture", &originalTextureVarCache );
// Select proper override material
int nAlphaTest = (int) ( ppMaterials[index]->IsAlphaTested() && pOriginalTextureVar->IsTexture() ); // alpha tested base texture
int nNoCull = (int) ppMaterials[index]->IsTwoSided();
pMaterial = m_pDepthWrite[nAlphaTest][nNoCull];
// If we're alpha tested, we should set up the texture variables from the original material
if ( nAlphaTest != 0 )
{
static unsigned int originalTextureFrameVarCache = 0;
IMaterialVar *pOriginalTextureFrameVar = ppMaterials[index]->FindVarFast( "$frame", &originalTextureFrameVarCache );
static unsigned int originalAlphaRefCache = 0;
IMaterialVar *pOriginalAlphaRefVar = ppMaterials[index]->FindVarFast( "$AlphaTestReference", &originalAlphaRefCache );
static unsigned int textureVarCache = 0;
IMaterialVar *pTextureVar = pMaterial->FindVarFast( "$basetexture", &textureVarCache );
static unsigned int textureFrameVarCache = 0;
IMaterialVar *pTextureFrameVar = pMaterial->FindVarFast( "$frame", &textureFrameVarCache );
static unsigned int alphaRefCache = 0;
IMaterialVar *pAlphaRefVar = pMaterial->FindVarFast( "$AlphaTestReference", &alphaRefCache );
if ( pOriginalTextureVar->IsTexture() ) // If $basetexture is defined
{
if( pTextureVar && pOriginalTextureVar )
{
pTextureVar->SetTextureValue( pOriginalTextureVar->GetTextureValue() );
}
if( pTextureFrameVar && pOriginalTextureFrameVar )
{
pTextureFrameVar->SetIntValue( pOriginalTextureFrameVar->GetIntValue() );
}
if( pAlphaRefVar && pOriginalAlphaRefVar )
{
pAlphaRefVar->SetFloatValue( pOriginalAlphaRefVar->GetFloatValue() );
}
}
}
}
}
// Set this bool to check after the bind below
bCheckForConVarDrawTranslucentSubModels = true;
if ( m_pRC->m_nForcedMaterialType != OVERRIDE_DEPTH_WRITE )
{
// Try to set the alpha based on the blend
pMaterial->AlphaModulate( m_pRC->m_AlphaMod );
// Try to set the color based on the colormod
pMaterial->ColorModulate( m_pRC->m_ColorMod[0], m_pRC->m_ColorMod[1], m_pRC->m_ColorMod[2] );
}
}
lighting = R_StudioComputeLighting( pMaterial, materialFlags, pColorMeshes );
if ( lighting == LIGHTING_MOUTH )
{
if ( !m_pRC->m_Config.bTeeth || !R_TeethAreVisible() )
return NULL;
// skin it and light it, but only if we need to.
if ( m_pRC->m_Config.m_bSupportsVertexAndPixelShaders )
{
R_MouthSetupVertexShader( pMaterial );
}
}
pRenderContext->Bind( pMaterial, pClientRenderable );
if ( bCheckForConVarDrawTranslucentSubModels )
{
bool translucent = pMaterial->IsTranslucent();
if (( m_bDrawTranslucentSubModels && !translucent ) ||
( !m_bDrawTranslucentSubModels && translucent ))
{
m_bSkippedMeshes = true;
return NULL;
}
}
return pMaterial;
}