void CBaseVSShader::SetPixelShaderTextureScaledTransform( int pixelReg, int transformVar, int scaleVar ) { Vector4D transformation[2]; IMaterialVar* pTransformationVar = s_ppParams[transformVar]; if (pTransformationVar && (pTransformationVar->GetType() == MATERIAL_VAR_TYPE_MATRIX)) { const VMatrix &mat = pTransformationVar->GetMatrixValue(); transformation[0].Init( mat[0][0], mat[0][1], mat[0][2], mat[0][3] ); transformation[1].Init( mat[1][0], mat[1][1], mat[1][2], mat[1][3] ); } else { transformation[0].Init( 1.0f, 0.0f, 0.0f, 0.0f ); transformation[1].Init( 0.0f, 1.0f, 0.0f, 0.0f ); } Vector2D scale( 1, 1 ); IMaterialVar* pScaleVar = s_ppParams[scaleVar]; if (pScaleVar) { if (pScaleVar->GetType() == MATERIAL_VAR_TYPE_VECTOR) pScaleVar->GetVecValue( scale.Base(), 2 ); else if (pScaleVar->IsDefined()) scale[0] = scale[1] = pScaleVar->GetFloatValue(); } // Apply the scaling transformation[0][0] *= scale[0]; transformation[0][1] *= scale[1]; transformation[1][0] *= scale[0]; transformation[1][1] *= scale[1]; transformation[0][3] *= scale[0]; transformation[1][3] *= scale[1]; s_pShaderAPI->SetPixelShaderConstant( pixelReg, transformation[0].Base(), 2 ); }
void CBaseOES2Shader::SetTextureScaledTransform(int reg, int transformVar, int scaleVar) { Vector4D transformation[2]; IMaterialVar *pTransformationVar = s_ppParams[transformVar]; if (pTransformationVar && (pTransformationVar->GetType() == MATERIAL_VAR_TYPE_MATRIX)) { const VMatrix &mat = pTransformationVar->GetMatrixValue(); transformation[0].Init(mat[0][0], mat[0][1], mat[0][2], mat[0][3]); transformation[1].Init(mat[1][0], mat[1][1], mat[1][2], mat[1][3]); } else { transformation[0].Init(1.0f, 0.0f, 0.0f, 0.0f); transformation[1].Init(0.0f, 1.0f, 0.0f, 0.0f); } float scale[2] = {1.0f, 1.0f}; IMaterialVar *pScaleVar = s_ppParams[scaleVar]; if (pScaleVar) { if (pScaleVar->GetType() == MATERIAL_VAR_TYPE_VECTOR) pScaleVar->GetVecValue(scale, 2); else if (pScaleVar->IsDefined()) scale[0] = scale[1] = pScaleVar->GetFloatValue(); } transformation[0][0] *= scale[0]; transformation[0][1] *= scale[1]; transformation[1][0] *= scale[0]; transformation[1][1] *= scale[1]; transformation[0][3] *= scale[0]; transformation[1][3] *= scale[1]; s_pShaderAPI->Uniform4fv(reg, 2, transformation[0].Base()); }
void CBaseVSShader::SetPixelShaderConstantGammaToLinear( int pixelReg, int constantVar, int constantVar2 ) { Assert( !IsSnapshotting() ); if ((!s_ppParams) || (constantVar == -1) || (constantVar2 == -1)) return; IMaterialVar* pPixelVar = s_ppParams[constantVar]; Assert( pPixelVar ); IMaterialVar* pPixelVar2 = s_ppParams[constantVar2]; Assert( pPixelVar2 ); float val[4]; if (pPixelVar->GetType() == MATERIAL_VAR_TYPE_VECTOR) { pPixelVar->GetVecValue( val, 3 ); } else { val[0] = val[1] = val[2] = pPixelVar->GetFloatValue(); } val[3] = pPixelVar2->GetFloatValue(); val[0] = val[0] > 1.0f ? val[0] : GammaToLinear( val[0] ); val[1] = val[1] > 1.0f ? val[1] : GammaToLinear( val[1] ); val[2] = val[2] > 1.0f ? val[2] : GammaToLinear( val[2] ); s_pShaderAPI->SetPixelShaderConstant( pixelReg, val ); }
//----------------------------------------------------------------------------- // Returns the translucency... //----------------------------------------------------------------------------- void CBaseShader::ApplyColor2Factor( float *pColorOut ) const // (*pColorOut) *= COLOR2 { if ( !g_pConfig->bShowDiffuse ) { pColorOut[0] = pColorOut[1] = pColorOut[2] = 0.0f; return; } IMaterialVar* pColor2Var = s_ppParams[COLOR2]; if ( pColor2Var->GetType() == MATERIAL_VAR_TYPE_VECTOR ) { float flColor2[3]; pColor2Var->GetVecValue( flColor2, 3 ); pColorOut[0] *= flColor2[0]; pColorOut[1] *= flColor2[1]; pColorOut[2] *= flColor2[2]; } if ( g_pHardwareConfig->UsesSRGBCorrectBlending() ) { IMaterialVar* pSRGBVar = s_ppParams[SRGBTINT]; if (pSRGBVar->GetType() == MATERIAL_VAR_TYPE_VECTOR) { float flSRGB[3]; pSRGBVar->GetVecValue( flSRGB, 3 ); pColorOut[0] *= flSRGB[0]; pColorOut[1] *= flSRGB[1]; pColorOut[2] *= flSRGB[2]; } } }
void CBaseShader::SetFixedFunctionTextureTransform( MaterialMatrixMode_t textureTransform, int transformVar ) { Assert( !IsSnapshotting() ); IMaterialVar* pTransformationVar = s_ppParams[transformVar]; if (pTransformationVar && (pTransformationVar->GetType() == MATERIAL_VAR_TYPE_MATRIX)) { s_pShaderAPI->MatrixMode( textureTransform ); const VMatrix &transformation = pTransformationVar->GetMatrixValue(); // only do the upper 3x3 since this is a 2D matrix float mat[16]; mat[0] = transformation[0][0]; mat[1] = transformation[1][0]; mat[2] = transformation[3][0]; mat[4] = transformation[0][1]; mat[5] = transformation[1][1]; mat[6] = transformation[3][1]; mat[8] = transformation[0][3]; mat[9] = transformation[1][3]; mat[10] = transformation[3][3]; // Better set the stuff we don't set with some sort of value! mat[3] = mat[7] = mat[11] = 0; mat[12] = mat[13] = mat[14] = 0; mat[15] = 1; s_pShaderAPI->LoadMatrix( mat ); } else { LoadIdentity( textureTransform ); } }
//----------------------------------------------------------------------------- // Sets the color + transparency //----------------------------------------------------------------------------- void CBaseShader::SetColorState( int colorVar, bool setAlpha ) { Assert( !IsSnapshotting() ); if ( !s_ppParams ) return; // Use tint instead of color if it was specified... IMaterialVar* pColorVar = (colorVar != -1) ? s_ppParams[colorVar] : 0; float color[4] = { 1.0, 1.0, 1.0, 1.0 }; if (pColorVar) { if (pColorVar->GetType() == MATERIAL_VAR_TYPE_VECTOR) { pColorVar->GetVecValue( color, 3 ); } else { color[0] = color[1] = color[2] = pColorVar->GetFloatValue(); } // Clamp... color[0] = clamp( color[0], 0.0f, 1.0f ); color[1] = clamp( color[1], 0.0f, 1.0f ); color[2] = clamp( color[2], 0.0f, 1.0f ); } color[3] = setAlpha ? GetAlpha() : 1.0f; s_pShaderAPI->Color4fv( color ); }
void CLessOrEqualProxy::OnBind( void *pC_BaseEntity ) { Assert( m_pSrc1 && m_pSrc2 && m_pLessVar && m_pGreaterVar && m_pResult ); IMaterialVar *pSourceVar; if (m_pSrc1->GetFloatValue() <= m_pSrc2->GetFloatValue()) { pSourceVar = m_pLessVar; } else { pSourceVar = m_pGreaterVar; } int vecSize = 0; MaterialVarType_t resultType = m_pResult->GetType(); if (resultType == MATERIAL_VAR_TYPE_VECTOR) { if (m_ResultVecComp >= 0) resultType = MATERIAL_VAR_TYPE_FLOAT; vecSize = m_pResult->VectorSize(); } else if (resultType == MATERIAL_VAR_TYPE_UNDEFINED) { resultType = pSourceVar->GetType(); if (resultType == MATERIAL_VAR_TYPE_VECTOR) { vecSize = pSourceVar->VectorSize(); } } switch( resultType ) { case MATERIAL_VAR_TYPE_VECTOR: { Vector src; pSourceVar->GetVecValue( src.Base(), vecSize ); m_pResult->SetVecValue( src.Base(), vecSize ); } break; case MATERIAL_VAR_TYPE_FLOAT: SetFloatResult( pSourceVar->GetFloatValue() ); break; case MATERIAL_VAR_TYPE_INT: m_pResult->SetFloatValue( pSourceVar->GetIntValue() ); break; } if ( ToolsEnabled() ) { ToolFramework_RecordMaterialParams( GetMaterial() ); } }
bool CEngineSprite::Init( const char *pName ) { m_hAVIMaterial = AVIMATERIAL_INVALID; m_width = m_height = m_numFrames = 1; const char *pExt = Q_GetFileExtension( pName ); bool bIsAVI = pExt && !Q_stricmp( pExt, "avi" ); if ( bIsAVI ) { m_hAVIMaterial = avi->CreateAVIMaterial( pName, pName, "GAME" ); if ( m_hAVIMaterial == AVIMATERIAL_INVALID ) return false; m_material = avi->GetMaterial( m_hAVIMaterial ); avi->GetFrameSize( m_hAVIMaterial, &m_width, &m_height ); m_numFrames = avi->GetFrameCount( m_hAVIMaterial ); } else { m_material = materials->FindMaterial( pName, TEXTURE_GROUP_CLIENT_EFFECTS ); m_width = m_material->GetMappingWidth(); m_height = m_material->GetMappingHeight(); m_numFrames = (!bIsAVI) ? m_material->GetNumAnimationFrames() : avi->GetFrameCount( m_hAVIMaterial ); } if ( !m_material ) return false; m_material->IncrementReferenceCount(); IMaterialVar *orientationVar = m_material->FindVarFast( "$spriteorientation", &spriteOrientationCache ); m_orientation = orientationVar ? orientationVar->GetIntValue() : C_SpriteRenderer::SPR_VP_PARALLEL_UPRIGHT; IMaterialVar *originVar = m_material->FindVarFast( "$spriteorigin", &spriteOriginCache ); Vector origin, originVarValue; if( !originVar || ( originVar->GetType() != MATERIAL_VAR_TYPE_VECTOR ) ) { origin[0] = -m_width * 0.5f; origin[1] = m_height * 0.5f; } else { originVar->GetVecValue( &originVarValue[0], 3 ); origin[0] = -m_width * originVarValue[0]; origin[1] = m_height * originVarValue[1]; } up = origin[1]; down = origin[1] - m_height; left = origin[0]; right = m_width + origin[0]; return true; }
void CBaseShader::SetFixedFunctionTextureScaledTransform( MaterialMatrixMode_t textureTransform, int transformVar, int scaleVar ) { Assert( !IsSnapshotting() ); float mat[16]; IMaterialVar* pTransformationVar = s_ppParams[transformVar]; if (pTransformationVar && (pTransformationVar->GetType() == MATERIAL_VAR_TYPE_MATRIX)) { Vector2D scale( 1, 1 ); IMaterialVar* pScaleVar = s_ppParams[scaleVar]; if (pScaleVar) { if (pScaleVar->GetType() == MATERIAL_VAR_TYPE_VECTOR) pScaleVar->GetVecValue( scale.Base(), 2 ); else if (pScaleVar->IsDefined()) scale[0] = scale[1] = pScaleVar->GetFloatValue(); } s_pShaderAPI->MatrixMode( textureTransform ); const VMatrix &transformation = pTransformationVar->GetMatrixValue(); // only do the upper 3x3 since this is a 2D matrix mat[0] = transformation[0][0] * scale[0]; mat[1] = transformation[1][0] * scale[0]; mat[2] = transformation[3][0] * scale[0]; mat[4] = transformation[0][1] * scale[1]; mat[5] = transformation[1][1] * scale[1]; mat[6] = transformation[3][1] * scale[1]; mat[8] = transformation[0][3]; mat[9] = transformation[1][3]; mat[10] = transformation[3][3]; // Better set the stuff we don't set with some sort of value! mat[3] = mat[7] = mat[11] = 0; mat[12] = mat[13] = mat[14] = 0; mat[15] = 1; s_pShaderAPI->LoadMatrix( mat ); } else { SetFixedFunctionTextureScale( textureTransform, scaleVar ); } }
void CConveyorMaterialProxy::OnBind( void *pC_BaseEntity ) { if( !pC_BaseEntity ) return; C_BaseEntity *pEntity = BindArgToEntity( pC_BaseEntity ); if ( !pEntity ) return; C_FuncConveyor *pConveyor = dynamic_cast<C_FuncConveyor*>(pEntity); if ( !pConveyor ) return; if ( !m_pTextureScrollVar ) { return; } float flConveyorSpeed = pConveyor->GetConveyorSpeed(); float flRate = abs( flConveyorSpeed ) / 128.0; float flAngle = (flConveyorSpeed >= 0) ? 180 : 0; float sOffset = gpGlobals->curtime * cos( flAngle * ( M_PI / 180.0f ) ) * flRate; float tOffset = gpGlobals->curtime * sin( flAngle * ( M_PI / 180.0f ) ) * flRate; // make sure that we are positive if( sOffset < 0.0f ) { sOffset += 1.0f + -( int )sOffset; } if( tOffset < 0.0f ) { tOffset += 1.0f + -( int )tOffset; } // make sure that we are in a [0,1] range sOffset = sOffset - ( int )sOffset; tOffset = tOffset - ( int )tOffset; if (m_pTextureScrollVar->GetType() == MATERIAL_VAR_TYPE_MATRIX) { VMatrix mat; MatrixBuildTranslation( mat, sOffset, tOffset, 0.0f ); m_pTextureScrollVar->SetMatrixValue( mat ); } else { m_pTextureScrollVar->SetVecValue( sOffset, tOffset, 0.0f ); } }
inline void GetVecParam( int constantVar, float *val ) { if( constantVar == -1 ) return; IMaterialVar* pVar = s_ppParams[constantVar]; Assert( pVar ); if (pVar->GetType() == MATERIAL_VAR_TYPE_VECTOR) pVar->GetVecValue( val, 4 ); else val[0] = val[1] = val[2] = val[3] = pVar->GetFloatValue(); }
void CTextureScrollMaterialProxy::OnBind( void *pC_BaseEntity ) { if( !m_pTextureScrollVar ) { return; } float rate, angle, scale; // set default values if these variables don't exist. rate = m_TextureScrollRate.GetFloat(); angle = m_TextureScrollAngle.GetFloat(); scale = m_TextureScale.GetFloat(); float sOffset, tOffset; sOffset = gpGlobals->curtime * cos( angle * ( M_PI / 180.0f ) ) * rate; tOffset = gpGlobals->curtime * sin( angle * ( M_PI / 180.0f ) ) * rate; // make sure that we are positive if( sOffset < 0.0f ) { sOffset += 1.0f + -( int )sOffset; } if( tOffset < 0.0f ) { tOffset += 1.0f + -( int )tOffset; } // make sure that we are in a [0,1] range sOffset = sOffset - ( int )sOffset; tOffset = tOffset - ( int )tOffset; if (m_pTextureScrollVar->GetType() == MATERIAL_VAR_TYPE_MATRIX) { VMatrix mat( scale, 0.0f, 0.0f, sOffset, 0.0f, scale, 0.0f, tOffset, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f ); m_pTextureScrollVar->SetMatrixValue( mat ); } else { m_pTextureScrollVar->SetVecValue( sOffset, tOffset, 0.0f ); } if ( ToolsEnabled() ) { ToolFramework_RecordMaterialParams( GetMaterial() ); } }
void CBaseOES2Shader::SetTextureScale(int reg, int scaleVar) { float scale[2] = {1.0f, 1.0f}; IMaterialVar *pScaleVar = s_ppParams[scaleVar]; if (pScaleVar) { if (pScaleVar->GetType() == MATERIAL_VAR_TYPE_VECTOR) pScaleVar->GetVecValue(scale, 2); else if (pScaleVar->IsDefined()) scale[0] = scale[1] = pScaleVar->GetFloatValue(); } Vector4D scaleMatrix[2]; scaleMatrix[0].Init(scale[0], 0.0f, 0.0f, 0.0f); scaleMatrix[1].Init(0.0f, scale[1], 0.0f, 0.0f); s_pShaderAPI->Uniform4fv(reg, 2, scaleMatrix[0].Base()); }
void CBaseVSShader::SetVertexShaderConstant( int vertexReg, int constantVar ) { Assert( !IsSnapshotting() ); if ((!s_ppParams) || (constantVar == -1)) return; IMaterialVar* pVertexVar = s_ppParams[constantVar]; Assert( pVertexVar ); float val[4]; if (pVertexVar->GetType() == MATERIAL_VAR_TYPE_VECTOR) pVertexVar->GetVecValue( val, 4 ); else val[0] = val[1] = val[2] = val[3] = pVertexVar->GetFloatValue(); s_pShaderAPI->SetVertexShaderConstant( vertexReg, val ); }
void CBaseVSShader::SetPixelShaderConstant_W( int pixelReg, int constantVar, float fWValue ) { Assert( !IsSnapshotting() ); if ((!s_ppParams) || (constantVar == -1)) return; IMaterialVar* pPixelVar = s_ppParams[constantVar]; Assert( pPixelVar ); float val[4]; if (pPixelVar->GetType() == MATERIAL_VAR_TYPE_VECTOR) pPixelVar->GetVecValue( val, 4 ); else val[0] = val[1] = val[2] = val[3] = pPixelVar->GetFloatValue(); val[3]=fWValue; s_pShaderAPI->SetPixelShaderConstant( pixelReg, val ); }
void CBaseOES2Shader::SetTextureTransform(int reg, int transformVar) { Vector4D transformation[2]; IMaterialVar *pTransformationVar = s_ppParams[transformVar]; if (pTransformationVar && (pTransformationVar->GetType() == MATERIAL_VAR_TYPE_MATRIX)) { const VMatrix &mat = pTransformationVar->GetMatrixValue(); transformation[0].Init(mat[0][0], mat[0][1], mat[0][2], mat[0][3]); transformation[1].Init(mat[1][0], mat[1][1], mat[1][2], mat[1][3]); } else { transformation[0].Init(1.0f, 0.0f, 0.0f, 0.0f); transformation[1].Init(0.0f, 1.0f, 0.0f, 0.0f); } s_pShaderAPI->Uniform4fv(reg, 2, transformation[0].Base()); }
void CBaseVSShader::SetPixelShaderTextureTransform( int pixelReg, int transformVar ) { Vector4D transformation[2]; IMaterialVar* pTransformationVar = s_ppParams[transformVar]; if (pTransformationVar && (pTransformationVar->GetType() == MATERIAL_VAR_TYPE_MATRIX)) { const VMatrix &mat = pTransformationVar->GetMatrixValue(); transformation[0].Init( mat[0][0], mat[0][1], mat[0][2], mat[0][3] ); transformation[1].Init( mat[1][0], mat[1][1], mat[1][2], mat[1][3] ); } else { transformation[0].Init( 1.0f, 0.0f, 0.0f, 0.0f ); transformation[1].Init( 0.0f, 1.0f, 0.0f, 0.0f ); } s_pShaderAPI->SetPixelShaderConstant( pixelReg, transformation[0].Base(), 2 ); }
void CPupilProxy::OnBind( C_BaseEntity *pBaseEntity ) { if (!pBaseEntity || !m_pAnimatedTextureVar ) return; if( m_pAnimatedTextureVar->GetType() != MATERIAL_VAR_TYPE_TEXTURE ) return; ITexture *pTexture = m_pAnimatedTextureVar->GetTextureValue(); int nFrameCount = pTexture->GetNumAnimationFrames(); // Compute the lighting at the eye position of the entity; use it to dialate the pupil Vector forward; pBaseEntity->GetVectors( &forward, NULL, NULL ); Vector eyePt = pBaseEntity->EyePosition(); Vector color; engine->ComputeLighting( eyePt, &forward, false, color ); // Compute the intensity... float flIntensity = ( 0.299f * color[0] + 0.587f * color[1] + 0.114f * color[2] ) * 0.5; flIntensity = clamp( flIntensity, 0, 1 ); float flLastIntensity = m_pLightingVar->GetFloatValue( ); if ( flIntensity > flLastIntensity ) { float flMaxChange = m_flPupilCloseRate.GetFloat() * gpGlobals->frametime; if ( flIntensity > (flMaxChange + flLastIntensity) ) { flIntensity = flLastIntensity + flMaxChange; } } else { float flMaxChange = m_flPupilOpenRate.GetFloat() * gpGlobals->frametime; if ( flIntensity < (flLastIntensity - flMaxChange) ) { flIntensity = flLastIntensity - flMaxChange; } } int nFrame = nFrameCount * flIntensity; nFrame = clamp( nFrame, 0, nFrameCount - 1 ); m_pAnimatedTextureFrameNumVar->SetIntValue( nFrame ); m_pLightingVar->SetFloatValue( flIntensity ); }
//----------------------------------------------------------------------------- // Sets pixel shader texture transforms //----------------------------------------------------------------------------- void CBaseVSShader::SetPixelShaderTextureTranslation( int pixelReg, int translationVar ) { float offset[2] = {0, 0}; IMaterialVar* pTranslationVar = s_ppParams[translationVar]; if (pTranslationVar) { if (pTranslationVar->GetType() == MATERIAL_VAR_TYPE_VECTOR) pTranslationVar->GetVecValue( offset, 2 ); else offset[0] = offset[1] = pTranslationVar->GetFloatValue(); } Vector4D translation[2]; translation[0].Init( 1.0f, 0.0f, 0.0f, offset[0] ); translation[1].Init( 0.0f, 1.0f, 0.0f, offset[1] ); s_pShaderAPI->SetPixelShaderConstant( pixelReg, translation[0].Base(), 2 ); }
void CBaseVSShader::SetPixelShaderTextureScale( int pixelReg, int scaleVar ) { float scale[2] = {1, 1}; IMaterialVar* pScaleVar = s_ppParams[scaleVar]; if (pScaleVar) { if (pScaleVar->GetType() == MATERIAL_VAR_TYPE_VECTOR) pScaleVar->GetVecValue( scale, 2 ); else if (pScaleVar->IsDefined()) scale[0] = scale[1] = pScaleVar->GetFloatValue(); } Vector4D scaleMatrix[2]; scaleMatrix[0].Init( scale[0], 0.0f, 0.0f, 0.0f ); scaleMatrix[1].Init( 0.0f, scale[1], 0.0f, 0.0f ); s_pShaderAPI->SetPixelShaderConstant( pixelReg, scaleMatrix[0].Base(), 2 ); }
//----------------------------------------------------------------------------- // Converts a color + alpha into a vector4 //----------------------------------------------------------------------------- void CBaseVSShader::ColorVarsToVector( int colorVar, int alphaVar, Vector4D &color ) { color.Init( 1.0, 1.0, 1.0, 1.0 ); if ( colorVar != -1 ) { IMaterialVar* pColorVar = s_ppParams[colorVar]; if ( pColorVar->GetType() == MATERIAL_VAR_TYPE_VECTOR ) { pColorVar->GetVecValue( color.Base(), 3 ); } else { color[0] = color[1] = color[2] = pColorVar->GetFloatValue(); } } if ( alphaVar != -1 ) { float flAlpha = s_ppParams[alphaVar]->GetFloatValue(); color[3] = clamp( flAlpha, 0.0f, 1.0f ); } }
void CBaseShader::ComputeModulationColor( float* color ) { Assert( !IsSnapshotting() ); if (!s_ppParams) return; IMaterialVar* pColorVar = s_ppParams[COLOR]; if (pColorVar->GetType() == MATERIAL_VAR_TYPE_VECTOR) { pColorVar->GetVecValue( color, 3 ); } else { color[0] = color[1] = color[2] = pColorVar->GetFloatValue(); } if( !g_pConfig->bShowDiffuse ) { color[0] = color[1] = color[2] = 0.0f; } color[3] = GetAlpha(); }
bool CEngineSprite::Init( const char *pName ) { m_VideoMaterial = NULL; for ( int i = 0; i < kRenderModeCount; ++i ) { m_material[ i ] = NULL; } m_width = m_height = m_numFrames = 1; Assert( g_pVideo != NULL ); if ( g_pVideo != NULL && g_pVideo->LocateVideoSystemForPlayingFile( pName ) != VideoSystem::NONE ) { m_VideoMaterial = g_pVideo->CreateVideoMaterial( pName, pName, "GAME", VideoPlaybackFlags::DEFAULT_MATERIAL_OPTIONS, VideoSystem::DETERMINE_FROM_FILE_EXTENSION, false ); if ( m_VideoMaterial == NULL ) return false; IMaterial *pMaterial = m_VideoMaterial->GetMaterial(); m_VideoMaterial->GetVideoImageSize( &m_width, &m_height ); m_numFrames = m_VideoMaterial->GetFrameCount(); for ( int i = 0; i < kRenderModeCount; ++i ) { m_material[i] = pMaterial; pMaterial->IncrementReferenceCount(); } } else { char pTemp[MAX_PATH]; char pMaterialName[MAX_PATH]; char pMaterialPath[MAX_PATH]; Q_StripExtension( pName, pTemp, sizeof(pTemp) ); Q_strlower( pTemp ); Q_FixSlashes( pTemp, '/' ); // Check to see if this is a UNC-specified material name bool bIsUNC = pTemp[0] == '/' && pTemp[1] == '/' && pTemp[2] != '/'; if ( !bIsUNC ) { Q_strncpy( pMaterialName, "materials/", sizeof(pMaterialName) ); Q_strncat( pMaterialName, pTemp, sizeof(pMaterialName), COPY_ALL_CHARACTERS ); } else { Q_strncpy( pMaterialName, pTemp, sizeof(pMaterialName) ); } Q_strncpy( pMaterialPath, pMaterialName, sizeof(pMaterialPath) ); Q_SetExtension( pMaterialPath, ".vmt", sizeof(pMaterialPath) ); KeyValues *kv = new KeyValues( "vmt" ); if ( !kv->LoadFromFile( g_pFullFileSystem, pMaterialPath, "GAME" ) ) { Warning( "Unable to load sprite material %s!\n", pMaterialPath ); return false; } for ( int i = 0; i < kRenderModeCount; ++i ) { if ( i == kRenderNone || i == kRenderEnvironmental ) { m_material[i] = NULL; continue; } Q_snprintf( pMaterialPath, sizeof(pMaterialPath), "%s_rendermode_%d", pMaterialName, i ); KeyValues *pMaterialKV = kv->MakeCopy(); pMaterialKV->SetInt( "$spriteRenderMode", i ); m_material[i] = g_pMaterialSystem->FindProceduralMaterial( pMaterialPath, TEXTURE_GROUP_CLIENT_EFFECTS, pMaterialKV ); m_material[ i ]->IncrementReferenceCount(); } kv->deleteThis(); m_width = m_material[0]->GetMappingWidth(); m_height = m_material[0]->GetMappingHeight(); m_numFrames = m_material[0]->GetNumAnimationFrames(); } for ( int i = 0; i < kRenderModeCount; ++i ) { if ( i == kRenderNone || i == kRenderEnvironmental ) continue; if ( !m_material[i] ) return false; } IMaterialVar *orientationVar = m_material[0]->FindVarFast( "$spriteorientation", &spriteOrientationCache ); m_orientation = orientationVar ? orientationVar->GetIntValue() : C_SpriteRenderer::SPR_VP_PARALLEL_UPRIGHT; IMaterialVar *originVar = m_material[0]->FindVarFast( "$spriteorigin", &spriteOriginCache ); Vector origin, originVarValue; if( !originVar || ( originVar->GetType() != MATERIAL_VAR_TYPE_VECTOR ) ) { origin[0] = -m_width * 0.5f; origin[1] = m_height * 0.5f; } else { originVar->GetVecValue( &originVarValue[0], 3 ); origin[0] = -m_width * originVarValue[0]; origin[1] = m_height * originVarValue[1]; } up = origin[1]; down = origin[1] - m_height; left = origin[0]; right = m_width + origin[0]; return true; }
bool CEngineSprite::Init( const char *pName ) { m_hAVIMaterial = AVIMATERIAL_INVALID; m_hBIKMaterial = BIKMATERIAL_INVALID; m_width = m_height = m_numFrames = 1; const char *pExt = Q_GetFileExtension( pName ); bool bIsAVI = pExt && !Q_stricmp( pExt, "avi" ); #if !defined( _X360 ) || defined( BINK_ENABLED_FOR_X360 ) bool bIsBIK = pExt && !Q_stricmp( pExt, "bik" ); #endif if ( bIsAVI && IsPC() ) { m_hAVIMaterial = avi->CreateAVIMaterial( pName, pName, "GAME" ); if ( m_hAVIMaterial == AVIMATERIAL_INVALID ) return false; IMaterial *pMaterial = avi->GetMaterial( m_hAVIMaterial ); avi->GetFrameSize( m_hAVIMaterial, &m_width, &m_height ); m_numFrames = avi->GetFrameCount( m_hAVIMaterial ); for ( int i = 0; i < kRenderModeCount; ++i ) { m_material[i] = pMaterial; pMaterial->IncrementReferenceCount(); } } #if !defined( _X360 ) || defined( BINK_ENABLED_FOR_X360 ) else if ( bIsBIK ) { m_hBIKMaterial = bik->CreateMaterial( pName, pName, "GAME" ); if ( m_hBIKMaterial == BIKMATERIAL_INVALID ) return false; IMaterial *pMaterial = bik->GetMaterial( m_hBIKMaterial ); bik->GetFrameSize( m_hBIKMaterial, &m_width, &m_height ); m_numFrames = bik->GetFrameCount( m_hBIKMaterial ); for ( int i = 0; i < kRenderModeCount; ++i ) { m_material[i] = pMaterial; pMaterial->IncrementReferenceCount(); } } #endif else { char pTemp[MAX_PATH]; char pMaterialName[MAX_PATH]; char pMaterialPath[MAX_PATH]; Q_StripExtension( pName, pTemp, sizeof(pTemp) ); Q_strlower( pTemp ); Q_FixSlashes( pTemp, '/' ); // Check to see if this is a UNC-specified material name bool bIsUNC = pTemp[0] == '/' && pTemp[1] == '/' && pTemp[2] != '/'; if ( !bIsUNC ) { Q_strncpy( pMaterialName, "materials/", sizeof(pMaterialName) ); Q_strncat( pMaterialName, pTemp, sizeof(pMaterialName), COPY_ALL_CHARACTERS ); } else { Q_strncpy( pMaterialName, pTemp, sizeof(pMaterialName) ); } Q_strncpy( pMaterialPath, pMaterialName, sizeof(pMaterialPath) ); Q_SetExtension( pMaterialPath, ".vmt", sizeof(pMaterialPath) ); for ( int i = 0; i < kRenderModeCount; ++i ) { m_material[i] = NULL; } KeyValues *kv = new KeyValues( "vmt" ); if ( !kv->LoadFromFile( g_pFullFileSystem, pMaterialPath, "GAME" ) ) { Warning( "Unable to load sprite material %s!\n", pMaterialPath ); return false; } for ( int i = 0; i < kRenderModeCount; ++i ) { if ( i == kRenderNone || i == kRenderEnvironmental ) { continue; } // strip possible materials/ Q_snprintf( pMaterialPath, sizeof(pMaterialPath), "%s_rendermode_%d", pMaterialName + ( bIsUNC ? 0 : 10 ), i ); KeyValues *pMaterialKV = kv->MakeCopy(); pMaterialKV->SetInt( "$spriteRenderMode", i ); m_material[i] = g_pMaterialSystem->FindProceduralMaterial( pMaterialPath, TEXTURE_GROUP_CLIENT_EFFECTS, pMaterialKV ); m_material[i]->IncrementReferenceCount(); } kv->deleteThis(); m_width = m_material[0]->GetMappingWidth(); m_height = m_material[0]->GetMappingHeight(); m_numFrames = m_material[0]->GetNumAnimationFrames(); } for ( int i = 0; i < kRenderModeCount; ++i ) { if ( i == kRenderNone || i == kRenderEnvironmental ) continue; if ( !m_material[i] ) return false; } IMaterialVar *orientationVar = m_material[0]->FindVarFast( "$spriteorientation", &spriteOrientationCache ); m_orientation = orientationVar ? orientationVar->GetIntValue() : C_SpriteRenderer::SPR_VP_PARALLEL_UPRIGHT; IMaterialVar *originVar = m_material[0]->FindVarFast( "$spriteorigin", &spriteOriginCache ); Vector origin, originVarValue; if( !originVar || ( originVar->GetType() != MATERIAL_VAR_TYPE_VECTOR ) ) { origin[0] = -m_width * 0.5f; origin[1] = m_height * 0.5f; } else { originVar->GetVecValue( &originVarValue[0], 3 ); origin[0] = -m_width * originVarValue[0]; origin[1] = m_height * originVarValue[1]; } up = origin[1]; down = origin[1] - m_height; left = origin[0]; right = m_width + origin[0]; return true; }