id/doom3-bfg
0
0
Fork 0
mirror of https://github.com/id-Software/DOOM-3-BFG.git synced 2024-12-02 08:51:57 +00:00
Code Issues Projects Releases Packages Wiki Activity
doom3-bfg/neo/renderer/Image_intrinsic.cpp
Robert Beckebans 277964f074 Because I can :) 
- Implemented soft shadows using PCF hardware shadow mapping

  The implementation uses sampler2DArrayShadow and PCF which usually
  requires Direct3D 10.1 however it is in the OpenGL 3.2 core so it should
  be widely supported.
  All 3 light types are supported which means parallel lights (sun) use
  scene independent cascaded shadow mapping.
  The implementation is very fast with single taps (400 fps average per
  scene on a GTX 660 ti OC) however I defaulted it to 16 taps so the shadows look
  really good which should you give stable 100 fps on todays hardware.

  The shadow filtering algorithm is based on Carmack's research which was
  released in the original Doom 3 GPL release draw_exp.cpp.

- Changed interaction shaders to use Half-Lambert lighting like in HL2 to
  make the game less dark

- Fixed some of the renderer debugging/development tools like r_showTris
2014-05-10 14:40:01 +02:00

590 lines
No EOL
14 KiB
C++
Raw Blame History

/*
===========================================================================
Doom 3 BFG Edition GPL Source Code
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
Copyright (C) 2013-2014 Robert Beckebans
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
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Doom 3 BFG Edition Source Code. If not, see <http://www.gnu.org/licenses/>.
In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code. If not, please request a copy in writing from id Software at the address below.
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
===========================================================================
*/
#pragma hdrstop
#include "precompiled.h"
#include "tr_local.h"
#define DEFAULT_SIZE 16
/*
==================
idImage::MakeDefault
the default image will be grey with a white box outline
to allow you to see the mapping coordinates on a surface
==================
*/
void idImage::MakeDefault()
{
int x, y;
byte data[DEFAULT_SIZE][DEFAULT_SIZE][4];
if( com_developer.GetBool() )
{
// grey center
for( y = 0 ; y < DEFAULT_SIZE ; y++ )
{
for( x = 0 ; x < DEFAULT_SIZE ; x++ )
{
data[y][x][0] = 32;
data[y][x][1] = 32;
data[y][x][2] = 32;
data[y][x][3] = 255;
}
}
// white border
for( x = 0 ; x < DEFAULT_SIZE ; x++ )
{
data[0][x][0] =
data[0][x][1] =
data[0][x][2] =
data[0][x][3] = 255;
data[x][0][0] =
data[x][0][1] =
data[x][0][2] =
data[x][0][3] = 255;
data[DEFAULT_SIZE - 1][x][0] =
data[DEFAULT_SIZE - 1][x][1] =
data[DEFAULT_SIZE - 1][x][2] =
data[DEFAULT_SIZE - 1][x][3] = 255;
data[x][DEFAULT_SIZE - 1][0] =
data[x][DEFAULT_SIZE - 1][1] =
data[x][DEFAULT_SIZE - 1][2] =
data[x][DEFAULT_SIZE - 1][3] = 255;
}
}
else
{
for( y = 0 ; y < DEFAULT_SIZE ; y++ )
{
for( x = 0 ; x < DEFAULT_SIZE ; x++ )
{
data[y][x][0] = 0;
data[y][x][1] = 0;
data[y][x][2] = 0;
data[y][x][3] = 0;
}
}
}
GenerateImage( ( byte* )data,
DEFAULT_SIZE, DEFAULT_SIZE,
TF_DEFAULT, TR_REPEAT, TD_DEFAULT );
defaulted = true;
}
static void R_DefaultImage( idImage* image )
{
image->MakeDefault();
}
static void R_WhiteImage( idImage* image )
{
byte data[DEFAULT_SIZE][DEFAULT_SIZE][4];
// solid white texture
memset( data, 255, sizeof( data ) );
image->GenerateImage( ( byte* )data, DEFAULT_SIZE, DEFAULT_SIZE,
TF_DEFAULT, TR_REPEAT, TD_DEFAULT );
}
static void R_BlackImage( idImage* image )
{
byte data[DEFAULT_SIZE][DEFAULT_SIZE][4];
// solid black texture
memset( data, 0, sizeof( data ) );
image->GenerateImage( ( byte* )data, DEFAULT_SIZE, DEFAULT_SIZE,
TF_DEFAULT, TR_REPEAT, TD_DEFAULT );
}
static void R_RGBA8Image( idImage* image )
{
byte data[DEFAULT_SIZE][DEFAULT_SIZE][4];
memset( data, 0, sizeof( data ) );
data[0][0][0] = 16;
data[0][0][1] = 32;
data[0][0][2] = 48;
data[0][0][3] = 96;
image->GenerateImage( ( byte* )data, DEFAULT_SIZE, DEFAULT_SIZE, TF_DEFAULT, TR_REPEAT, TD_LOOKUP_TABLE_RGBA );
}
static void R_DepthImage( idImage* image )
{
byte data[DEFAULT_SIZE][DEFAULT_SIZE][4];
memset( data, 0, sizeof( data ) );
data[0][0][0] = 16;
data[0][0][1] = 32;
data[0][0][2] = 48;
data[0][0][3] = 96;
image->GenerateImage( ( byte* )data, DEFAULT_SIZE, DEFAULT_SIZE, TF_NEAREST, TR_CLAMP, TD_DEPTH );
}
static void R_AlphaNotchImage( idImage* image )
{
byte data[2][4];
// this is used for alpha test clip planes
data[0][0] = data[0][1] = data[0][2] = 255;
data[0][3] = 0;
data[1][0] = data[1][1] = data[1][2] = 255;
data[1][3] = 255;
image->GenerateImage( ( byte* )data, 2, 1, TF_NEAREST, TR_CLAMP, TD_LOOKUP_TABLE_ALPHA );
}
static void R_FlatNormalImage( idImage* image )
{
byte data[DEFAULT_SIZE][DEFAULT_SIZE][4];
// flat normal map for default bunp mapping
for( int i = 0 ; i < 4 ; i++ )
{
data[0][i][0] = 128;
data[0][i][1] = 128;
data[0][i][2] = 255;
data[0][i][3] = 255;
}
image->GenerateImage( ( byte* )data, 2, 2, TF_DEFAULT, TR_REPEAT, TD_BUMP );
}
/*
================
R_CreateNoFalloffImage
This is a solid white texture that is zero clamped.
================
*/
static void R_CreateNoFalloffImage( idImage* image )
{
int x, y;
byte data[16][FALLOFF_TEXTURE_SIZE][4];
memset( data, 0, sizeof( data ) );
for( x = 1 ; x < FALLOFF_TEXTURE_SIZE - 1 ; x++ )
{
for( y = 1 ; y < 15 ; y++ )
{
data[y][x][0] = 255;
data[y][x][1] = 255;
data[y][x][2] = 255;
data[y][x][3] = 255;
}
}
image->GenerateImage( ( byte* )data, FALLOFF_TEXTURE_SIZE, 16, TF_DEFAULT, TR_CLAMP_TO_ZERO, TD_LOOKUP_TABLE_MONO );
}
/*
================
R_FogImage
We calculate distance correctly in two planes, but the
third will still be projection based
================
*/
const int FOG_SIZE = 128;
void R_FogImage( idImage* image )
{
int x, y;
byte data[FOG_SIZE][FOG_SIZE][4];
int b;
float step[256];
int i;
float remaining = 1.0;
for( i = 0 ; i < 256 ; i++ )
{
step[i] = remaining;
remaining *= 0.982f;
}
for( x = 0 ; x < FOG_SIZE ; x++ )
{
for( y = 0 ; y < FOG_SIZE ; y++ )
{
float d;
d = idMath::Sqrt( ( x - FOG_SIZE / 2 ) * ( x - FOG_SIZE / 2 )
+ ( y - FOG_SIZE / 2 ) * ( y - FOG_SIZE / 2 ) );
d /= FOG_SIZE / 2 - 1;
b = ( byte )( d * 255 );
if( b <= 0 )
{
b = 0;
}
else if( b > 255 )
{
b = 255;
}
b = ( byte )( 255 * ( 1.0 - step[b] ) );
if( x == 0 || x == FOG_SIZE - 1 || y == 0 || y == FOG_SIZE - 1 )
{
b = 255; // avoid clamping issues
}
data[y][x][0] =
data[y][x][1] =
data[y][x][2] = 255;
data[y][x][3] = b;
}
}
image->GenerateImage( ( byte* )data, FOG_SIZE, FOG_SIZE, TF_LINEAR, TR_CLAMP, TD_LOOKUP_TABLE_ALPHA );
}
/*
================
FogFraction
Height values below zero are inside the fog volume
================
*/
static const float RAMP_RANGE = 8;
static const float DEEP_RANGE = -30;
static float FogFraction( float viewHeight, float targetHeight )
{
float total = idMath::Fabs( targetHeight - viewHeight );
// return targetHeight >= 0 ? 0 : 1.0;
// only ranges that cross the ramp range are special
if( targetHeight > 0 && viewHeight > 0 )
{
return 0.0;
}
if( targetHeight < -RAMP_RANGE && viewHeight < -RAMP_RANGE )
{
return 1.0;
}
float above;
if( targetHeight > 0 )
{
above = targetHeight;
}
else if( viewHeight > 0 )
{
above = viewHeight;
}
else
{
above = 0;
}
float rampTop, rampBottom;
if( viewHeight > targetHeight )
{
rampTop = viewHeight;
rampBottom = targetHeight;
}
else
{
rampTop = targetHeight;
rampBottom = viewHeight;
}
if( rampTop > 0 )
{
rampTop = 0;
}
if( rampBottom < -RAMP_RANGE )
{
rampBottom = -RAMP_RANGE;
}
float rampSlope = 1.0 / RAMP_RANGE;
if( !total )
{
return -viewHeight * rampSlope;
}
float ramp = ( 1.0 - ( rampTop * rampSlope + rampBottom * rampSlope ) * -0.5 ) * ( rampTop - rampBottom );
float frac = ( total - above - ramp ) / total;
// after it gets moderately deep, always use full value
float deepest = viewHeight < targetHeight ? viewHeight : targetHeight;
float deepFrac = deepest / DEEP_RANGE;
if( deepFrac >= 1.0 )
{
return 1.0;
}
frac = frac * ( 1.0 - deepFrac ) + deepFrac;
return frac;
}
/*
================
R_FogEnterImage
Modulate the fog alpha density based on the distance of the
start and end points to the terminator plane
================
*/
void R_FogEnterImage( idImage* image )
{
int x, y;
byte data[FOG_ENTER_SIZE][FOG_ENTER_SIZE][4];
int b;
for( x = 0 ; x < FOG_ENTER_SIZE ; x++ )
{
for( y = 0 ; y < FOG_ENTER_SIZE ; y++ )
{
float d;
d = FogFraction( x - ( FOG_ENTER_SIZE / 2 ), y - ( FOG_ENTER_SIZE / 2 ) );
b = ( byte )( d * 255 );
if( b <= 0 )
{
b = 0;
}
else if( b > 255 )
{
b = 255;
}
data[y][x][0] =
data[y][x][1] =
data[y][x][2] = 255;
data[y][x][3] = b;
}
}
// if mipmapped, acutely viewed surfaces fade wrong
image->GenerateImage( ( byte* )data, FOG_ENTER_SIZE, FOG_ENTER_SIZE, TF_LINEAR, TR_CLAMP, TD_LOOKUP_TABLE_ALPHA );
}
/*
================
R_QuadraticImage
================
*/
static const int QUADRATIC_WIDTH = 32;
static const int QUADRATIC_HEIGHT = 4;
void R_QuadraticImage( idImage* image )
{
int x, y;
byte data[QUADRATIC_HEIGHT][QUADRATIC_WIDTH][4];
int b;
for( x = 0 ; x < QUADRATIC_WIDTH ; x++ )
{
for( y = 0 ; y < QUADRATIC_HEIGHT ; y++ )
{
float d;
d = x - ( QUADRATIC_WIDTH / 2 - 0.5 );
d = idMath::Fabs( d );
d -= 0.5;
d /= QUADRATIC_WIDTH / 2;
d = 1.0 - d;
d = d * d;
b = ( byte )( d * 255 );
if( b <= 0 )
{
b = 0;
}
else if( b > 255 )
{
b = 255;
}
data[y][x][0] =
data[y][x][1] =
data[y][x][2] = b;
data[y][x][3] = 255;
}
}
image->GenerateImage( ( byte* )data, QUADRATIC_WIDTH, QUADRATIC_HEIGHT, TF_DEFAULT, TR_CLAMP, TD_LOOKUP_TABLE_RGB1 );
}
// RB begin
static void R_CreateShadowMapImage( idImage* image )
{
int size = r_shadowMapImageSize.GetInteger();
image->GenerateShadowArray( size, size, TF_LINEAR, TR_CLAMP_TO_ZERO_ALPHA, TD_SHADOW_ARRAY );
}
const static int JITTER_SIZE = 128;
static void R_CreateJitterImage16( idImage* image )
{
static byte data[JITTER_SIZE][JITTER_SIZE * 16][4];
for( int i = 0 ; i < JITTER_SIZE ; i++ )
{
for( int s = 0 ; s < 16 ; s++ )
{
int sOfs = 64 * ( s & 3 );
int tOfs = 64 * ( ( s >> 2 ) & 3 );
for( int j = 0 ; j < JITTER_SIZE ; j++ )
{
data[i][s * JITTER_SIZE + j][0] = ( rand() & 63 ) | sOfs;
data[i][s * JITTER_SIZE + j][1] = ( rand() & 63 ) | tOfs;
data[i][s * JITTER_SIZE + j][2] = rand();
data[i][s * JITTER_SIZE + j][3] = 0;
}
}
}
image->GenerateImage( ( byte* )data, JITTER_SIZE * 16, JITTER_SIZE, TF_NEAREST, TR_REPEAT, TD_LOOKUP_TABLE_RGBA );
}
static void R_CreateJitterImage4( idImage* image )
{
byte data[JITTER_SIZE][JITTER_SIZE * 4][4];
for( int i = 0 ; i < JITTER_SIZE ; i++ )
{
for( int s = 0 ; s < 4 ; s++ )
{
int sOfs = 128 * ( s & 1 );
int tOfs = 128 * ( ( s >> 1 ) & 1 );
for( int j = 0 ; j < JITTER_SIZE ; j++ )
{
data[i][s * JITTER_SIZE + j][0] = ( rand() & 127 ) | sOfs;
data[i][s * JITTER_SIZE + j][1] = ( rand() & 127 ) | tOfs;
data[i][s * JITTER_SIZE + j][2] = rand();
data[i][s * JITTER_SIZE + j][3] = 0;
}
}
}
image->GenerateImage( ( byte* )data, JITTER_SIZE * 4, JITTER_SIZE, TF_NEAREST, TR_REPEAT, TD_LOOKUP_TABLE_RGBA );
}
static void R_CreateJitterImage1( idImage* image )
{
byte data[JITTER_SIZE][JITTER_SIZE][4];
for( int i = 0 ; i < JITTER_SIZE ; i++ )
{
for( int j = 0 ; j < JITTER_SIZE ; j++ )
{
data[i][j][0] = rand();
data[i][j][1] = rand();
data[i][j][2] = rand();
data[i][j][3] = 0;
}
}
image->GenerateImage( ( byte* )data, JITTER_SIZE, JITTER_SIZE, TF_NEAREST, TR_REPEAT, TD_LOOKUP_TABLE_RGBA );
}
static void R_CreateRandom256Image( idImage* image )
{
byte data[256][256][4];
for( int i = 0 ; i < 256 ; i++ )
{
for( int j = 0 ; j < 256 ; j++ )
{
data[i][j][0] = rand();
data[i][j][1] = rand();
data[i][j][2] = rand();
data[i][j][3] = rand();
}
}
image->GenerateImage( ( byte* )data, 256, 256, TF_NEAREST, TR_REPEAT, TD_LOOKUP_TABLE_RGBA );
}
// RB end
/*
================
idImageManager::CreateIntrinsicImages
================
*/
void idImageManager::CreateIntrinsicImages()
{
// create built in images
defaultImage = ImageFromFunction( "_default", R_DefaultImage );
whiteImage = ImageFromFunction( "_white", R_WhiteImage );
blackImage = ImageFromFunction( "_black", R_BlackImage );
flatNormalMap = ImageFromFunction( "_flat", R_FlatNormalImage );
alphaNotchImage = ImageFromFunction( "_alphaNotch", R_AlphaNotchImage );
fogImage = ImageFromFunction( "_fog", R_FogImage );
fogEnterImage = ImageFromFunction( "_fogEnter", R_FogEnterImage );
noFalloffImage = ImageFromFunction( "_noFalloff", R_CreateNoFalloffImage );
ImageFromFunction( "_quadratic", R_QuadraticImage );
// RB begin
shadowImage = ImageFromFunction( va( "_shadowMap%i_0", r_shadowMapImageSize.GetInteger() ), R_CreateShadowMapImage );
jitterImage1 = globalImages->ImageFromFunction( "_jitter1", R_CreateJitterImage1 );
jitterImage4 = globalImages->ImageFromFunction( "_jitter4", R_CreateJitterImage4 );
jitterImage16 = globalImages->ImageFromFunction( "_jitter16", R_CreateJitterImage16 );
randomImage256 = globalImages->ImageFromFunction( "_random256", R_CreateRandom256Image );
// RB end
// scratchImage is used for screen wipes/doublevision etc..
scratchImage = ImageFromFunction( "_scratch", R_RGBA8Image );
scratchImage2 = ImageFromFunction( "_scratch2", R_RGBA8Image );
accumImage = ImageFromFunction( "_accum", R_RGBA8Image );
currentRenderImage = ImageFromFunction( "_currentRender", R_RGBA8Image );
currentDepthImage = ImageFromFunction( "_currentDepth", R_DepthImage );
// save a copy of this for material comparison, because currentRenderImage may get
// reassigned during stereo rendering
originalCurrentRenderImage = currentRenderImage;
loadingIconImage = ImageFromFile( "textures/loadingicon2", TF_DEFAULT, TR_CLAMP, TD_DEFAULT, CF_2D );
hellLoadingIconImage = ImageFromFile( "textures/loadingicon3", TF_DEFAULT, TR_CLAMP, TD_DEFAULT, CF_2D );
release_assert( loadingIconImage->referencedOutsideLevelLoad );
release_assert( hellLoadingIconImage->referencedOutsideLevelLoad );
}
Reference in a new issue View git blame Copy permalink