Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

251 lines
8.3 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Teeth renderer
//
// $Header: $
// $NoKeywords: $
//=============================================================================//
#include "BaseVSShader.h"
#include "mathlib/vmatrix.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
DEFINE_FALLBACK_SHADER( Eyes, Eyes_dx6 )
BEGIN_VS_SHADER( Eyes_dx6,
"Help for Eyes" )
BEGIN_SHADER_PARAMS
SHADER_PARAM( IRIS, SHADER_PARAM_TYPE_TEXTURE, "shadertest/BaseTexture", "iris texture" )
SHADER_PARAM( IRISFRAME, SHADER_PARAM_TYPE_INTEGER, "0", "frame for the iris texture" )
SHADER_PARAM( GLINT, SHADER_PARAM_TYPE_TEXTURE, "shadertest/BaseTexture", "glint texture" )
SHADER_PARAM( EYEORIGIN, SHADER_PARAM_TYPE_VEC3, "[0 0 0]", "origin for the eyes" )
SHADER_PARAM( EYEUP, SHADER_PARAM_TYPE_VEC3, "[0 0 1]", "up vector for the eyes" )
SHADER_PARAM( IRISU, SHADER_PARAM_TYPE_VEC4, "[0 1 0 0 ]", "U projection vector for the iris" )
SHADER_PARAM( IRISV, SHADER_PARAM_TYPE_VEC4, "[0 0 1 0]", "V projection vector for the iris" )
SHADER_PARAM( GLINTU, SHADER_PARAM_TYPE_VEC4, "[0 1 0 0]", "U projection vector for the glint" )
SHADER_PARAM( GLINTV, SHADER_PARAM_TYPE_VEC4, "[0 0 1 0]", "V projection vector for the glint" )
END_SHADER_PARAMS
SHADER_INIT_PARAMS()
{
// FLASHLIGHTFIXME
params[FLASHLIGHTTEXTURE]->SetStringValue( "effects/flashlight001" );
SET_FLAGS2( MATERIAL_VAR2_SUPPORTS_HW_SKINNING );
}
SHADER_INIT
{
LoadTexture( FLASHLIGHTTEXTURE );
LoadTexture( BASETEXTURE );
LoadTexture( IRIS );
}
void SetTextureTransform( IMaterialVar** params, IShaderDynamicAPI *pShaderAPI,
MaterialMatrixMode_t textureTransform, int uparam, int vparam )
{
Vector4D u, v;
params[uparam]->GetVecValue( u.Base(), 4 );
params[vparam]->GetVecValue( v.Base(), 4 );
// Need to transform these puppies into camera space
// they are defined in world space
VMatrix mat, invTrans;
pShaderAPI->GetMatrix( MATERIAL_VIEW, mat.m[0] );
mat = mat.Transpose();
// Compute the inverse transpose of the matrix
// NOTE: I only have to invert it here because VMatrix is transposed
// with respect to what gets returned from GetMatrix.
mat.InverseGeneral( invTrans );
invTrans = invTrans.Transpose();
// Transform the u and v planes into view space
Vector4D uview, vview;
uview.AsVector3D() = invTrans.VMul3x3( u.AsVector3D() );
vview.AsVector3D() = invTrans.VMul3x3( v.AsVector3D() );
uview[3] = u[3] - DotProduct( mat.GetTranslation(), uview.AsVector3D() );
vview[3] = v[3] - DotProduct( mat.GetTranslation(), vview.AsVector3D() );
float m[16];
m[0] = uview[0]; m[1] = vview[0]; m[2] = 0.0f; m[3] = 0.0f;
m[4] = uview[1]; m[5] = vview[1]; m[6] = 0.0f; m[7] = 0.0f;
m[8] = uview[2]; m[9] = vview[2]; m[10] = 1.0f; m[11] = 0.0f;
m[12] = uview[3]; m[13] = vview[3]; m[14] = 0.0f; m[15] = 1.0f;
pShaderAPI->MatrixMode( textureTransform );
pShaderAPI->LoadMatrix( m );
}
void DrawFlashlight_Iris( IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow )
{
SHADOW_STATE
{
SET_FLAGS2( MATERIAL_VAR2_NEEDS_FIXED_FUNCTION_FLASHLIGHT );
// Alpha blend
pShaderShadow->EnableBlending( true );
pShaderShadow->BlendFunc( SHADER_BLEND_SRC_ALPHA, SHADER_BLEND_ONE_MINUS_SRC_ALPHA );
pShaderShadow->EnableDepthWrites( false );
pShaderShadow->EnableAlphaWrites( false );
int flags = SHADER_DRAW_POSITION | SHADER_DRAW_COLOR | SHADER_DRAW_NORMAL;
pShaderShadow->DrawFlags( flags );
FogToBlack();
pShaderShadow->EnableLighting( true );
pShaderShadow->EnableCustomPixelPipe( true );
pShaderShadow->CustomTextureStages( 2 );
pShaderShadow->CustomTextureOperation( SHADER_TEXTURE_STAGE0,
SHADER_TEXCHANNEL_COLOR,
SHADER_TEXOP_MODULATE,
SHADER_TEXARG_TEXTURE,
SHADER_TEXARG_VERTEXCOLOR );
pShaderShadow->CustomTextureOperation( SHADER_TEXTURE_STAGE1,
SHADER_TEXCHANNEL_COLOR,
SHADER_TEXOP_MODULATE,
SHADER_TEXARG_TEXTURE, SHADER_TEXARG_PREVIOUSSTAGE );
// alpha stage 0
// get alpha from constant alpha
pShaderShadow->CustomTextureOperation( SHADER_TEXTURE_STAGE0,
SHADER_TEXCHANNEL_ALPHA,
SHADER_TEXOP_SELECTARG1,
SHADER_TEXARG_CONSTANTCOLOR, SHADER_TEXARG_NONE );
// alpha stage 1
// get alpha from $basetexture
pShaderShadow->CustomTextureOperation( SHADER_TEXTURE_STAGE1,
SHADER_TEXCHANNEL_ALPHA,
SHADER_TEXOP_MODULATE,
SHADER_TEXARG_TEXTURE, SHADER_TEXARG_PREVIOUSSTAGE );
pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );
// Shove the view position into texcoord 0 before the texture matrix.
pShaderShadow->TexGen( SHADER_TEXTURE_STAGE0, SHADER_TEXGENPARAM_EYE_LINEAR );
pShaderShadow->EnableTexGen( SHADER_TEXTURE_STAGE0, true );
// iris transform
pShaderShadow->EnableTexGen( SHADER_TEXTURE_STAGE1, true );
pShaderShadow->TexGen( SHADER_TEXTURE_STAGE1, SHADER_TEXGENPARAM_EYE_LINEAR );
}
DYNAMIC_STATE
{
SetFlashlightFixedFunctionTextureTransform( MATERIAL_TEXTURE0 );
// NOTE: This has to come after the loadmatrix since the loadmatrix screws with the
// transform flags!!!!!!
// Specify that we have XYZ texcoords that need to be divided by W before the pixel shader.
// NOTE Tried to divide XY by Z, but doesn't work.
pShaderAPI->SetTextureTransformDimension( SHADER_TEXTURE_STAGE0, 3, true );
BindTexture( SHADER_SAMPLER0, FLASHLIGHTTEXTURE, FLASHLIGHTTEXTUREFRAME );
BindTexture( SHADER_SAMPLER1, IRIS, IRISFRAME );
SetTextureTransform( params, pShaderAPI, MATERIAL_TEXTURE1, IRISU, IRISV );
}
Draw();
}
void DrawFlashlight( IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow )
{
// whites
DrawFlashlight_dx70( params, pShaderAPI, pShaderShadow,
FLASHLIGHTTEXTURE, FLASHLIGHTTEXTUREFRAME, true );
// iris
DrawFlashlight_Iris( params, pShaderAPI, pShaderShadow );
}
void DrawUsingSoftwareLighting( IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow )
{
// whites
SHADOW_STATE
{
pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
pShaderShadow->OverbrightValue( SHADER_TEXTURE_STAGE0, OVERBRIGHT );
pShaderShadow->DrawFlags( SHADER_DRAW_POSITION | SHADER_DRAW_COLOR | SHADER_DRAW_TEXCOORD0 );
FogToFogColor();
}
DYNAMIC_STATE
{
BindTexture( SHADER_SAMPLER0, BASETEXTURE, FRAME );
}
Draw();
// iris
SHADOW_STATE
{
pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
pShaderShadow->OverbrightValue( SHADER_TEXTURE_STAGE0, OVERBRIGHT );
pShaderShadow->DrawFlags( SHADER_DRAW_POSITION | SHADER_DRAW_COLOR );
pShaderShadow->EnableTexGen( SHADER_TEXTURE_STAGE0, true );
pShaderShadow->TexGen( SHADER_TEXTURE_STAGE0, SHADER_TEXGENPARAM_EYE_LINEAR );
pShaderShadow->EnableBlending( true );
pShaderShadow->BlendFunc( SHADER_BLEND_SRC_ALPHA, SHADER_BLEND_ONE_MINUS_SRC_ALPHA );
FogToFogColor();
}
DYNAMIC_STATE
{
BindTexture( SHADER_SAMPLER0, IRIS, IRISFRAME );
SetTextureTransform( params, pShaderAPI, MATERIAL_TEXTURE0, IRISU, IRISV );
}
Draw();
// Glint
SHADOW_STATE
{
pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
pShaderShadow->EnableTexture( SHADER_SAMPLER1, false );
pShaderShadow->OverbrightValue( SHADER_TEXTURE_STAGE0, 1.0f );
pShaderShadow->OverbrightValue( SHADER_TEXTURE_STAGE1, 1.0f );
pShaderShadow->EnableConstantColor( true );
pShaderShadow->EnableDepthWrites( false );
pShaderShadow->EnableBlending( true );
pShaderShadow->BlendFunc( SHADER_BLEND_SRC_ALPHA, SHADER_BLEND_ONE );
pShaderShadow->EnableTexGen( SHADER_TEXTURE_STAGE0, true );
pShaderShadow->TexGen( SHADER_TEXTURE_STAGE0, SHADER_TEXGENPARAM_EYE_LINEAR );
pShaderShadow->DrawFlags( SHADER_DRAW_POSITION );
FogToBlack();
}
DYNAMIC_STATE
{
BindTexture( SHADER_SAMPLER0, GLINT );
SetTextureTransform( params, pShaderAPI, MATERIAL_TEXTURE0, GLINTU, GLINTV );
}
Draw( );
}
SHADER_DRAW
{
SHADOW_STATE
{
SET_FLAGS2( MATERIAL_VAR2_LIGHTING_VERTEX_LIT );
}
bool hasFlashlight = UsingFlashlight( params );
if( hasFlashlight )
{
DrawFlashlight( params, pShaderAPI, pShaderShadow );
}
else
{
DrawUsingSoftwareLighting( params, pShaderAPI, pShaderShadow );
}
}
END_SHADER