mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2025-03-14 06:34:10 +00:00
Added filmic post process effects
This commit is contained in:
Robert Beckebans
parent
a38bfe949e
commit
da7eedf04d
10 changed files with 213 additions and 30 deletions
|
|
@ -181,7 +181,8 @@ float rand( float2 co ) {
|
|||
#define DEG2RAD( a ) ( ( a ) * PI / 180.0f )
|
||||
#define RAD2DEG( a ) ( ( a ) * 180.0f / PI )
|
||||
|
||||
static const half4 LUMINANCE_VECTOR = half4( 0.2125, 0.7154, 0.0721, 0.0 );
|
||||
static const half4 LUMINANCE_SRGB = half4( 0.2125, 0.7154, 0.0721, 0.0 );
|
||||
static const half4 LUMINANCE_LINEAR = half4( 0.299, 0.587, 0.144, 0.0 );
|
||||
// RB end
|
||||
|
||||
#define _half2( x ) half2( x )
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@
|
|||
|
||||
Doom 3 BFG Edition GPL Source Code
|
||||
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
|
||||
Copyright (C) 2014 Robert Beckebans
|
||||
Copyright (C) 2014-2015 Robert Beckebans
|
||||
|
||||
This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").
|
||||
|
||||
|
|
@ -74,7 +74,7 @@ void main( PS_IN fragment, out PS_OUT result )
|
|||
const float3 chromaticOffsets[9] = float3[](
|
||||
float3(0.5, 0.5, 0.5), // w
|
||||
float3(0.8, 0.3, 0.3),
|
||||
//float3(1.0, 0.2, 0.2), // r
|
||||
// float3(1.0, 0.2, 0.2), // r
|
||||
float3(0.5, 0.2, 0.8),
|
||||
float3(0.2, 0.2, 1.0), // b
|
||||
float3(0.2, 0.3, 0.9),
|
||||
|
|
@ -91,10 +91,9 @@ void main( PS_IN fragment, out PS_OUT result )
|
|||
const int tap = 4;
|
||||
const int samples = 9;
|
||||
|
||||
float scale = 13.0;
|
||||
const float weightScale = 2.7;
|
||||
float scale = 13.0; // bloom width
|
||||
const float weightScale = 2.3; // bloom strength
|
||||
|
||||
//for( int i = -tap; i < tap; i++ )
|
||||
for( int i = 0; i < samples; i++ )
|
||||
{
|
||||
//float t = ( ( float( 4 + ( i ) ) ) / ( float( samples ) - 1.0 ) );
|
||||
|
|
@ -103,13 +102,10 @@ void main( PS_IN fragment, out PS_OUT result )
|
|||
|
||||
//float3 so = spectrumoffset( t );
|
||||
float3 so = chromaticOffsets[ i ];
|
||||
//float3 so = float3( 1.0 );
|
||||
float4 color = tex2D( samp0, st + float2( float( i ), 0 ) * rpWindowCoord.xy * scale );
|
||||
|
||||
float weight = gaussFact[ i ];
|
||||
//sumColor += color.rgb * ( so.rgb * weight * weightScale );
|
||||
sumColor += color.rgb * ( so.rgb * weight * weightScale );
|
||||
sumSpectrum += ( so.rgb * weight * weightScale );
|
||||
}
|
||||
|
||||
#if 1
|
||||
|
|
@ -123,7 +119,6 @@ void main( PS_IN fragment, out PS_OUT result )
|
|||
|
||||
float weight = gaussFact[ i ];
|
||||
sumColor += color.rgb * ( so.rgb * weight * weightScale );
|
||||
sumSpectrum += ( so.rgb * weight * weightScale );
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -2,9 +2,10 @@
|
|||
===========================================================================
|
||||
|
||||
Doom 3 BFG Edition GPL Source Code
|
||||
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
|
||||
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
|
||||
Copyright (C) 2015 Robert Beckebans
|
||||
|
||||
This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").
|
||||
This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").
|
||||
|
||||
Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
|
|
@ -28,18 +29,130 @@ If you have questions concerning this license or the applicable additional terms
|
|||
|
||||
#include "renderprogs/global.inc"
|
||||
|
||||
// *INDENT-OFF*
|
||||
uniform sampler2D samp0 : register(s0);
|
||||
|
||||
struct PS_IN {
|
||||
uniform sampler2D samp1 : register(s1);
|
||||
|
||||
struct PS_IN
|
||||
{
|
||||
float4 position : VPOS;
|
||||
float2 texcoord0 : TEXCOORD0_centroid;
|
||||
};
|
||||
|
||||
struct PS_OUT {
|
||||
|
||||
struct PS_OUT
|
||||
{
|
||||
float4 color : COLOR;
|
||||
};
|
||||
// *INDENT-ON*
|
||||
|
||||
void main( PS_IN fragment, out PS_OUT result ) {
|
||||
float2 tCoords = fragment.texcoord0;
|
||||
result.color = tex2D( samp0, tCoords );
|
||||
#define USE_TECHNICOLOR 1 // [0 or 1]
|
||||
|
||||
#define Technicolor_Amount 0.5 // [0.00 to 1.00]
|
||||
#define Technicolor_Power 4.0 // [0.00 to 8.00]
|
||||
#define Technicolor_RedNegativeAmount 0.88 // [0.00 to 1.00]
|
||||
#define Technicolor_GreenNegativeAmount 0.88 // [0.00 to 1.00]
|
||||
#define Technicolor_BlueNegativeAmount 0.88 // [0.00 to 1.00]
|
||||
|
||||
#define USE_VIBRANCE 1
|
||||
#define Vibrance 0.75 // [-1.00 to 1.00]
|
||||
#define Vibrance_RGB_Balance float3( 1.0, 1.0, 1.0 )
|
||||
|
||||
#define USE_FILMGRAIN 1
|
||||
|
||||
float3 overlay( float3 a, float3 b )
|
||||
{
|
||||
//return pow( abs( b ), 2.2 ) < 0.5 ? ( 2.0 * a * b ) : float3( 1.0, 1.0, 1.0 ) - float3( 2.0, 2.0, 2.0 ) * ( float3( 1.0, 1.0, 1.0 ) - a ) * ( 1.0 - b );
|
||||
//return abs( b ) < 0.5 ? ( 2.0 * a * b ) : float3( 1.0, 1.0, 1.0 ) - float3( 2.0, 2.0, 2.0 ) * ( float3( 1.0, 1.0, 1.0 ) - a ) * ( 1.0 - b );
|
||||
|
||||
return float3(
|
||||
b.x < 0.5 ? ( 2.0 * a.x * b.x ) : ( 1.0 - 2.0 * ( 1.0 - a.x ) * ( 1.0 - b.x ) ),
|
||||
b.y < 0.5 ? ( 2.0 * a.y * b.y ) : ( 1.0 - 2.0 * ( 1.0 - a.y ) * ( 1.0 - b.y ) ),
|
||||
b.z < 0.5 ? ( 2.0 * a.z * b.z ) : ( 1.0 - 2.0 * ( 1.0 - a.z ) * ( 1.0 - b.z ) ) );
|
||||
}
|
||||
|
||||
|
||||
void TechnicolorPass( inout float4 color )
|
||||
{
|
||||
const float3 cyanFilter = float3( 0.0, 1.30, 1.0 );
|
||||
const float3 magentaFilter = float3( 1.0, 0.0, 1.05 );
|
||||
const float3 yellowFilter = float3( 1.6, 1.6, 0.05 );
|
||||
const float3 redOrangeFilter = float3( 1.05, 0.62, 0.0 );
|
||||
const float3 greenFilter = float3( 0.3, 1.0, 0.0 );
|
||||
|
||||
float2 redNegativeMul = color.rg * ( 1.0 / ( Technicolor_RedNegativeAmount * Technicolor_Power ) );
|
||||
float2 greenNegativeMul = color.rg * ( 1.0 / ( Technicolor_GreenNegativeAmount * Technicolor_Power ) );
|
||||
float2 blueNegativeMul = color.rb * ( 1.0 / ( Technicolor_BlueNegativeAmount * Technicolor_Power ) );
|
||||
|
||||
float redNegative = dot( redOrangeFilter.rg, redNegativeMul );
|
||||
float greenNegative = dot( greenFilter.rg, greenNegativeMul );
|
||||
float blueNegative = dot( magentaFilter.rb, blueNegativeMul );
|
||||
|
||||
float3 redOutput = float3( redNegative ) + cyanFilter;
|
||||
float3 greenOutput = float3( greenNegative ) + magentaFilter;
|
||||
float3 blueOutput = float3( blueNegative ) + yellowFilter;
|
||||
|
||||
float3 result = redOutput * greenOutput * blueOutput;
|
||||
color.rgb = lerp( color.rgb, result, Technicolor_Amount );
|
||||
}
|
||||
|
||||
|
||||
void VibrancePass( inout float4 color )
|
||||
{
|
||||
const float3 vibrance = Vibrance_RGB_Balance * Vibrance;
|
||||
|
||||
float Y = dot( LUMINANCE_SRGB, color );
|
||||
|
||||
float minColor = min( color.r, min( color.g, color.b ) );
|
||||
float maxColor = max( color.r, max( color.g, color.b ) );
|
||||
|
||||
float colorSat = maxColor - minColor;
|
||||
|
||||
color.rgb = lerp( float3( Y ), color.rgb, ( 1.0 + ( vibrance * ( 1.0 - ( sign( vibrance ) * colorSat ) ) ) ) );
|
||||
}
|
||||
|
||||
|
||||
void FilmgrainPass( inout float4 color )
|
||||
{
|
||||
float4 jitterTC = ( fragment.position * rpScreenCorrectionFactor ) + rpJitterTexOffset;
|
||||
//float4 jitterTC = ( fragment.position * ( 1.0 / 128.0 ) ) + rpJitterTexOffset;
|
||||
//float2 jitterTC = fragment.position.xy * 2.0;
|
||||
//jitterTC.x *= rpWindowCoord.y / rpWindowCoord.x;
|
||||
|
||||
float4 noiseColor = tex2D( samp1, fragment.position.xy + jitterTC.xy );
|
||||
float Y = noiseColor.r;
|
||||
//float Y = dot( LUMINANCE_VECTOR, noiseColor );
|
||||
//noiseColor.rgb = float3( Y, Y, Y );
|
||||
|
||||
float exposureFactor = 1.0;
|
||||
exposureFactor = sqrt( exposureFactor );
|
||||
const float noiseIntensity = 1.7; //rpScreenCorrectionFactor.z;
|
||||
|
||||
float t = lerp( 3.5 * noiseIntensity, 1.13 * noiseIntensity, exposureFactor );
|
||||
color.rgb = overlay( color.rgb, lerp( float3( 0.5 ), noiseColor.rgb, t ) );
|
||||
|
||||
//color.rgb = noiseColor.rgb;
|
||||
//color.rgb = lerp( color.rgb, noiseColor.rgb, 0.3 );
|
||||
}
|
||||
|
||||
|
||||
void main( PS_IN fragment, out PS_OUT result )
|
||||
{
|
||||
float2 tCoords = fragment.texcoord0;
|
||||
|
||||
// base color with tone mapping and other post processing applied
|
||||
float4 color = tex2D( samp0, tCoords );
|
||||
|
||||
#if USE_TECHNICOLOR
|
||||
TechnicolorPass( color );
|
||||
#endif
|
||||
|
||||
#if USE_VIBRANCE
|
||||
VibrancePass( color );
|
||||
#endif
|
||||
|
||||
#if USE_FILMGRAIN
|
||||
FilmgrainPass( color );
|
||||
#endif
|
||||
|
||||
result.color = color;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -68,7 +68,7 @@ void main( PS_IN fragment, out PS_OUT result )
|
|||
float4 color = tex2D( samp0, tCoords );
|
||||
|
||||
// get the luminance of the current pixel
|
||||
float Y = dot( LUMINANCE_VECTOR, color );
|
||||
float Y = dot( LUMINANCE_SRGB, color );
|
||||
|
||||
#if 1
|
||||
// convert from sRGB to linear RGB
|
||||
|
|
@ -105,7 +105,7 @@ void main( PS_IN fragment, out PS_OUT result )
|
|||
#else
|
||||
// Uncharted 2 tone mapper but looks weird :(
|
||||
|
||||
float exposure = ( hdrKey / hdrAverageLuminance ) * 0.4;
|
||||
float exposure = ( hdrKey / hdrAverageLuminance ) * 0.2;
|
||||
//float exposure = Yr * 1.0;
|
||||
float3 exposedColor = exposure * color.rgb;
|
||||
|
||||
|
|
@ -143,7 +143,7 @@ void main( PS_IN fragment, out PS_OUT result )
|
|||
|
||||
#if defined(HDR_DEBUG)
|
||||
//color = tex2D( samp1, float2( L, 0.0 ) );
|
||||
color = tex2D( samp1, float2( dot( LUMINANCE_VECTOR, color ), 0.0 ) );
|
||||
color = tex2D( samp1, float2( dot( LUMINANCE_SRGB, color ), 0.0 ) );
|
||||
#endif
|
||||
|
||||
result.color = color;
|
||||
|
|
|
|||
|
|
@ -1,4 +1,5 @@
|
|||
astyle.exe -v --formatted --options=astyle-options.ini --exclude="libs" --recursive *.h
|
||||
astyle.exe -v --formatted --options=astyle-options.ini --exclude="libs" --exclude="d3xp/gamesys/SysCvar.cpp" --exclude="d3xp/gamesys/Callbacks.cpp" --exclude="sys/win32/win_cpu.cpp" --exclude="sys/win32/win_main.cpp" --recursive *.cpp
|
||||
astyle.exe -v -Q --options=astyle-options.ini ../base/renderprogs/postprocess.pixel
|
||||
|
||||
pause
|
||||
|
|
@ -349,6 +349,7 @@ public:
|
|||
idImage* jitterImage1; // shadow jitter
|
||||
idImage* jitterImage4;
|
||||
idImage* jitterImage16;
|
||||
idImage* grainImage1;
|
||||
idImage* randomImage256;
|
||||
idImage* currentRenderHDRImage;
|
||||
idImage* currentRenderHDRImageNoMSAA;
|
||||
|
|
|
|||
|
|
@ -589,6 +589,8 @@ static void R_CreateRandom256Image( idImage* image )
|
|||
image->GenerateImage( ( byte* )data, 256, 256, TF_NEAREST, TR_REPEAT, TD_LOOKUP_TABLE_RGBA );
|
||||
}
|
||||
|
||||
|
||||
|
||||
static void R_CreateHeatmap5ColorsImage( idImage* image )
|
||||
{
|
||||
int x, y;
|
||||
|
|
@ -690,6 +692,39 @@ static void R_CreateHeatmap7ColorsImage( idImage* image )
|
|||
|
||||
image->GenerateImage( ( byte* )data, FALLOFF_TEXTURE_SIZE, 16, TF_LINEAR, TR_CLAMP, TD_LOOKUP_TABLE_RGBA );
|
||||
}
|
||||
|
||||
static void R_CreateGrainImage1( idImage* image )
|
||||
{
|
||||
const static int GRAIN_SIZE = 128;
|
||||
|
||||
static byte data[GRAIN_SIZE][GRAIN_SIZE][4];
|
||||
|
||||
idRandom2 random( Sys_Milliseconds() );
|
||||
|
||||
for( int i = 0 ; i < GRAIN_SIZE ; i++ )
|
||||
{
|
||||
for( int j = 0 ; j < GRAIN_SIZE ; j++ )
|
||||
{
|
||||
#if 0
|
||||
//int value = 127 - 8 + ( rand() & 15 ); //random.RandomInt( 127 );
|
||||
int value = 127 - 8 + random.RandomInt( 15 );
|
||||
|
||||
data[i][j][0] = value;
|
||||
data[i][j][1] = value;
|
||||
data[i][j][2] = value;
|
||||
data[i][j][3] = 0;
|
||||
#else
|
||||
data[i][j][0] = 127 - 8 + random.RandomInt( 15 );
|
||||
data[i][j][1] = 127 - 8 + random.RandomInt( 15 );
|
||||
data[i][j][2] = 127 - 8 + random.RandomInt( 15 );
|
||||
data[i][j][3] = 0;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
image->GenerateImage( ( byte* )data, GRAIN_SIZE, GRAIN_SIZE, TF_NEAREST, TR_REPEAT, TD_LOOKUP_TABLE_RGBA );
|
||||
}
|
||||
|
||||
// RB end
|
||||
|
||||
/*
|
||||
|
|
@ -733,6 +768,8 @@ void idImageManager::CreateIntrinsicImages()
|
|||
|
||||
heatmap5Image = ImageFromFunction( "_heatmap5", R_CreateHeatmap5ColorsImage );
|
||||
heatmap7Image = ImageFromFunction( "_heatmap7", R_CreateHeatmap7ColorsImage );
|
||||
|
||||
grainImage1 = globalImages->ImageFromFunction( "_grain1", R_CreateGrainImage1 );
|
||||
// RB end
|
||||
|
||||
// scratchImage is used for screen wipes/doublevision etc..
|
||||
|
|
|
|||
|
|
@ -246,16 +246,18 @@ idCVar r_shadowMapSunDepthBiasScale( "r_shadowMapSunDepthBiasScale", "0.999991",
|
|||
|
||||
// RB: HDR parameters
|
||||
idCVar r_useHDR( "r_useHDR", "1", CVAR_RENDERER | CVAR_ARCHIVE | CVAR_BOOL, "use high dynamic range rendering" );
|
||||
idCVar r_hdrMinLuminance( "r_hdrMinLuminance", "0.001", CVAR_RENDERER | CVAR_FLOAT, "" );
|
||||
idCVar r_hdrMinLuminance( "r_hdrMinLuminance", "0.01", CVAR_RENDERER | CVAR_FLOAT, "" );
|
||||
idCVar r_hdrMaxLuminance( "r_hdrMaxLuminance", "3000", CVAR_RENDERER | CVAR_FLOAT, "" );
|
||||
idCVar r_hdrKey( "r_hdrKey", "0.18", CVAR_RENDERER | CVAR_FLOAT, "" );
|
||||
idCVar r_hdrContrastThreshold( "r_hdrContrastThreshold", "13", CVAR_RENDERER | CVAR_FLOAT, "" );
|
||||
idCVar r_hdrKey( "r_hdrKey", "0.18", CVAR_RENDERER | CVAR_FLOAT, "mid-gray 0.5 in linear RGB space (without gamma curve applied)" );
|
||||
idCVar r_hdrContrastThreshold( "r_hdrContrastThreshold", "13", CVAR_RENDERER | CVAR_FLOAT, "all pixels brighter than this cause HDR bloom glares" );
|
||||
idCVar r_hdrContrastOffset( "r_hdrContrastOffset", "100", CVAR_RENDERER | CVAR_FLOAT, "" );
|
||||
idCVar r_hdrGlarePasses( "r_hdrGlarePasses", "8", CVAR_RENDERER | CVAR_INTEGER, "" );
|
||||
idCVar r_hdrDebug( "r_hdrDebug", "0", CVAR_RENDERER | CVAR_FLOAT, "" );
|
||||
idCVar r_hdrGlarePasses( "r_hdrGlarePasses", "8", CVAR_RENDERER | CVAR_INTEGER, "how many times the bloom blur is rendered offscreen. number should be even" );
|
||||
idCVar r_hdrDebug( "r_hdrDebug", "0", CVAR_RENDERER | CVAR_FLOAT, "show scene luminance as heat map" );
|
||||
|
||||
idCVar r_ldrContrastThreshold( "r_ldrContrastThreshold", "1.1", CVAR_RENDERER | CVAR_FLOAT, "" );
|
||||
idCVar r_ldrContrastOffset( "r_ldrContrastOffset", "3", CVAR_RENDERER | CVAR_FLOAT, "" );
|
||||
|
||||
idCVar r_useFilmicPostProcessEffects( "r_useFilmicPostProcessEffects", "1", CVAR_RENDERER | CVAR_ARCHIVE | CVAR_BOOL, "apply several post process effects to mimic a filmic look" );
|
||||
// RB end
|
||||
|
||||
const char* fileExten[3] = { "tga", "png", "jpg" };
|
||||
|
|
|
|||
|
|
@ -3815,7 +3815,7 @@ static void RB_CalculateAdaptation()
|
|||
float avgLuminance;
|
||||
float maxLuminance;
|
||||
double sum;
|
||||
const idVec3 LUMINANCE_VECTOR( 0.2125f, 0.7154f, 0.0721f ); // FIXME be careful wether this should be linear RGB or sRGB
|
||||
const idVec3 LUMINANCE_SRGB( 0.2125f, 0.7154f, 0.0721f ); // be careful wether this should be linear RGB or sRGB
|
||||
idVec4 color;
|
||||
float newAdaptation;
|
||||
float newMaximum;
|
||||
|
|
@ -3838,7 +3838,7 @@ static void RB_CalculateAdaptation()
|
|||
color[2] = image[i * 4 + 2];
|
||||
color[3] = image[i * 4 + 3];
|
||||
|
||||
luminance = ( color.x * LUMINANCE_VECTOR.x + color.y * LUMINANCE_VECTOR.y + color.z * LUMINANCE_VECTOR.z ) + 0.0001f;
|
||||
luminance = ( color.x * LUMINANCE_SRGB.x + color.y * LUMINANCE_SRGB.y + color.z * LUMINANCE_SRGB.z ) + 0.0001f;
|
||||
if( luminance > maxLuminance )
|
||||
{
|
||||
maxLuminance = luminance;
|
||||
|
|
@ -4607,11 +4607,13 @@ void RB_PostProcess( const void* data )
|
|||
|
||||
// only do the post process step if resolution scaling is enabled. Prevents the unnecessary copying of the framebuffer and
|
||||
// corresponding full screen quad pass.
|
||||
if( rs_enable.GetInteger() == 0 )
|
||||
if( rs_enable.GetInteger() == 0 && !r_useFilmicPostProcessEffects.GetBool() )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
RENDERLOG_PRINTF( "---------- RB_PostProcess() ----------\n" );
|
||||
|
||||
// resolve the scaled rendering to a temporary texture
|
||||
postProcessCommand_t* cmd = ( postProcessCommand_t* )data;
|
||||
const idScreenRect& viewport = cmd->viewDef->viewport;
|
||||
|
|
@ -4629,8 +4631,37 @@ void RB_PostProcess( const void* data )
|
|||
|
||||
GL_SelectTexture( 0 );
|
||||
globalImages->currentRenderImage->Bind();
|
||||
|
||||
GL_SelectTexture( 1 );
|
||||
globalImages->grainImage1->Bind();
|
||||
|
||||
renderProgManager.BindShader_PostProcess();
|
||||
|
||||
const static int GRAIN_SIZE = 128;
|
||||
|
||||
// screen power of two correction factor
|
||||
float screenCorrectionParm[4];
|
||||
screenCorrectionParm[0] = 1.0f / GRAIN_SIZE;
|
||||
screenCorrectionParm[1] = 1.0f / GRAIN_SIZE;
|
||||
screenCorrectionParm[2] = 1.0f;
|
||||
screenCorrectionParm[3] = 1.0f;
|
||||
SetFragmentParm( RENDERPARM_SCREENCORRECTIONFACTOR, screenCorrectionParm ); // rpScreenCorrectionFactor
|
||||
|
||||
float jitterTexOffset[4];
|
||||
if( r_shadowMapRandomizeJitter.GetBool() )
|
||||
{
|
||||
jitterTexOffset[0] = ( rand() & 255 ) / 255.0;
|
||||
jitterTexOffset[1] = ( rand() & 255 ) / 255.0;
|
||||
}
|
||||
else
|
||||
{
|
||||
jitterTexOffset[0] = 0;
|
||||
jitterTexOffset[1] = 0;
|
||||
}
|
||||
jitterTexOffset[2] = 0.0f;
|
||||
jitterTexOffset[3] = 0.0f;
|
||||
SetFragmentParm( RENDERPARM_JITTERTEXOFFSET, jitterTexOffset ); // rpJitterTexOffset
|
||||
|
||||
// Draw
|
||||
RB_DrawElementsWithCounters( &backEnd.unitSquareSurface );
|
||||
|
||||
|
|
|
|||
|
|
@ -1089,6 +1089,8 @@ extern idCVar r_hdrDebug;
|
|||
|
||||
extern idCVar r_ldrContrastThreshold;
|
||||
extern idCVar r_ldrContrastOffset;
|
||||
|
||||
extern idCVar r_useFilmicPostProcessEffects;
|
||||
// RB end
|
||||
|
||||
/*
|
||||
|
|
|
|||
Loading…
Reference in a new issue