END_SHADER_PARAMS SHADER_INIT_PARAMS() { SET_FLAGS2( MATERIAL_VAR2_SUPPORTS_HW_SKINNING ); if( !params[ENVMAPMASKSCALE]->IsDefined() ) params[ENVMAPMASKSCALE]->SetFloatValue( 1.0f ); if( !params[ENVMAPTINT]->IsDefined() ) params[ENVMAPTINT]->SetVecValue( 1.0f, 1.0f, 1.0f ); if( !params[SELFILLUMTINT]->IsDefined() ) params[SELFILLUMTINT]->SetVecValue( 1.0f, 1.0f, 1.0f ); if( !params[DETAILSCALE]->IsDefined() ) params[DETAILSCALE]->SetFloatValue( 4.0f ); // No envmap uses mode 0, it's one less pass // Also, if multipass = 0, then go to mode 0 also if ( ( !params[ENVMAP]->IsDefined() ) || ( !IS_FLAG_SET(MATERIAL_VAR_MULTIPASS) ) ) { CLEAR_FLAGS( MATERIAL_VAR_ENVMAPMODE ); } // Vertex color requires mode 1 if ( IS_FLAG_SET(MATERIAL_VAR_VERTEXCOLOR) ) { SET_FLAGS( MATERIAL_VAR_ENVMAPMODE ); } // No texture means no self-illum or env mask in base alpha if ( !params[BASETEXTURE]->IsDefined() ) { CLEAR_FLAGS( MATERIAL_VAR_SELFILLUM ); CLEAR_FLAGS( MATERIAL_VAR_BASEALPHAENVMAPMASK ); } // If in decal mode, no debug override... if ( IS_FLAG_SET(MATERIAL_VAR_DECAL) ) { SET_FLAGS( MATERIAL_VAR_NO_DEBUG_OVERRIDE ); } SET_FLAGS2( MATERIAL_VAR2_LIGHTING_VERTEX_LIT ); SET_FLAGS2( MATERIAL_VAR2_NEEDS_SOFTWARE_LIGHTING ); // Get rid of the envmap if it's optional for this dx level. if( params[ENVMAPOPTIONAL]->IsDefined() && params[ENVMAPOPTIONAL]->GetIntValue() ) { params[ENVMAP]->SetUndefined(); } // If mat_specular 0, then get rid of envmap if( !g_pConfig->UseSpecular() && params[ENVMAP]->IsDefined() && params[BASETEXTURE]->IsDefined() ) { params[ENVMAP]->SetUndefined(); } }
inline const char *GetPixelShaderName( IMaterialVar** params, bool bBumpedEnvMap ) { static char const* s_pPixelShaders[] = { // Unmasked "LightmappedGeneric_EnvMapV2", "LightmappedGeneric_SelfIlluminatedEnvMapV2", "LightmappedGeneric_BaseAlphaMaskedEnvMapV2", "LightmappedGeneric_SelfIlluminatedEnvMapV2", // Env map mask "LightmappedGeneric_MaskedEnvMapV2", "LightmappedGeneric_SelfIlluminatedMaskedEnvMapV2", "LightmappedGeneric_MaskedEnvMapV2", "LightmappedGeneric_SelfIlluminatedMaskedEnvMapV2", }; if (!params[BASETEXTURE]->IsTexture()) { if (params[ENVMAP]->IsTexture() && !bBumpedEnvMap ) { if (!params[ENVMAPMASK]->IsDefined() ) { return "LightmappedGeneric_EnvmapNoTexture"; } else { return "LightmappedGeneric_MaskedEnvmapNoTexture"; } } else { return "LightmappedGeneric_NoTexture"; } } else { if (params[ENVMAP]->IsTexture() && !bBumpedEnvMap ) { int pshIndex = 0; if (IS_FLAG_SET(MATERIAL_VAR_SELFILLUM)) pshIndex |= 0x1; if (IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK)) pshIndex |= 0x2; if (params[ENVMAPMASK]->IsTexture()) pshIndex |= 0x4; return s_pPixelShaders[pshIndex]; } else { if (IS_FLAG_SET(MATERIAL_VAR_SELFILLUM)) return "LightmappedGeneric_SelfIlluminated"; else return "LightmappedGeneric"; } } }
bool DrawToGBuffer( IMaterialVar **params ) { #if DEFCFG_DEFERRED_SHADING == 1 return true; #else const bool bIsDecal = IS_FLAG_SET( MATERIAL_VAR_DECAL ); const bool bTranslucent = IS_FLAG_SET( MATERIAL_VAR_TRANSLUCENT ); return !bTranslucent && !bIsDecal; #endif }
/** * Request that a backup should be restored to the connected device. * * @param client The connected MobileBackup client to use. * @param backup_manifest The backup manifest, a plist_t of type PLIST_DICT * containing the backup state to be restored. * @param flags Flags to send with the request. Currently this is a combination * of the following mobilebackup_flags_t: * MB_RESTORE_NOTIFY_SPRINGBOARD - let SpringBoard show a 'Restore' screen * MB_RESTORE_PRESERVE_SETTINGS - do not overwrite any settings * MB_RESTORE_PRESERVE_CAMERA_ROLL - preserve the photos of the camera roll * @param proto_version A string denoting the version of the backup protocol * to use. Latest known version is "1.6". Ideally this value should be * extracted from the given manifest plist. * * @return MOBILEBACKUP_E_SUCCESS on success, MOBILEBACKUP_E_INVALID_ARG if * one of the parameters is invalid, MOBILEBACKUP_E_PLIST_ERROR if * backup_manifest is not of type PLIST_DICT, MOBILEBACKUP_E_MUX_ERROR * if a communication error occurs, or MOBILEBACKUP_E_REPLY_NOT_OK * if the device did not accept the request. */ mobilebackup_error_t mobilebackup_request_restore(mobilebackup_client_t client, plist_t backup_manifest, mobilebackup_flags_t flags, const char *proto_version) { if (!client || !client->parent || !backup_manifest || !proto_version) return MOBILEBACKUP_E_INVALID_ARG; if (backup_manifest && (plist_get_node_type(backup_manifest) != PLIST_DICT)) return MOBILEBACKUP_E_PLIST_ERROR; mobilebackup_error_t err; /* construct request plist */ plist_t dict = plist_new_dict(); plist_dict_insert_item(dict, "BackupManifestKey", plist_copy(backup_manifest)); plist_dict_insert_item(dict, "BackupMessageTypeKey", plist_new_string("kBackupMessageRestoreRequest")); plist_dict_insert_item(dict, "BackupProtocolVersion", plist_new_string(proto_version)); /* add flags */ plist_dict_insert_item(dict, "BackupNotifySpringBoard", plist_new_bool(IS_FLAG_SET(flags, MB_RESTORE_NOTIFY_SPRINGBOARD))); plist_dict_insert_item(dict, "BackupPreserveSettings", plist_new_bool(IS_FLAG_SET(flags, MB_RESTORE_PRESERVE_SETTINGS))); plist_dict_insert_item(dict, "BackupPreserveCameraRoll", plist_new_bool(IS_FLAG_SET(flags, MB_RESTORE_PRESERVE_CAMERA_ROLL))); /* send request */ err = mobilebackup_send_message(client, NULL, dict); plist_free(dict); dict = NULL; if (err != MOBILEBACKUP_E_SUCCESS) { debug_info("ERROR: Could not send restore request message (%d)!", err); goto leave; } /* now receive and hopefully get a BackupMessageRestoreReplyOK */ err = mobilebackup_receive_message(client, "BackupMessageRestoreReplyOK", &dict); if (err != MOBILEBACKUP_E_SUCCESS) { debug_info("ERROR: Could not receive RestoreReplyOK message (%d)!", err); goto leave; } plist_t node = plist_dict_get_item(dict, "BackupProtocolVersion"); if (node) { char *str = NULL; plist_get_string_val(node, &str); if (str) { if (strcmp(str, proto_version) != 0) { err = MOBILEBACKUP_E_BAD_VERSION; } free(str); } } leave: if (dict) plist_free(dict); return err; }
END_SHADER_PARAMS SHADER_INIT_PARAMS() { SET_FLAGS2( MATERIAL_VAR2_LIGHTING_LIGHTMAP ); if( !params[ENVMAPMASKSCALE]->IsDefined() ) params[ENVMAPMASKSCALE]->SetFloatValue( 1.0f ); if( !params[DETAILSCALE]->IsDefined() ) params[DETAILSCALE]->SetFloatValue( 1.0f ); if( !params[ENVMAPTINT]->IsDefined() ) params[ENVMAPTINT]->SetVecValue( 1.0f, 1.0f, 1.0f ); // No texture means no self-illum or env mask in base alpha if ( !params[BASETEXTURE]->IsDefined() ) { CLEAR_FLAGS( MATERIAL_VAR_BASEALPHAENVMAPMASK ); } // If in decal mode, no debug override... if (IS_FLAG_SET(MATERIAL_VAR_DECAL)) { SET_FLAGS( MATERIAL_VAR_NO_DEBUG_OVERRIDE ); } }
static int OnGetFileAttributes(HWND hDlg) { TFileTestData * pData = GetDialogData(hDlg); TFlagInfo * pFlags = FileAttributesValues; TCHAR szFileAttributes[512] = _T(""); DWORD dwAttr; int nError = ERROR_SUCCESS; SaveDialog(hDlg); dwAttr = GetFileAttributes(pData->szFileName1); if(dwAttr != INVALID_FILE_ATTRIBUTES) { for(int i = 0; pFlags->dwValue != 0; i++, pFlags++) { if(IS_FLAG_SET(pFlags, dwAttr)) { if(szFileAttributes[0] != 0) StringCchCat(szFileAttributes, _countof(szFileAttributes), _T("\n")); StringCchCat(szFileAttributes, _countof(szFileAttributes), pFlags->szFlagText); } } if(szFileAttributes[0] == 0) StringCchCopy(szFileAttributes, _countof(szFileAttributes), _T("0")); MessageBoxRc(hDlg, IDS_FILE_ATTRIBUTES, (UINT_PTR)szFileAttributes); } else nError = GetLastError(); SetResultInfo(hDlg, nError); return TRUE; }
//----------------------------------------------------------------------------- // Does the texture store translucency in its alpha channel? //----------------------------------------------------------------------------- bool CBaseShader::TextureIsTranslucent( int textureVar, bool isBaseTexture ) { if (textureVar < 0) return false; IMaterialVar** params = s_ppParams; if (params[textureVar]->GetType() == MATERIAL_VAR_TYPE_TEXTURE) { if (!isBaseTexture) { return params[textureVar]->GetTextureValue()->IsTranslucent(); } else { // Override translucency settings if this flag is set. if (IS_FLAG_SET(MATERIAL_VAR_OPAQUETEXTURE)) return false; if ( (CurrentMaterialVarFlags() & (MATERIAL_VAR_SELFILLUM | MATERIAL_VAR_BASEALPHAENVMAPMASK)) == 0) { if ((CurrentMaterialVarFlags() & MATERIAL_VAR_TRANSLUCENT) || (CurrentMaterialVarFlags() & MATERIAL_VAR_ALPHATEST)) { return params[textureVar]->GetTextureValue()->IsTranslucent(); } } } } return false; }
//----------------------------------------------------------------------------- // Initialize shader parameters //----------------------------------------------------------------------------- void InitParamsPhong_DX9( CBaseVSShader *pShader, IMaterialVar** params, const char *pMaterialName, VertexLitGeneric_DX9_Vars_t &info ) { // FLASHLIGHTFIXME: Do ShaderAPI::BindFlashlightTexture Assert( info.m_nFlashlightTexture >= 0 ); params[FLASHLIGHTTEXTURE]->SetStringValue( GetFlashlightTextureFilename() ); // Write over $basetexture with $info.m_nBumpmap if we are going to be using diffuse normal mapping. if( info.m_nAlbedo != -1 && g_pConfig->UseBumpmapping() && info.m_nBumpmap != -1 && params[info.m_nBumpmap]->IsDefined() && params[info.m_nAlbedo]->IsDefined() && params[info.m_nBaseTexture]->IsDefined() ) { params[info.m_nBaseTexture]->SetStringValue( params[info.m_nAlbedo]->GetStringValue() ); } // This shader can be used with hw skinning SET_FLAGS2( MATERIAL_VAR2_SUPPORTS_HW_SKINNING ); SET_FLAGS2( MATERIAL_VAR2_LIGHTING_VERTEX_LIT ); // No texture means no env mask in base alpha if ( !params[info.m_nBaseTexture]->IsDefined() ) { CLEAR_FLAGS( MATERIAL_VAR_BASEALPHAENVMAPMASK ); } // If in decal mode, no debug override... if (IS_FLAG_SET(MATERIAL_VAR_DECAL)) { SET_FLAGS( MATERIAL_VAR_NO_DEBUG_OVERRIDE ); } // We always specify we're using user data, therefore we always need tangent spaces SET_FLAGS2( MATERIAL_VAR2_NEEDS_TANGENT_SPACES ); bool bBump = (info.m_nBumpmap != -1) && g_pConfig->UseBumpmapping() && params[info.m_nBumpmap]->IsDefined(); bool bEnvMap = (info.m_nEnvmap != -1) && params[info.m_nEnvmap]->IsDefined(); bool bDiffuseWarp = (info.m_nDiffuseWarpTexture != -1) && params[info.m_nDiffuseWarpTexture]->IsDefined(); bool bPhong = (info.m_nPhong != -1) && params[info.m_nPhong]->IsDefined(); if( !bBump && !bEnvMap && !bDiffuseWarp && !bPhong ) { CLEAR_FLAGS( MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK ); } if ( ( info.m_nSelfIllumFresnelMinMaxExp != -1 ) && ( !params[info.m_nSelfIllumFresnelMinMaxExp]->IsDefined() ) ) { params[info.m_nSelfIllumFresnelMinMaxExp]->SetVecValue( 0.0f, 1.0f, 1.0f ); } InitFloatParam( info.m_nEnvmapFresnel, params, 0.0f ); InitFloatParam( info.m_nAmbientOcclusion, params, 0.0f ); InitFloatParam( info.m_nDisplacementWrinkleMap, params, 0.0f ); InitIntParam( info.m_nSelfIllumFresnel, params, 0 ); InitIntParam( info.m_nBaseMapAlphaPhongMask, params, 0 ); InitIntParam( info.m_nBaseMapLuminancePhongMask, params, 0 ); InitIntParam( info.m_nShaderSrgbRead360, params, 0 ); InitIntParam( info.m_nAllowDiffuseModulation, params, 1 ); InitIntParam( info.m_nPhongDisableHalfLambert, params, 0 ); SET_PARAM_STRING_IF_NOT_DEFINED( info.m_nFoW, "_rt_fog_of_war" ); }
END_SHADER_PARAMS SHADER_INIT_PARAMS() { if( !params[ENVMAPTINT]->IsDefined() ) params[ENVMAPTINT]->SetVecValue( 1.0f, 1.0f, 1.0f ); if( !params[ENVMAPMASKSCALE]->IsDefined() ) params[ENVMAPMASKSCALE]->SetFloatValue( 1.0f ); if( !params[DETAILSCALE]->IsDefined() ) params[DETAILSCALE]->SetFloatValue( 4.0f ); // No texture means no env mask in base alpha if ( !params[BASETEXTURE]->IsDefined() ) { CLEAR_FLAGS( MATERIAL_VAR_BASEALPHAENVMAPMASK ); } // If in decal mode, no debug override... if (IS_FLAG_SET(MATERIAL_VAR_DECAL)) { SET_FLAGS( MATERIAL_VAR_NO_DEBUG_OVERRIDE ); } // Get rid of the envmap if it's optional for this dx level. if( params[ENVMAPOPTIONAL]->IsDefined() && params[ENVMAPOPTIONAL]->GetIntValue() ) { params[ENVMAP]->SetUndefined(); } // If mat_specular 0, then get rid of envmap if( !g_pConfig->UseSpecular() && params[ENVMAP]->IsDefined() && params[BASETEXTURE]->IsDefined() ) { params[ENVMAP]->SetUndefined(); } }
CNdasDevice::CNdasDevice( DWORD dwSlotNo, CONST NDAS_DEVICE_ID& deviceId, DWORD dwFlags) : m_status(NDAS_DEVICE_STATUS_DISABLED), m_lastError(NDAS_DEVICE_ERROR_NONE), m_dwSlotNo(dwSlotNo), m_deviceId(deviceId), m_grantedAccess(0x00000000L), m_dwLastHeartbeatTick(0), m_dwCommFailureCount(0), m_fAutoRegistered(IS_FLAG_SET(dwFlags,NDAS_DEVICE_REG_FLAG_AUTO_REGISTERED)), m_fVolatile(IS_FLAG_SET(dwFlags,NDAS_DEVICE_REG_FLAG_VOLATILE)), m_fHidden(IS_FLAG_SET(dwFlags,NDAS_DEVICE_REG_FLAG_HIDDEN)) { m_szDeviceName[0] = TEXT('\0'); ::ZeroMemory( &m_hwInfo, sizeof(HARDWARE_INFO)); ::ZeroMemory( m_pUnitDevices, sizeof(CNdasUnitDevice*) * MAX_NDAS_UNITDEVICE_COUNT); HRESULT hr = ::StringCchPrintf( m_szCfgContainer, 30, TEXT("Devices\\%04d"), dwSlotNo); _ASSERT(SUCCEEDED(hr)); // // After we allocate m_szCfgContainer, we can use SetConfigValue // if (m_fAutoRegistered) { (VOID) SetConfigValue(_T("AutoRegistered"), m_fAutoRegistered); } else { (VOID) DeleteConfigValue(_T("AutoRegistered")); } DBGPRT_TRACE(_FT("ctor: %s\n"), ToString()); }
int GetDrawFlagsPass1(IMaterialVar** params ) { int flags = SHADER_DRAW_POSITION; if (IS_FLAG_SET(MATERIAL_VAR_VERTEXCOLOR)) flags |= SHADER_DRAW_COLOR; flags |= SHADER_DRAW_TEXCOORD0; return flags; }
int GetDrawFlagsPass1(IMaterialVar** params, bool doDetail) { int flags = SHADER_DRAW_POSITION; if (IS_FLAG_SET(MATERIAL_VAR_VERTEXCOLOR)) flags |= SHADER_DRAW_COLOR; if (params[BASETEXTURE]->IsTexture()) flags |= SHADER_DRAW_TEXCOORD0; if (doDetail) flags |= SHADER_DRAW_TEXCOORD1; return flags; }
HRESULT RemoveAllInheritedAces(PACL *ppAcl) { BOOL bResult = FALSE; DWORD errorCode = S_OK; HRESULT hr = S_OK; ACL_SIZE_INFORMATION aclInformation; DWORD totalCount; DWORD aceIndex = 0; LPVOID ace = nullptr; BYTE aceFlags = 0; if ( !ARGUMENT_PRESENT(*ppAcl) ) { return E_INVALIDARG; } bResult = GetAclInformation( *ppAcl, &aclInformation, sizeof(aclInformation), AclSizeInformation ); FailGracefullyGLE(bResult, L"GetAclInformation"); totalCount = aclInformation.AceCount; while ( aceIndex < totalCount ) { bResult = GetAce( *ppAcl, aceIndex, &ace ); FailGracefullyGLE(bResult, L"GetAce"); aceFlags = ((PACE_HEADER)ace)->AceFlags; if (IS_FLAG_SET(aceFlags,INHERITED_ACE)) { bResult = DeleteAce( *ppAcl, aceIndex); FailGracefullyGLE(bResult, L"DeleteAce"); totalCount--; } else { aceIndex++; } } exit_gracefully: return hr; }
SHADER_INIT_PARAMS() { SET_FLAGS2( MATERIAL_VAR2_SUPPORTS_HW_SKINNING ); if ( g_pHardwareConfig->HasFastVertexTextures() ) SET_FLAGS2( MATERIAL_VAR2_USES_VERTEXID ); //const bool bIsDecal = IS_FLAG_SET( MATERIAL_VAR_DECAL ); const bool bDeferredActive = GetDeferredExt()->IsDeferredLightingEnabled(); if( bDeferredActive )// && !bIsDecal ) { const bool bTranslucent = IS_FLAG_SET( MATERIAL_VAR_TRANSLUCENT ); const bool bAlphaTest = IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ); if( bTranslucent ) { CLEAR_FLAGS( MATERIAL_VAR_TRANSLUCENT ); SET_FLAGS( MATERIAL_VAR_ALPHATEST ); params[ALPHATESTREFERENCE]->SetFloatValue( 0.5f ); } else if( bAlphaTest ) { if( params[ALPHATESTREFERENCE]->GetFloatValue() == 0.0f ) params[ALPHATESTREFERENCE]->SetFloatValue( 0.5f ); } } const bool bDrawToGBuffer = DrawToGBuffer( params ); if ( bDrawToGBuffer ) { defParms_gBuffer parms_gbuffer; SetupParmsGBuffer( parms_gbuffer ); InitParmsGBuffer( parms_gbuffer, this, params ); defParms_shadow parms_shadow; SetupParmsShadow( parms_shadow ); InitParmsShadowPass( parms_shadow, this, params ); } }
bool IsTranslucent( IMaterialVar **params ) const { if ( params[CLOAKPASSENABLED]->GetIntValue() ) // If material supports cloaking { if ( ( params[CLOAKFACTOR]->GetFloatValue() > 0.0f ) && ( params[CLOAKFACTOR]->GetFloatValue() < 1.0f ) ) // Per-frame check return true; // else, not cloaking this frame, so check flag in case the base material still needs it } // Check flag if not drawing cloak pass return IS_FLAG_SET( MATERIAL_VAR_TRANSLUCENT ); }
BEGIN_SHADER_PARAMS END_SHADER_PARAMS // Set up anything that is necessary to make decisions in SHADER_FALLBACK. SHADER_INIT_PARAMS() { // No texture means no self-illum or env mask in base alpha CLEAR_FLAGS( MATERIAL_VAR_BASEALPHAENVMAPMASK ); // If in decal mode, no debug override... if (IS_FLAG_SET(MATERIAL_VAR_DECAL)) { SET_FLAGS( MATERIAL_VAR_NO_DEBUG_OVERRIDE ); } SET_FLAGS2( MATERIAL_VAR2_LIGHTING_LIGHTMAP ); }
// Arranging the dialog layout for pre-arranged dialogs static void CreateDialogLayout_PreArranged(TFlagDialogData * pData) { TFlagInfo * pFlags; HWND hWndChild; UINT nChecked; // Parse all flags and setup every child item for(pFlags = pData->pFlags; pFlags->nIDCtrl != 0; pFlags++) { // Retrieve the child window belonging to this flag hWndChild = GetDlgItem(pData->hDlg, pFlags->nIDCtrl); assert(hWndChild != NULL); // Set the pointer to flag info structure to the child's window data SetWindowLongPtr(hWndChild, GWLP_USERDATA, (LONG_PTR)pFlags); // If the flag is set, we need to check that item nChecked = IS_FLAG_SET(pFlags, pData->dwFlags); Button_SetCheck(hWndChild, nChecked); } }
static void ComputePhongShaderInfo( CBaseVSShader *pShader, IMaterialVar** params, VertexLitGeneric_DX9_Vars_t &info, bool bHasFlashlightOnly, PhongShaderInfo_t *pInfo ) { pInfo->m_bHasBaseTexture = (info.m_nBaseTexture != -1) && params[info.m_nBaseTexture]->IsTexture(); pInfo->m_bHasBaseTextureWrinkle = pInfo->m_bHasBaseTexture && (info.m_nWrinkle != -1) && params[info.m_nWrinkle]->IsTexture() && (info.m_nStretch != -1) && params[info.m_nStretch]->IsTexture(); pInfo->m_bHasBumpWrinkle = (info.m_nBumpmap != -1) && params[info.m_nBumpmap]->IsTexture() && (info.m_nNormalWrinkle != -1) && params[info.m_nNormalWrinkle]->IsTexture() && (info.m_nNormalStretch != -1) && params[info.m_nNormalStretch]->IsTexture(); pInfo->m_bHasEnvmap = !bHasFlashlightOnly && params[info.m_nEnvmap]->IsTexture(); pInfo->m_bHasSelfIllum = IS_FLAG_SET( MATERIAL_VAR_SELFILLUM ) != 0; pInfo->m_bHasSelfIllumFresnel = ( pInfo->m_bHasSelfIllum ) && ( info.m_nSelfIllumFresnel != -1 ) && ( params[info.m_nSelfIllumFresnel]->GetIntValue() != 0 ); pInfo->m_bHasPhong = (info.m_nPhong != -1) && ( params[info.m_nPhong]->GetIntValue() != 0 ); pInfo->m_bHasPhongWarp = (info.m_nPhongWarpTexture != -1) && params[info.m_nPhongWarpTexture]->IsTexture(); pInfo->m_bHasDiffuseWarp = (info.m_nDiffuseWarpTexture != -1) && params[info.m_nDiffuseWarpTexture]->IsTexture(); pInfo->m_bHasDetailTexture = ( info.m_nDetail != -1 ) && params[info.m_nDetail]->IsTexture(); // Rimlight must be set to non-zero to trigger rim light combo (also requires Phong) pInfo->m_bHasRimLight = r_rimlight.GetBool() && pInfo->m_bHasPhong && (info.m_nRimLight != -1) && ( params[info.m_nRimLight]->GetIntValue() != 0 ); }
//----------------------------------------------------------------------------- // Does the texture store translucency in its alpha channel? //----------------------------------------------------------------------------- bool CBaseShader::TextureIsTranslucent( int textureVar, bool isBaseTexture ) { if (textureVar < 0) return false; IMaterialVar** params = s_ppParams; if (params[textureVar]->GetType() == MATERIAL_VAR_TYPE_TEXTURE) { if (!isBaseTexture) { return params[textureVar]->GetTextureValue()->IsTranslucent(); } else { // Override translucency settings if this flag is set. if (IS_FLAG_SET(MATERIAL_VAR_OPAQUETEXTURE)) return false; bool bHasSelfIllum = ( ( CurrentMaterialVarFlags() & MATERIAL_VAR_SELFILLUM ) != 0 ); bool bHasSelfIllumMask = ( ( CurrentMaterialVarFlags2() & MATERIAL_VAR2_SELFILLUMMASK ) != 0 ); bool bHasBaseAlphaEnvmapMask = ( ( CurrentMaterialVarFlags() & MATERIAL_VAR_BASEALPHAENVMAPMASK ) != 0 ); bool bUsingBaseTextureAlphaForSelfIllum = bHasSelfIllum && !bHasSelfIllumMask; // Check if we are using base texture alpha for something other than translucency. if ( !bUsingBaseTextureAlphaForSelfIllum && !bHasBaseAlphaEnvmapMask ) { // We aren't using base alpha for anything other than trancluceny. // check if the material is marked as translucent or alpha test. if ((CurrentMaterialVarFlags() & MATERIAL_VAR_TRANSLUCENT) || (CurrentMaterialVarFlags() & MATERIAL_VAR_ALPHATEST)) { // Make sure the texture has an alpha channel. return params[textureVar]->GetTextureValue()->IsTranslucent(); } } } } return false; }
END_SHADER_PARAMS SHADER_INIT_PARAMS() { if( !params[DETAILSCALE]->IsDefined() ) params[DETAILSCALE]->SetFloatValue( 1.0f ); if( !params[ENVMAPTINT]->IsDefined() ) params[ENVMAPTINT]->SetVecValue( 1.0f, 1.0f, 1.0f ); if( !params[ENVMAPCONTRAST]->IsDefined() ) params[ENVMAPCONTRAST]->SetFloatValue( 0.0f ); if( !params[ENVMAPSATURATION]->IsDefined() ) params[ENVMAPSATURATION]->SetFloatValue( 1.0f ); if( !params[UNLITFACTOR]->IsDefined() ) params[UNLITFACTOR]->SetFloatValue( 0.3f ); if( !params[FRESNELREFLECTION]->IsDefined() ) params[FRESNELREFLECTION]->SetFloatValue( 1.0f ); if( !params[ENVMAPMASKFRAME]->IsDefined() ) params[ENVMAPMASKFRAME]->SetIntValue( 0 ); if( !params[ENVMAPFRAME]->IsDefined() ) params[ENVMAPFRAME]->SetIntValue( 0 ); // No texture means no self-illum or env mask in base alpha if ( !params[BASETEXTURE]->IsDefined() ) { CLEAR_FLAGS( MATERIAL_VAR_BASEALPHAENVMAPMASK ); } // If in decal mode, no debug override... if (IS_FLAG_SET(MATERIAL_VAR_DECAL)) { SET_FLAGS( MATERIAL_VAR_NO_DEBUG_OVERRIDE ); } }
// Set up anything that is necessary to make decisions in SHADER_FALLBACK. SHADER_INIT_PARAMS() { // FLASHLIGHTFIXME params[FLASHLIGHTTEXTURE]->SetStringValue( "effects/flashlight001" ); // Write over $basetexture with $albedo if we are going to be using diffuse normal mapping. if( ShouldUseBumpmapping( params ) && params[ALBEDO]->IsDefined() && params[BASETEXTURE]->IsDefined() && !( params[NODIFFUSEBUMPLIGHTING]->IsDefined() && params[NODIFFUSEBUMPLIGHTING]->GetIntValue() ) ) { params[BASETEXTURE]->SetStringValue( params[ALBEDO]->GetStringValue() ); } if( IsUsingGraphics() && params[ENVMAP]->IsDefined() && !CanUseEditorMaterials() ) { if( stricmp( params[ENVMAP]->GetStringValue(), "env_cubemap" ) == 0 ) { Warning( "env_cubemap used on world geometry without rebuilding map. . ignoring: %s\n", pMaterialName ); params[ENVMAP]->SetUndefined(); } } if( !params[ENVMAPMASKSCALE]->IsDefined() ) { params[ENVMAPMASKSCALE]->SetFloatValue( 1.0f ); } if( !params[ENVMAPTINT]->IsDefined() ) { params[ENVMAPTINT]->SetVecValue( 1.0f, 1.0f, 1.0f ); } if( !params[SELFILLUMTINT]->IsDefined() ) { params[SELFILLUMTINT]->SetVecValue( 1.0f, 1.0f, 1.0f ); } if( !params[DETAILSCALE]->IsDefined() ) { params[DETAILSCALE]->SetFloatValue( 4.0f ); } if( !params[DETAILBLENDFACTOR]->IsDefined() ) { params[DETAILBLENDFACTOR]->SetFloatValue( 1.0f ); } if( !params[FRESNELREFLECTION]->IsDefined() ) { params[FRESNELREFLECTION]->SetFloatValue( 1.0f ); } if( !params[ENVMAPMASKFRAME]->IsDefined() ) { params[ENVMAPMASKFRAME]->SetIntValue( 0 ); } if( !params[ENVMAPFRAME]->IsDefined() ) { params[ENVMAPFRAME]->SetIntValue( 0 ); } if( !params[BUMPFRAME]->IsDefined() ) { params[BUMPFRAME]->SetIntValue( 0 ); } if( !params[ENVMAPCONTRAST]->IsDefined() ) { params[ENVMAPCONTRAST]->SetFloatValue( 0.0f ); } if( !params[ENVMAPSATURATION]->IsDefined() ) { params[ENVMAPSATURATION]->SetFloatValue( 1.0f ); } if( !params[ALPHATESTREFERENCE]->IsDefined() ) { params[ALPHATESTREFERENCE]->SetFloatValue( 0.0f ); } // No texture means no self-illum or env mask in base alpha if ( !params[BASETEXTURE]->IsDefined() ) { CLEAR_FLAGS( MATERIAL_VAR_SELFILLUM ); CLEAR_FLAGS( MATERIAL_VAR_BASEALPHAENVMAPMASK ); } // If in decal mode, no debug override... if (IS_FLAG_SET(MATERIAL_VAR_DECAL)) { SET_FLAGS( MATERIAL_VAR_NO_DEBUG_OVERRIDE ); } SET_FLAGS2( MATERIAL_VAR2_LIGHTING_LIGHTMAP ); if( ShouldUseBumpmapping( params ) && (params[NODIFFUSEBUMPLIGHTING]->GetIntValue() == 0) ) { SET_FLAGS2( MATERIAL_VAR2_LIGHTING_BUMPED_LIGHTMAP ); } // Get rid of the envmap if it's optional for this dx level. if( params[ENVMAPOPTIONAL]->IsDefined() && (params[ENVMAPOPTIONAL]->GetIntValue() > g_pHardwareConfig->GetDXSupportLevel()) ) { params[ENVMAP]->SetUndefined(); } // If mat_specular 0, then get rid of envmap if( !g_pConfig->UseSpecular() && params[ENVMAP]->IsDefined() && params[BASETEXTURE]->IsDefined() ) { params[ENVMAP]->SetUndefined(); } if( params[SEAMLESS_SCALE]->IsDefined() && params[SEAMLESS_SCALE]->GetFloatValue() != 0.0f ) { if( params[BUMPMAP]->IsDefined() ) { Warning( "Can't use $bumpmap with $seamless_scale for lightmappedgeneric_dx8. Implicitly disabling $bumpmap: %s\n", pMaterialName ); params[BUMPMAP]->SetUndefined(); } if( params[ENVMAP]->IsDefined() ) { Warning( "Can't use $envmap with $seamless_scale for lightmappedgeneric_dx8. Implicitly disabling $envmap: %s\n", pMaterialName ); params[ENVMAP]->SetUndefined(); } } if ( !params[SEAMLESS_SCALE]->IsDefined() ) { // zero means don't do seamless mapping. params[SEAMLESS_SCALE]->SetFloatValue( 0.0f ); } // Get rid of envmap if we aren't using bumpmapping // *and* we have normalmapalphaenvmapmask *and* we don't have envmapmask elsewhere if ( params[ENVMAP]->IsDefined() && params[BUMPMAP]->IsDefined() && IS_FLAG_SET( MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK ) && !ShouldUseBumpmapping( params ) ) { if ( !IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK) && !params[ENVMAPMASK]->IsDefined() ) { params[ENVMAP]->SetUndefined(); } } }
void InitParamsLightmappedGeneric_DX9( CBaseVSShader *pShader, IMaterialVar** params, const char *pMaterialName, LightmappedGeneric_DX9_Vars_t &info ) { if ( g_pHardwareConfig->SupportsBorderColor() ) { params[FLASHLIGHTTEXTURE]->SetStringValue( "effects/flashlight_border" ); } else { params[FLASHLIGHTTEXTURE]->SetStringValue( "effects/flashlight001" ); } // Write over $basetexture with $albedo if we are going to be using diffuse normal mapping. if( g_pConfig->UseBumpmapping() && params[info.m_nBumpmap]->IsDefined() && params[info.m_nAlbedo]->IsDefined() && params[info.m_nBaseTexture]->IsDefined() && !( params[info.m_nNoDiffuseBumpLighting]->IsDefined() && params[info.m_nNoDiffuseBumpLighting]->GetIntValue() ) ) { params[info.m_nBaseTexture]->SetStringValue( params[info.m_nAlbedo]->GetStringValue() ); } if( pShader->IsUsingGraphics() && params[info.m_nEnvmap]->IsDefined() && !pShader->CanUseEditorMaterials() ) { if( stricmp( params[info.m_nEnvmap]->GetStringValue(), "env_cubemap" ) == 0 ) { Warning( "env_cubemap used on world geometry without rebuilding map. . ignoring: %s\n", pMaterialName ); params[info.m_nEnvmap]->SetUndefined(); } } if ( (mat_disable_lightwarp.GetBool() ) && (info.m_nLightWarpTexture != -1) ) { params[info.m_nLightWarpTexture]->SetUndefined(); } if ( (mat_disable_fancy_blending.GetBool() ) && (info.m_nBlendModulateTexture != -1) ) { params[info.m_nBlendModulateTexture]->SetUndefined(); } if( !params[info.m_nEnvmapTint]->IsDefined() ) params[info.m_nEnvmapTint]->SetVecValue( 1.0f, 1.0f, 1.0f ); if( !params[info.m_nNoDiffuseBumpLighting]->IsDefined() ) params[info.m_nNoDiffuseBumpLighting]->SetIntValue( 0 ); if( !params[info.m_nSelfIllumTint]->IsDefined() ) params[info.m_nSelfIllumTint]->SetVecValue( 1.0f, 1.0f, 1.0f ); if( !params[info.m_nDetailScale]->IsDefined() ) params[info.m_nDetailScale]->SetFloatValue( 4.0f ); if ( !params[info.m_nDetailTint]->IsDefined() ) params[info.m_nDetailTint]->SetVecValue( 1.0f, 1.0f, 1.0f, 1.0f ); InitFloatParam( info.m_nDetailTextureBlendFactor, params, 1.0 ); InitIntParam( info.m_nDetailTextureCombineMode, params, 0 ); if( !params[info.m_nFresnelReflection]->IsDefined() ) params[info.m_nFresnelReflection]->SetFloatValue( 1.0f ); if( !params[info.m_nEnvmapMaskFrame]->IsDefined() ) params[info.m_nEnvmapMaskFrame]->SetIntValue( 0 ); if( !params[info.m_nEnvmapFrame]->IsDefined() ) params[info.m_nEnvmapFrame]->SetIntValue( 0 ); if( !params[info.m_nBumpFrame]->IsDefined() ) params[info.m_nBumpFrame]->SetIntValue( 0 ); if( !params[info.m_nDetailFrame]->IsDefined() ) params[info.m_nDetailFrame]->SetIntValue( 0 ); if( !params[info.m_nEnvmapContrast]->IsDefined() ) params[info.m_nEnvmapContrast]->SetFloatValue( 0.0f ); if( !params[info.m_nEnvmapSaturation]->IsDefined() ) params[info.m_nEnvmapSaturation]->SetFloatValue( 1.0f ); InitFloatParam( info.m_nAlphaTestReference, params, 0.0f ); // No texture means no self-illum or env mask in base alpha if ( !params[info.m_nBaseTexture]->IsDefined() ) { CLEAR_FLAGS( MATERIAL_VAR_SELFILLUM ); CLEAR_FLAGS( MATERIAL_VAR_BASEALPHAENVMAPMASK ); } if( params[info.m_nBumpmap]->IsDefined() ) { params[info.m_nEnvmapMask]->SetUndefined(); } // If in decal mode, no debug override... if (IS_FLAG_SET(MATERIAL_VAR_DECAL)) { SET_FLAGS( MATERIAL_VAR_NO_DEBUG_OVERRIDE ); } SET_FLAGS2( MATERIAL_VAR2_LIGHTING_LIGHTMAP ); if( g_pConfig->UseBumpmapping() && params[info.m_nBumpmap]->IsDefined() && (params[info.m_nNoDiffuseBumpLighting]->GetIntValue() == 0) ) { SET_FLAGS2( MATERIAL_VAR2_LIGHTING_BUMPED_LIGHTMAP ); } // If mat_specular 0, then get rid of envmap if( !g_pConfig->UseSpecular() && params[info.m_nEnvmap]->IsDefined() && params[info.m_nBaseTexture]->IsDefined() ) { params[info.m_nEnvmap]->SetUndefined(); } if( !params[info.m_nBaseTextureNoEnvmap]->IsDefined() ) { params[info.m_nBaseTextureNoEnvmap]->SetIntValue( 0 ); } if( !params[info.m_nBaseTexture2NoEnvmap]->IsDefined() ) { params[info.m_nBaseTexture2NoEnvmap]->SetIntValue( 0 ); } if( ( info.m_nSelfShadowedBumpFlag != -1 ) && ( !params[info.m_nSelfShadowedBumpFlag]->IsDefined() ) ) { params[info.m_nSelfShadowedBumpFlag]->SetIntValue( 0 ); } // handle line art parms InitFloatParam( info.m_nEdgeSoftnessStart, params, 0.5 ); InitFloatParam( info.m_nEdgeSoftnessEnd, params, 0.5 ); InitFloatParam( info.m_nOutlineAlpha, params, 1.0 ); // Parallax cubemaps //cubemap parallax correction requires all 4 lines (if the 2nd, 3rd, or 4th are undef, undef the first one (checking done on first var) if (!(params[info.m_nEnvmapParallaxObb2]->IsDefined() && params[info.m_nEnvmapParallaxObb3]->IsDefined() && params[info.m_nEnvmapOrigin]->IsDefined())) { params[info.m_nEnvmapParallaxObb1]->SetUndefined(); } }
SHADER_INIT_PARAMS() { if( !params[DETAIL_ALPHA_MASK_BASE_TEXTURE]->IsDefined() ) { params[DETAIL_ALPHA_MASK_BASE_TEXTURE]->SetIntValue( 0 ); } params[FLASHLIGHTTEXTURE]->SetStringValue( GetFlashlightTextureFilename() ); // Write over $basetexture with $albedo if we are going to be using diffuse normal mapping. if( g_pConfig->UseBumpmapping() && params[BUMPMAP]->IsDefined() && params[ALBEDO]->IsDefined() && params[BASETEXTURE]->IsDefined() && !( params[NODIFFUSEBUMPLIGHTING]->IsDefined() && params[NODIFFUSEBUMPLIGHTING]->GetIntValue() ) ) { params[BASETEXTURE]->SetStringValue( params[ALBEDO]->GetStringValue() ); } if( !params[NODIFFUSEBUMPLIGHTING]->IsDefined() ) { params[NODIFFUSEBUMPLIGHTING]->SetIntValue( 0 ); } if( !params[SELFILLUMTINT]->IsDefined() ) { params[SELFILLUMTINT]->SetVecValue( 1.0f, 1.0f, 1.0f ); } if( !params[DETAILSCALE]->IsDefined() ) { params[DETAILSCALE]->SetFloatValue( 4.0f ); } if( !params[BUMPFRAME]->IsDefined() ) { params[BUMPFRAME]->SetIntValue( 0 ); } if( !params[DETAILFRAME]->IsDefined() ) { params[DETAILFRAME]->SetIntValue( 0 ); } // No texture means no self-illum or env mask in base alpha if ( !params[BASETEXTURE]->IsDefined() ) { CLEAR_FLAGS( MATERIAL_VAR_SELFILLUM ); CLEAR_FLAGS( MATERIAL_VAR_BASEALPHAENVMAPMASK ); } // If in decal mode, no debug override... if (IS_FLAG_SET(MATERIAL_VAR_DECAL)) { SET_FLAGS( MATERIAL_VAR_NO_DEBUG_OVERRIDE ); } SET_FLAGS2( MATERIAL_VAR2_LIGHTING_LIGHTMAP ); if( g_pConfig->UseBumpmapping() && params[BUMPMAP]->IsDefined() && (params[NODIFFUSEBUMPLIGHTING]->GetIntValue() == 0) ) { SET_FLAGS2( MATERIAL_VAR2_LIGHTING_BUMPED_LIGHTMAP ); } // srgb read 360 InitIntParam( SHADERSRGBREAD360, params, 0 ); }
void DrawPass( IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow, bool hasFlashlight, VertexCompressionType_t vertexCompression ) { bool bSinglePassFlashlight = false; bool hasBump = params[BUMPMAP]->IsTexture(); bool hasDiffuseBumpmap = hasBump && (params[NODIFFUSEBUMPLIGHTING]->GetIntValue() == 0); bool hasBaseTexture = params[BASETEXTURE]->IsTexture(); bool hasDetailTexture = /*!hasBump && */params[DETAIL]->IsTexture(); bool hasVertexColor = IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR ) != 0; bool bHasDetailAlpha = params[DETAIL_ALPHA_MASK_BASE_TEXTURE]->GetIntValue() != 0; bool bIsAlphaTested = IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ) != 0; BlendType_t nBlendType = EvaluateBlendRequirements( BASETEXTURE, true ); bool bFullyOpaque = (nBlendType != BT_BLENDADD) && (nBlendType != BT_BLEND) && !IS_FLAG_SET(MATERIAL_VAR_ALPHATEST); //dest alpha is free for special use bool bSeamlessMapping = params[SEAMLESS_SCALE]->GetFloatValue() != 0.0; bool bShaderSrgbRead = ( IsX360() && IS_PARAM_DEFINED( SHADERSRGBREAD360 ) && params[SHADERSRGBREAD360]->GetIntValue() ); SHADOW_STATE { int nShadowFilterMode = 0; // Alpha test: FIXME: shouldn't this be handled in Shader_t::SetInitialShadowState pShaderShadow->EnableAlphaTest( bIsAlphaTested ); if( hasFlashlight ) { if ( g_pHardwareConfig->SupportsPixelShaders_2_b() ) { nShadowFilterMode = g_pHardwareConfig->GetShadowFilterMode(); // Based upon vendor and device dependent formats } SetAdditiveBlendingShadowState( BASETEXTURE, true ); pShaderShadow->EnableDepthWrites( false ); // Be sure not to write to dest alpha pShaderShadow->EnableAlphaWrites( false ); } else { SetDefaultBlendingShadowState( BASETEXTURE, true ); } unsigned int flags = VERTEX_POSITION; if( hasBaseTexture ) { pShaderShadow->EnableTexture( SHADER_SAMPLER0, true ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, !bShaderSrgbRead ); } // if( hasLightmap ) { pShaderShadow->EnableTexture( SHADER_SAMPLER1, true ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER1, true ); } if( hasFlashlight ) { pShaderShadow->EnableTexture( SHADER_SAMPLER2, true ); pShaderShadow->EnableTexture( SHADER_SAMPLER7, true ); pShaderShadow->SetShadowDepthFiltering( SHADER_SAMPLER7 ); flags |= VERTEX_TANGENT_S | VERTEX_TANGENT_T | VERTEX_NORMAL; } if( hasDetailTexture ) { pShaderShadow->EnableTexture( SHADER_SAMPLER3, true ); } if( hasBump ) { pShaderShadow->EnableTexture( SHADER_SAMPLER4, true ); } if( hasVertexColor ) { flags |= VERTEX_COLOR; } // Normalizing cube map pShaderShadow->EnableTexture( SHADER_SAMPLER6, true ); // texcoord0 : base texcoord // texcoord1 : lightmap texcoord // texcoord2 : lightmap texcoord offset int numTexCoords = 2; if( hasBump ) { numTexCoords = 3; } pShaderShadow->VertexShaderVertexFormat( flags, numTexCoords, 0, 0 ); // Pre-cache pixel shaders bool hasSelfIllum = IS_FLAG_SET( MATERIAL_VAR_SELFILLUM ); pShaderShadow->EnableSRGBWrite( true ); int nLightingPreviewMode = IS_FLAG2_SET( MATERIAL_VAR2_USE_GBUFFER0 ) + 2 * IS_FLAG2_SET( MATERIAL_VAR2_USE_GBUFFER1 ); #ifndef _X360 if ( g_pHardwareConfig->HasFastVertexTextures() ) { DECLARE_STATIC_VERTEX_SHADER( lightmappedgeneric_vs30 ); SET_STATIC_VERTEX_SHADER_COMBO( ENVMAP_MASK, false ); SET_STATIC_VERTEX_SHADER_COMBO( BUMPMASK, false ); SET_STATIC_VERTEX_SHADER_COMBO( TANGENTSPACE, hasFlashlight ); SET_STATIC_VERTEX_SHADER_COMBO( BUMPMAP, hasBump ); SET_STATIC_VERTEX_SHADER_COMBO( DIFFUSEBUMPMAP, hasDiffuseBumpmap ); SET_STATIC_VERTEX_SHADER_COMBO( VERTEXCOLOR, hasVertexColor ); SET_STATIC_VERTEX_SHADER_COMBO( VERTEXALPHATEXBLENDFACTOR, false ); SET_STATIC_VERTEX_SHADER_COMBO( PARALLAX_MAPPING, 0 ); //( bumpmap_variant == 2 )?1:0); SET_STATIC_VERTEX_SHADER_COMBO( SEAMLESS, bSeamlessMapping ); //( bumpmap_variant == 2 )?1:0); SET_STATIC_VERTEX_SHADER_COMBO( DETAILTEXTURE, hasDetailTexture ); SET_STATIC_VERTEX_SHADER_COMBO( SELFILLUM, hasSelfIllum ); SET_STATIC_VERTEX_SHADER_COMBO( FANCY_BLENDING, false ); SET_STATIC_VERTEX_SHADER_COMBO( LIGHTING_PREVIEW, nLightingPreviewMode != 0 ); SET_STATIC_VERTEX_SHADER( lightmappedgeneric_vs30 ); } else #endif { DECLARE_STATIC_VERTEX_SHADER( lightmappedgeneric_vs20 ); SET_STATIC_VERTEX_SHADER_COMBO( ENVMAP_MASK, false ); SET_STATIC_VERTEX_SHADER_COMBO( BUMPMASK, false ); SET_STATIC_VERTEX_SHADER_COMBO( TANGENTSPACE, hasFlashlight ); SET_STATIC_VERTEX_SHADER_COMBO( BUMPMAP, hasBump ); SET_STATIC_VERTEX_SHADER_COMBO( DIFFUSEBUMPMAP, hasDiffuseBumpmap ); SET_STATIC_VERTEX_SHADER_COMBO( VERTEXCOLOR, hasVertexColor ); SET_STATIC_VERTEX_SHADER_COMBO( VERTEXALPHATEXBLENDFACTOR, false ); SET_STATIC_VERTEX_SHADER_COMBO( PARALLAX_MAPPING, 0 ); //( bumpmap_variant == 2 )?1:0); SET_STATIC_VERTEX_SHADER_COMBO( SEAMLESS, bSeamlessMapping ); //( bumpmap_variant == 2 )?1:0); SET_STATIC_VERTEX_SHADER_COMBO( DETAILTEXTURE, hasDetailTexture ); SET_STATIC_VERTEX_SHADER_COMBO( SELFILLUM, hasSelfIllum ); SET_STATIC_VERTEX_SHADER_COMBO( FANCY_BLENDING, false ); SET_STATIC_VERTEX_SHADER_COMBO( LIGHTING_PREVIEW, nLightingPreviewMode != 0 ); #ifdef _X360 SET_STATIC_VERTEX_SHADER_COMBO( FLASHLIGHT, hasFlashlight ); #endif SET_STATIC_VERTEX_SHADER( lightmappedgeneric_vs20 ); } #ifndef _X360 if ( g_pHardwareConfig->HasFastVertexTextures() ) { DECLARE_STATIC_PIXEL_SHADER( worldtwotextureblend_ps30 ); SET_STATIC_PIXEL_SHADER_COMBO( DETAILTEXTURE, hasDetailTexture ); SET_STATIC_PIXEL_SHADER_COMBO( BUMPMAP, hasBump ); SET_STATIC_PIXEL_SHADER_COMBO( DIFFUSEBUMPMAP, hasDiffuseBumpmap ); SET_STATIC_PIXEL_SHADER_COMBO( VERTEXCOLOR, hasVertexColor ); SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM, hasSelfIllum ); SET_STATIC_PIXEL_SHADER_COMBO( DETAIL_ALPHA_MASK_BASE_TEXTURE, bHasDetailAlpha ); SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHT, hasFlashlight ); SET_STATIC_PIXEL_SHADER_COMBO( SEAMLESS, bSeamlessMapping ); SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHTDEPTHFILTERMODE, nShadowFilterMode ); SET_STATIC_PIXEL_SHADER_COMBO( SHADER_SRGB_READ, bShaderSrgbRead ); SET_STATIC_PIXEL_SHADER( worldtwotextureblend_ps30 ); } else #endif if ( g_pHardwareConfig->SupportsPixelShaders_2_b() ) { DECLARE_STATIC_PIXEL_SHADER( worldtwotextureblend_ps20b ); SET_STATIC_PIXEL_SHADER_COMBO( DETAILTEXTURE, hasDetailTexture ); SET_STATIC_PIXEL_SHADER_COMBO( BUMPMAP, hasBump ); SET_STATIC_PIXEL_SHADER_COMBO( DIFFUSEBUMPMAP, hasDiffuseBumpmap ); SET_STATIC_PIXEL_SHADER_COMBO( VERTEXCOLOR, hasVertexColor ); SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM, hasSelfIllum ); SET_STATIC_PIXEL_SHADER_COMBO( DETAIL_ALPHA_MASK_BASE_TEXTURE, bHasDetailAlpha ); SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHT, hasFlashlight ); SET_STATIC_PIXEL_SHADER_COMBO( SEAMLESS, bSeamlessMapping ); SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHTDEPTHFILTERMODE, nShadowFilterMode ); SET_STATIC_PIXEL_SHADER_COMBO( SHADER_SRGB_READ, bShaderSrgbRead ); SET_STATIC_PIXEL_SHADER( worldtwotextureblend_ps20b ); } else { DECLARE_STATIC_PIXEL_SHADER( worldtwotextureblend_ps20 ); SET_STATIC_PIXEL_SHADER_COMBO( DETAILTEXTURE, hasDetailTexture ); SET_STATIC_PIXEL_SHADER_COMBO( BUMPMAP, hasBump ); SET_STATIC_PIXEL_SHADER_COMBO( DIFFUSEBUMPMAP, hasDiffuseBumpmap ); SET_STATIC_PIXEL_SHADER_COMBO( VERTEXCOLOR, hasVertexColor ); SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM, hasSelfIllum ); SET_STATIC_PIXEL_SHADER_COMBO( DETAIL_ALPHA_MASK_BASE_TEXTURE, bHasDetailAlpha ); SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHT, hasFlashlight ); SET_STATIC_PIXEL_SHADER_COMBO( SEAMLESS, bSeamlessMapping ); SET_STATIC_PIXEL_SHADER_COMBO( SHADER_SRGB_READ, bShaderSrgbRead ); SET_STATIC_PIXEL_SHADER( worldtwotextureblend_ps20 ); } // HACK HACK HACK - enable alpha writes all the time so that we have them for // underwater stuff. // But only do it if we're not using the alpha already for translucency pShaderShadow->EnableAlphaWrites( bFullyOpaque ); if( hasFlashlight ) { FogToBlack(); } else { DefaultFog(); } PI_BeginCommandBuffer(); PI_SetModulationVertexShaderDynamicState( ); PI_EndCommandBuffer(); } DYNAMIC_STATE { if( hasBaseTexture ) { BindTexture( SHADER_SAMPLER0, BASETEXTURE, FRAME ); } else { pShaderAPI->BindStandardTexture( SHADER_SAMPLER0, TEXTURE_WHITE ); } // if( hasLightmap ) { pShaderAPI->BindStandardTexture( SHADER_SAMPLER1, TEXTURE_LIGHTMAP ); } bool bFlashlightShadows = false; bool bUberlight = false; if( hasFlashlight ) { VMatrix worldToTexture; ITexture *pFlashlightDepthTexture; FlashlightState_t state = pShaderAPI->GetFlashlightStateEx( worldToTexture, &pFlashlightDepthTexture ); bFlashlightShadows = state.m_bEnableShadows; bUberlight = state.m_bUberlight; SetFlashLightColorFromState( state, pShaderAPI, bSinglePassFlashlight ); BindTexture( SHADER_SAMPLER2, state.m_pSpotlightTexture, state.m_nSpotlightTextureFrame ); if( pFlashlightDepthTexture && g_pConfig->ShadowDepthTexture() ) { BindTexture( SHADER_SAMPLER7, pFlashlightDepthTexture ); } } if( hasDetailTexture ) { BindTexture( SHADER_SAMPLER3, DETAIL, DETAILFRAME ); } if( hasBump ) { if( !g_pConfig->m_bFastNoBump ) { BindTexture( SHADER_SAMPLER4, BUMPMAP, BUMPFRAME ); } else { pShaderAPI->BindStandardTexture( SHADER_SAMPLER4, TEXTURE_NORMALMAP_FLAT ); } } pShaderAPI->BindStandardTexture( SHADER_SAMPLER6, TEXTURE_NORMALIZATION_CUBEMAP_SIGNED ); // If we don't have a texture transform, we don't have // to set vertex shader constants or run vertex shader instructions // for the texture transform. bool bHasTextureTransform = !( params[BASETEXTURETRANSFORM]->MatrixIsIdentity() && params[BUMPTRANSFORM]->MatrixIsIdentity() ); bool bVertexShaderFastPath = !bHasTextureTransform; if( params[DETAIL]->IsTexture() ) { bVertexShaderFastPath = false; } if( pShaderAPI->GetIntRenderingParameter(INT_RENDERPARM_ENABLE_FIXED_LIGHTING) != 0 ) { bVertexShaderFastPath = false; } if( !bVertexShaderFastPath ) { if ( !bSeamlessMapping ) { SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, BASETEXTURETRANSFORM ); } if( hasBump && !bHasDetailAlpha ) { SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, BUMPTRANSFORM ); Assert( !hasDetailTexture ); } } MaterialFogMode_t fogType = pShaderAPI->GetSceneFogMode(); if ( IsPC() ) { bool bWorldNormal = pShaderAPI->GetIntRenderingParameter( INT_RENDERPARM_ENABLE_FIXED_LIGHTING ) == ENABLE_FIXED_LIGHTING_OUTPUTNORMAL_AND_DEPTH; if ( bWorldNormal ) { float vEyeDir[4]; pShaderAPI->GetWorldSpaceCameraDirection( vEyeDir ); float flFarZ = pShaderAPI->GetFarZ(); vEyeDir[0] /= flFarZ; // Divide by farZ for SSAO algorithm vEyeDir[1] /= flFarZ; vEyeDir[2] /= flFarZ; pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_12, vEyeDir ); } } #ifndef _X360 if (g_pHardwareConfig->HasFastVertexTextures() ) { DECLARE_DYNAMIC_VERTEX_SHADER( lightmappedgeneric_vs30 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( FASTPATH, bVertexShaderFastPath ); SET_DYNAMIC_VERTEX_SHADER( lightmappedgeneric_vs30 ); } else #endif { DECLARE_DYNAMIC_VERTEX_SHADER( lightmappedgeneric_vs20 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( FASTPATH, bVertexShaderFastPath ); SET_DYNAMIC_VERTEX_SHADER( lightmappedgeneric_vs20 ); } bool bWriteDepthToAlpha; bool bWriteWaterFogToAlpha; 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." ); } else { //can't write a special value to dest alpha if we're actually using as-intended alpha bWriteDepthToAlpha = false; bWriteWaterFogToAlpha = false; } #ifndef _X360 if ( g_pHardwareConfig->HasFastVertexTextures() ) { DECLARE_DYNAMIC_PIXEL_SHADER( worldtwotextureblend_ps30 ); // Don't write fog to alpha if we're using translucency SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITEWATERFOGTODESTALPHA, bWriteWaterFogToAlpha ); SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITE_DEPTH_TO_DESTALPHA, bWriteDepthToAlpha ); SET_DYNAMIC_PIXEL_SHADER_COMBO( FLASHLIGHTSHADOWS, bFlashlightShadows ); SET_DYNAMIC_PIXEL_SHADER_COMBO( UBERLIGHT, bUberlight ); SET_DYNAMIC_PIXEL_SHADER( worldtwotextureblend_ps30 ); } else #endif if ( g_pHardwareConfig->SupportsPixelShaders_2_b() ) { DECLARE_DYNAMIC_PIXEL_SHADER( worldtwotextureblend_ps20b ); // Don't write fog to alpha if we're using translucency SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITEWATERFOGTODESTALPHA, bWriteWaterFogToAlpha ); SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITE_DEPTH_TO_DESTALPHA, bWriteDepthToAlpha ); SET_DYNAMIC_PIXEL_SHADER_COMBO( FLASHLIGHTSHADOWS, bFlashlightShadows ); SET_DYNAMIC_PIXEL_SHADER( worldtwotextureblend_ps20b ); } else { DECLARE_DYNAMIC_PIXEL_SHADER( worldtwotextureblend_ps20 ); // Don't write fog to alpha if we're using translucency SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITEWATERFOGTODESTALPHA, (fogType == MATERIAL_FOG_LINEAR_BELOW_FOG_Z) && (nBlendType != BT_BLENDADD) && (nBlendType != BT_BLEND) && !bIsAlphaTested ); SET_DYNAMIC_PIXEL_SHADER( worldtwotextureblend_ps20 ); } // always set the transform for detail textures since I'm assuming that you'll // always have a detailscale. if( hasDetailTexture ) { SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, BASETEXTURETRANSFORM, DETAILSCALE ); Assert( !( hasBump && !bHasDetailAlpha ) ); } SetPixelShaderConstantGammaToLinear( 7, SELFILLUMTINT ); float eyePos[4]; pShaderAPI->GetWorldSpaceCameraPosition( eyePos ); pShaderAPI->SetPixelShaderConstant( 10, eyePos, 1 ); pShaderAPI->SetPixelShaderFogParams( 11 ); if ( bSeamlessMapping ) { float map_scale[4]={ params[SEAMLESS_SCALE]->GetFloatValue(),0,0,0}; pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, map_scale ); } if( hasFlashlight ) { VMatrix worldToTexture; const FlashlightState_t &flashlightState = pShaderAPI->GetFlashlightState( worldToTexture ); // Set the flashlight attenuation factors float atten[4]; atten[0] = flashlightState.m_fConstantAtten; atten[1] = flashlightState.m_fLinearAtten; atten[2] = flashlightState.m_fQuadraticAtten; atten[3] = flashlightState.m_FarZAtten; pShaderAPI->SetPixelShaderConstant( 20, atten, 1 ); // Set the flashlight origin float pos[4]; pos[0] = flashlightState.m_vecLightOrigin[0]; pos[1] = flashlightState.m_vecLightOrigin[1]; pos[2] = flashlightState.m_vecLightOrigin[2]; pos[3] = flashlightState.m_FarZ; // didn't have this in main. . probably need this? pShaderAPI->SetPixelShaderConstant( 15, pos, 1 ); pShaderAPI->SetPixelShaderConstant( 16, worldToTexture.Base(), 4 ); if ( IsPC() && g_pHardwareConfig->HasFastVertexTextures() ) { SetupUberlightFromState( pShaderAPI, flashlightState ); } } } Draw(); }
void Draw_Eyes_Refract_Internal( CBaseVSShader *pShader, IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow, bool bDrawFlashlightAdditivePass, Eye_Refract_Vars_t &info, VertexCompressionType_t vertexCompression ) { bool bDiffuseWarp = IS_PARAM_DEFINED( info.m_nDiffuseWarpTexture ); bool bIntro = IS_PARAM_DEFINED( info.m_nIntro ) ? ( params[info.m_nIntro]->GetIntValue() ? true : false ) : false; SHADOW_STATE { SET_FLAGS2( MATERIAL_VAR2_LIGHTING_VERTEX_LIT ); pShaderShadow->EnableTexture( SHADER_SAMPLER0, true ); // Cornea normal pShaderShadow->EnableTexture( SHADER_SAMPLER1, true ); // Iris pShaderShadow->EnableTexture( SHADER_SAMPLER2, true ); // Cube reflection pShaderShadow->EnableTexture( SHADER_SAMPLER3, true ); // Ambient occlusion // Set stream format (note that this shader supports compression) unsigned int flags = VERTEX_POSITION | VERTEX_NORMAL | VERTEX_FORMAT_COMPRESSED; int nTexCoordCount = 1; int userDataSize = 0; pShaderShadow->VertexShaderVertexFormat( flags, nTexCoordCount, NULL, userDataSize ); if ( bDiffuseWarp ) { pShaderShadow->EnableTexture( SHADER_SAMPLER4, true ); // Light warp } #if !defined( PLATFORM_X360 ) bool bWorldNormal = ( ENABLE_FIXED_LIGHTING_OUTPUTNORMAL_AND_DEPTH == ( IS_FLAG2_SET( MATERIAL_VAR2_USE_GBUFFER0 ) + 2 * IS_FLAG2_SET( MATERIAL_VAR2_USE_GBUFFER1 ))); #endif int nShadowFilterMode = 0; if ( bDrawFlashlightAdditivePass == true ) { if ( g_pHardwareConfig->SupportsPixelShaders_2_b() ) { nShadowFilterMode = g_pHardwareConfig->GetShadowFilterMode(); // Based upon vendor and device dependent formats } pShaderShadow->EnableDepthWrites( false ); pShaderShadow->EnableAlphaWrites( false ); pShader->EnableAlphaBlending( SHADER_BLEND_ONE, SHADER_BLEND_ONE ); // Additive blending pShaderShadow->EnableTexture( SHADER_SAMPLER5, true ); // Flashlight cookie } else { pShaderShadow->EnableAlphaWrites( true ); } #ifndef _X360 if ( !g_pHardwareConfig->HasFastVertexTextures() ) #endif { DECLARE_STATIC_VERTEX_SHADER( eye_refract_vs20 ); SET_STATIC_VERTEX_SHADER_COMBO( HALFLAMBERT, IS_FLAG_SET( MATERIAL_VAR_HALFLAMBERT ) ); SET_STATIC_VERTEX_SHADER_COMBO( INTRO, bIntro ? 1 : 0 ); SET_STATIC_VERTEX_SHADER_COMBO( FLASHLIGHT, bDrawFlashlightAdditivePass ? 1 : 0 ); SET_STATIC_VERTEX_SHADER_COMBO( LIGHTWARPTEXTURE, bDiffuseWarp ? 1 : 0 ); SET_STATIC_VERTEX_SHADER_COMBO( WORLD_NORMAL, 0 ); SET_STATIC_VERTEX_SHADER( eye_refract_vs20 ); if ( g_pHardwareConfig->SupportsPixelShaders_2_b() ) { bool bSphereTexKillCombo = IS_PARAM_DEFINED( info.m_nSphereTexKillCombo ) ? ( params[info.m_nSphereTexKillCombo]->GetIntValue() ? true : false ) : ( kDefaultSphereTexKillCombo ? true : false ); bool bRayTraceSphere = IS_PARAM_DEFINED( info.m_nRaytraceSphere ) ? ( params[info.m_nRaytraceSphere]->GetIntValue() ? true : false ) : ( kDefaultRaytraceSphere ? true : false ); DECLARE_STATIC_PIXEL_SHADER( eye_refract_ps20b ); SET_STATIC_PIXEL_SHADER_COMBO( SPHERETEXKILLCOMBO, bSphereTexKillCombo ? 1 : 0 ); SET_STATIC_PIXEL_SHADER_COMBO( RAYTRACESPHERE, bRayTraceSphere ? 1 : 0 ); SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHT, bDrawFlashlightAdditivePass ? 1 : 0 ); SET_STATIC_PIXEL_SHADER_COMBO( LIGHTWARPTEXTURE, bDiffuseWarp ? 1 : 0 ); SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHTDEPTHFILTERMODE, nShadowFilterMode ); SET_STATIC_PIXEL_SHADER_COMBO( WORLD_NORMAL, 0 ); SET_STATIC_PIXEL_SHADER( eye_refract_ps20b ); if ( bDrawFlashlightAdditivePass == true ) { pShaderShadow->EnableTexture( SHADER_SAMPLER6, true ); // Shadow depth map pShaderShadow->SetShadowDepthFiltering( SHADER_SAMPLER6 ); pShaderShadow->EnableTexture( SHADER_SAMPLER7, true ); // Noise map } } else { DECLARE_STATIC_PIXEL_SHADER( eye_refract_ps20 ); SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHT, bDrawFlashlightAdditivePass ? 1 : 0 ); SET_STATIC_PIXEL_SHADER_COMBO( LIGHTWARPTEXTURE, bDiffuseWarp ? 1 : 0 ); SET_STATIC_PIXEL_SHADER_COMBO( WORLD_NORMAL, 0 ); SET_STATIC_PIXEL_SHADER( eye_refract_ps20 ); } } #ifndef _X360 else { pShaderShadow->EnableTexture( SHADER_SAMPLER8, true ); // Screen space ambient occlusion // The vertex shader uses the vertex id stream SET_FLAGS2( MATERIAL_VAR2_USES_VERTEXID ); SET_FLAGS2( MATERIAL_VAR2_SUPPORTS_TESSELLATION ); DECLARE_STATIC_VERTEX_SHADER( eye_refract_vs30 ); SET_STATIC_VERTEX_SHADER_COMBO( HALFLAMBERT, IS_FLAG_SET( MATERIAL_VAR_HALFLAMBERT ) ); SET_STATIC_VERTEX_SHADER_COMBO( INTRO, bIntro ? 1 : 0 ); SET_STATIC_VERTEX_SHADER_COMBO( FLASHLIGHT, bDrawFlashlightAdditivePass ? 1 : 0 ); SET_STATIC_VERTEX_SHADER_COMBO( LIGHTWARPTEXTURE, bDiffuseWarp ? 1 : 0 ); SET_STATIC_VERTEX_SHADER_COMBO( WORLD_NORMAL, bWorldNormal ); SET_STATIC_VERTEX_SHADER( eye_refract_vs30 ); bool bSphereTexKillCombo = IS_PARAM_DEFINED( info.m_nSphereTexKillCombo ) ? ( params[info.m_nSphereTexKillCombo]->GetIntValue() ? true : false ) : ( kDefaultSphereTexKillCombo ? true : false ); bool bRayTraceSphere = IS_PARAM_DEFINED( info.m_nRaytraceSphere ) ? ( params[info.m_nRaytraceSphere]->GetIntValue() ? true : false ) : ( kDefaultRaytraceSphere ? true : false ); DECLARE_STATIC_PIXEL_SHADER( eye_refract_ps30 ); SET_STATIC_PIXEL_SHADER_COMBO( SPHERETEXKILLCOMBO, bSphereTexKillCombo ? 1 : 0 ); SET_STATIC_PIXEL_SHADER_COMBO( RAYTRACESPHERE, bRayTraceSphere ? 1 : 0 ); SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHT, bDrawFlashlightAdditivePass ? 1 : 0 ); SET_STATIC_PIXEL_SHADER_COMBO( LIGHTWARPTEXTURE, bDiffuseWarp ? 1 : 0 ); SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHTDEPTHFILTERMODE, nShadowFilterMode ); SET_STATIC_PIXEL_SHADER_COMBO( WORLD_NORMAL, bWorldNormal ); SET_STATIC_PIXEL_SHADER( eye_refract_ps30 ); if ( bDrawFlashlightAdditivePass == true ) { pShaderShadow->EnableTexture( SHADER_SAMPLER6, true ); // Shadow depth map pShaderShadow->EnableTexture( SHADER_SAMPLER7, true ); // Noise map } } #endif // On DX9, get the gamma read and write correct //pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, false ); // Cornea normal pShaderShadow->EnableSRGBRead( SHADER_SAMPLER1, true ); // Iris pShaderShadow->EnableSRGBRead( SHADER_SAMPLER2, true ); // Cube map reflection pShaderShadow->EnableSRGBRead( SHADER_SAMPLER3, true ); // Ambient occlusion pShaderShadow->EnableSRGBWrite( true ); if ( bDiffuseWarp ) { pShaderShadow->EnableSRGBRead( SHADER_SAMPLER4, true ); // Light Warp } if ( bDrawFlashlightAdditivePass == true ) { pShaderShadow->EnableSRGBRead( SHADER_SAMPLER5, true ); // Flashlight cookie } // Fog if ( bDrawFlashlightAdditivePass == true ) { pShader->FogToBlack(); } else { pShader->FogToFogColor(); } // Per-instance state pShader->PI_BeginCommandBuffer(); if ( !bDrawFlashlightAdditivePass ) { pShader->PI_SetPixelShaderLocalLighting( PSREG_LIGHT_INFO_ARRAY ); } pShader->PI_SetVertexShaderAmbientLightCube(); pShader->PI_SetPixelShaderAmbientLightCubeLuminance( 10 ); pShader->PI_EndCommandBuffer(); } DYNAMIC_STATE { VMatrix worldToTexture; ITexture *pFlashlightDepthTexture = NULL; FlashlightState_t flashlightState; bool bFlashlightShadows = false; if ( bDrawFlashlightAdditivePass == true ) { flashlightState = pShaderAPI->GetFlashlightStateEx( worldToTexture, &pFlashlightDepthTexture ); bFlashlightShadows = flashlightState.m_bEnableShadows; } bool bSinglePassFlashlight = false; pShader->BindTexture( SHADER_SAMPLER0, info.m_nCorneaTexture ); pShader->BindTexture( SHADER_SAMPLER1, info.m_nIris, info.m_nIrisFrame ); pShader->BindTexture( SHADER_SAMPLER2, info.m_nEnvmap ); pShader->BindTexture( SHADER_SAMPLER3, info.m_nAmbientOcclTexture ); if ( bDiffuseWarp ) { if ( r_lightwarpidentity.GetBool() ) { pShaderAPI->BindStandardTexture( SHADER_SAMPLER4, TEXTURE_IDENTITY_LIGHTWARP ); } else { pShader->BindTexture( SHADER_SAMPLER4, info.m_nDiffuseWarpTexture ); } } // On PC, we sample from ambient occlusion texture if ( IsPC() && g_pHardwareConfig->HasFastVertexTextures() ) { ITexture *pAOTexture = pShaderAPI->GetTextureRenderingParameter( TEXTURE_RENDERPARM_AMBIENT_OCCLUSION ); if ( pAOTexture ) { pShader->BindTexture( SHADER_SAMPLER8, pAOTexture ); } else { pShaderAPI->BindStandardTexture( SHADER_SAMPLER8, TEXTURE_WHITE ); } } if ( bDrawFlashlightAdditivePass == true ) pShader->BindTexture( SHADER_SAMPLER5, flashlightState.m_pSpotlightTexture, flashlightState.m_nSpotlightTextureFrame ); pShader->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, info.m_nEyeOrigin ); pShader->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, info.m_nIrisU ); pShader->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_3, info.m_nIrisV ); if ( bDrawFlashlightAdditivePass == true ) pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_4, flashlightState.m_vecLightOrigin.Base(), 1 ); LightState_t lightState = { 0, false, false }; if ( bDrawFlashlightAdditivePass == false ) { pShaderAPI->GetDX9LightState( &lightState ); } int nFixedLightingMode = pShaderAPI->GetIntRenderingParameter( INT_RENDERPARM_ENABLE_FIXED_LIGHTING ); #ifndef _X360 if ( !g_pHardwareConfig->HasFastVertexTextures() ) #endif { DECLARE_DYNAMIC_VERTEX_SHADER( eye_refract_vs20 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, pShaderAPI->GetCurrentNumBones() > 0 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( DYNAMIC_LIGHT, lightState.HasDynamicLight() ); SET_DYNAMIC_VERTEX_SHADER_COMBO( NUM_LIGHTS, lightState.m_nNumLights ); SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (int)vertexCompression ); SET_DYNAMIC_VERTEX_SHADER_COMBO( TESSELLATION, 0 ); SET_DYNAMIC_VERTEX_SHADER( eye_refract_vs20 ); } #ifndef _X360 else { pShader->SetHWMorphVertexShaderState( VERTEX_SHADER_SHADER_SPECIFIC_CONST_10, VERTEX_SHADER_SHADER_SPECIFIC_CONST_11, SHADER_VERTEXTEXTURE_SAMPLER0 ); if ( nFixedLightingMode == ENABLE_FIXED_LIGHTING_OUTPUTNORMAL_AND_DEPTH ) { float vEyeDir[4]; pShaderAPI->GetWorldSpaceCameraDirection( vEyeDir ); float flFarZ = pShaderAPI->GetFarZ(); vEyeDir[0] /= flFarZ; // Divide by farZ for SSAO algorithm vEyeDir[1] /= flFarZ; vEyeDir[2] /= flFarZ; pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_5, vEyeDir ); } TessellationMode_t nTessellationMode = pShaderAPI->GetTessellationMode(); if ( nTessellationMode != TESSELLATION_MODE_DISABLED ) { pShaderAPI->BindStandardVertexTexture( SHADER_VERTEXTEXTURE_SAMPLER1, TEXTURE_SUBDIVISION_PATCHES ); bool bHasDisplacement = false; // TODO float vSubDDimensions[4] = { 1.0f/pShaderAPI->GetSubDHeight(), bHasDisplacement && mat_displacementmap.GetBool() ? 1.0f : 0.0f, 0.0f, 0.0f }; pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_1, vSubDDimensions ); } DECLARE_DYNAMIC_VERTEX_SHADER( eye_refract_vs30 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, pShaderAPI->GetCurrentNumBones() > 0 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( DYNAMIC_LIGHT, lightState.HasDynamicLight() ); SET_DYNAMIC_VERTEX_SHADER_COMBO( NUM_LIGHTS, lightState.m_nNumLights ); SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (int)vertexCompression ); SET_DYNAMIC_VERTEX_SHADER_COMBO( TESSELLATION, nTessellationMode ); SET_DYNAMIC_VERTEX_SHADER( eye_refract_vs30 ); } #endif // Special constant for DX9 eyes: { Dilation, Glossiness, x, x }; float vPSConst[4] = { 0.0f, 0.0f, 0.0f, 0.0f }; vPSConst[0] = IS_PARAM_DEFINED( info.m_nDilation ) ? params[info.m_nDilation]->GetFloatValue() : kDefaultDilation; vPSConst[1] = IS_PARAM_DEFINED( info.m_nGlossiness ) ? params[info.m_nGlossiness]->GetFloatValue() : kDefaultGlossiness; vPSConst[2] = 0.0f; // NOT USED vPSConst[3] = IS_PARAM_DEFINED( info.m_nCorneaBumpStrength ) ? params[info.m_nCorneaBumpStrength]->GetFloatValue() : kDefaultCorneaBumpStrength; pShaderAPI->SetPixelShaderConstant( 0, vPSConst, 1 ); pShaderAPI->SetPixelShaderConstant( 1, IS_PARAM_DEFINED( info.m_nEyeOrigin ) ? params[info.m_nEyeOrigin]->GetVecValue() : kDefaultEyeOrigin, 1 ); pShaderAPI->SetPixelShaderConstant( 2, IS_PARAM_DEFINED( info.m_nIrisU ) ? params[info.m_nIrisU]->GetVecValue() : kDefaultIrisU, 1 ); pShaderAPI->SetPixelShaderConstant( 3, IS_PARAM_DEFINED( info.m_nIrisV ) ? params[info.m_nIrisV]->GetVecValue() : kDefaultIrisV, 1 ); float vEyePos[4] = { 0.0f, 0.0f, 0.0f, 0.0f }; pShaderAPI->GetWorldSpaceCameraPosition( vEyePos ); pShaderAPI->SetPixelShaderConstant( 4, vEyePos, 1 ); float vAmbientOcclusion[4] = { 0.33f, 0.33f, 0.33f, 0.0f }; if ( IS_PARAM_DEFINED( info.m_nAmbientOcclColor ) ) { params[info.m_nAmbientOcclColor]->GetVecValue( vAmbientOcclusion, 3 ); } vAmbientOcclusion[3] = IS_PARAM_DEFINED( info.m_nAmbientOcclusion ) ? params[info.m_nAmbientOcclusion]->GetFloatValue() : 0.0f; float vPackedConst6[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; //vPackedConst6[0] Unused vPackedConst6[1] = IS_PARAM_DEFINED( info.m_nEyeballRadius ) ? params[info.m_nEyeballRadius]->GetFloatValue() : kDefaultEyeballRadius; //vPackedConst6[2] = IS_PARAM_DEFINED( info.m_nRaytraceSphere ) ? params[info.m_nRaytraceSphere]->GetFloatValue() : kDefaultRaytraceSphere; vPackedConst6[3] = IS_PARAM_DEFINED( info.m_nParallaxStrength ) ? params[info.m_nParallaxStrength]->GetFloatValue() : kDefaultParallaxStrength; pShaderAPI->SetPixelShaderConstant( 6, vPackedConst6, 1 ); if ( bDrawFlashlightAdditivePass == true ) { SetFlashLightColorFromState( flashlightState, pShaderAPI, bSinglePassFlashlight ); if ( pFlashlightDepthTexture && g_pConfig->ShadowDepthTexture() && flashlightState.m_bEnableShadows ) { pShader->BindTexture( SHADER_SAMPLER6, pFlashlightDepthTexture, 0 ); pShaderAPI->BindStandardTexture( SHADER_SAMPLER7, TEXTURE_SHADOW_NOISE_2D ); } } if ( nFixedLightingMode == ENABLE_FIXED_LIGHTING_OUTPUTNORMAL_AND_DEPTH ) { float vEyeDir[4]; pShaderAPI->GetWorldSpaceCameraDirection( vEyeDir ); float flFarZ = pShaderAPI->GetFarZ(); vEyeDir[0] /= flFarZ; // Divide by farZ for SSAO algorithm vEyeDir[1] /= flFarZ; vEyeDir[2] /= flFarZ; pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_5, vEyeDir ); } // Flashlight tax #ifndef _X360 if ( !g_pHardwareConfig->HasFastVertexTextures() ) #endif { if ( g_pHardwareConfig->SupportsPixelShaders_2_b() ) { DECLARE_DYNAMIC_PIXEL_SHADER( eye_refract_ps20b ); SET_DYNAMIC_PIXEL_SHADER_COMBO( NUM_LIGHTS, lightState.m_nNumLights ); SET_DYNAMIC_PIXEL_SHADER_COMBO( FLASHLIGHTSHADOWS, bFlashlightShadows ); SET_DYNAMIC_PIXEL_SHADER( eye_refract_ps20b ); } else // ps.2.0 { DECLARE_DYNAMIC_PIXEL_SHADER( eye_refract_ps20 ); SET_DYNAMIC_PIXEL_SHADER_COMBO( NUM_LIGHTS, lightState.m_nNumLights ); SET_DYNAMIC_PIXEL_SHADER( eye_refract_ps20 ); } } #ifndef _X360 else { DECLARE_DYNAMIC_PIXEL_SHADER( eye_refract_ps30 ); SET_DYNAMIC_PIXEL_SHADER_COMBO( NUM_LIGHTS, nFixedLightingMode ? 0 : lightState.m_nNumLights ); SET_DYNAMIC_PIXEL_SHADER_COMBO( FLASHLIGHTSHADOWS, nFixedLightingMode ? false : bFlashlightShadows ); SET_DYNAMIC_PIXEL_SHADER_COMBO( UBERLIGHT, flashlightState.m_bUberlight ); SET_DYNAMIC_PIXEL_SHADER( eye_refract_ps30 ); // Set constant to enable translation of VPOS to render target coordinates in ps_3_0 pShaderAPI->SetScreenSizeForVPOS(); SetupUberlightFromState( pShaderAPI, flashlightState ); } #endif pShaderAPI->SetPixelShaderFogParams( PSREG_FOG_PARAMS ); if ( bDrawFlashlightAdditivePass == true ) { float atten[4], pos[4], tweaks[4]; atten[0] = flashlightState.m_fConstantAtten; // Set the flashlight attenuation factors atten[1] = flashlightState.m_fLinearAtten; atten[2] = flashlightState.m_fQuadraticAtten; atten[3] = flashlightState.m_FarZAtten; pShaderAPI->SetPixelShaderConstant( 7, atten, 1 ); pos[0] = flashlightState.m_vecLightOrigin[0]; // Set the flashlight origin pos[1] = flashlightState.m_vecLightOrigin[1]; pos[2] = flashlightState.m_vecLightOrigin[2]; pShaderAPI->SetPixelShaderConstant( 8, pos, 1 ); pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_6, 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] ); pShaderAPI->SetPixelShaderConstant( 9, 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 ); int nTexWidth, nTexHeight; pShaderAPI->GetStandardTextureDimensions( &nTexWidth, &nTexHeight, TEXTURE_SHADOW_NOISE_2D ); vScreenScale[0] = (float) nWidth / nTexWidth; vScreenScale[1] = (float) nHeight / nTexHeight; pShaderAPI->SetPixelShaderConstant( PSREG_FLASHLIGHT_SCREEN_SCALE, vScreenScale, 1 ); vAmbientOcclusion[3] *= flashlightState.m_flAmbientOcclusion; } vAmbientOcclusion[3] = MIN( MAX( vAmbientOcclusion[3], 0.0f ), 1.0f ); pShaderAPI->SetPixelShaderConstant( 5, vAmbientOcclusion, 1 ); // Intro tax if ( bIntro ) { float curTime = params[info.m_nWarpParam]->GetFloatValue(); float timeVec[4] = { 0.0f, 0.0f, 0.0f, curTime }; if ( IS_PARAM_DEFINED( info.m_nEntityOrigin ) ) { params[info.m_nEntityOrigin]->GetVecValue( timeVec, 3 ); } pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_5, timeVec, 1 ); } } pShader->Draw(); }
//-------------------------------------------------------------------------------------------------- // Name: IsFlagSet // Desc: Checks a game effect flag //-------------------------------------------------------------------------------------------------- bool CGameEffect::IsFlagSet(uint32 flag) const { return IS_FLAG_SET(m_flags,flag); }//-------------------------------------------------------------------------------------------------
void DrawPassShadowPass( const defParms_shadow &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 bNoCull = IS_FLAG_SET( MATERIAL_VAR_NOCULL ); const bool bAlbedo = PARM_TEX( info.iAlbedo ); const bool bAlbedo2 = PARM_TEX( info.iAlbedo2 ); const bool bAlbedo3 = PARM_TEX( info.iAlbedo3 ); const bool bAlbedo4 = PARM_TEX( info.iAlbedo4 ); const bool bAlphatest = IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ) && bAlbedo; const bool bMultiBlend = PARM_SET( info.iMultiblend ) && bAlbedo && bAlbedo2 && bAlbedo3; const bool bBaseTexture2 = !bMultiBlend && bAlbedo2; 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; } #ifndef DEFCFG_ENABLE_RADIOSITY if ( bAlphatest ) #endif { pShaderShadow->EnableTexture( SHADER_SAMPLER0, true ); if ( bBaseTexture2 || bMultiBlend ) pShaderShadow->EnableTexture( SHADER_SAMPLER1, true ); if ( bMultiBlend ) { pShaderShadow->EnableTexture( SHADER_SAMPLER2, true ); pShaderShadow->EnableTexture( SHADER_SAMPLER3, true ); } } pShaderShadow->VertexShaderVertexFormat( iVFmtFlags, iTexCoordNum, pTexCoordDim, iUserDataSize ); DECLARE_STATIC_VERTEX_SHADER( shadowpass_vs30 ); SET_STATIC_VERTEX_SHADER_COMBO( MODEL, bModel ); SET_STATIC_VERTEX_SHADER_COMBO( MORPHING_VTEX, bModel && bFastVTex ); SET_STATIC_VERTEX_SHADER_COMBO( MULTITEXTURE, bMultiBlend ? 2 : bBaseTexture2 ? 1 : 0 ); SET_STATIC_VERTEX_SHADER( shadowpass_vs30 ); DECLARE_STATIC_PIXEL_SHADER( shadowpass_ps30 ); SET_STATIC_PIXEL_SHADER_COMBO( ALPHATEST, bAlphatest ); SET_STATIC_PIXEL_SHADER_COMBO( MULTITEXTURE, bMultiBlend ? 2 : bBaseTexture2 ? 1 : 0 ); SET_STATIC_PIXEL_SHADER( shadowpass_ps30 ); } DYNAMIC_STATE { Assert( pDeferredContext != NULL ); const int shadowMode = pShaderAPI->GetIntRenderingParameter( INT_RENDERPARM_DEFERRED_SHADOW_MODE ); const int radiosityOutput = DEFCFG_ENABLE_RADIOSITY != 0 && pShaderAPI->GetIntRenderingParameter( INT_RENDERPARM_DEFERRED_SHADOW_RADIOSITY ); if ( pDeferredContext->m_bMaterialVarsChanged || !pDeferredContext->HasCommands( CDeferredPerMaterialContextData::DEFSTAGE_SHADOW ) ) { tmpBuf.Reset(); if ( bAlphatest ) { PARM_VALIDATE( info.iAlphatestRef ); tmpBuf.SetPixelShaderConstant1( 0, PARM_FLOAT( info.iAlphatestRef ) ); #ifndef DEFCFG_ENABLE_RADIOSITY tmpBuf.BindTexture( pShader, SHADER_SAMPLER0, info.iAlbedo ); #endif } #if DEFCFG_ENABLE_RADIOSITY if ( bAlbedo ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER0, info.iAlbedo ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER0, TEXTURE_WHITE ); if ( bBaseTexture2 || bMultiBlend ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER1, info.iAlbedo2 ); if ( bMultiBlend ) { tmpBuf.BindTexture( pShader, SHADER_SAMPLER2, info.iAlbedo3 ); if ( bAlbedo4 ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER3, info.iAlbedo4 ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER3, TEXTURE_WHITE ); } #endif tmpBuf.End(); pDeferredContext->SetCommands( CDeferredPerMaterialContextData::DEFSTAGE_SHADOW, 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( shadowpass_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_COMBO( SHADOW_MODE, shadowMode ); SET_DYNAMIC_VERTEX_SHADER_COMBO( RADIOSITY, radiosityOutput ); SET_DYNAMIC_VERTEX_SHADER( shadowpass_vs30 ); DECLARE_DYNAMIC_PIXEL_SHADER( shadowpass_ps30 ); SET_DYNAMIC_PIXEL_SHADER_COMBO( SHADOW_MODE, shadowMode ); SET_DYNAMIC_PIXEL_SHADER_COMBO( RADIOSITY, radiosityOutput ); SET_DYNAMIC_PIXEL_SHADER( shadowpass_ps30 ); if ( bModel && bFastVTex ) { bool bUnusedTexCoords[3] = { false, true, !pShaderAPI->IsHWMorphingEnabled() || !bIsDecal }; pShaderAPI->MarkUnusedVertexFields( 0, 3, bUnusedTexCoords ); } pShaderAPI->ExecuteCommandBuffer( pDeferredContext->GetCommands( CDeferredPerMaterialContextData::DEFSTAGE_SHADOW ) ); switch ( shadowMode ) { case DEFERRED_SHADOW_MODE_ORTHO: { CommitShadowcastingConstants_Ortho( pShaderAPI, pShaderAPI->GetIntRenderingParameter( INT_RENDERPARM_DEFERRED_SHADOW_INDEX ), VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, VERTEX_SHADER_SHADER_SPECIFIC_CONST_1, VERTEX_SHADER_SHADER_SPECIFIC_CONST_2 ); } break; case DEFERRED_SHADOW_MODE_PROJECTED: { CommitShadowcastingConstants_Proj( pShaderAPI, pShaderAPI->GetIntRenderingParameter( INT_RENDERPARM_DEFERRED_SHADOW_INDEX ), VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, VERTEX_SHADER_SHADER_SPECIFIC_CONST_1, VERTEX_SHADER_SHADER_SPECIFIC_CONST_2 ); } break; } #ifdef SHADOWMAPPING_USE_COLOR CommitViewVertexShader( pShaderAPI, VERTEX_SHADER_SHADER_SPECIFIC_CONST_7 ); #endif } pShader->Draw(); }
//----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- bool CBaseShader::IsTranslucent( IMaterialVar **params ) const { return IS_FLAG_SET( MATERIAL_VAR_TRANSLUCENT ); }
//----------------------------------------------------------------------------- // Draws the shader //----------------------------------------------------------------------------- void DrawVortWarp_DX9( CBaseVSShader *pShader, IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow, bool bVertexLitGeneric, bool hasFlashlight, VortWarp_DX9_Vars_t &info, VertexCompressionType_t vertexCompression ) { bool hasBaseTexture = params[info.m_nBaseTexture]->IsTexture(); bool hasBump = (info.m_nBumpmap != -1) && params[info.m_nBumpmap]->IsTexture(); bool hasDetailTexture = !hasBump && params[info.m_nDetail]->IsTexture(); bool hasNormalMapAlphaEnvmapMask = IS_FLAG_SET( MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK ); bool hasVertexColor = bVertexLitGeneric ? false : IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR ); bool hasVertexAlpha = bVertexLitGeneric ? false : IS_FLAG_SET( MATERIAL_VAR_VERTEXALPHA ); bool bIsAlphaTested = IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ) != 0; bool hasSelfIllumInEnvMapMask = ( info.m_nSelfIllumEnvMapMask_Alpha != -1 ) && ( params[info.m_nSelfIllumEnvMapMask_Alpha]->GetFloatValue() != 0.0 ) ; bool bHasFlowMap = ( info.m_nFlowMap != -1 ) && params[info.m_nFlowMap]->IsTexture(); bool bHasSelfIllumMap = ( info.m_nSelfIllumMap != -1 ) && params[info.m_nSelfIllumMap]->IsTexture(); BlendType_t blendType; if ( params[info.m_nBaseTexture]->IsTexture() ) { blendType = pShader->EvaluateBlendRequirements( info.m_nBaseTexture, true ); } else { blendType = pShader->EvaluateBlendRequirements( info.m_nEnvmapMask, false ); } if( pShader->IsSnapshotting() ) { // look at color and alphamod stuff. // Unlit generic never uses the flashlight bool hasEnvmap = !hasFlashlight && params[info.m_nEnvmap]->IsTexture(); bool hasEnvmapMask = (hasSelfIllumInEnvMapMask || !hasFlashlight) && params[info.m_nEnvmapMask]->IsTexture(); bool bHasNormal = bVertexLitGeneric || hasEnvmap; if( hasFlashlight ) { hasEnvmapMask = false; } bool bHalfLambert = IS_FLAG_SET( MATERIAL_VAR_HALFLAMBERT ); // 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() ); } if( hasFlashlight ) { if (params[info.m_nBaseTexture]->IsTexture()) { pShader->SetAdditiveBlendingShadowState( info.m_nBaseTexture, true ); } else { pShader->SetAdditiveBlendingShadowState( info.m_nEnvmapMask, false ); } 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 ); } else { if (params[info.m_nBaseTexture]->IsTexture()) { pShader->SetDefaultBlendingShadowState( info.m_nBaseTexture, true ); } else { pShader->SetDefaultBlendingShadowState( info.m_nEnvmapMask, false ); } } unsigned int flags = VERTEX_POSITION; int nTexCoordCount = 1; // texcoord0 : base texcoord int userDataSize = 0; if( bHasNormal ) { flags |= VERTEX_NORMAL; } if( hasBaseTexture ) { pShaderShadow->EnableTexture( SHADER_SAMPLER0, true ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, true ); } if( hasEnvmap ) { pShaderShadow->EnableTexture( SHADER_SAMPLER1, true ); if( g_pHardwareConfig->GetHDRType() == HDR_TYPE_NONE ) { pShaderShadow->EnableSRGBRead( SHADER_SAMPLER1, true ); } } if( hasFlashlight ) { pShaderShadow->EnableTexture( SHADER_SAMPLER7, true ); pShaderShadow->EnableTexture( SHADER_SAMPLER4, true ); userDataSize = 4; // tangent S } if( hasDetailTexture ) { pShaderShadow->EnableTexture( SHADER_SAMPLER2, true ); } if( hasBump ) { pShaderShadow->EnableTexture( SHADER_SAMPLER3, true ); userDataSize = 4; // tangent S // Normalizing cube map pShaderShadow->EnableTexture( SHADER_SAMPLER5, true ); } if( hasEnvmapMask ) { pShaderShadow->EnableTexture( SHADER_SAMPLER4, true ); } if( hasVertexColor || hasVertexAlpha ) { flags |= VERTEX_COLOR; } pShaderShadow->EnableSRGBWrite( true ); if( bHasSelfIllumMap ) { pShaderShadow->EnableTexture( SHADER_SAMPLER6, true ); } if( bHasFlowMap ) { pShaderShadow->EnableTexture( SHADER_SAMPLER2, true ); } // This shader supports compressed vertices, so OR in that flag: flags |= VERTEX_FORMAT_COMPRESSED; pShaderShadow->VertexShaderVertexFormat( flags, nTexCoordCount, NULL, userDataSize ); Assert( hasBump ); #ifndef _X360 if ( !g_pHardwareConfig->HasFastVertexTextures() ) #endif { DECLARE_STATIC_VERTEX_SHADER( vortwarp_vs20 ); SET_STATIC_VERTEX_SHADER_COMBO( HALFLAMBERT, bHalfLambert); SET_STATIC_VERTEX_SHADER( vortwarp_vs20 ); if( g_pHardwareConfig->SupportsPixelShaders_2_b() ) { DECLARE_STATIC_PIXEL_SHADER( vortwarp_ps20b ); SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURE, hasBaseTexture ); SET_STATIC_PIXEL_SHADER_COMBO( CUBEMAP, hasEnvmap ); SET_STATIC_PIXEL_SHADER_COMBO( DIFFUSELIGHTING, !params[info.m_nUnlit]->GetIntValue() ); SET_STATIC_PIXEL_SHADER_COMBO( NORMALMAPALPHAENVMAPMASK, hasNormalMapAlphaEnvmapMask ); SET_STATIC_PIXEL_SHADER_COMBO( HALFLAMBERT, bHalfLambert); SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHT, hasFlashlight ); SET_STATIC_PIXEL_SHADER_COMBO( TRANSLUCENT, blendType == BT_BLEND ); SET_STATIC_PIXEL_SHADER( vortwarp_ps20b ); } else { DECLARE_STATIC_PIXEL_SHADER( vortwarp_ps20 ); SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURE, hasBaseTexture ); SET_STATIC_PIXEL_SHADER_COMBO( CUBEMAP, hasEnvmap ); SET_STATIC_PIXEL_SHADER_COMBO( DIFFUSELIGHTING, !params[info.m_nUnlit]->GetIntValue() ); SET_STATIC_PIXEL_SHADER_COMBO( NORMALMAPALPHAENVMAPMASK, hasNormalMapAlphaEnvmapMask ); SET_STATIC_PIXEL_SHADER_COMBO( HALFLAMBERT, bHalfLambert); SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHT, hasFlashlight ); SET_STATIC_PIXEL_SHADER_COMBO( TRANSLUCENT, blendType == BT_BLEND ); SET_STATIC_PIXEL_SHADER( vortwarp_ps20 ); } } #ifndef _X360 else { // The vertex shader uses the vertex id stream SET_FLAGS2( MATERIAL_VAR2_USES_VERTEXID ); DECLARE_STATIC_VERTEX_SHADER( vortwarp_vs30 ); SET_STATIC_VERTEX_SHADER_COMBO( HALFLAMBERT, bHalfLambert); SET_STATIC_VERTEX_SHADER( vortwarp_vs30 ); DECLARE_STATIC_PIXEL_SHADER( vortwarp_ps30 ); SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURE, hasBaseTexture ); SET_STATIC_PIXEL_SHADER_COMBO( CUBEMAP, hasEnvmap ); SET_STATIC_PIXEL_SHADER_COMBO( DIFFUSELIGHTING, !params[info.m_nUnlit]->GetIntValue() ); SET_STATIC_PIXEL_SHADER_COMBO( NORMALMAPALPHAENVMAPMASK, hasNormalMapAlphaEnvmapMask ); SET_STATIC_PIXEL_SHADER_COMBO( HALFLAMBERT, bHalfLambert); SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHT, hasFlashlight ); SET_STATIC_PIXEL_SHADER_COMBO( TRANSLUCENT, blendType == BT_BLEND ); SET_STATIC_PIXEL_SHADER( vortwarp_ps30 ); } #endif if( hasFlashlight ) { pShader->FogToBlack(); } else { pShader->DefaultFog(); } if( blendType == BT_BLEND ) { pShaderShadow->EnableBlending( true ); pShaderShadow->BlendFunc( SHADER_BLEND_SRC_ALPHA, SHADER_BLEND_ONE_MINUS_SRC_ALPHA ); pShaderShadow->EnableAlphaWrites( false ); } else { pShaderShadow->EnableAlphaWrites( true ); } } else { bool hasEnvmap = !hasFlashlight && params[info.m_nEnvmap]->IsTexture(); bool hasEnvmapMask = !hasFlashlight && params[info.m_nEnvmapMask]->IsTexture(); if( hasBaseTexture ) { pShader->BindTexture( SHADER_SAMPLER0, info.m_nBaseTexture, info.m_nBaseTextureFrame ); } if( hasEnvmap ) { pShader->BindTexture( SHADER_SAMPLER1, info.m_nEnvmap, info.m_nEnvmapFrame ); } if( hasDetailTexture ) { pShader->BindTexture( SHADER_SAMPLER2, info.m_nDetail, info.m_nDetailFrame ); } if( !g_pConfig->m_bFastNoBump ) { if( hasBump ) { pShader->BindTexture( SHADER_SAMPLER3, info.m_nBumpmap, info.m_nBumpFrame ); } } else { if( hasBump ) { pShaderAPI->BindStandardTexture( SHADER_SAMPLER3, TEXTURE_NORMALMAP_FLAT ); } } if( hasEnvmapMask ) { pShader->BindTexture( SHADER_SAMPLER4, info.m_nEnvmapMask, info.m_nEnvmapMaskFrame ); } if( hasFlashlight ) { Assert( info.m_nFlashlightTexture >= 0 && info.m_nFlashlightTextureFrame >= 0 ); pShader->BindTexture( SHADER_SAMPLER7, info.m_nFlashlightTexture, info.m_nFlashlightTextureFrame ); VMatrix worldToTexture; ITexture *pFlashlightDepthTexture; FlashlightState_t state = pShaderAPI->GetFlashlightStateEx( worldToTexture, &pFlashlightDepthTexture ); SetFlashLightColorFromState( state, pShaderAPI ); } // Set up light combo state LightState_t lightState = {0, false, false}; if ( bVertexLitGeneric && !hasFlashlight ) { pShaderAPI->GetDX9LightState( &lightState ); } MaterialFogMode_t fogType = pShaderAPI->GetSceneFogMode(); int fogIndex = ( fogType == MATERIAL_FOG_LINEAR_BELOW_FOG_Z ) ? 1 : 0; int numBones = pShaderAPI->GetCurrentNumBones(); Assert( hasBump ); #ifndef _X360 if ( !g_pHardwareConfig->HasFastVertexTextures() ) #endif { DECLARE_DYNAMIC_VERTEX_SHADER( vortwarp_vs20 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( DOWATERFOG, fogIndex ); SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, numBones > 0 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (int)vertexCompression ); SET_DYNAMIC_VERTEX_SHADER( vortwarp_vs20 ); if( g_pHardwareConfig->SupportsPixelShaders_2_b() ) { DECLARE_DYNAMIC_PIXEL_SHADER( vortwarp_ps20b ); SET_DYNAMIC_PIXEL_SHADER_COMBO( NUM_LIGHTS, lightState.m_nNumLights ); SET_DYNAMIC_PIXEL_SHADER_COMBO( AMBIENT_LIGHT, lightState.m_bAmbientLight ? 1 : 0 ); SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITEWATERFOGTODESTALPHA, fogType == MATERIAL_FOG_LINEAR_BELOW_FOG_Z && blendType != BT_BLENDADD && blendType != BT_BLEND && !bIsAlphaTested ); SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() ); float warpParam = params[info.m_nWarpParam]->GetFloatValue(); // float selfIllumTint = params[info.m_nSelfIllumTint]->GetFloatValue(); // DevMsg( 1, "warpParam: %f %f\n", warpParam, selfIllumTint ); SET_DYNAMIC_PIXEL_SHADER_COMBO( WARPINGIN, warpParam > 0.0f && warpParam < 1.0f ); SET_DYNAMIC_PIXEL_SHADER( vortwarp_ps20b ); } else { DECLARE_DYNAMIC_PIXEL_SHADER( vortwarp_ps20 ); SET_DYNAMIC_PIXEL_SHADER_COMBO( NUM_LIGHTS, lightState.m_nNumLights ); SET_DYNAMIC_PIXEL_SHADER_COMBO( AMBIENT_LIGHT, lightState.m_bAmbientLight ? 1 : 0 ); SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITEWATERFOGTODESTALPHA, fogType == MATERIAL_FOG_LINEAR_BELOW_FOG_Z && blendType != BT_BLENDADD && blendType != BT_BLEND && !bIsAlphaTested ); SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() ); float warpParam = params[info.m_nWarpParam]->GetFloatValue(); // float selfIllumTint = params[info.m_nSelfIllumTint]->GetFloatValue(); // DevMsg( 1, "warpParam: %f %f\n", warpParam, selfIllumTint ); SET_DYNAMIC_PIXEL_SHADER_COMBO( WARPINGIN, warpParam > 0.0f && warpParam < 1.0f ); SET_DYNAMIC_PIXEL_SHADER( vortwarp_ps20 ); } } #ifndef _X360 else { pShader->SetHWMorphVertexShaderState( VERTEX_SHADER_SHADER_SPECIFIC_CONST_6, VERTEX_SHADER_SHADER_SPECIFIC_CONST_7, SHADER_VERTEXTEXTURE_SAMPLER0 ); DECLARE_DYNAMIC_VERTEX_SHADER( vortwarp_vs30 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( DOWATERFOG, fogIndex ); SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, numBones > 0 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( MORPHING, pShaderAPI->IsHWMorphingEnabled() ); SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (int)vertexCompression ); SET_DYNAMIC_VERTEX_SHADER( vortwarp_vs30 ); DECLARE_DYNAMIC_PIXEL_SHADER( vortwarp_ps30 ); SET_DYNAMIC_PIXEL_SHADER_COMBO( NUM_LIGHTS, lightState.m_nNumLights ); SET_DYNAMIC_PIXEL_SHADER_COMBO( AMBIENT_LIGHT, lightState.m_bAmbientLight ? 1 : 0 ); SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITEWATERFOGTODESTALPHA, fogType == MATERIAL_FOG_LINEAR_BELOW_FOG_Z && blendType != BT_BLENDADD && blendType != BT_BLEND && !bIsAlphaTested ); SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() ); float warpParam = params[info.m_nWarpParam]->GetFloatValue(); // float selfIllumTint = params[info.m_nSelfIllumTint]->GetFloatValue(); // DevMsg( 1, "warpParam: %f %f\n", warpParam, selfIllumTint ); SET_DYNAMIC_PIXEL_SHADER_COMBO( WARPINGIN, warpParam > 0.0f && warpParam < 1.0f ); SET_DYNAMIC_PIXEL_SHADER( vortwarp_ps30 ); } #endif pShader->SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, info.m_nBaseTextureTransform ); if( hasDetailTexture ) { pShader->SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, info.m_nBaseTextureTransform, info.m_nDetailScale ); Assert( !hasBump ); } if( hasBump ) { pShader->SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, info.m_nBumpTransform ); Assert( !hasDetailTexture ); } if( hasEnvmapMask ) { pShader->SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_4, info.m_nEnvmapMaskTransform ); } if( hasEnvmap ) { pShader->SetEnvMapTintPixelShaderDynamicState( 0, info.m_nEnvmapTint, -1, true ); } if( ( info.m_nHDRColorScale != -1 ) && pShader->IsHDREnabled() ) { pShader->SetModulationPixelShaderDynamicState_LinearColorSpace_LinearScale( 1, params[info.m_nHDRColorScale]->GetFloatValue() ); } else { pShader->SetModulationPixelShaderDynamicState_LinearColorSpace( 1 ); } pShader->SetPixelShaderConstant( 2, info.m_nEnvmapContrast ); pShader->SetPixelShaderConstant( 3, info.m_nEnvmapSaturation ); pShader->SetPixelShaderConstant( 4, info.m_nSelfIllumTint ); pShader->SetAmbientCubeDynamicStateVertexShader(); if( hasBump ) { pShaderAPI->BindStandardTexture( SHADER_SAMPLER5, TEXTURE_NORMALIZATION_CUBEMAP_SIGNED ); pShaderAPI->SetPixelShaderStateAmbientLightCube( 5 ); pShaderAPI->CommitPixelShaderLighting( 13 ); } if( bHasSelfIllumMap ) { pShader->BindTexture( SHADER_SAMPLER6, info.m_nSelfIllumMap, -1 ); } if( bHasFlowMap ) { pShader->BindTexture( SHADER_SAMPLER2, info.m_nFlowMap, -1 ); } float eyePos[4]; pShaderAPI->GetWorldSpaceCameraPosition( eyePos ); pShaderAPI->SetPixelShaderConstant( 20, eyePos, 1 ); pShaderAPI->SetPixelShaderFogParams( 21 ); // dynamic drawing code that extends vertexlitgeneric float curTime = params[info.m_nWarpParam]->GetFloatValue(); float timeVec[4] = { 0.0f, 0.0f, 0.0f, curTime }; Assert( params[info.m_nEntityOrigin]->IsDefined() ); params[info.m_nEntityOrigin]->GetVecValue( timeVec, 3 ); pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_4, timeVec, 1 ); curTime = pShaderAPI->CurrentTime(); timeVec[0] = curTime; timeVec[1] = curTime; timeVec[2] = curTime; timeVec[3] = curTime; pShaderAPI->SetPixelShaderConstant( 22, timeVec, 1 ); // flashlightfixme: put this in common code. if( hasFlashlight ) { VMatrix worldToTexture; const FlashlightState_t &flashlightState = pShaderAPI->GetFlashlightState( worldToTexture ); // Set the flashlight attenuation factors float atten[4]; atten[0] = flashlightState.m_fConstantAtten; atten[1] = flashlightState.m_fLinearAtten; atten[2] = flashlightState.m_fQuadraticAtten; atten[3] = flashlightState.m_FarZ; pShaderAPI->SetPixelShaderConstant( 22, atten, 1 ); // Set the flashlight origin float pos[4]; pos[0] = flashlightState.m_vecLightOrigin[0]; pos[1] = flashlightState.m_vecLightOrigin[1]; pos[2] = flashlightState.m_vecLightOrigin[2]; pos[3] = 1.0f; pShaderAPI->SetPixelShaderConstant( 23, pos, 1 ); pShaderAPI->SetPixelShaderConstant( 24, worldToTexture.Base(), 4 ); } } pShader->Draw(); }
void DrawUnbumpedUsingVertexShader( IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow, bool bBumpedEnvMap ) { bool hasEnvmap = params[ENVMAP]->IsTexture() && !bBumpedEnvMap; bool hasBaseTexture = params[BASETEXTURE]->IsTexture(); bool hasVertexColor = IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR ); bool hasEnvmapCameraSpace = IS_FLAG_SET( MATERIAL_VAR_ENVMAPCAMERASPACE ); bool hasEnvmapSphere = IS_FLAG_SET( MATERIAL_VAR_ENVMAPSPHERE ); if ( hasEnvmap || hasBaseTexture || hasVertexColor || !bBumpedEnvMap ) { SHADOW_STATE { // Alpha test pShaderShadow->EnableAlphaTest( IS_FLAG_SET(MATERIAL_VAR_ALPHATEST) ); if ( params[ALPHATESTREFERENCE]->GetFloatValue() > 0.0f ) { pShaderShadow->AlphaFunc( SHADER_ALPHAFUNC_GEQUAL, params[ALPHATESTREFERENCE]->GetFloatValue() ); } // Base texture on stage 0 if (params[BASETEXTURE]->IsTexture()) { pShaderShadow->EnableTexture( SHADER_SAMPLER0, true ); } // Lightmap on stage 1 pShaderShadow->EnableTexture( SHADER_SAMPLER1, true ); int fmt = VERTEX_POSITION; if ( hasEnvmap ) { fmt |= VERTEX_NORMAL; // envmap on stage 2 pShaderShadow->EnableTexture( SHADER_SAMPLER2, true ); // envmapmask on stage 3 if (params[ENVMAPMASK]->IsTexture() || IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK ) ) { pShaderShadow->EnableTexture( SHADER_SAMPLER3, true ); } } if (params[BASETEXTURE]->IsTexture() || bBumpedEnvMap) { SetDefaultBlendingShadowState( BASETEXTURE, true ); } else { SetDefaultBlendingShadowState( ENVMAPMASK, false ); } if (IS_FLAG_SET(MATERIAL_VAR_VERTEXCOLOR)) { fmt |= VERTEX_COLOR; } pShaderShadow->VertexShaderVertexFormat( fmt, 2, 0, 0 ); lightmappedgeneric_vs11_Static_Index vshIndex; vshIndex.SetDETAIL( false ); vshIndex.SetENVMAP( hasEnvmap ); vshIndex.SetENVMAPCAMERASPACE( hasEnvmap && hasEnvmapCameraSpace ); vshIndex.SetENVMAPSPHERE( hasEnvmap && hasEnvmapSphere ); vshIndex.SetVERTEXCOLOR( hasVertexColor ); pShaderShadow->SetVertexShader( "LightmappedGeneric_vs11", vshIndex.GetIndex() ); const char *pshName = GetPixelShaderName( params, bBumpedEnvMap ); pShaderShadow->SetPixelShader( pshName ); DefaultFog(); } DYNAMIC_STATE { if (hasBaseTexture) { BindTexture( SHADER_SAMPLER0, BASETEXTURE, FRAME ); SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, BASETEXTURETRANSFORM ); } pShaderAPI->BindStandardTexture( SHADER_SAMPLER1, TEXTURE_LIGHTMAP ); if ( hasEnvmap ) { BindTexture( SHADER_SAMPLER2, ENVMAP, ENVMAPFRAME ); if (params[ENVMAPMASK]->IsTexture() || IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK) ) { if (params[ENVMAPMASK]->IsTexture() ) BindTexture( SHADER_SAMPLER3, ENVMAPMASK, ENVMAPMASKFRAME ); else BindTexture( SHADER_SAMPLER3, BASETEXTURE, FRAME ); SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, BASETEXTURETRANSFORM, ENVMAPMASKSCALE ); } if (IS_FLAG_SET(MATERIAL_VAR_ENVMAPSPHERE) || IS_FLAG_SET(MATERIAL_VAR_ENVMAPCAMERASPACE)) { LoadViewMatrixIntoVertexShaderConstant( VERTEX_SHADER_VIEWMODEL ); } SetEnvMapTintPixelShaderDynamicState( 2, ENVMAPTINT, -1 ); } if ( !hasEnvmap || hasBaseTexture || hasVertexColor ) { SetModulationVertexShaderDynamicState(); } EnablePixelShaderOverbright( 0, true, true ); SetPixelShaderConstant( 1, SELFILLUMTINT ); lightmappedgeneric_vs11_Dynamic_Index vshIndex; vshIndex.SetDOWATERFOG( pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z ); pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() ); } Draw(); }