Night Vision
Night Vision is something that many people have been stumped on, but it has already been implemented in the NightFall mod.
Summary
This example is a very early attempt (it works), and just one of many ways to get the Night Vision Mode to work with your mod.
Setting up the ConVar
Open the file src/cl_dll/view_scene.cpp, and append the code below to the end of this ifdef
//-----------------------------------------------------------------------------
// Precache of necessary materials
//-----------------------------------------------------------------------------
#ifdef HL2_CLIENT_DLL
Found around line 170 (to go to a line number quickly, press ctrl+g)
//Precache Night Vision
CLIENTEFFECT_MATERIAL( "HUDoverlays/nightvision" )
Now jump to the end of the page (ctrl+end) and add this class
//nightfall - amckern - [email protected]
//NightVision
static void ScreenOver_f( void )
{
IMaterial *pMaterial = materials->FindMaterial( "HUDoverlays/nightvision", TEXTURE_GROUP_OTHER, true );
//This is the texture we are going to use for the 'effect' - never use an ext on material files
{
static bool bDisplayed = false;
if( bDisplayed )
{
// turn it off
view->SetScreenOverlayMaterial( NULL );
// Deactivate the 'light'
cvar->FindVar("mat_fullbright")->SetValue(0);
CLocalPlayerFilter filter;
C_BaseEntity::EmitSound( filter, 0, "Nightfall.NightVisOff" );
//play the off sound
}
else
{
// turn it on
view->SetScreenOverlayMaterial( pMaterial );
//this is the HUDoverlays/nightvision texture we made a pointer to above
// Activate the 'light'
cvar->FindVar("mat_fullbright")->SetValue(1);
CLocalPlayerFilter filter;
C_BaseEntity::EmitSound( filter, 0, "Nightfall.NightVisOn" );
//On we go - play a sound to let the player know that the NV is on
}
bDisplayed = !bDisplayed;
//check if fullbright has been disabled, or enabled
if (cvar->FindVar("mat_fullbright")->GetInt() == 1)//is it on?
cvar->FindVar("mat_fullbright")->SetValue(0);//well turn it off.
}
}
static ConCommand r_screenover( "r_screenover", ScreenOver_f );
So what we have done here is set a bool cvar (on/off) that either enables or disables the night vision effect. If you read the comments, you will understand what each part does.
This section has been edited to keep the Fullbright cheat a cheat, to stop people exploiting it - the code has been updated from that supplied in the comments.
It might sound strange to have the off function first, but you don't want the player to be running around the game with night vision turned on from the time they spawn.
The sound
Nightfall.NightVisOn / Nightfall.NightVisOff
This code is calling on the script file nightfall_engine_sounds.txt that in turn is precached in game_sounds_manifest.txt like so
"precache_file" "scripts/nightfall_engine_sounds.txt"
Sounds are precached with PrecacheScript("Nightfall.NightVisOn"); in the player.cpp precache function, just in case you are wondering why the game lags when you go to use the sound effect.
You can always use a direct sound event like engine->ClientCmd( "play your_effect_sound.wav\n"); if you don't know how to make a soundscript sound. The downside of this is the game will always lag while it loads the sound file for the first time, and from what is understood, there is no way to precache a sound file directly within the code.
Nightvision with shaders
Creating nightvision with a shader requires a 5 things, the HLSL pixel and vertex shader files, the C++ shader file, the material using the shader and a way to trigger the material from the game. This assumes you have set up and know how to compile shaders as shown here. Credit goes to wraiyth for his amazingly useful tutorials on HLSL.
The pixel shader:
#include "common_ps_fxc.h"
const HALF Brightness : register (c0); //this is a variable to set how bright the NV will be.
sampler BaseTextureSampler : register( s0 ); //a sampler to get the texture this shader will be used on (in this case it will be a frame buffer)
HALF4 main(float2 iTexCoord : TEXCOORD0) : COLOR //out main function
{
float4 vAdd = float4(0.1,0.1,0.1,0); // just a float4 for use later
float4 cColor = tex2D(BaseTextureSampler,iTexCoord); //this takes our sampler and turns the rgba into floats between 0 and 1
cColor += tex2D(BaseTextureSampler, iTexCoord.xy + 0.001); // these 3 lines blur the image slightly
cColor += tex2D(BaseTextureSampler, iTexCoord.xy + 0.002);
cColor += tex2D(BaseTextureSampler, iTexCoord.xy + 0.003);
if (((cColor.r + cColor.g + cColor.b)/3) < 0.9) // if the pixel is bright leave it bright
{
cColor = cColor / 4; //otherwise set it to an average color of the 4 images we just added together
}
float4 cTempColor = cColor; //a new float4 cTempColor for use later
float4 cFinal = cTempColor + vAdd; //adds the floats together
cFinal.g = (cTempColor.r + cTempColor.g + cTempColor.b)/3; // sets green the the average of rgb
cFinal.r = 0; //removes red and blue colors
cFinal.b = 0;
return cFinal * Brightness; // brighten the final image and return it
}
Save this as post_nightvision_ps20.fxc.
Next up the vertex shader:
#include "common_vs_fxc.h"
void main( in float4 iPosition : POSITION, in float2 iTexCoord : TEXCOORD0, out float4 oPosition : POSITION, out float2 oTexCoord : TEXCOORD0)
{
oPosition=iPosition;
oTexCoord=iTexCoord;
}
Save this as PassThrough_vs20.fxc and compile the 2 shaders.
Next the C++ file:
#include "BaseVSShader.h"
#include "post_nightvision_ps20.inc"
#include "PassThrough_vs20.inc" //files generated by compiling the fxc files
BEGIN_VS_SHADER( Post_NightVision, "Help for Post_NightVision" ) //Begin the shader
BEGIN_SHADER_PARAMS
SHADER_PARAM(NVLEVEL, SHADER_PARAM_TYPE_FLOAT, "1.0", "")
//This is our shader parameter taken from the material file called NVLEVEL, write "$nvlevel" 10 for example in the .vmt
END_SHADER_PARAMS
SHADER_INIT_PARAMS() //called after parameters have been initialized
{
}
SHADER_FALLBACK //doesn't fallback to anything (I know this works on dx9, hasn't been tested on others)
{
return 0;
}
bool NeedsFullFrameBufferTexture( IMaterialVar **params ) const //does this need the full screen? in our case yes
{
return true;
}
SHADER_INIT //initializes the shader
{
}
SHADER_DRAW
{
SHADOW_STATE
{
pShaderShadow->EnableTexture( SHADER_TEXTURE_STAGE0, true ); //enables SHADER_TEXTURE_STAGE0
pShaderShadow->EnableDepthWrites( false ); //depth writes aren't needed
int fmt = VERTEX_POSITION;
pShaderShadow->VertexShaderVertexFormat( fmt, 1, 0, 0, 0 ); //sets the vertex format for the .fxc
pShaderShadow->SetVertexShader( "PassThrough_vs20", 0 ); //set the vertex shader
pShaderShadow->SetPixelShader( "post_nightvision_ps20" ); //set the pixel shader
DefaultFog();
}
DYNAMIC_STATE
{
float Scale = params[NVLEVEL]->GetFloatValue(); // get the value of NVLEVEL and turn it to a float
float vScale[4] = {Scale, Scale, Scale, 1}; //new float using NVLEVEL values
pShaderAPI->SetPixelShaderConstant(0, vScale); //set the first shader variable to our float
pShaderAPI->BindFBTexture( SHADER_TEXTURE_STAGE0 ); //set the shader texture to our frame buffer
}
Draw(); //draw the shader
}
END_SHADER
Add that to the game_shader_generic_sample project (or whatever other one your using) and compile it.
Now create a material in your mods materials folder all it needs is a .vmt file:
"Post_NightVision"
{
"$basetexture" "_rt_FullFrameFB"
"$nvlevel" 10 //can be whatever value you want
}
Now open view_scene.cpp in the client project of you mod and add the following code at the bottom:
//-----------------------------------------------------------------------------
// NightVision
//-----------------------------------------------------------------------------
static void NightVision_f ( void )
{
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer(); //get the local player
const Vector *vOrigin = &pPlayer->GetAbsOrigin(); //get the local players origin
static bool bDisplayed; //static bool
if ( bDisplayed )
{
view->SetScreenOverlayMaterial( null ); //set screenoverlay to nothing
CLocalPlayerFilter filter;
pPlayer->EmitSound(filter, 0, "TestMod.NightVisionOff", vOrigin); //and play sound
}
else
{
IMaterial *pMaterial = materials->FindMaterial( "NightVision", TEXTURE_GROUP_OTHER, true); //set pMaterial to our texture
view->SetScreenOverlayMaterial( pMaterial ); //and overlay it on the screen
CLocalPlayerFilter filter;
pPlayer->EmitSound(filter, 0, "TestMod.NightVisionOn", vOrigin); //and play a sound
}
bDisplayed = !bDisplayed; // flip flop the bool
}
//night vision console command
static ConCommand r_nightvision( "r_nightvision", NightVision_f ); // console command to trigger the function, bind it by typing bind n r_nightvision.
Compile it and you should have fully working shader driven night vision, customize it to your desire. You can also precache the sounds and material as explained earlier.
