okseby/Quake-III-Arena
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Fix floating point precision loss in renderer [part 2]

Browse source 
Fix floatTime using float precision instead of double using GCC.
Fix R_BindAnimatedImage to be in sync with function table.
Fix vertexDeform bulge, vertexDeform normals, noise wave function
at high level time.

Revert unnecessary float -> double conversions.
This commit is contained in:
Zack Middleton 2017-08-02 23:29:46 -05:00
parent 30fdd88c9f
commit 59b1262b82
12 changed files with 62 additions and 69 deletions
Download patch file Download diff file Expand all files Collapse all files

2
code/renderergl2/tr_backend.c
View file

@ -661,7 +661,7 @@ void RB_SetGL2D (void) {
// set time for 2D shaders
backEnd.refdef.time = ri.Milliseconds();
backEnd.refdef.floatTime = (double)backEnd.refdef.time * 0.001f;
backEnd.refdef.floatTime = backEnd.refdef.time * 0.001;
}

59
code/renderergl2/tr_local.h
View file

@ -268,10 +268,10 @@ typedef enum {
typedef struct {
genFunc_t func;
double base;
double amplitude;
double phase;
double frequency;
float base;
float amplitude;
float phase;
float frequency;
} waveForm_t;
#define TR_MAX_TEXMODS 4
@ -331,7 +331,7 @@ typedef struct {
typedef struct {
image_t *image[MAX_IMAGE_ANIMATIONS];
int numImageAnimations;
double imageAnimationSpeed;
float imageAnimationSpeed;
texCoordGen_t tcGen;
vec3_t tcGenVectors[2];
@ -479,29 +479,6 @@ typedef struct shader_s {
struct shader_s *next;
} shader_t;
static ID_INLINE qboolean ShaderRequiresCPUDeforms(const shader_t * shader)
{
if(shader->numDeforms)
{
const deformStage_t *ds = &shader->deforms[0];
if (shader->numDeforms > 1)
return qtrue;
switch (ds->deformation)
{
case DEFORM_WAVE:
case DEFORM_BULGE:
return qfalse;
default:
return qtrue;
}
}
return qfalse;
}
enum
{
ATTR_INDEX_POSITION = 0,
@ -1791,6 +1768,32 @@ extern cvar_t *r_marksOnTriangleMeshes;
//====================================================================
static ID_INLINE qboolean ShaderRequiresCPUDeforms(const shader_t * shader)
{
if(shader->numDeforms)
{
const deformStage_t *ds = &shader->deforms[0];
if (shader->numDeforms > 1)
return qtrue;
switch (ds->deformation)
{
case DEFORM_WAVE:
case DEFORM_BULGE:
// need CPU deforms at high level-times to avoid floating point percision loss
return ( backEnd.refdef.floatTime != (float)backEnd.refdef.floatTime );
default:
return qtrue;
}
}
return qfalse;
}
//====================================================================
void R_SwapBuffers( int );
void R_RenderView( viewParms_t *parms );

2
code/renderergl2/tr_scene.c
View file

@ -400,7 +400,7 @@ void RE_BeginScene(const refdef_t *fd)
// derived info
tr.refdef.floatTime = tr.refdef.time * 0.001f;
tr.refdef.floatTime = tr.refdef.time * 0.001;
tr.refdef.numDrawSurfs = r_firstSceneDrawSurf;
tr.refdef.drawSurfs = backEndData->drawSurfs;

7
code/renderergl2/tr_shade.c
View file

@ -66,7 +66,6 @@ R_BindAnimatedImageToTMU
*/
static void R_BindAnimatedImageToTMU( textureBundle_t *bundle, int tmu ) {
int64_t index;
double v;
if ( bundle->isVideoMap ) {
ri.CIN_RunCinematic(bundle->videoMapHandle);
@ -82,10 +81,8 @@ static void R_BindAnimatedImageToTMU( textureBundle_t *bundle, int tmu ) {
// it is necessary to do this messy calc to make sure animations line up
// exactly with waveforms of the same frequency
//index = ri.ftol(tess.shaderTime * bundle->imageAnimationSpeed * FUNCTABLE_SIZE);
//index >>= FUNCTABLE_SIZE2;
v = tess.shaderTime * bundle->imageAnimationSpeed;
index = v;
index = tess.shaderTime * bundle->imageAnimationSpeed * FUNCTABLE_SIZE;
index >>= FUNCTABLE_SIZE2;
if ( index < 0 ) {
index = 0; // may happen with shader time offsets

16
code/renderergl2/tr_shade_calc.c
View file

@ -27,7 +27,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#endif
#define WAVEVALUE( table, base, amplitude, phase, freq ) ((base) + table[ (int)( ( ( (phase) + tess.shaderTime * (freq) ) * FUNCTABLE_SIZE ) ) & FUNCTABLE_MASK ] * (amplitude))
#define WAVEVALUE( table, base, amplitude, phase, freq ) ((base) + table[ ( (int64_t) ( ( (phase) + tess.shaderTime * (freq) ) * FUNCTABLE_SIZE ) ) & FUNCTABLE_MASK ] * (amplitude))
static float *TableForFunc( genFunc_t func )
{
@ -204,12 +204,12 @@ void RB_CalcBulgeVertexes( deformStage_t *ds ) {
const float *st = ( const float * ) tess.texCoords[0];
float *xyz = ( float * ) tess.xyz;
int16_t *normal = tess.normal[0];
float now;
double now;
now = backEnd.refdef.time * ds->bulgeSpeed * 0.001f;
now = backEnd.refdef.time * 0.001 * ds->bulgeSpeed;
for ( i = 0; i < tess.numVertexes; i++, xyz += 4, st += 2, normal += 4 ) {
int off;
int64_t off;
float scale;
vec3_t fNormal;
@ -776,18 +776,16 @@ void RB_CalcScaleTexMatrix( const float scale[2], float *matrix )
*/
void RB_CalcScrollTexMatrix( const float scrollSpeed[2], float *matrix )
{
double timeScale;
double timeScale = tess.shaderTime;
double adjustedScrollS, adjustedScrollT;
timeScale = tess.shaderTime;
adjustedScrollS = scrollSpeed[0] * timeScale;
adjustedScrollT = scrollSpeed[1] * timeScale;
// clamp so coordinates don't continuously get larger, causing problems
// with hardware limits
adjustedScrollS = (double)adjustedScrollS - floor( adjustedScrollS );
adjustedScrollT = (double)adjustedScrollT - floor( adjustedScrollT );
adjustedScrollS = adjustedScrollS - floor( adjustedScrollS );
adjustedScrollT = adjustedScrollT - floor( adjustedScrollT );
matrix[0] = 1.0f; matrix[2] = 0.0f; matrix[4] = adjustedScrollS;
matrix[1] = 0.0f; matrix[3] = 1.0f; matrix[5] = adjustedScrollT;