//----------------------------------------------------------------------------- // Draws the shader //----------------------------------------------------------------------------- void DrawSkin_DX9_Internal( CBaseVSShader *pShader, IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow, bool bHasFlashlight, VertexLitGeneric_DX9_Vars_t &info, VertexCompressionType_t vertexCompression, CBasePerMaterialContextData **pContextDataPtr ) { bool bHasBaseTexture = (info.m_nBaseTexture != -1) && params[info.m_nBaseTexture]->IsTexture(); bool bHasBump = (info.m_nBumpmap != -1) && params[info.m_nBumpmap]->IsTexture(); bool bHasBaseTextureWrinkle = bHasBaseTexture && (info.m_nWrinkle != -1) && params[info.m_nWrinkle]->IsTexture() && (info.m_nStretch != -1) && params[info.m_nStretch]->IsTexture(); bool bHasBumpWrinkle = bHasBump && (info.m_nNormalWrinkle != -1) && params[info.m_nNormalWrinkle]->IsTexture() && (info.m_nNormalStretch != -1) && params[info.m_nNormalStretch]->IsTexture(); bool bHasVertexColor = IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR ); bool bHasVertexAlpha = IS_FLAG_SET( MATERIAL_VAR_VERTEXALPHA ); bool bIsAlphaTested = IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ) != 0; bool bHasSelfIllum = IS_FLAG_SET( MATERIAL_VAR_SELFILLUM ) != 0; bool bHasSelfIllumFresnel = ( bHasSelfIllum ) && ( info.m_nSelfIllumFresnel != -1 ) && ( params[info.m_nSelfIllumFresnel]->GetIntValue() != 0 ); bool bHasSelfIllumMask = ( bHasSelfIllum ) && (info.m_nSelfIllumMask != -1) && params[info.m_nSelfIllumMask]->IsTexture(); // Tie these to specular bool bHasPhong = (info.m_nPhong != -1) && ( params[info.m_nPhong]->GetIntValue() != 0 ); bool bHasSpecularExponentTexture = (info.m_nPhongExponentTexture != -1) && params[info.m_nPhongExponentTexture]->IsTexture(); bool bHasPhongTintMap = bHasSpecularExponentTexture && (info.m_nPhongAlbedoTint != -1) && ( params[info.m_nPhongAlbedoTint]->GetIntValue() != 0 ); bool bHasDiffuseWarp = (info.m_nDiffuseWarpTexture != -1) && params[info.m_nDiffuseWarpTexture]->IsTexture(); bool bHasPhongWarp = (info.m_nPhongWarpTexture != -1) && params[info.m_nPhongWarpTexture]->IsTexture(); bool bHasNormalMapAlphaEnvmapMask = IS_FLAG_SET( MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK ); #if !defined( _X360 ) bool bIsDecal = IS_FLAG_SET( MATERIAL_VAR_DECAL ); #endif // Rimlight must be set to non-zero to trigger rim light combo (also requires Phong) bool bHasRimLight = r_rimlight.GetBool() && bHasPhong && (info.m_nRimLight != -1) && ( params[info.m_nRimLight]->GetIntValue() != 0 ); bool bHasRimMaskMap = bHasSpecularExponentTexture && bHasRimLight && (info.m_nRimMask != -1) && ( params[info.m_nRimMask]->GetIntValue() != 0 ); int nDetailBlendMode = ( info.m_nDetailTextureCombineMode == -1 ) ? 0 : params[info.m_nDetailTextureCombineMode]->GetIntValue(); float fBlendFactor=( info.m_nDetailTextureBlendFactor == -1 )? 1 : params[info.m_nDetailTextureBlendFactor]->GetFloatValue(); BlendType_t nBlendType = pShader->EvaluateBlendRequirements( info.m_nBaseTexture, true ); bool bFullyOpaque = (nBlendType != BT_BLENDADD) && (nBlendType != BT_BLEND) && !bIsAlphaTested && !bHasFlashlight; //dest alpha is free for special use bool hasDetailTexture = ( info.m_nDetail != -1 ) && params[info.m_nDetail]->IsTexture(); CSkin_DX9_Context *pContextData = reinterpret_cast< CSkin_DX9_Context *> ( *pContextDataPtr ); if ( ! pContextData ) { pContextData = new CSkin_DX9_Context; *pContextDataPtr = pContextData; } if( pShader->IsSnapshotting() ) { // look at color and alphamod stuff. // Unlit generic never uses the flashlight bool bHasEnvmap = !bHasFlashlight && params[info.m_nEnvmap]->IsTexture(); bool bHasNormal = params[info.m_nBumpmap]->IsTexture(); bool bCanUseBaseAlphaPhongMaskFastPath = (info.m_nBaseMapAlphaPhongMask != -1) && ( params[info.m_nBaseMapAlphaPhongMask]->GetIntValue() != 0 ); if ( ! ( params[info.m_nBaseTexture]->GetTextureValue()->IsTranslucent() ) ) bCanUseBaseAlphaPhongMaskFastPath = true; pContextData->m_bFastPath = (! bHasBump ) && (! bHasSpecularExponentTexture ) && (! bHasPhongTintMap ) && (! bHasPhongWarp ) && (! bHasRimLight ) && (! hasDetailTexture ) && bCanUseBaseAlphaPhongMaskFastPath && (! bHasSelfIllum ); // Alpha test: FIXME: shouldn't this be handled in CBaseVSShader::SetInitialShadowState pShaderShadow->EnableAlphaTest( bIsAlphaTested ); if( info.m_nAlphaTestReference != -1 && params[info.m_nAlphaTestReference]->GetFloatValue() > 0.0f ) { pShaderShadow->AlphaFunc( SHADER_ALPHAFUNC_GEQUAL, params[info.m_nAlphaTestReference]->GetFloatValue() ); } const int nShadowFilterMode = g_pHardwareConfig->GetShadowFilterMode(); if( bHasFlashlight ) { if (params[info.m_nBaseTexture]->IsTexture()) { pShader->SetAdditiveBlendingShadowState( info.m_nBaseTexture, true ); } if( bIsAlphaTested ) { // disable alpha test and use the zfunc zequals since alpha isn't guaranteed to // be the same on both the regular pass and the flashlight pass. pShaderShadow->EnableAlphaTest( false ); pShaderShadow->DepthFunc( SHADER_DEPTHFUNC_EQUAL ); } pShaderShadow->EnableBlending( true ); pShaderShadow->EnableDepthWrites( false ); // Be sure not to write to dest alpha pShaderShadow->EnableAlphaWrites( false ); //nShadowFilterMode = g_pHardwareConfig->GetShadowFilterMode(); // Based upon vendor and device dependent formats } else // not flashlight pass { if (params[info.m_nBaseTexture]->IsTexture()) { pShader->SetDefaultBlendingShadowState( info.m_nBaseTexture, true ); } if ( bHasEnvmap ) { pShaderShadow->EnableTexture( SHADER_SAMPLER8, true ); // Cubic environment map if( g_pHardwareConfig->GetHDRType() == HDR_TYPE_NONE ) { pShaderShadow->EnableSRGBRead( SHADER_SAMPLER8, true ); } } } unsigned int flags = VERTEX_POSITION; if( bHasNormal ) { flags |= VERTEX_NORMAL; } int userDataSize = 0; // Always enable...will bind white if nothing specified... pShaderShadow->EnableTexture( SHADER_SAMPLER0, true ); // Base (albedo) map pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, true ); if ( bHasBaseTextureWrinkle || bHasBumpWrinkle ) { pShaderShadow->EnableTexture( SHADER_SAMPLER9, true ); // Base (albedo) compression map pShaderShadow->EnableSRGBRead( SHADER_SAMPLER9, true ); pShaderShadow->EnableTexture( SHADER_SAMPLER10, true ); // Base (albedo) expansion map pShaderShadow->EnableSRGBRead( SHADER_SAMPLER10, true ); } if( bHasDiffuseWarp ) { pShaderShadow->EnableTexture( SHADER_SAMPLER2, true ); // Diffuse warp texture } if( bHasPhongWarp ) { pShaderShadow->EnableTexture( SHADER_SAMPLER1, true ); // Specular warp texture } // Specular exponent map or dummy pShaderShadow->EnableTexture( SHADER_SAMPLER7, true ); // Specular exponent map if( bHasFlashlight ) { pShaderShadow->EnableTexture( SHADER_SAMPLER4, true ); // Shadow depth map pShaderShadow->SetShadowDepthFiltering( SHADER_SAMPLER4 ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER4, false ); pShaderShadow->EnableTexture( SHADER_SAMPLER6, true ); // Flashlight cookie userDataSize = 4; // tangent S } else { pShaderShadow->EnableTexture( SHADER_SAMPLER4, true ); // Shadow depth map pShaderShadow->SetShadowDepthFiltering( SHADER_SAMPLER4 ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER4, false ); } // Always enable, since flat normal will be bound pShaderShadow->EnableTexture( SHADER_SAMPLER3, true ); // Normal map userDataSize = 4; // tangent S pShaderShadow->EnableTexture( SHADER_SAMPLER5, true ); // Normalizing cube map if ( bHasBaseTextureWrinkle || bHasBumpWrinkle ) { pShaderShadow->EnableTexture( SHADER_SAMPLER11, true ); // Normal compression map pShaderShadow->EnableTexture( SHADER_SAMPLER12, true ); // Normal expansion map } if ( hasDetailTexture ) { pShaderShadow->EnableTexture( SHADER_SAMPLER13, true ); if ( nDetailBlendMode != 0 ) //Not Mod2X pShaderShadow->EnableSRGBRead( SHADER_SAMPLER13, true ); } if ( bHasSelfIllum ) { pShaderShadow->EnableTexture( SHADER_SAMPLER14, true ); } if( bHasVertexColor || bHasVertexAlpha ) { flags |= VERTEX_COLOR; } pShaderShadow->EnableSRGBWrite( true ); // texcoord0 : base texcoord, texcoord2 : decal hw morph delta int pTexCoordDim[3] = { 2, 0, 3 }; int nTexCoordCount = 1; #ifndef _X360 // Special morphed decal information if ( bIsDecal && g_pHardwareConfig->HasFastVertexTextures() ) { nTexCoordCount = 3; } #endif // This shader supports compressed vertices, so OR in that flag: flags |= VERTEX_FORMAT_COMPRESSED; pShaderShadow->VertexShaderVertexFormat( flags, nTexCoordCount, pTexCoordDim, userDataSize ); #ifndef _X360 if ( !g_pHardwareConfig->SupportsShaderModel_3_0() ) #endif { DECLARE_STATIC_VERTEX_SHADER( sdk_skin_vs20 ); SET_STATIC_VERTEX_SHADER( sdk_skin_vs20 ); // Assume we're only going to get in here if we support 2b DECLARE_STATIC_PIXEL_SHADER( sdk_skin_ps20b ); SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHT, bHasFlashlight ); SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM, bHasSelfIllum && !bHasFlashlight ); SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUMFRESNEL, bHasSelfIllumFresnel && !bHasFlashlight ); SET_STATIC_PIXEL_SHADER_COMBO( LIGHTWARPTEXTURE, bHasDiffuseWarp && bHasPhong ); SET_STATIC_PIXEL_SHADER_COMBO( PHONGWARPTEXTURE, bHasPhongWarp && bHasPhong ); SET_STATIC_PIXEL_SHADER_COMBO( WRINKLEMAP, bHasBaseTextureWrinkle || bHasBumpWrinkle ); SET_STATIC_PIXEL_SHADER_COMBO( DETAILTEXTURE, hasDetailTexture ); SET_STATIC_PIXEL_SHADER_COMBO( DETAIL_BLEND_MODE, nDetailBlendMode ); SET_STATIC_PIXEL_SHADER_COMBO( RIMLIGHT, bHasRimLight ); SET_STATIC_PIXEL_SHADER_COMBO( CUBEMAP, bHasEnvmap ); SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHTDEPTHFILTERMODE, nShadowFilterMode ); SET_STATIC_PIXEL_SHADER_COMBO( CONVERT_TO_SRGB, 0 ); SET_STATIC_PIXEL_SHADER_COMBO( FASTPATH_NOBUMP, pContextData->m_bFastPath ); SET_STATIC_PIXEL_SHADER( sdk_skin_ps20b ); } #ifndef _X360 else { const bool bFastVertexTextures = g_pHardwareConfig->HasFastVertexTextures(); // The vertex shader uses the vertex id stream if ( bFastVertexTextures ) SET_FLAGS2( MATERIAL_VAR2_USES_VERTEXID ); DECLARE_STATIC_VERTEX_SHADER( sdk_skin_vs30 ); SET_STATIC_VERTEX_SHADER_COMBO( DECAL, bIsDecal && bFastVertexTextures ); SET_STATIC_VERTEX_SHADER( sdk_skin_vs30 ); DECLARE_STATIC_PIXEL_SHADER( sdk_skin_ps30 ); SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHT, bHasFlashlight ); SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM, bHasSelfIllum && !bHasFlashlight ); SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUMFRESNEL, bHasSelfIllumFresnel && !bHasFlashlight ); SET_STATIC_PIXEL_SHADER_COMBO( LIGHTWARPTEXTURE, bHasDiffuseWarp && bHasPhong ); SET_STATIC_PIXEL_SHADER_COMBO( PHONGWARPTEXTURE, bHasPhongWarp && bHasPhong ); SET_STATIC_PIXEL_SHADER_COMBO( WRINKLEMAP, bHasBaseTextureWrinkle || bHasBumpWrinkle ); SET_STATIC_PIXEL_SHADER_COMBO( DETAILTEXTURE, hasDetailTexture ); SET_STATIC_PIXEL_SHADER_COMBO( DETAIL_BLEND_MODE, nDetailBlendMode ); SET_STATIC_PIXEL_SHADER_COMBO( RIMLIGHT, bHasRimLight ); SET_STATIC_PIXEL_SHADER_COMBO( CUBEMAP, bHasEnvmap ); SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHTDEPTHFILTERMODE, nShadowFilterMode ); SET_STATIC_PIXEL_SHADER_COMBO( CONVERT_TO_SRGB, 0 ); SET_STATIC_PIXEL_SHADER_COMBO( FASTPATH_NOBUMP, pContextData->m_bFastPath ); SET_STATIC_PIXEL_SHADER( sdk_skin_ps30 ); } #endif if( bHasFlashlight ) { pShader->FogToBlack(); } else { pShader->DefaultFog(); } // HACK HACK HACK - enable alpha writes all the time so that we have them for underwater stuff pShaderShadow->EnableAlphaWrites( bFullyOpaque ); } else // not snapshotting -- begin dynamic state { static CCommandBufferBuilder< CFixedCommandStorageBuffer< 2000 > > DynamicCmdsOut; DynamicCmdsOut.Reset(); bool bLightingOnly = mat_fullbright.GetInt() == 2 && !IS_FLAG_SET( MATERIAL_VAR_NO_DEBUG_OVERRIDE ); bool bHasEnvmap = !bHasFlashlight && params[info.m_nEnvmap]->IsTexture(); if ( bHasBaseTexture ) { DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER0, info.m_nBaseTexture, info.m_nBaseTextureFrame ); } else { DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER0, TEXTURE_WHITE ); } if ( bHasBaseTextureWrinkle ) { DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER9, info.m_nWrinkle, info.m_nBaseTextureFrame ); DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER10, info.m_nStretch, info.m_nBaseTextureFrame ); } else if ( bHasBumpWrinkle ) { DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER9, info.m_nBaseTexture, info.m_nBaseTextureFrame ); DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER10, info.m_nBaseTexture, info.m_nBaseTextureFrame ); } if( bHasDiffuseWarp && bHasPhong ) { if ( r_lightwarpidentity.GetBool() ) { DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER2, TEXTURE_IDENTITY_LIGHTWARP ); } else { DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER2, info.m_nDiffuseWarpTexture, -1 ); } } if( bHasPhongWarp ) { DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER1, info.m_nPhongWarpTexture, -1 ); } if( bHasSpecularExponentTexture && bHasPhong ) { DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER7, info.m_nPhongExponentTexture, -1 ); } else { DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER7, TEXTURE_WHITE ); } if( !g_pConfig->m_bFastNoBump ) { if( bHasBump ) DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER3, info.m_nBumpmap, info.m_nBumpFrame ); else DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER3, TEXTURE_NORMALMAP_FLAT ); if ( bHasBumpWrinkle ) { DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER11, info.m_nNormalWrinkle, info.m_nBumpFrame ); DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER12, info.m_nNormalStretch, info.m_nBumpFrame ); } else if ( bHasBaseTextureWrinkle ) { DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER11, info.m_nBumpmap, info.m_nBumpFrame ); DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER12, info.m_nBumpmap, info.m_nBumpFrame ); } } else { if( bHasBump ) { DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER3, TEXTURE_NORMALMAP_FLAT ); } if ( bHasBaseTextureWrinkle || bHasBumpWrinkle ) { DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER11, TEXTURE_NORMALMAP_FLAT ); DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER12, TEXTURE_NORMALMAP_FLAT ); } } if ( hasDetailTexture ) { DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER13, info.m_nDetail, info.m_nDetailFrame ); } if ( bHasSelfIllum ) { if ( bHasSelfIllumMask ) // Separate texture for self illum? { DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER14, info.m_nSelfIllumMask, -1 ); // Bind it } else // else { DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER14, TEXTURE_BLACK ); // Bind dummy } } float vRimBoost[4] = {1, 1, 1, 1}; ITexture *pCascadedDepthTexture = NULL; LightState_t lightState = { 0, false, false }; bool bFlashlightShadows = false; if ( bHasFlashlight ) { Assert( info.m_nFlashlightTexture >= 0 && info.m_nFlashlightTextureFrame >= 0 ); //DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER6, info.m_nFlashlightTexture, info.m_nFlashlightTextureFrame ); VMatrix worldToTexture; ITexture *pFlashlightDepthTexture; const FlashlightState_t &flashlightState = pShaderAPI->GetFlashlightStateEx( worldToTexture, &pFlashlightDepthTexture ); bFlashlightShadows = flashlightState.m_bEnableShadows; if ( pFlashlightDepthTexture && g_pConfig->ShadowDepthTexture() && flashlightState.m_bEnableShadows ) { pShader->BindTexture( SHADER_SAMPLER4, pFlashlightDepthTexture ); DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER5, TEXTURE_SHADOW_NOISE_2D ); } float atten[4], pos[4], tweaks[4]; SetFlashLightColorFromState( flashlightState, pShaderAPI, PSREG_FLASHLIGHT_COLOR ); //DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER6, info.m_nFlashlightTexture, info.m_nFlashlightTextureFrame ); pShader->BindTexture( SHADER_SAMPLER6, flashlightState.m_pSpotlightTexture, flashlightState.m_nSpotlightTextureFrame ); atten[0] = flashlightState.m_fConstantAtten; // Set the flashlight attenuation factors atten[1] = flashlightState.m_fLinearAtten; atten[2] = flashlightState.m_fQuadraticAtten; atten[3] = flashlightState.m_FarZ; DynamicCmdsOut.SetPixelShaderConstant( PSREG_FLASHLIGHT_ATTENUATION, atten, 1 ); pos[0] = flashlightState.m_vecLightOrigin[0]; // Set the flashlight origin pos[1] = flashlightState.m_vecLightOrigin[1]; pos[2] = flashlightState.m_vecLightOrigin[2]; DynamicCmdsOut.SetPixelShaderConstant( PSREG_FLASHLIGHT_POSITION_RIM_BOOST, pos, 1 ); // steps on rim boost DynamicCmdsOut.SetPixelShaderConstant( PSREG_FLASHLIGHT_TO_WORLD_TEXTURE, worldToTexture.Base(), 4 ); // Tweaks associated with a given flashlight tweaks[0] = ShadowFilterFromState( flashlightState ); tweaks[1] = ShadowAttenFromState( flashlightState ); pShader->HashShadow2DJitter( flashlightState.m_flShadowJitterSeed, &tweaks[2], &tweaks[3] ); DynamicCmdsOut.SetPixelShaderConstant( PSREG_ENVMAP_TINT__SHADOW_TWEAKS, tweaks, 1 ); // Dimensions of screen, used for screen-space noise map sampling float vScreenScale[4] = {1280.0f / 32.0f, 720.0f / 32.0f, 0, 0}; int nWidth, nHeight; pShaderAPI->GetBackBufferDimensions( nWidth, nHeight ); vScreenScale[0] = (float) nWidth / 32.0f; vScreenScale[1] = (float) nHeight / 32.0f; DynamicCmdsOut.SetPixelShaderConstant( PSREG_FLASHLIGHT_SCREEN_SCALE, vScreenScale, 1 ); if ( IsX360() ) { pShaderAPI->SetBooleanPixelShaderConstant( 0, &flashlightState.m_nShadowQuality, 1 ); } } else // no flashlight { if ( bHasEnvmap ) { DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER8, info.m_nEnvmap, info.m_nEnvmapFrame ); } // GSTRINGMIGRATION pShaderAPI->GetDX9LightState( &lightState ); pCascadedDepthTexture = (ITexture*)pShaderAPI->GetIntRenderingParameter( INT_CASCADED_DEPTHTEXTURE ); if ( pCascadedDepthTexture != NULL ) { pShader->BindTexture( SHADER_SAMPLER4, pCascadedDepthTexture ); VMatrix *worldToTexture0 = (VMatrix*)pShaderAPI->GetIntRenderingParameter( INT_CASCADED_MATRIX_ADDRESS_0 ); DynamicCmdsOut.SetVertexShaderConstant( 240, worldToTexture0->Base(), 4 ); const Vector vecCascadedFwd = pShaderAPI->GetVectorRenderingParameter( VECTOR_RENDERPARM_GSTRING_CASCADED_FORWARD ); vRimBoost[0] = vecCascadedFwd.x; vRimBoost[1] = vecCascadedFwd.y; vRimBoost[2] = vecCascadedFwd.z; float vScreenScale[4] = {1280.0f / 32.0f, 720.0f / 32.0f, 0, 0}; int nWidth, nHeight; pShaderAPI->GetBackBufferDimensions( nWidth, nHeight ); vScreenScale[0] = (float) nWidth / 32.0f; vScreenScale[1] = (float) nHeight / 32.0f; DynamicCmdsOut.SetPixelShaderConstant( PSREG_FLASHLIGHT_SCREEN_SCALE, vScreenScale, 1 ); // We have to rebuild the lighting state by hand. Fading static lights are out of order! float vDirectionalLights[4] = { 0.0f }; SetCustomPixelLightingState( DynamicCmdsOut, lightState, pShaderAPI, PSREG_LIGHT_INFO_ARRAY ); SetCustomVertexLightingState( DynamicCmdsOut, lightState, pShaderAPI, 27, vDirectionalLights ); DynamicCmdsOut.SetPixelShaderConstant( PSREG_FLASHLIGHT_COLOR, vDirectionalLights ); const Vector vecCascadedStep = pShaderAPI->GetVectorRenderingParameter( VECTOR_RENDERPARM_GSTRING_CASCADED_STEP ); float vCascadedStep[4] = { XYZ( vecCascadedStep ) }; DynamicCmdsOut.SetPixelShaderConstant( PSREG_FLASHLIGHT_TO_WORLD_TEXTURE, vCascadedStep, 1 ); } } if ( pCascadedDepthTexture == NULL ) { DynamicCmdsOut.CommitPixelShaderLighting( PSREG_LIGHT_INFO_ARRAY ); } // END GSTRINGMIGRATION MaterialFogMode_t fogType = pShaderAPI->GetSceneFogMode(); int fogIndex = ( fogType == MATERIAL_FOG_LINEAR_BELOW_FOG_Z ) ? 1 : 0; int numBones = pShaderAPI->GetCurrentNumBones(); bool bWriteDepthToAlpha = false; bool bWriteWaterFogToAlpha = false; if( bFullyOpaque ) { bWriteDepthToAlpha = pShaderAPI->ShouldWriteDepthToDestAlpha(); bWriteWaterFogToAlpha = (fogType == MATERIAL_FOG_LINEAR_BELOW_FOG_Z); AssertMsg( !(bWriteDepthToAlpha && bWriteWaterFogToAlpha), "Can't write two values to alpha at the same time." ); } #ifndef _X360 if ( !g_pHardwareConfig->SupportsShaderModel_3_0() ) #endif { DECLARE_DYNAMIC_VERTEX_SHADER( sdk_skin_vs20 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( DOWATERFOG, fogIndex ); SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, numBones > 0 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( LIGHTING_PREVIEW, pShaderAPI->GetIntRenderingParameter(INT_RENDERPARM_ENABLE_FIXED_LIGHTING)!=0); SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (int)vertexCompression ); SET_DYNAMIC_VERTEX_SHADER( sdk_skin_vs20 ); DECLARE_DYNAMIC_PIXEL_SHADER( sdk_skin_ps20b ); SET_DYNAMIC_PIXEL_SHADER_COMBO( NUM_LIGHTS, lightState.m_nNumLights ); SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITEWATERFOGTODESTALPHA, bWriteWaterFogToAlpha ); SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITE_DEPTH_TO_DESTALPHA, bWriteDepthToAlpha ); SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() ); SET_DYNAMIC_PIXEL_SHADER_COMBO( FLASHLIGHTSHADOWS, bFlashlightShadows ); SET_DYNAMIC_PIXEL_SHADER( sdk_skin_ps20b ); } #ifndef _X360 else { const bool bFastVertexTextures = g_pHardwareConfig->HasFastVertexTextures(); const int iCascadedShadowCombo = ( pCascadedDepthTexture != NULL ) ? 1 : 0; if ( bFastVertexTextures ) pShader->SetHWMorphVertexShaderState( VERTEX_SHADER_SHADER_SPECIFIC_CONST_6, VERTEX_SHADER_SHADER_SPECIFIC_CONST_7, SHADER_VERTEXTEXTURE_SAMPLER0 ); DECLARE_DYNAMIC_VERTEX_SHADER( sdk_skin_vs30 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( DOWATERFOG, fogIndex ); SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, numBones > 0 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( LIGHTING_PREVIEW, pShaderAPI->GetIntRenderingParameter(INT_RENDERPARM_ENABLE_FIXED_LIGHTING)!=0); SET_DYNAMIC_VERTEX_SHADER_COMBO( MORPHING, pShaderAPI->IsHWMorphingEnabled() && bFastVertexTextures ); SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (int)vertexCompression ); SET_DYNAMIC_VERTEX_SHADER_COMBO( CASCADED_SHADOW, iCascadedShadowCombo ); SET_DYNAMIC_VERTEX_SHADER( sdk_skin_vs30 ); DECLARE_DYNAMIC_PIXEL_SHADER( sdk_skin_ps30 ); SET_DYNAMIC_PIXEL_SHADER_COMBO( NUM_LIGHTS, lightState.m_nNumLights ); SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITEWATERFOGTODESTALPHA, bWriteWaterFogToAlpha ); SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITE_DEPTH_TO_DESTALPHA, bWriteDepthToAlpha ); SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() ); SET_DYNAMIC_PIXEL_SHADER_COMBO( FLASHLIGHTSHADOWS, bFlashlightShadows ); SET_DYNAMIC_PIXEL_SHADER_COMBO( CASCADED_SHADOW, iCascadedShadowCombo ); SET_DYNAMIC_PIXEL_SHADER( sdk_skin_ps30 ); if ( bFastVertexTextures ) { bool bUnusedTexCoords[3] = { false, false, !pShaderAPI->IsHWMorphingEnabled() || !bIsDecal }; pShaderAPI->MarkUnusedVertexFields( 0, 3, bUnusedTexCoords ); } } #endif DynamicCmdsOut.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, info.m_nBaseTextureTransform ); if( bHasBump ) { DynamicCmdsOut.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, info.m_nBumpTransform ); } if ( hasDetailTexture ) { if ( IS_PARAM_DEFINED( info.m_nDetailTextureTransform ) ) DynamicCmdsOut.SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_4, info.m_nDetailTextureTransform, info.m_nDetailScale ); else DynamicCmdsOut.SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_4, info.m_nBaseTextureTransform, info.m_nDetailScale ); } pShader->SetModulationPixelShaderDynamicState_LinearColorSpace( 1 ); DynamicCmdsOut.SetPixelShaderConstant_W( PSREG_SELFILLUMTINT, info.m_nSelfIllumTint, fBlendFactor ); bool bInvertPhongMask = ( info.m_nInvertPhongMask != -1 ) && ( params[info.m_nInvertPhongMask]->GetIntValue() != 0 ); float fInvertPhongMask = bInvertPhongMask ? 1 : 0; bool bHasBaseAlphaPhongMask = (info.m_nBaseMapAlphaPhongMask != -1) && ( params[info.m_nBaseMapAlphaPhongMask]->GetIntValue() != 0 ); float fHasBaseAlphaPhongMask = bHasBaseAlphaPhongMask ? 1 : 0; // Controls for lerp-style paths through shader code const float flMinLighting = pShaderAPI->GetFloatRenderingParameter( FLOAT_RENDERPARM_MINIMUMLIGHTING ); // GSTRINGMIGRATION float vShaderControls[4] = { fHasBaseAlphaPhongMask, flMinLighting, 0.0f, fInvertPhongMask }; // GSTRINGMIGRATION DynamicCmdsOut.SetPixelShaderConstant( PSREG_CONSTANT_27, vShaderControls, 1 ); if ( hasDetailTexture ) { #if 0 // needs constant change if ( info.m_nDetailTint != -1 ) pShader->SetPixelShaderConstantGammaToLinear( 10, info.m_nDetailTint ); else { float boring_tint[4]={1,1,1,1}; pShaderAPI->SetPixelShaderConstant( 10, boring_tint, 1 ); } #endif } if ( bHasSelfIllumFresnel && !bHasFlashlight ) { float vConstScaleBiasExp[4] = { 1.0f, 0.0f, 1.0f, 0.0f }; float flMin = IS_PARAM_DEFINED( info.m_nSelfIllumFresnelMinMaxExp ) ? params[info.m_nSelfIllumFresnelMinMaxExp]->GetVecValue()[0] : 0.0f; float flMax = IS_PARAM_DEFINED( info.m_nSelfIllumFresnelMinMaxExp ) ? params[info.m_nSelfIllumFresnelMinMaxExp]->GetVecValue()[1] : 1.0f; float flExp = IS_PARAM_DEFINED( info.m_nSelfIllumFresnelMinMaxExp ) ? params[info.m_nSelfIllumFresnelMinMaxExp]->GetVecValue()[2] : 1.0f; vConstScaleBiasExp[1] = ( flMax != 0.0f ) ? ( flMin / flMax ) : 0.0f; // Bias vConstScaleBiasExp[0] = 1.0f - vConstScaleBiasExp[1]; // Scale vConstScaleBiasExp[2] = flExp; // Exp vConstScaleBiasExp[3] = flMax; // Brightness DynamicCmdsOut.SetPixelShaderConstant( PSREG_SELFILLUM_SCALE_BIAS_EXP, vConstScaleBiasExp, 1 ); } DynamicCmdsOut.SetAmbientCubeDynamicStateVertexShader(); if( !bHasFlashlight ) { if ( g_pHardwareConfig->SupportsShaderModel_3_0() ) { DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER5, TEXTURE_SHADOW_NOISE_2D ); } else { DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER5, TEXTURE_NORMALIZATION_CUBEMAP_SIGNED ); } // Setting .x to 1 means to apply Fresnel to env map. Setting w to 1 means use separate selfillummask float vEnvMapFresnel_SelfIllumMask[4] = {0.0f, 0.0f, 0.0f, 0.0f}; vEnvMapFresnel_SelfIllumMask[3] = bHasSelfIllumMask ? 1.0f : 0.0f; if( bHasEnvmap ) { float vEnvMapTint_MaskControl[4] = {1.0f, 1.0f, 1.0f, 0.0f}; // If we have a tint, grab it if ( (info.m_nEnvmapTint != -1) && params[info.m_nEnvmapTint]->IsDefined() ) params[info.m_nEnvmapTint]->GetVecValue(vEnvMapTint_MaskControl, 3); // Set control for source of env map mask (normal alpha or base alpha) vEnvMapTint_MaskControl[3] = bHasNormalMapAlphaEnvmapMask ? 1.0f : 0.0f; if ( (info.m_nEnvmapFresnel != -1) && params[info.m_nEnvmapFresnel]->IsDefined() ) vEnvMapFresnel_SelfIllumMask[0] = params[info.m_nEnvmapFresnel]->GetFloatValue(); // Handle mat_fullbright 2 (diffuse lighting only with 50% gamma space basetexture) if( bLightingOnly ) { vEnvMapTint_MaskControl[0] = vEnvMapTint_MaskControl[1] = vEnvMapTint_MaskControl[2] = 0.0f; } DynamicCmdsOut.SetPixelShaderConstant( PSREG_ENVMAP_TINT__SHADOW_TWEAKS, vEnvMapTint_MaskControl, 1 ); } DynamicCmdsOut.SetPixelShaderConstant( PSREG_ENVMAP_FRESNEL__SELFILLUMMASK, vEnvMapFresnel_SelfIllumMask, 1 ); } DynamicCmdsOut.SetPixelShaderStateAmbientLightCube( PSREG_AMBIENT_CUBE ); //pShaderAPI->SetPixelShaderStateAmbientLightCube( PSREG_AMBIENT_CUBE, !lightState.m_bAmbientLight ); // Force to black if not bAmbientLight // Pack Phong exponent in with the eye position float vEyePos_SpecExponent[4], vFresnelRanges_SpecBoost[4] = {0, 0.5, 1, 1}; float vSpecularTint[4] = {1, 1, 1, 4}; pShaderAPI->GetWorldSpaceCameraPosition( vEyePos_SpecExponent ); if ( (info.m_nPhongExponent != -1) && params[info.m_nPhongExponent]->IsDefined() ) vEyePos_SpecExponent[3] = params[info.m_nPhongExponent]->GetFloatValue(); // This overrides the channel in the map else vEyePos_SpecExponent[3] = 0; // Use the alpha channel of the normal map for the exponent // Get the tint parameter if ( (info.m_nPhongTint != -1) && params[info.m_nPhongTint]->IsDefined() ) { params[info.m_nPhongTint]->GetVecValue(vSpecularTint, 3); } // Get the rim light power (goes in w of Phong tint) if ( bHasRimLight && (info.m_nRimLightPower != -1) && params[info.m_nRimLightPower]->IsDefined() ) { vSpecularTint[3] = params[info.m_nRimLightPower]->GetFloatValue(); vSpecularTint[3] = max(vSpecularTint[3], 1.0f); // Make sure this is at least 1 } // Get the rim boost (goes in w of flashlight position) if ( bHasRimLight && (info.m_nRimLightBoost != -1) && params[info.m_nRimLightBoost]->IsDefined() ) { vRimBoost[3] = params[info.m_nRimLightBoost]->GetFloatValue(); } if ( !bHasFlashlight ) { float vRimMaskControl[4] = {0, 0, 0, 0}; // Only x is relevant in shader code vRimMaskControl[0] = bHasRimMaskMap ? params[info.m_nRimMask]->GetFloatValue() : 0.0f; // Rim mask...if this is true, use alpha channel of spec exponent texture to mask the rim term DynamicCmdsOut.SetPixelShaderConstant( PSREG_FLASHLIGHT_ATTENUATION, vRimMaskControl, 1 ); } // If it's all zeros, there was no constant tint in the vmt if ( (vSpecularTint[0] == 0.0f) && (vSpecularTint[1] == 0.0f) && (vSpecularTint[2] == 0.0f) ) { if ( bHasPhongTintMap ) // If we have a map to use, tell the shader { vSpecularTint[0] = -1; } else // Otherwise, just tint with white { vSpecularTint[0] = 1.0f; vSpecularTint[1] = 1.0f; vSpecularTint[2] = 1.0f; } } // handle mat_fullbright 2 (diffuse lighting only) if( bLightingOnly ) { // BASETEXTURE if( bHasSelfIllum && !bHasFlashlight ) { DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER0, TEXTURE_GREY_ALPHA_ZERO ); } else { DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER0, TEXTURE_GREY ); } // DETAILTEXTURE if ( hasDetailTexture ) { DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER13, TEXTURE_GREY ); } // turn off specularity vSpecularTint[0] = vSpecularTint[1] = vSpecularTint[2] = 0.0f; } if ( (info.m_nPhongFresnelRanges != -1) && params[info.m_nPhongFresnelRanges]->IsDefined() ) params[info.m_nPhongFresnelRanges]->GetVecValue( vFresnelRanges_SpecBoost, 3 ); // Grab optional Fresnel range parameters if ( (info.m_nPhongBoost != -1 ) && params[info.m_nPhongBoost]->IsDefined()) // Grab optional Phong boost param vFresnelRanges_SpecBoost[3] = params[info.m_nPhongBoost]->GetFloatValue(); else vFresnelRanges_SpecBoost[3] = 1.0f; DynamicCmdsOut.SetPixelShaderConstant( PSREG_EYEPOS_SPEC_EXPONENT, vEyePos_SpecExponent, 1 ); DynamicCmdsOut.SetPixelShaderConstant( PSREG_FRESNEL_SPEC_PARAMS, vFresnelRanges_SpecBoost, 1 ); if ( !bHasFlashlight ) { DynamicCmdsOut.SetPixelShaderConstant( PSREG_FLASHLIGHT_POSITION_RIM_BOOST, vRimBoost, 1 ); // Rim boost in w on non-flashlight pass } DynamicCmdsOut.SetPixelShaderConstant( PSREG_SPEC_RIM_PARAMS, vSpecularTint, 1 ); DynamicCmdsOut.SetPixelShaderFogParams( PSREG_FOG_PARAMS ); DynamicCmdsOut.End(); pShaderAPI->ExecuteCommandBuffer( DynamicCmdsOut.Base() ); } pShader->Draw(); }
void DrawPassComposite( const defParms_composite &info, CBaseVSShader *pShader, IMaterialVar **params, IShaderShadow* pShaderShadow, IShaderDynamicAPI* pShaderAPI, VertexCompressionType_t vertexCompression, CDeferredPerMaterialContextData *pDeferredContext ) { const bool bModel = info.bModel; const bool bIsDecal = IS_FLAG_SET( MATERIAL_VAR_DECAL ); const bool bFastVTex = g_pHardwareConfig->HasFastVertexTextures(); const bool bAlbedo = PARM_TEX( info.iAlbedo ); const bool bAlbedo2 = !bModel && bAlbedo && PARM_TEX( info.iAlbedo2 ); const bool bAlbedo3 = !bModel && bAlbedo && PARM_TEX( info.iAlbedo3 ); const bool bAlbedo4 = !bModel && bAlbedo && PARM_TEX( info.iAlbedo4 ); const bool bAlphatest = IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ) && bAlbedo; const bool bTranslucent = IS_FLAG_SET( MATERIAL_VAR_TRANSLUCENT ) && bAlbedo && !bAlphatest; const bool bNoCull = IS_FLAG_SET( MATERIAL_VAR_NOCULL ); const bool bUseSRGB = DEFCFG_USE_SRGB_CONVERSION != 0; const bool bPhongFresnel = PARM_SET( info.iPhongFresnel ); const bool bEnvmap = PARM_TEX( info.iEnvmap ); const bool bEnvmapMask = bEnvmap && PARM_TEX( info.iEnvmapMask ); const bool bEnvmapMask2 = bEnvmapMask && PARM_TEX( info.iEnvmapMask2 ); const bool bEnvmapFresnel = bEnvmap && PARM_SET( info.iEnvmapFresnel ); const bool bRimLight = PARM_SET( info.iRimlightEnable ); const bool bRimLightModLight = bRimLight && PARM_SET( info.iRimlightModLight ); const bool bBlendmodulate = bAlbedo2 && PARM_TEX( info.iBlendmodulate ); const bool bBlendmodulate2 = bBlendmodulate && PARM_TEX( info.iBlendmodulate2 ); const bool bBlendmodulate3 = bBlendmodulate && PARM_TEX( info.iBlendmodulate3 ); const bool bSelfIllum = !bAlbedo2 && IS_FLAG_SET( MATERIAL_VAR_SELFILLUM ); const bool bSelfIllumMaskInEnvmapMask = bSelfIllum && bEnvmapMask && PARM_SET( info.iSelfIllumMaskInEnvmapAlpha ); const bool bSelfIllumMask = bSelfIllum && !bSelfIllumMaskInEnvmapMask && !bEnvmapMask && PARM_TEX( info.iSelfIllumMask ); const bool bMultiBlend = PARM_SET( info.iMultiblend ) && bAlbedo && bAlbedo2 && bAlbedo3 && !bEnvmapMask && !bSelfIllumMask; const bool bNeedsFresnel = bPhongFresnel || bEnvmapFresnel; const bool bGBufferNormal = bEnvmap || bRimLight || bNeedsFresnel; const bool bWorldEyeVec = bGBufferNormal; AssertMsgOnce( !(bTranslucent || bAlphatest) || !bAlbedo2, "blended albedo not supported by gbuffer pass!" ); AssertMsgOnce( IS_FLAG_SET( MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK ) == false, "Normal map sampling should stay out of composition pass." ); AssertMsgOnce( !PARM_TEX( info.iSelfIllumMask ) || !bEnvmapMask, "Can't use separate selfillum mask with envmap mask - use SELFILLUM_ENVMAPMASK_ALPHA instead." ); AssertMsgOnce( PARM_SET( info.iMultiblend ) == bMultiBlend, "Multiblend forced off due to invalid usage! May cause vertexformat mis-matches between passes." ); SHADOW_STATE { pShaderShadow->SetDefaultState(); pShaderShadow->EnableSRGBWrite( bUseSRGB ); if ( bNoCull ) { pShaderShadow->EnableCulling( false ); } int iVFmtFlags = VERTEX_POSITION; int iUserDataSize = 0; int *pTexCoordDim; int iTexCoordNum; GetTexcoordSettings( ( bModel && bIsDecal && bFastVTex ), bMultiBlend, iTexCoordNum, &pTexCoordDim ); if ( bModel ) { iVFmtFlags |= VERTEX_NORMAL; iVFmtFlags |= VERTEX_FORMAT_COMPRESSED; } else { if ( bAlbedo2 ) iVFmtFlags |= VERTEX_COLOR; } pShaderShadow->EnableTexture( SHADER_SAMPLER0, true ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, bUseSRGB ); if ( bGBufferNormal ) { pShaderShadow->EnableTexture( SHADER_SAMPLER1, true ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER1, false ); } if ( bTranslucent ) { pShader->EnableAlphaBlending( SHADER_BLEND_SRC_ALPHA, SHADER_BLEND_ONE_MINUS_SRC_ALPHA ); } pShaderShadow->EnableTexture( SHADER_SAMPLER2, true ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER2, false ); if ( bEnvmap ) { pShaderShadow->EnableTexture( SHADER_SAMPLER3, true ); if( g_pHardwareConfig->GetHDRType() == HDR_TYPE_NONE ) pShaderShadow->EnableSRGBRead( SHADER_SAMPLER3, true ); if ( bEnvmapMask ) { pShaderShadow->EnableTexture( SHADER_SAMPLER4, true ); if ( bAlbedo2 ) pShaderShadow->EnableTexture( SHADER_SAMPLER7, true ); } } else if ( bSelfIllumMask ) { pShaderShadow->EnableTexture( SHADER_SAMPLER4, true ); } if ( bAlbedo2 ) { pShaderShadow->EnableTexture( SHADER_SAMPLER5, true ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER5, bUseSRGB ); if ( bBlendmodulate ) pShaderShadow->EnableTexture( SHADER_SAMPLER6, true ); } if ( bMultiBlend ) { pShaderShadow->EnableTexture( SHADER_SAMPLER7, true ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER7, bUseSRGB ); if ( bAlbedo4 ) { pShaderShadow->EnableTexture( SHADER_SAMPLER8, true ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER8, bUseSRGB ); } if ( bBlendmodulate ) { pShaderShadow->EnableTexture( SHADER_SAMPLER9, true ); pShaderShadow->EnableTexture( SHADER_SAMPLER10, true ); } } pShaderShadow->EnableAlphaWrites( false ); pShaderShadow->EnableDepthWrites( !bTranslucent ); pShader->DefaultFog(); pShaderShadow->VertexShaderVertexFormat( iVFmtFlags, iTexCoordNum, pTexCoordDim, iUserDataSize ); DECLARE_STATIC_VERTEX_SHADER( composite_vs30 ); SET_STATIC_VERTEX_SHADER_COMBO( MODEL, bModel ); SET_STATIC_VERTEX_SHADER_COMBO( MORPHING_VTEX, bModel && bFastVTex ); SET_STATIC_VERTEX_SHADER_COMBO( DECAL, bModel && bIsDecal ); SET_STATIC_VERTEX_SHADER_COMBO( EYEVEC, bWorldEyeVec ); SET_STATIC_VERTEX_SHADER_COMBO( BASETEXTURE2, bAlbedo2 && !bMultiBlend ); SET_STATIC_VERTEX_SHADER_COMBO( BLENDMODULATE, bBlendmodulate ); SET_STATIC_VERTEX_SHADER_COMBO( MULTIBLEND, bMultiBlend ); SET_STATIC_VERTEX_SHADER( composite_vs30 ); DECLARE_STATIC_PIXEL_SHADER( composite_ps30 ); SET_STATIC_PIXEL_SHADER_COMBO( ALPHATEST, bAlphatest ); SET_STATIC_PIXEL_SHADER_COMBO( TRANSLUCENT, bTranslucent ); SET_STATIC_PIXEL_SHADER_COMBO( READNORMAL, bGBufferNormal ); SET_STATIC_PIXEL_SHADER_COMBO( NOCULL, bNoCull ); SET_STATIC_PIXEL_SHADER_COMBO( ENVMAP, bEnvmap ); SET_STATIC_PIXEL_SHADER_COMBO( ENVMAPMASK, bEnvmapMask ); SET_STATIC_PIXEL_SHADER_COMBO( ENVMAPFRESNEL, bEnvmapFresnel ); SET_STATIC_PIXEL_SHADER_COMBO( PHONGFRESNEL, bPhongFresnel ); SET_STATIC_PIXEL_SHADER_COMBO( RIMLIGHT, bRimLight ); SET_STATIC_PIXEL_SHADER_COMBO( RIMLIGHTMODULATELIGHT, bRimLightModLight ); SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURE2, bAlbedo2 && !bMultiBlend ); SET_STATIC_PIXEL_SHADER_COMBO( BLENDMODULATE, bBlendmodulate ); SET_STATIC_PIXEL_SHADER_COMBO( MULTIBLEND, bMultiBlend ); SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM, bSelfIllum ); SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM_MASK, bSelfIllumMask ); SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM_ENVMAP_ALPHA, bSelfIllumMaskInEnvmapMask ); SET_STATIC_PIXEL_SHADER( composite_ps30 ); } DYNAMIC_STATE { Assert( pDeferredContext != NULL ); if ( pDeferredContext->m_bMaterialVarsChanged || !pDeferredContext->HasCommands( CDeferredPerMaterialContextData::DEFSTAGE_COMPOSITE ) || building_cubemaps.GetBool() ) { tmpBuf.Reset(); if ( bAlphatest ) { PARM_VALIDATE( info.iAlphatestRef ); tmpBuf.SetPixelShaderConstant1( 0, PARM_FLOAT( info.iAlphatestRef ) ); } if ( bAlbedo ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER0, info.iAlbedo ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER0, TEXTURE_GREY ); if ( bEnvmap ) { if ( building_cubemaps.GetBool() ) tmpBuf.BindStandardTexture( SHADER_SAMPLER3, TEXTURE_BLACK ); else { if ( PARM_TEX( info.iEnvmap ) && !bModel ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER3, info.iEnvmap ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER3, TEXTURE_LOCAL_ENV_CUBEMAP ); } if ( bEnvmapMask ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER4, info.iEnvmapMask ); if ( bAlbedo2 ) { if ( bEnvmapMask2 ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER7, info.iEnvmapMask2 ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER7, TEXTURE_WHITE ); } tmpBuf.SetPixelShaderConstant( 5, info.iEnvmapTint ); float fl6[4] = { 0 }; fl6[0] = PARM_FLOAT( info.iEnvmapSaturation ); fl6[1] = PARM_FLOAT( info.iEnvmapContrast ); tmpBuf.SetPixelShaderConstant( 6, fl6 ); } if ( bNeedsFresnel ) { tmpBuf.SetPixelShaderConstant( 7, info.iFresnelRanges ); } if ( bRimLight ) { float fl9[4] = { 0 }; fl9[0] = PARM_FLOAT( info.iRimlightExponent ); fl9[1] = PARM_FLOAT( info.iRimlightAlbedoScale ); tmpBuf.SetPixelShaderConstant( 9, fl9 ); } if ( bAlbedo2 ) { tmpBuf.BindTexture( pShader, SHADER_SAMPLER5, info.iAlbedo2 ); if ( bBlendmodulate ) { tmpBuf.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_1, info.iBlendmodulateTransform ); tmpBuf.BindTexture( pShader, SHADER_SAMPLER6, info.iBlendmodulate ); } } if ( bMultiBlend ) { tmpBuf.BindTexture( pShader, SHADER_SAMPLER7, info.iAlbedo3 ); if ( bAlbedo4 ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER8, info.iAlbedo4 ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER8, TEXTURE_WHITE ); if ( bBlendmodulate ) { tmpBuf.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_3, info.iBlendmodulateTransform2 ); tmpBuf.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_5, info.iBlendmodulateTransform3 ); if ( bBlendmodulate2 ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER9, info.iBlendmodulate2 ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER9, TEXTURE_BLACK ); if ( bBlendmodulate3 ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER10, info.iBlendmodulate3 ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER10, TEXTURE_BLACK ); } } if ( bSelfIllum && bSelfIllumMask ) { tmpBuf.BindTexture( pShader, SHADER_SAMPLER4, info.iSelfIllumMask ); } int x, y, w, t; pShaderAPI->GetCurrentViewport( x, y, w, t ); float fl1[4] = { 1.0f / w, 1.0f / t, 0, 0 }; tmpBuf.SetPixelShaderConstant( 1, fl1 ); tmpBuf.SetPixelShaderFogParams( 2 ); float fl4 = { PARM_FLOAT( info.iPhongScale ) }; tmpBuf.SetPixelShaderConstant1( 4, fl4 ); tmpBuf.End(); pDeferredContext->SetCommands( CDeferredPerMaterialContextData::DEFSTAGE_COMPOSITE, tmpBuf.Copy() ); } pShaderAPI->SetDefaultState(); if ( bModel && bFastVTex ) pShader->SetHWMorphVertexShaderState( VERTEX_SHADER_SHADER_SPECIFIC_CONST_10, VERTEX_SHADER_SHADER_SPECIFIC_CONST_11, SHADER_VERTEXTEXTURE_SAMPLER0 ); DECLARE_DYNAMIC_VERTEX_SHADER( composite_vs30 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (bModel && (int)vertexCompression) ? 1 : 0 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, (bModel && pShaderAPI->GetCurrentNumBones() > 0) ? 1 : 0 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( MORPHING, (bModel && pShaderAPI->IsHWMorphingEnabled()) ? 1 : 0 ); SET_DYNAMIC_VERTEX_SHADER( composite_vs30 ); DECLARE_DYNAMIC_PIXEL_SHADER( composite_ps30 ); SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() ); SET_DYNAMIC_PIXEL_SHADER( composite_ps30 ); if ( bModel && bFastVTex ) { bool bUnusedTexCoords[3] = { false, true, !pShaderAPI->IsHWMorphingEnabled() || !bIsDecal }; pShaderAPI->MarkUnusedVertexFields( 0, 3, bUnusedTexCoords ); } pShaderAPI->ExecuteCommandBuffer( pDeferredContext->GetCommands( CDeferredPerMaterialContextData::DEFSTAGE_COMPOSITE ) ); if ( bGBufferNormal ) pShader->BindTexture( SHADER_SAMPLER1, GetDeferredExt()->GetTexture_Normals() ); pShader->BindTexture( SHADER_SAMPLER2, GetDeferredExt()->GetTexture_LightAccum() ); CommitBaseDeferredConstants_Origin( pShaderAPI, 3 ); if ( bWorldEyeVec ) { float vEyepos[4] = {0,0,0,0}; pShaderAPI->GetWorldSpaceCameraPosition( vEyepos ); pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, vEyepos ); } if ( bRimLight ) { pShaderAPI->SetPixelShaderConstant( 8, params[ info.iRimlightTint ]->GetVecValue() ); } if ( bSelfIllum ) { pShaderAPI->SetPixelShaderConstant( 10, params[ info.iSelfIllumTint ]->GetVecValue() ); } } pShader->Draw(); }
void DrawPassGBuffer( const defParms_gBuffer &info, CBaseVSShader *pShader, IMaterialVar **params, IShaderShadow* pShaderShadow, IShaderDynamicAPI* pShaderAPI, VertexCompressionType_t vertexCompression, CDeferredPerMaterialContextData *pDeferredContext ) { const bool bDeferredShading = DEFCFG_DEFERRED_SHADING == 1; const bool bModel = info.bModel; const bool bIsDecal = IS_FLAG_SET( MATERIAL_VAR_DECAL ); const bool bFastVTex = g_pHardwareConfig->HasFastVertexTextures(); const bool bNoCull = IS_FLAG_SET( MATERIAL_VAR_NOCULL ); const bool bAlbedo = PARM_TEX( info.iAlbedo ); const bool bAlbedo2 = bDeferredShading && PARM_TEX( info.iAlbedo2 ); const bool bAlbedo3 = bDeferredShading && PARM_TEX( info.iAlbedo3 ); const bool bAlbedo4 = bDeferredShading && PARM_TEX( info.iAlbedo4 ); const bool bBumpmap = PARM_TEX( info.iBumpmap ); const bool bBumpmap2 = bBumpmap && PARM_TEX( info.iBumpmap2 ); const bool bBumpmap3 = bBumpmap && PARM_TEX( info.iBumpmap3 ); const bool bBumpmap4 = bBumpmap && PARM_TEX( info.iBumpmap4 ); const bool bPhongmap = PARM_TEX( info.iPhongmap ); const bool bMultiBlend = PARM_SET( info.iMultiblend ); const bool bMultiBlendBump = bMultiBlend && bBumpmap; const bool bBlendmodulate = ( bAlbedo2 || bBumpmap2 || bMultiBlendBump ) && PARM_TEX( info.iBlendmodulate ); const bool bBlendmodulate2 = bBlendmodulate && PARM_TEX( info.iBlendmodulate2 ); const bool bBlendmodulate3 = bBlendmodulate && PARM_TEX( info.iBlendmodulate3 ); const bool bAlphatest = IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ) && bAlbedo; const bool bTranslucent = IS_FLAG_SET( MATERIAL_VAR_TRANSLUCENT ) && bAlbedo && bIsDecal; const bool bSSBump = bBumpmap && PARM_SET( info.iSSBump ); Assert( !bIsDecal || bDeferredShading ); Assert( !bTranslucent || bDeferredShading ); SHADOW_STATE { pShaderShadow->SetDefaultState(); pShaderShadow->EnableSRGBWrite( false ); if ( bNoCull ) { pShaderShadow->EnableCulling( false ); } int iVFmtFlags = VERTEX_POSITION | VERTEX_NORMAL; int iUserDataSize = 0; int *pTexCoordDim; int iTexCoordNum; GetTexcoordSettings( ( bModel && bIsDecal && bFastVTex ), bMultiBlend, iTexCoordNum, &pTexCoordDim ); if ( bModel ) { iVFmtFlags |= VERTEX_FORMAT_COMPRESSED; } else { if ( bBumpmap2 || bAlbedo2 ) iVFmtFlags |= VERTEX_COLOR; } if ( bAlphatest || bDeferredShading ) { pShaderShadow->EnableTexture( SHADER_SAMPLER0, true ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, false ); } if ( bBumpmap ) { pShaderShadow->EnableTexture( SHADER_SAMPLER1, true ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER1, false ); if ( bModel ) iUserDataSize = 4; else { iVFmtFlags |= VERTEX_TANGENT_SPACE; } } if ( bPhongmap ) { pShaderShadow->EnableTexture( SHADER_SAMPLER2, true ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER2, false ); } if ( bAlbedo2 || bBumpmap2 || bMultiBlendBump ) { pShaderShadow->EnableTexture( SHADER_SAMPLER3, true ); if ( bAlbedo2 ) pShaderShadow->EnableTexture( SHADER_SAMPLER9, true ); if ( bBlendmodulate ) pShaderShadow->EnableTexture( SHADER_SAMPLER4, true ); } if ( bMultiBlendBump ) { pShaderShadow->EnableTexture( SHADER_SAMPLER5, true ); pShaderShadow->EnableTexture( SHADER_SAMPLER6, true ); if ( bDeferredShading ) { pShaderShadow->EnableTexture( SHADER_SAMPLER10, true ); pShaderShadow->EnableTexture( SHADER_SAMPLER11, true ); } if ( bBlendmodulate ) { pShaderShadow->EnableTexture( SHADER_SAMPLER7, true ); pShaderShadow->EnableTexture( SHADER_SAMPLER8, true ); } } pShaderShadow->EnableAlphaWrites( true ); pShaderShadow->VertexShaderVertexFormat( iVFmtFlags, iTexCoordNum, pTexCoordDim, iUserDataSize ); if ( bTranslucent ) { pShader->EnableAlphaBlending( SHADER_BLEND_SRC_ALPHA, SHADER_BLEND_ONE_MINUS_SRC_ALPHA ); } DECLARE_STATIC_VERTEX_SHADER( gbuffer_vs30 ); SET_STATIC_VERTEX_SHADER_COMBO( MODEL, bModel ); SET_STATIC_VERTEX_SHADER_COMBO( MORPHING_VTEX, bModel && bFastVTex ); SET_STATIC_VERTEX_SHADER_COMBO( TANGENTSPACE, bBumpmap ); SET_STATIC_VERTEX_SHADER_COMBO( BUMPMAP2, bBumpmap2 && !bMultiBlend ); SET_STATIC_VERTEX_SHADER_COMBO( BLENDMODULATE, bBlendmodulate ); SET_STATIC_VERTEX_SHADER_COMBO( MULTIBLEND, bMultiBlendBump ); SET_STATIC_VERTEX_SHADER( gbuffer_vs30 ); #if DEFCFG_DEFERRED_SHADING == 1 DECLARE_STATIC_PIXEL_SHADER( gbuffer_defshading_ps30 ); #else DECLARE_STATIC_PIXEL_SHADER( gbuffer_ps30 ); SET_STATIC_PIXEL_SHADER_COMBO( BUMPMAP2, bBumpmap2 && !bMultiBlend ); #endif SET_STATIC_PIXEL_SHADER_COMBO( ALPHATEST, bAlphatest ); SET_STATIC_PIXEL_SHADER_COMBO( BUMPMAP, bBumpmap ? bSSBump ? 2 : 1 : 0 ); SET_STATIC_PIXEL_SHADER_COMBO( NOCULL, bNoCull ); SET_STATIC_PIXEL_SHADER_COMBO( PHONGMAP, bPhongmap ); SET_STATIC_PIXEL_SHADER_COMBO( BLENDMODULATE, bBlendmodulate ); SET_STATIC_PIXEL_SHADER_COMBO( MULTIBLEND, bMultiBlendBump ); #if DEFCFG_DEFERRED_SHADING == 1 SET_STATIC_PIXEL_SHADER_COMBO( TWOTEXTURE, (bAlbedo2 || bBumpmap2) && !bMultiBlend ); SET_STATIC_PIXEL_SHADER_COMBO( DECAL, bIsDecal ); SET_STATIC_PIXEL_SHADER( gbuffer_defshading_ps30 ); #else SET_STATIC_PIXEL_SHADER( gbuffer_ps30 ); #endif } DYNAMIC_STATE { Assert( pDeferredContext != NULL ); if ( pDeferredContext->m_bMaterialVarsChanged || !pDeferredContext->HasCommands( CDeferredPerMaterialContextData::DEFSTAGE_GBUFFER ) ) { tmpBuf.Reset(); if ( bAlphatest ) { PARM_VALIDATE( info.iAlphatestRef ); tmpBuf.SetPixelShaderConstant1( 0, PARM_FLOAT( info.iAlphatestRef ) ); } if ( bAlphatest || bDeferredShading ) { if ( bAlbedo ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER0, info.iAlbedo ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER0, TEXTURE_GREY ); } if ( bBumpmap ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER1, info.iBumpmap ); if ( bPhongmap ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER2, info.iPhongmap ); else { float flPhongExp[2] = { 0 }; flPhongExp[0] = clamp( PARM_FLOAT( info.iPhongExp ), 0, 1 ) * 63.0f; if ( bBumpmap2 || bAlbedo2 ) { PARM_VALIDATE( info.iPhongExp2 ); flPhongExp[1] = clamp( PARM_FLOAT( info.iPhongExp2 ), 0, 1 ) * 63.0f; tmpBuf.SetPixelShaderConstant2( 2, flPhongExp[0], flPhongExp[1] ); } else tmpBuf.SetPixelShaderConstant1( 2, flPhongExp[0] ); } if ( bAlbedo2 || bBumpmap2 || bMultiBlendBump ) { if ( bBumpmap2 ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER3, info.iBumpmap2 ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER3, TEXTURE_NORMALMAP_FLAT ); if ( bAlbedo2 ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER9, info.iAlbedo2 ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER9, TEXTURE_GREY ); if ( bBlendmodulate ) { tmpBuf.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_3, info.iBlendmodulateTransform ); tmpBuf.BindTexture( pShader, SHADER_SAMPLER4, info.iBlendmodulate ); } } if ( bMultiBlendBump ) { if ( bBumpmap3 ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER5, info.iBumpmap3 ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER5, TEXTURE_NORMALMAP_FLAT ); if ( bBumpmap4 ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER6, info.iBumpmap4 ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER6, TEXTURE_NORMALMAP_FLAT ); if ( bAlbedo3 ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER10, info.iAlbedo3 ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER10, TEXTURE_GREY ); if ( bAlbedo4 ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER11, info.iAlbedo4 ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER11, TEXTURE_GREY ); if ( bBlendmodulate ) { tmpBuf.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_5, info.iBlendmodulateTransform2 ); tmpBuf.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_7, info.iBlendmodulateTransform3 ); if ( bBlendmodulate2 ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER7, info.iBlendmodulate2 ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER7, TEXTURE_BLACK ); if ( bBlendmodulate3 ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER8, info.iBlendmodulate3 ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER8, TEXTURE_BLACK ); } } tmpBuf.SetPixelShaderConstant2( 1, IS_FLAG_SET( MATERIAL_VAR_HALFLAMBERT ) ? 1.0f : 0.0f, PARM_SET( info.iLitface ) ? 1.0f : 0.0f ); tmpBuf.End(); pDeferredContext->SetCommands( CDeferredPerMaterialContextData::DEFSTAGE_GBUFFER, tmpBuf.Copy() ); } pShaderAPI->SetDefaultState(); if ( bModel && bFastVTex ) pShader->SetHWMorphVertexShaderState( VERTEX_SHADER_SHADER_SPECIFIC_CONST_10, VERTEX_SHADER_SHADER_SPECIFIC_CONST_11, SHADER_VERTEXTEXTURE_SAMPLER0 ); DECLARE_DYNAMIC_VERTEX_SHADER( gbuffer_vs30 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (bModel && (int)vertexCompression) ? 1 : 0 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, (bModel && pShaderAPI->GetCurrentNumBones() > 0) ? 1 : 0 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( MORPHING, (bModel && pShaderAPI->IsHWMorphingEnabled()) ? 1 : 0 ); SET_DYNAMIC_VERTEX_SHADER( gbuffer_vs30 ); #if DEFCFG_DEFERRED_SHADING == 1 DECLARE_DYNAMIC_PIXEL_SHADER( gbuffer_defshading_ps30 ); SET_DYNAMIC_PIXEL_SHADER( gbuffer_defshading_ps30 ); #else DECLARE_DYNAMIC_PIXEL_SHADER( gbuffer_ps30 ); SET_DYNAMIC_PIXEL_SHADER( gbuffer_ps30 ); #endif if ( bModel && bFastVTex ) { bool bUnusedTexCoords[3] = { false, true, !pShaderAPI->IsHWMorphingEnabled() || !bIsDecal }; pShaderAPI->MarkUnusedVertexFields( 0, 3, bUnusedTexCoords ); } float vPos[4] = {0,0,0,0}; pShaderAPI->GetWorldSpaceCameraPosition( vPos ); float zScale[4] = {GetDeferredExt()->GetZScale(),0,0,0}; pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, vPos ); pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_1, GetDeferredExt()->GetForwardBase() ); pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, zScale ); pShader->LoadViewMatrixIntoVertexShaderConstant( VERTEX_SHADER_AMBIENT_LIGHT ); pShaderAPI->ExecuteCommandBuffer( pDeferredContext->GetCommands( CDeferredPerMaterialContextData::DEFSTAGE_GBUFFER ) ); } pShader->Draw(); }