ubergames
/
lilium-voyager
mirror of https://github.com/UberGames/lilium-voyager.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

OpenGL2: Store vertex colors and hdr lightmaps/lightgrid as RGBA16.

This commit is contained in:
SmileTheory 2016-10-11 03:28:20 -07:00
parent 239f539702
commit aa79738c50
15 changed files with 240 additions and 184 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
code/renderergl2/tr_backend.c
View File

@ -881,14 +881,14 @@ const void *RB_StretchPic ( const void *data ) {
tess.indexes[ numIndexes + 5 ] = numVerts + 1; tess.indexes[ numIndexes + 5 ] = numVerts + 1;
{ {
vec4_t color; uint16_t color[4];
VectorScale4(backEnd.color2D, 1.0f / 255.0f, color); VectorScale4(backEnd.color2D, 257, color);
VectorCopy4(color, tess.vertexColors[ numVerts ]); VectorCopy4(color, tess.color[ numVerts ]);
VectorCopy4(color, tess.vertexColors[ numVerts + 1]); VectorCopy4(color, tess.color[ numVerts + 1]);
VectorCopy4(color, tess.vertexColors[ numVerts + 2]); VectorCopy4(color, tess.color[ numVerts + 2]);
VectorCopy4(color, tess.vertexColors[ numVerts + 3 ]); VectorCopy4(color, tess.color[ numVerts + 3 ]);
} }
tess.xyz[ numVerts ][0] = cmd->x; tess.xyz[ numVerts ][0] = cmd->x;

94
code/renderergl2/tr_bsp.c
View File

@ -136,11 +136,10 @@ R_ColorShiftLightingFloats
=============== ===============
*/ */
static void R_ColorShiftLightingFloats(float in[4], float out[4], float scale ) static void R_ColorShiftLightingFloats(float in[4], float out[4])
{ {
float r, g, b; float r, g, b;
float scale = (1 << (r_mapOverBrightBits->integer - tr.overbrightBits)) / 255.0f;
scale *= 1 << (r_mapOverBrightBits->integer - tr.overbrightBits);
r = in[0] * scale; r = in[0] * scale;
g = in[1] * scale; g = in[1] * scale;
@ -185,12 +184,11 @@ void ColorToRGBM(const vec3_t color, unsigned char rgbm[4])
rgbm[2] = (unsigned char) (sample[2] * 255); rgbm[2] = (unsigned char) (sample[2] * 255);
} }
void ColorToRGBA16F(const vec3_t color, unsigned short rgba16f[4]) void ColorToRGB16(const vec3_t color, uint16_t rgb16[3])
{ {
rgba16f[0] = FloatToHalf(color[0]); rgb16[0] = color[0] * 65535.0f + 0.5f;
rgba16f[1] = FloatToHalf(color[1]); rgb16[1] = color[1] * 65535.0f + 0.5f;
rgba16f[2] = FloatToHalf(color[2]); rgb16[2] = color[2] * 65535.0f + 0.5f;
rgba16f[3] = FloatToHalf(1.0f);
} }
@ -277,10 +275,16 @@ static void R_LoadLightmaps( lump_t *l, lump_t *surfs ) {
if (tr.worldDeluxeMapping) if (tr.worldDeluxeMapping)
tr.deluxemaps = ri.Hunk_Alloc( tr.numLightmaps * sizeof(image_t *), h_low ); tr.deluxemaps = ri.Hunk_Alloc( tr.numLightmaps * sizeof(image_t *), h_low );
if (glRefConfig.floatLightmap) textureInternalFormat = GL_RGBA8;
textureInternalFormat = GL_RGBA16F_ARB; if (r_hdr->integer)
else {
textureInternalFormat = GL_RGBA8; // Check for the first hdr lightmap, if it exists, use GL_RGBA16 for textures.
char filename[MAX_QPATH];
Com_sprintf(filename, sizeof(filename), "maps/%s/lm_0000.hdr", s_worldData.baseName);
if (ri.FS_FileExists(filename))
textureInternalFormat = GL_RGBA16;
}
if (r_mergeLightmaps->integer) if (r_mergeLightmaps->integer)
{ {
@ -318,7 +322,7 @@ static void R_LoadLightmaps( lump_t *l, lump_t *surfs ) {
int size = 0; int size = 0;
// look for hdr lightmaps // look for hdr lightmaps
if (r_hdr->integer) if (textureInternalFormat == GL_RGBA16)
{ {
Com_sprintf( filename, sizeof( filename ), "maps/%s/lm_%04d.hdr", s_worldData.baseName, i * (tr.worldDeluxeMapping ? 2 : 1) ); Com_sprintf( filename, sizeof( filename ), "maps/%s/lm_%04d.hdr", s_worldData.baseName, i * (tr.worldDeluxeMapping ? 2 : 1) );
//ri.Printf(PRINT_ALL, "looking for %s\n", filename); //ri.Printf(PRINT_ALL, "looking for %s\n", filename);
@ -382,14 +386,12 @@ static void R_LoadLightmaps( lump_t *l, lump_t *surfs ) {
#endif #endif
color[3] = 1.0f; color[3] = 1.0f;
R_ColorShiftLightingFloats(color, color, 1.0f/255.0f); R_ColorShiftLightingFloats(color, color);
if (glRefConfig.floatLightmap) ColorToRGB16(color, (uint16_t *)(&image[j * 8]));
ColorToRGBA16F(color, (unsigned short *)(&image[j*8])); ((uint16_t *)(&image[j * 8]))[3] = 65535;
else
ColorToRGBM(color, &image[j*4]);
} }
else if (glRefConfig.floatLightmap) else if (textureInternalFormat == GL_RGBA16)
{ {
vec4_t color; vec4_t color;
@ -409,9 +411,10 @@ static void R_LoadLightmaps( lump_t *l, lump_t *surfs ) {
} }
color[3] = 1.0f; color[3] = 1.0f;
R_ColorShiftLightingFloats(color, color, 1.0f/255.0f); R_ColorShiftLightingFloats(color, color);
ColorToRGBA16F(color, (unsigned short *)(&image[j*8])); ColorToRGB16(color, (uint16_t *)(&image[j * 8]));
((uint16_t *)(&image[j * 8]))[3] = 65535;
} }
else else
{ {
@ -679,7 +682,8 @@ void LoadDrawVertToSrfVert(srfVert_t *s, drawVert_t *d, int realLightmapNum, flo
} }
v[3] = d->color[3] / 255.0f; v[3] = d->color[3] / 255.0f;
R_ColorShiftLightingFloats(v, s->vertexColors, 1.0f / 255.0f); R_ColorShiftLightingFloats(v, v);
R_VaoPackColor(s->color, v);
} }
@ -1738,7 +1742,7 @@ static void CopyVert(const srfVert_t * in, srfVert_t * out)
VectorCopy2(in->st, out->st); VectorCopy2(in->st, out->st);
VectorCopy2(in->lightmap, out->lightmap); VectorCopy2(in->lightmap, out->lightmap);
VectorCopy4(in->vertexColors, out->vertexColors); VectorCopy4(in->color, out->color);
} }
@ -2636,25 +2640,47 @@ void R_LoadLightGrid( lump_t *l ) {
if (hdrLightGrid) if (hdrLightGrid)
{ {
float lightScale = 1 << (r_mapOverBrightBits->integer - tr.overbrightBits);
//ri.Printf(PRINT_ALL, "found!\n"); //ri.Printf(PRINT_ALL, "found!\n");
if (size != sizeof(float) * 6 * numGridPoints) if (size != sizeof(float) * 6 * numGridPoints)
{
ri.Error(ERR_DROP, "Bad size for %s (%i, expected %i)!", filename, size, (int)(sizeof(float)) * 6 * numGridPoints); ri.Error(ERR_DROP, "Bad size for %s (%i, expected %i)!", filename, size, (int)(sizeof(float)) * 6 * numGridPoints);
}
w->hdrLightGrid = ri.Hunk_Alloc(size, h_low); w->lightGrid16 = ri.Hunk_Alloc(sizeof(w->lightGrid16) * 6 * numGridPoints, h_low);
for (i = 0; i < numGridPoints ; i++) for (i = 0; i < numGridPoints ; i++)
{ {
w->hdrLightGrid[i * 6 ] = hdrLightGrid[i * 6 ] * lightScale; vec4_t c;
w->hdrLightGrid[i * 6 + 1] = hdrLightGrid[i * 6 + 1] * lightScale;
w->hdrLightGrid[i * 6 + 2] = hdrLightGrid[i * 6 + 2] * lightScale; c[0] = hdrLightGrid[i * 6];
w->hdrLightGrid[i * 6 + 3] = hdrLightGrid[i * 6 + 3] * lightScale; c[1] = hdrLightGrid[i * 6 + 1];
w->hdrLightGrid[i * 6 + 4] = hdrLightGrid[i * 6 + 4] * lightScale; c[2] = hdrLightGrid[i * 6 + 2];
w->hdrLightGrid[i * 6 + 5] = hdrLightGrid[i * 6 + 5] * lightScale; c[3] = 1.0f;
R_ColorShiftLightingFloats(c, c);
ColorToRGB16(c, &w->lightGrid16[i * 6]);
c[0] = hdrLightGrid[i * 6 + 3];
c[1] = hdrLightGrid[i * 6 + 4];
c[2] = hdrLightGrid[i * 6 + 5];
c[3] = 1.0f;
R_ColorShiftLightingFloats(c, c);
ColorToRGB16(c, &w->lightGrid16[i * 6 + 3]);
}
}
else if (0)
{
// promote 8-bit lightgrid to 16-bit
w->lightGrid16 = ri.Hunk_Alloc(sizeof(w->lightGrid16) * 6 * numGridPoints, h_low);
for (i = 0; i < numGridPoints; i++)
{
w->lightGrid16[i * 6] = w->lightGridData[i * 8] * 257;
w->lightGrid16[i * 6 + 1] = w->lightGridData[i * 8 + 1] * 257;
w->lightGrid16[i * 6 + 2] = w->lightGridData[i * 8 + 2] * 257;
w->lightGrid16[i * 6 + 3] = w->lightGridData[i * 8 + 3] * 257;
w->lightGrid16[i * 6 + 4] = w->lightGridData[i * 8 + 4] * 257;
w->lightGrid16[i * 6 + 5] = w->lightGridData[i * 8 + 5] * 257;
} }
} }

8
code/renderergl2/tr_curve.c
View File

@ -54,10 +54,10 @@ static void LerpDrawVert( srfVert_t *a, srfVert_t *b, srfVert_t *out ) {
out->lightmap[0] = 0.5f * (a->lightmap[0] + b->lightmap[0]); out->lightmap[0] = 0.5f * (a->lightmap[0] + b->lightmap[0]);
out->lightmap[1] = 0.5f * (a->lightmap[1] + b->lightmap[1]); out->lightmap[1] = 0.5f * (a->lightmap[1] + b->lightmap[1]);
out->vertexColors[0] = 0.5f * (a->vertexColors[0] + b->vertexColors[0]); out->color[0] = ((int)a->color[0] + (int)b->color[0]) >> 1;
out->vertexColors[1] = 0.5f * (a->vertexColors[1] + b->vertexColors[1]); out->color[1] = ((int)a->color[1] + (int)b->color[1]) >> 1;
out->vertexColors[2] = 0.5f * (a->vertexColors[2] + b->vertexColors[2]); out->color[2] = ((int)a->color[2] + (int)b->color[2]) >> 1;
out->vertexColors[3] = 0.5f * (a->vertexColors[3] + b->vertexColors[3]); out->color[3] = ((int)a->color[3] + (int)b->color[3]) >> 1;
} }
/* /*

7
code/renderergl2/tr_extensions.c
View File

@ -295,9 +295,6 @@ void GLimp_InitExtraExtensions()
ri.Printf(PRINT_ALL, result[2], extension); ri.Printf(PRINT_ALL, result[2], extension);
} }
// use float lightmaps?
glRefConfig.floatLightmap = (glRefConfig.textureFloat && glRefConfig.halfFloatPixel && r_floatLightmap->integer && r_hdr->integer);
// GL_ARB_vertex_array_object // GL_ARB_vertex_array_object
extension = "GL_ARB_vertex_array_object"; extension = "GL_ARB_vertex_array_object";
glRefConfig.vertexArrayObject = qfalse; glRefConfig.vertexArrayObject = qfalse;
@ -318,8 +315,6 @@ void GLimp_InitExtraExtensions()
extension = "GL_ARB_half_float_vertex"; extension = "GL_ARB_half_float_vertex";
glRefConfig.packedTexcoordDataType = GL_FLOAT; glRefConfig.packedTexcoordDataType = GL_FLOAT;
glRefConfig.packedTexcoordDataSize = sizeof(float) * 2; glRefConfig.packedTexcoordDataSize = sizeof(float) * 2;
glRefConfig.packedColorDataType = GL_FLOAT;
glRefConfig.packedColorDataSize = sizeof(float) * 4;
if( GLimp_HaveExtension( extension ) ) if( GLimp_HaveExtension( extension ) )
{ {
qboolean useExt = !!r_arb_half_float_vertex->integer; qboolean useExt = !!r_arb_half_float_vertex->integer;
@ -328,8 +323,6 @@ void GLimp_InitExtraExtensions()
{ {
glRefConfig.packedTexcoordDataType = GL_HALF_FLOAT; glRefConfig.packedTexcoordDataType = GL_HALF_FLOAT;
glRefConfig.packedTexcoordDataSize = sizeof(uint16_t) * 2; glRefConfig.packedTexcoordDataSize = sizeof(uint16_t) * 2;
glRefConfig.packedColorDataType = GL_HALF_FLOAT;
glRefConfig.packedColorDataSize = sizeof(uint16_t) * 4;
} }
ri.Printf(PRINT_ALL, result[useExt], extension); ri.Printf(PRINT_ALL, result[useExt], extension);

20
code/renderergl2/tr_extramath.c
View File

@ -201,7 +201,7 @@ int NextPowerOfTwo(int in)
union f32_u { union f32_u {
float f; float f;
uint32_t i; uint32_t ui;
struct { struct {
unsigned int fraction:23; unsigned int fraction:23;
unsigned int exponent:8; unsigned int exponent:8;
@ -210,7 +210,7 @@ union f32_u {
}; };
union f16_u { union f16_u {
uint16_t i; uint16_t ui;
struct { struct {
unsigned int fraction:10; unsigned int fraction:10;
unsigned int exponent:5; unsigned int exponent:5;
@ -229,5 +229,19 @@ uint16_t FloatToHalf(float in)
f16.pack.fraction = f32.pack.fraction >> 13; f16.pack.fraction = f32.pack.fraction >> 13;
f16.pack.sign = f32.pack.sign; f16.pack.sign = f32.pack.sign;
return f16.i; return f16.ui;
}
float HalfToFloat(uint16_t in)
{
union f32_u f32;
union f16_u f16;
f16.ui = in;
f32.pack.exponent = (int)(f16.pack.exponent) + 112;
f32.pack.fraction = f16.pack.fraction << 13;
f32.pack.sign = f16.pack.sign;
return f32.f;
} }

1
code/renderergl2/tr_extramath.h
View File

@ -98,5 +98,6 @@ void BoundingSphereOfSpheres(vec3_t origin1, float radius1, vec3_t origin2, floa
int NextPowerOfTwo(int in); int NextPowerOfTwo(int in);
unsigned short FloatToHalf(float in); unsigned short FloatToHalf(float in);
float HalfToFloat(unsigned short in);
#endif #endif

38
code/renderergl2/tr_flares.c
View File

@ -395,9 +395,9 @@ void RB_RenderFlare( flare_t *f ) {
return; return;
} }
iColor[0] = color[0] * fogFactors[0]; iColor[0] = color[0] * fogFactors[0] * 257;
iColor[1] = color[1] * fogFactors[1]; iColor[1] = color[1] * fogFactors[1] * 257;
iColor[2] = color[2] * fogFactors[2]; iColor[2] = color[2] * fogFactors[2] * 257;
RB_BeginSurface( tr.flareShader, f->fogNum, 0 ); RB_BeginSurface( tr.flareShader, f->fogNum, 0 );
@ -406,40 +406,40 @@ void RB_RenderFlare( flare_t *f ) {
tess.xyz[tess.numVertexes][1] = f->windowY - size; tess.xyz[tess.numVertexes][1] = f->windowY - size;
tess.texCoords[tess.numVertexes][0][0] = 0; tess.texCoords[tess.numVertexes][0][0] = 0;
tess.texCoords[tess.numVertexes][0][1] = 0; tess.texCoords[tess.numVertexes][0][1] = 0;
tess.vertexColors[tess.numVertexes][0] = iColor[0] / 255.0f; tess.color[tess.numVertexes][0] = iColor[0];
tess.vertexColors[tess.numVertexes][1] = iColor[1] / 255.0f; tess.color[tess.numVertexes][1] = iColor[1];
tess.vertexColors[tess.numVertexes][2] = iColor[2] / 255.0f; tess.color[tess.numVertexes][2] = iColor[2];
tess.vertexColors[tess.numVertexes][3] = 1.0f; tess.color[tess.numVertexes][3] = 65535;
tess.numVertexes++; tess.numVertexes++;
tess.xyz[tess.numVertexes][0] = f->windowX - size; tess.xyz[tess.numVertexes][0] = f->windowX - size;
tess.xyz[tess.numVertexes][1] = f->windowY + size; tess.xyz[tess.numVertexes][1] = f->windowY + size;
tess.texCoords[tess.numVertexes][0][0] = 0; tess.texCoords[tess.numVertexes][0][0] = 0;
tess.texCoords[tess.numVertexes][0][1] = 1; tess.texCoords[tess.numVertexes][0][1] = 1;
tess.vertexColors[tess.numVertexes][0] = iColor[0] / 255.0f; tess.color[tess.numVertexes][0] = iColor[0];
tess.vertexColors[tess.numVertexes][1] = iColor[1] / 255.0f; tess.color[tess.numVertexes][1] = iColor[1];
tess.vertexColors[tess.numVertexes][2] = iColor[2] / 255.0f; tess.color[tess.numVertexes][2] = iColor[2];
tess.vertexColors[tess.numVertexes][3] = 1.0f; tess.color[tess.numVertexes][3] = 65535;
tess.numVertexes++; tess.numVertexes++;
tess.xyz[tess.numVertexes][0] = f->windowX + size; tess.xyz[tess.numVertexes][0] = f->windowX + size;
tess.xyz[tess.numVertexes][1] = f->windowY + size; tess.xyz[tess.numVertexes][1] = f->windowY + size;
tess.texCoords[tess.numVertexes][0][0] = 1; tess.texCoords[tess.numVertexes][0][0] = 1;
tess.texCoords[tess.numVertexes][0][1] = 1; tess.texCoords[tess.numVertexes][0][1] = 1;
tess.vertexColors[tess.numVertexes][0] = iColor[0] / 255.0f; tess.color[tess.numVertexes][0] = iColor[0];
tess.vertexColors[tess.numVertexes][1] = iColor[1] / 255.0f; tess.color[tess.numVertexes][1] = iColor[1];
tess.vertexColors[tess.numVertexes][2] = iColor[2] / 255.0f; tess.color[tess.numVertexes][2] = iColor[2];
tess.vertexColors[tess.numVertexes][3] = 1.0f; tess.color[tess.numVertexes][3] = 65535;
tess.numVertexes++; tess.numVertexes++;
tess.xyz[tess.numVertexes][0] = f->windowX + size; tess.xyz[tess.numVertexes][0] = f->windowX + size;
tess.xyz[tess.numVertexes][1] = f->windowY - size; tess.xyz[tess.numVertexes][1] = f->windowY - size;
tess.texCoords[tess.numVertexes][0][0] = 1; tess.texCoords[tess.numVertexes][0][0] = 1;
tess.texCoords[tess.numVertexes][0][1] = 0; tess.texCoords[tess.numVertexes][0][1] = 0;
tess.vertexColors[tess.numVertexes][0] = iColor[0] / 255.0f; tess.color[tess.numVertexes][0] = iColor[0];
tess.vertexColors[tess.numVertexes][1] = iColor[1] / 255.0f; tess.color[tess.numVertexes][1] = iColor[1];
tess.vertexColors[tess.numVertexes][2] = iColor[2] / 255.0f; tess.color[tess.numVertexes][2] = iColor[2];
tess.vertexColors[tess.numVertexes][3] = 1.0f; tess.color[tess.numVertexes][3] = 65535;
tess.numVertexes++; tess.numVertexes++;
tess.indexes[tess.numIndexes++] = 0; tess.indexes[tess.numIndexes++] = 0;

3
code/renderergl2/tr_glsl.c
View File

@ -1028,9 +1028,6 @@ void GLSL_InitGPUShaders(void)
if (glRefConfig.swizzleNormalmap) if (glRefConfig.swizzleNormalmap)
Q_strcat(extradefines, 1024, "#define SWIZZLE_NORMALMAP\n"); Q_strcat(extradefines, 1024, "#define SWIZZLE_NORMALMAP\n");
if (r_hdr->integer && !glRefConfig.floatLightmap)
Q_strcat(extradefines, 1024, "#define RGBM_LIGHTMAP\n");
if (lightType) if (lightType)
{ {
Q_strcat(extradefines, 1024, "#define USE_LIGHT\n"); Q_strcat(extradefines, 1024, "#define USE_LIGHT\n");

79
code/renderergl2/tr_image.c
View File

@ -150,12 +150,12 @@ void R_ImageList_f( void ) {
int i; int i;
int estTotalSize = 0; int estTotalSize = 0;
ri.Printf(PRINT_ALL, "\n -w-- -h-- type -size- --name-------\n"); ri.Printf(PRINT_ALL, "\n -w-- -h-- -type-- -size- --name-------\n");
for ( i = 0 ; i < tr.numImages ; i++ ) for ( i = 0 ; i < tr.numImages ; i++ )
{ {
image_t *image = tr.images[i]; image_t *image = tr.images[i];
char *format = "???? "; char *format = "???? ";
char *sizeSuffix; char *sizeSuffix;
int estSize; int estSize;
int displaySize; int displaySize;
@ -165,95 +165,121 @@ void R_ImageList_f( void ) {
switch(image->internalFormat) switch(image->internalFormat)
{ {
case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
format = "sDXT1"; format = "sDXT1 ";
// 64 bits per 16 pixels, so 4 bits per pixel // 64 bits per 16 pixels, so 4 bits per pixel
estSize /= 2; estSize /= 2;
break; break;
case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
format = "sDXT5"; format = "sDXT5 ";
// 128 bits per 16 pixels, so 1 byte per pixel // 128 bits per 16 pixels, so 1 byte per pixel
break; break;
case GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB: case GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB:
format = "sBPTC"; format = "sBPTC ";
// 128 bits per 16 pixels, so 1 byte per pixel // 128 bits per 16 pixels, so 1 byte per pixel
break; break;
case GL_COMPRESSED_RG_RGTC2: case GL_COMPRESSED_RG_RGTC2:
format = "RGTC2"; format = "RGTC2 ";
// 128 bits per 16 pixels, so 1 byte per pixel // 128 bits per 16 pixels, so 1 byte per pixel
break; break;
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
format = "DXT1 "; format = "DXT1 ";
// 64 bits per 16 pixels, so 4 bits per pixel // 64 bits per 16 pixels, so 4 bits per pixel
estSize /= 2; estSize /= 2;
break; break;
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
format = "DXT1a"; format = "DXT1a ";
// 64 bits per 16 pixels, so 4 bits per pixel // 64 bits per 16 pixels, so 4 bits per pixel
estSize /= 2; estSize /= 2;
break; break;
case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
format = "DXT5 "; format = "DXT5 ";
// 128 bits per 16 pixels, so 1 byte per pixel // 128 bits per 16 pixels, so 1 byte per pixel
break; break;
case GL_COMPRESSED_RGBA_BPTC_UNORM_ARB: case GL_COMPRESSED_RGBA_BPTC_UNORM_ARB:
format = "BPTC "; format = "BPTC ";
// 128 bits per 16 pixels, so 1 byte per pixel // 128 bits per 16 pixels, so 1 byte per pixel
break; break;
case GL_RGB4_S3TC: case GL_RGB4_S3TC:
format = "S3TC "; format = "S3TC ";
// same as DXT1? // same as DXT1?
estSize /= 2; estSize /= 2;
break; break;
case GL_RGBA16F:
format = "RGBA16F";
// 8 bytes per pixel
estSize *= 8;
break;
case GL_RGBA16:
format = "RGBA16 ";
// 8 bytes per pixel
estSize *= 8;
break;
case GL_RGBA4: case GL_RGBA4:
case GL_RGBA8: case GL_RGBA8:
case GL_RGBA: case GL_RGBA:
format = "RGBA "; format = "RGBA ";
// 4 bytes per pixel // 4 bytes per pixel
estSize *= 4; estSize *= 4;
break; break;
case GL_LUMINANCE8: case GL_LUMINANCE8:
case GL_LUMINANCE16: case GL_LUMINANCE16:
case GL_LUMINANCE: case GL_LUMINANCE:
format = "L "; format = "L ";
// 1 byte per pixel? // 1 byte per pixel?
break; break;
case GL_RGB5: case GL_RGB5:
case GL_RGB8: case GL_RGB8:
case GL_RGB: case GL_RGB:
format = "RGB "; format = "RGB ";
// 3 bytes per pixel? // 3 bytes per pixel?
estSize *= 3; estSize *= 3;
break; break;
case GL_LUMINANCE8_ALPHA8: case GL_LUMINANCE8_ALPHA8:
case GL_LUMINANCE16_ALPHA16: case GL_LUMINANCE16_ALPHA16:
case GL_LUMINANCE_ALPHA: case GL_LUMINANCE_ALPHA:
format = "LA "; format = "LA ";
// 2 bytes per pixel? // 2 bytes per pixel?
estSize *= 2; estSize *= 2;
break; break;
case GL_SRGB_EXT: case GL_SRGB_EXT:
case GL_SRGB8_EXT: case GL_SRGB8_EXT:
format = "sRGB "; format = "sRGB ";
// 3 bytes per pixel? // 3 bytes per pixel?
estSize *= 3; estSize *= 3;
break; break;
case GL_SRGB_ALPHA_EXT: case GL_SRGB_ALPHA_EXT:
case GL_SRGB8_ALPHA8_EXT: case GL_SRGB8_ALPHA8_EXT:
format = "sRGBA"; format = "sRGBA ";
// 4 bytes per pixel? // 4 bytes per pixel?
estSize *= 4; estSize *= 4;
break; break;
case GL_SLUMINANCE_EXT: case GL_SLUMINANCE_EXT:
case GL_SLUMINANCE8_EXT: case GL_SLUMINANCE8_EXT:
format = "sL "; format = "sL ";
// 1 byte per pixel? // 1 byte per pixel?
break; break;
case GL_SLUMINANCE_ALPHA_EXT: case GL_SLUMINANCE_ALPHA_EXT:
case GL_SLUMINANCE8_ALPHA8_EXT: case GL_SLUMINANCE8_ALPHA8_EXT:
format = "sLA "; format = "sLA ";
// 2 byte per pixel? // 2 byte per pixel?
estSize *= 2; estSize *= 2;
break; break;
case GL_DEPTH_COMPONENT16:
format = "Depth16";
// 2 bytes per pixel
estSize *= 2;
break;
case GL_DEPTH_COMPONENT24:
format = "Depth24";
// 3 bytes per pixel
estSize *= 3;
break;
case GL_DEPTH_COMPONENT:
case GL_DEPTH_COMPONENT32:
format = "Depth32";
// 4 bytes per pixel
estSize *= 4;
break;
} }
// mipmap adds about 50% // mipmap adds about 50%
@ -1931,7 +1957,20 @@ static void RawImage_UploadTexture(GLuint texture, byte *data, int x, int y, int
dataFormat = PixelDataFormatFromInternalFormat(internalFormat); dataFormat = PixelDataFormatFromInternalFormat(internalFormat);
// FIXME: This is an old hack to use half floats with lightmaps, use picFormat to determine this instead. // FIXME: This is an old hack to use half floats with lightmaps, use picFormat to determine this instead.
dataType = (internalFormat == GL_RGBA16F_ARB) ? GL_HALF_FLOAT_ARB : GL_UNSIGNED_BYTE; switch (internalFormat)
{
case GL_RGBA16F_ARB:
dataType = GL_HALF_FLOAT_ARB;
break;
case GL_RGBA16:
dataType = GL_UNSIGNED_SHORT;
break;
default:
dataType = GL_UNSIGNED_BYTE;
break;
}
miplevel = 0; miplevel = 0;
do do

22
code/renderergl2/tr_light.c
View File

@ -201,10 +201,10 @@ static void R_SetupEntityLightingGrid( trRefEntity_t *ent, world_t *world ) {
continue; continue;
} }
if (world->hdrLightGrid) if (world->lightGrid16)
{ {
float *hdrData = world->hdrLightGrid + (int)(data - world->lightGridData) / 8 * 6; uint16_t *data16 = world->lightGrid16 + (int)(data - world->lightGridData) / 8 * 6;
if (!(hdrData[0]+hdrData[1]+hdrData[2]+hdrData[3]+hdrData[4]+hdrData[5]) ) { if (!(data16[0]+data16[1]+data16[2]+data16[3]+data16[4]+data16[5])) {
continue; // ignore samples in walls continue; // ignore samples in walls
} }
} }
@ -227,18 +227,18 @@ static void R_SetupEntityLightingGrid( trRefEntity_t *ent, world_t *world ) {
ent->directedLight[1] += factor * d4; ent->directedLight[1] += factor * d4;
ent->directedLight[2] += factor * d5; ent->directedLight[2] += factor * d5;
#else #else
if (world->hdrLightGrid) if (world->lightGrid16)
{ {
// FIXME: this is hideous // FIXME: this is hideous
float *hdrData = world->hdrLightGrid + (int)(data - world->lightGridData) / 8 * 6; uint16_t *data16 = world->lightGrid16 + (int)(data - world->lightGridData) / 8 * 6;
ent->ambientLight[0] += factor * hdrData[0]; ent->ambientLight[0] += factor * data16[0] / 257.0f;
ent->ambientLight[1] += factor * hdrData[1]; ent->ambientLight[1] += factor * data16[1] / 257.0f;
ent->ambientLight[2] += factor * hdrData[2]; ent->ambientLight[2] += factor * data16[2] / 257.0f;
ent->directedLight[0] += factor * hdrData[3]; ent->directedLight[0] += factor * data16[3] / 257.0f;
ent->directedLight[1] += factor * hdrData[4]; ent->directedLight[1] += factor * data16[4] / 257.0f;
ent->directedLight[2] += factor * hdrData[5]; ent->directedLight[2] += factor * data16[5] / 257.0f;
} }
else else
{ {

11
code/renderergl2/tr_local.h
View File

@ -894,7 +894,7 @@ typedef struct
int16_t normal[4]; int16_t normal[4];
int16_t tangent[4]; int16_t tangent[4];
int16_t lightdir[4]; int16_t lightdir[4];
vec4_t vertexColors; uint16_t color[4];
#if DEBUG_OPTIMIZEVERTICES #if DEBUG_OPTIMIZEVERTICES
unsigned int id; unsigned int id;
@ -1153,7 +1153,7 @@ typedef struct {
vec3_t lightGridInverseSize; vec3_t lightGridInverseSize;
int lightGridBounds[3]; int lightGridBounds[3];
byte *lightGridData; byte *lightGridData;
float *hdrLightGrid; uint16_t *lightGrid16;
int numClusters; int numClusters;
@ -1399,11 +1399,8 @@ typedef struct {
qboolean seamlessCubeMap; qboolean seamlessCubeMap;
GLenum packedTexcoordDataType; GLenum packedTexcoordDataType;
GLenum packedColorDataType;
int packedTexcoordDataSize; int packedTexcoordDataSize;
int packedColorDataSize;
qboolean floatLightmap;
qboolean vertexArrayObject; qboolean vertexArrayObject;
qboolean directStateAccess; qboolean directStateAccess;
} glRefConfig_t; } glRefConfig_t;
@ -1994,7 +1991,7 @@ typedef struct shaderCommands_s
int16_t normal[SHADER_MAX_VERTEXES][4] QALIGN(16); int16_t normal[SHADER_MAX_VERTEXES][4] QALIGN(16);
int16_t tangent[SHADER_MAX_VERTEXES][4] QALIGN(16); int16_t tangent[SHADER_MAX_VERTEXES][4] QALIGN(16);
vec2_t texCoords[SHADER_MAX_VERTEXES][2] QALIGN(16); vec2_t texCoords[SHADER_MAX_VERTEXES][2] QALIGN(16);
vec4_t vertexColors[SHADER_MAX_VERTEXES] QALIGN(16); uint16_t color[SHADER_MAX_VERTEXES][4] QALIGN(16);
int16_t lightdir[SHADER_MAX_VERTEXES][4] QALIGN(16); int16_t lightdir[SHADER_MAX_VERTEXES][4] QALIGN(16);
//int vertexDlightBits[SHADER_MAX_VERTEXES] QALIGN(16); //int vertexDlightBits[SHADER_MAX_VERTEXES] QALIGN(16);
@ -2161,7 +2158,7 @@ VERTEX BUFFER OBJECTS
void R_VaoPackTangent(int16_t *out, vec4_t v); void R_VaoPackTangent(int16_t *out, vec4_t v);
void R_VaoPackNormal(int16_t *out, vec3_t v); void R_VaoPackNormal(int16_t *out, vec3_t v);
int R_VaoPackTexCoord(byte *out, vec2_t st); int R_VaoPackTexCoord(byte *out, vec2_t st);
int R_VaoPackColors(byte *out, vec4_t color); void R_VaoPackColor(uint16_t *out, vec4_t c);
void R_VaoUnpackTangent(vec4_t v, int16_t *pack); void R_VaoUnpackTangent(vec4_t v, int16_t *pack);
void R_VaoUnpackNormal(vec3_t v, int16_t *pack); void R_VaoUnpackNormal(vec3_t v, int16_t *pack);

14
code/renderergl2/tr_model_iqm.c
View File

@ -1027,7 +1027,7 @@ void RB_IQMSurfaceAnim( surfaceType_t *surface ) {
int16_t *outNormal; int16_t *outNormal;
int16_t *outTangent; int16_t *outTangent;
vec2_t (*outTexCoord)[2]; vec2_t (*outTexCoord)[2];
vec4_t *outColor; uint16_t *outColor;
int frame = data->num_frames ? backEnd.currentEntity->e.frame % data->num_frames : 0; int frame = data->num_frames ? backEnd.currentEntity->e.frame % data->num_frames : 0;
int oldframe = data->num_frames ? backEnd.currentEntity->e.oldframe % data->num_frames : 0; int oldframe = data->num_frames ? backEnd.currentEntity->e.oldframe % data->num_frames : 0;
@ -1043,7 +1043,7 @@ void RB_IQMSurfaceAnim( surfaceType_t *surface ) {
outNormal = tess.normal[tess.numVertexes]; outNormal = tess.normal[tess.numVertexes];
outTangent = tess.tangent[tess.numVertexes]; outTangent = tess.tangent[tess.numVertexes];
outTexCoord = &tess.texCoords[tess.numVertexes]; outTexCoord = &tess.texCoords[tess.numVertexes];
outColor = &tess.vertexColors[tess.numVertexes]; outColor = tess.color[tess.numVertexes];
// compute interpolated joint matrices // compute interpolated joint matrices
if ( data->num_poses > 0 ) { if ( data->num_poses > 0 ) {
@ -1052,7 +1052,7 @@ void RB_IQMSurfaceAnim( surfaceType_t *surface ) {
// transform vertexes and fill other data // transform vertexes and fill other data
for( i = 0; i < surf->num_vertexes; for( i = 0; i < surf->num_vertexes;
i++, outXYZ++, outNormal+=4, outTexCoord++, outColor++ ) { i++, outXYZ++, outNormal+=4, outTexCoord++, outColor+=4 ) {
int j, k; int j, k;
float vtxMat[12]; float vtxMat[12];
float nrmMat[9]; float nrmMat[9];
@ -1137,10 +1137,10 @@ void RB_IQMSurfaceAnim( surfaceType_t *surface ) {
outTangent+=4; outTangent+=4;
} }
(*outColor)[0] = data->colors[4*vtx+0] / 255.0f; outColor[0] = data->colors[4*vtx+0] * 257;
(*outColor)[1] = data->colors[4*vtx+1] / 255.0f; outColor[1] = data->colors[4*vtx+1] * 257;
(*outColor)[2] = data->colors[4*vtx+2] / 255.0f; outColor[2] = data->colors[4*vtx+2] * 257;
(*outColor)[3] = data->colors[4*vtx+3] / 255.0f; outColor[3] = data->colors[4*vtx+3] * 257;
} }
tri = data->triangles + 3 * surf->first_triangle; tri = data->triangles + 3 * surf->first_triangle;

4
code/renderergl2/tr_shade_calc.c
View File

@ -384,6 +384,7 @@ static void AutospriteDeform( void ) {
} }
for ( i = 0 ; i < oldVerts ; i+=4 ) { for ( i = 0 ; i < oldVerts ; i+=4 ) {
vec4_t color;
// find the midpoint // find the midpoint
xyz = tess.xyz[i]; xyz = tess.xyz[i];
@ -414,7 +415,8 @@ static void AutospriteDeform( void ) {
VectorScale(up, axisLength, up); VectorScale(up, axisLength, up);
} }
RB_AddQuadStamp( mid, left, up, tess.vertexColors[i] ); VectorScale4(tess.color[i], 1.0f / 65535.0f, color);
RB_AddQuadStamp( mid, left, up, color );
} }
} }

62
code/renderergl2/tr_surface.c
View File

@ -89,6 +89,7 @@ RB_AddQuadStampExt
void RB_AddQuadStampExt( vec3_t origin, vec3_t left, vec3_t up, float color[4], float s1, float t1, float s2, float t2 ) { void RB_AddQuadStampExt( vec3_t origin, vec3_t left, vec3_t up, float color[4], float s1, float t1, float s2, float t2 ) {
vec3_t normal; vec3_t normal;
int16_t iNormal[4]; int16_t iNormal[4];
uint16_t iColor[4];
int ndx; int ndx;
RB_CheckVao(tess.vao); RB_CheckVao(tess.vao);
@ -148,10 +149,13 @@ void RB_AddQuadStampExt( vec3_t origin, vec3_t left, vec3_t up, float color[4],
// constant color all the way around // constant color all the way around
// should this be identity and let the shader specify from entity? // should this be identity and let the shader specify from entity?
VectorCopy4(color, tess.vertexColors[ndx]);
VectorCopy4(color, tess.vertexColors[ndx+1]); R_VaoPackColor(iColor, color);
VectorCopy4(color, tess.vertexColors[ndx+2]);
VectorCopy4(color, tess.vertexColors[ndx+3]); VectorCopy4(iColor, tess.color[ndx]);
VectorCopy4(iColor, tess.color[ndx + 1]);
VectorCopy4(iColor, tess.color[ndx + 2]);
VectorCopy4(iColor, tess.color[ndx + 3]);
tess.numVertexes += 4; tess.numVertexes += 4;
tess.numIndexes += 6; tess.numIndexes += 6;
@ -296,10 +300,10 @@ static void RB_SurfacePolychain( srfPoly_t *p ) {
VectorCopy( p->verts[i].xyz, tess.xyz[numv] ); VectorCopy( p->verts[i].xyz, tess.xyz[numv] );
tess.texCoords[numv][0][0] = p->verts[i].st[0]; tess.texCoords[numv][0][0] = p->verts[i].st[0];
tess.texCoords[numv][0][1] = p->verts[i].st[1]; tess.texCoords[numv][0][1] = p->verts[i].st[1];
tess.vertexColors[numv][0] = p->verts[ i ].modulate[0] / 255.0f; tess.color[numv][0] = (int)p->verts[i].modulate[0] * 257;
tess.vertexColors[numv][1] = p->verts[ i ].modulate[1] / 255.0f; tess.color[numv][1] = (int)p->verts[i].modulate[1] * 257;
tess.vertexColors[numv][2] = p->verts[ i ].modulate[2] / 255.0f; tess.color[numv][2] = (int)p->verts[i].modulate[2] * 257;
tess.vertexColors[numv][3] = p->verts[ i ].modulate[3] / 255.0f; tess.color[numv][3] = (int)p->verts[i].modulate[3] * 257;
numv++; numv++;
} }
@ -325,7 +329,7 @@ static void RB_SurfaceVertsAndIndexes( int numVerts, srfVert_t *verts, int numIn
int16_t *normal; int16_t *normal;
int16_t *tangent; int16_t *tangent;
glIndex_t *outIndex; glIndex_t *outIndex;
float *color; uint16_t *color;
RB_CheckVao(tess.vao); RB_CheckVao(tess.vao);
@ -381,9 +385,9 @@ static void RB_SurfaceVertsAndIndexes( int numVerts, srfVert_t *verts, int numIn
if ( tess.shader->vertexAttribs & ATTR_COLOR ) if ( tess.shader->vertexAttribs & ATTR_COLOR )
{ {
dv = verts; dv = verts;
color = tess.vertexColors[ tess.numVertexes ]; color = tess.color[ tess.numVertexes ];
for ( i = 0 ; i < numVerts ; i++, dv++, color+=4 ) for ( i = 0 ; i < numVerts ; i++, dv++, color+=4 )
VectorCopy4(dv->vertexColors, color); VectorCopy4(dv->color, color);
} }
if ( tess.shader->vertexAttribs & ATTR_LIGHTDIRECTION ) if ( tess.shader->vertexAttribs & ATTR_LIGHTDIRECTION )
@ -639,34 +643,34 @@ static void DoRailCore( const vec3_t start, const vec3_t end, const vec3_t up, f
VectorMA( start, spanWidth, up, tess.xyz[tess.numVertexes] ); VectorMA( start, spanWidth, up, tess.xyz[tess.numVertexes] );
tess.texCoords[tess.numVertexes][0][0] = 0; tess.texCoords[tess.numVertexes][0][0] = 0;
tess.texCoords[tess.numVertexes][0][1] = 0; tess.texCoords[tess.numVertexes][0][1] = 0;
tess.vertexColors[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0] * 0.25 / 255.0f; tess.color[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0] * 0.25f * 257.0f;
tess.vertexColors[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1] * 0.25 / 255.0f; tess.color[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1] * 0.25f * 257.0f;
tess.vertexColors[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2] * 0.25 / 255.0f; tess.color[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2] * 0.25f * 257.0f;
tess.numVertexes++; tess.numVertexes++;
VectorMA( start, spanWidth2, up, tess.xyz[tess.numVertexes] ); VectorMA( start, spanWidth2, up, tess.xyz[tess.numVertexes] );
tess.texCoords[tess.numVertexes][0][0] = 0; tess.texCoords[tess.numVertexes][0][0] = 0;
tess.texCoords[tess.numVertexes][0][1] = 1; tess.texCoords[tess.numVertexes][0][1] = 1;
tess.vertexColors[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0] / 255.0f; tess.color[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0] * 257;
tess.vertexColors[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1] / 255.0f; tess.color[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1] * 257;
tess.vertexColors[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2] / 255.0f; tess.color[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2] * 257;
tess.numVertexes++; tess.numVertexes++;
VectorMA( end, spanWidth, up, tess.xyz[tess.numVertexes] ); VectorMA( end, spanWidth, up, tess.xyz[tess.numVertexes] );
tess.texCoords[tess.numVertexes][0][0] = t; tess.texCoords[tess.numVertexes][0][0] = t;
tess.texCoords[tess.numVertexes][0][1] = 0; tess.texCoords[tess.numVertexes][0][1] = 0;
tess.vertexColors[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0] / 255.0f; tess.color[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0] * 257;
tess.vertexColors[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1] / 255.0f; tess.color[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1] * 257;
tess.vertexColors[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2] / 255.0f; tess.color[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2] * 257;
tess.numVertexes++; tess.numVertexes++;
VectorMA( end, spanWidth2, up, tess.xyz[tess.numVertexes] ); VectorMA( end, spanWidth2, up, tess.xyz[tess.numVertexes] );
tess.texCoords[tess.numVertexes][0][0] = t; tess.texCoords[tess.numVertexes][0][0] = t;
tess.texCoords[tess.numVertexes][0][1] = 1; tess.texCoords[tess.numVertexes][0][1] = 1;
tess.vertexColors[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0] / 255.0f; tess.color[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0] * 257;
tess.vertexColors[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1] / 255.0f; tess.color[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1] * 257;
tess.vertexColors[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2] / 255.0f; tess.color[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2] * 257;
tess.numVertexes++; tess.numVertexes++;
tess.indexes[tess.numIndexes++] = vbase; tess.indexes[tess.numIndexes++] = vbase;
@ -723,9 +727,9 @@ static void DoRailDiscs( int numSegs, const vec3_t start, const vec3_t dir, cons
VectorCopy( pos[j], tess.xyz[tess.numVertexes] ); VectorCopy( pos[j], tess.xyz[tess.numVertexes] );
tess.texCoords[tess.numVertexes][0][0] = ( j < 2 ); tess.texCoords[tess.numVertexes][0][0] = ( j < 2 );
tess.texCoords[tess.numVertexes][0][1] = ( j && j != 3 ); tess.texCoords[tess.numVertexes][0][1] = ( j && j != 3 );
tess.vertexColors[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0] / 255.0f; tess.color[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0] * 257;
tess.vertexColors[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1] / 255.0f; tess.color[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1] * 257;
tess.vertexColors[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2] / 255.0f; tess.color[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2] * 257;
tess.numVertexes++; tess.numVertexes++;
VectorAdd( pos[j], dir, pos[j] ); VectorAdd( pos[j], dir, pos[j] );
@ -1010,7 +1014,7 @@ static void RB_SurfaceGrid( srfBspSurface_t *srf ) {
float *texCoords, *lightCoords; float *texCoords, *lightCoords;
int16_t *normal; int16_t *normal;
int16_t *tangent; int16_t *tangent;
float *color; uint16_t *color;
int16_t *lightdir; int16_t *lightdir;
srfVert_t *dv; srfVert_t *dv;
int rows, irows, vrows; int rows, irows, vrows;
@ -1100,7 +1104,7 @@ static void RB_SurfaceGrid( srfBspSurface_t *srf ) {
tangent = tess.tangent[numVertexes]; tangent = tess.tangent[numVertexes];
texCoords = tess.texCoords[numVertexes][0]; texCoords = tess.texCoords[numVertexes][0];
lightCoords = tess.texCoords[numVertexes][1]; lightCoords = tess.texCoords[numVertexes][1];
color = tess.vertexColors[numVertexes]; color = tess.color[numVertexes];
lightdir = tess.lightdir[numVertexes]; lightdir = tess.lightdir[numVertexes];
//vDlightBits = &tess.vertexDlightBits[numVertexes]; //vDlightBits = &tess.vertexDlightBits[numVertexes];
@ -1141,7 +1145,7 @@ static void RB_SurfaceGrid( srfBspSurface_t *srf ) {
if ( tess.shader->vertexAttribs & ATTR_COLOR ) if ( tess.shader->vertexAttribs & ATTR_COLOR )
{ {
VectorCopy4(dv->vertexColors, color); VectorCopy4(dv->color, color);
color += 4; color += 4;
} }

49
code/renderergl2/tr_vbo.c
View File

@ -61,30 +61,12 @@ int R_VaoPackTexCoord(byte *out, vec2_t st)
} }
} }
int R_VaoPackColors(byte *out, vec4_t color) void R_VaoPackColor(uint16_t *out, vec4_t c)
{ {
if (glRefConfig.packedTexcoordDataType == GL_HALF_FLOAT) out[0] = c[0] * 65535.0f + 0.5f;
{ out[1] = c[1] * 65535.0f + 0.5f;
uint16_t *num = (uint16_t *)out; out[2] = c[2] * 65535.0f + 0.5f;
out[3] = c[3] * 65535.0f + 0.5f;
*num++ = FloatToHalf(color[0]);
*num++ = FloatToHalf(color[1]);
*num++ = FloatToHalf(color[2]);
*num++ = FloatToHalf(color[3]);
return sizeof(*num) * 4;
}
else
{
float *num = (float *)out;
*num++ = color[0];
*num++ = color[1];
*num++ = color[2];
*num++ = color[3];
return sizeof(*num) * 4;
}
} }
void R_VaoUnpackTangent(vec4_t v, int16_t *pack) void R_VaoUnpackTangent(vec4_t v, int16_t *pack)
@ -267,7 +249,7 @@ vao_t *R_CreateVao2(const char *name, int numVertexes, srfVert_t *verts, int num
vao->attribs[ATTR_INDEX_TANGENT ].type = GL_SHORT; vao->attribs[ATTR_INDEX_TANGENT ].type = GL_SHORT;
vao->attribs[ATTR_INDEX_TEXCOORD ].type = glRefConfig.packedTexcoordDataType; vao->attribs[ATTR_INDEX_TEXCOORD ].type = glRefConfig.packedTexcoordDataType;
vao->attribs[ATTR_INDEX_LIGHTCOORD ].type = glRefConfig.packedTexcoordDataType; vao->attribs[ATTR_INDEX_LIGHTCOORD ].type = glRefConfig.packedTexcoordDataType;
vao->attribs[ATTR_INDEX_COLOR ].type = glRefConfig.packedColorDataType; vao->attribs[ATTR_INDEX_COLOR ].type = GL_UNSIGNED_SHORT;
vao->attribs[ATTR_INDEX_LIGHTDIRECTION].type = GL_SHORT; vao->attribs[ATTR_INDEX_LIGHTDIRECTION].type = GL_SHORT;
vao->attribs[ATTR_INDEX_POSITION ].normalized = GL_FALSE; vao->attribs[ATTR_INDEX_POSITION ].normalized = GL_FALSE;
@ -275,7 +257,7 @@ vao_t *R_CreateVao2(const char *name, int numVertexes, srfVert_t *verts, int num
vao->attribs[ATTR_INDEX_TANGENT ].normalized = GL_TRUE; vao->attribs[ATTR_INDEX_TANGENT ].normalized = GL_TRUE;
vao->attribs[ATTR_INDEX_TEXCOORD ].normalized = GL_FALSE; vao->attribs[ATTR_INDEX_TEXCOORD ].normalized = GL_FALSE;
vao->attribs[ATTR_INDEX_LIGHTCOORD ].normalized = GL_FALSE; vao->attribs[ATTR_INDEX_LIGHTCOORD ].normalized = GL_FALSE;
vao->attribs[ATTR_INDEX_COLOR ].normalized = GL_FALSE; vao->attribs[ATTR_INDEX_COLOR ].normalized = GL_TRUE;
vao->attribs[ATTR_INDEX_LIGHTDIRECTION].normalized = GL_TRUE; vao->attribs[ATTR_INDEX_LIGHTDIRECTION].normalized = GL_TRUE;
vao->attribs[ATTR_INDEX_POSITION ].offset = 0; dataSize = sizeof(verts[0].xyz); vao->attribs[ATTR_INDEX_POSITION ].offset = 0; dataSize = sizeof(verts[0].xyz);
@ -283,7 +265,7 @@ vao_t *R_CreateVao2(const char *name, int numVertexes, srfVert_t *verts, int num
vao->attribs[ATTR_INDEX_TANGENT ].offset = dataSize; dataSize += sizeof(verts[0].tangent); vao->attribs[ATTR_INDEX_TANGENT ].offset = dataSize; dataSize += sizeof(verts[0].tangent);
vao->attribs[ATTR_INDEX_TEXCOORD ].offset = dataSize; dataSize += glRefConfig.packedTexcoordDataSize; vao->attribs[ATTR_INDEX_TEXCOORD ].offset = dataSize; dataSize += glRefConfig.packedTexcoordDataSize;
vao->attribs[ATTR_INDEX_LIGHTCOORD ].offset = dataSize; dataSize += glRefConfig.packedTexcoordDataSize; vao->attribs[ATTR_INDEX_LIGHTCOORD ].offset = dataSize; dataSize += glRefConfig.packedTexcoordDataSize;
vao->attribs[ATTR_INDEX_COLOR ].offset = dataSize; dataSize += glRefConfig.packedColorDataSize; vao->attribs[ATTR_INDEX_COLOR ].offset = dataSize; dataSize += sizeof(verts[0].color);
vao->attribs[ATTR_INDEX_LIGHTDIRECTION].offset = dataSize; dataSize += sizeof(verts[0].lightdir); vao->attribs[ATTR_INDEX_LIGHTDIRECTION].offset = dataSize; dataSize += sizeof(verts[0].lightdir);
vao->attribs[ATTR_INDEX_POSITION ].stride = dataSize; vao->attribs[ATTR_INDEX_POSITION ].stride = dataSize;
@ -328,7 +310,8 @@ vao_t *R_CreateVao2(const char *name, int numVertexes, srfVert_t *verts, int num
dataOfs += R_VaoPackTexCoord(data + dataOfs, verts[i].lightmap); dataOfs += R_VaoPackTexCoord(data + dataOfs, verts[i].lightmap);
// colors // colors
dataOfs += R_VaoPackColors(data + dataOfs, verts[i].vertexColors); memcpy(data + dataOfs, &verts[i].color, sizeof(verts[i].color));
dataOfs += sizeof(verts[i].color);
// light directions // light directions
memcpy(data + dataOfs, &verts[i].lightdir, sizeof(verts[i].lightdir)); memcpy(data + dataOfs, &verts[i].lightdir, sizeof(verts[i].lightdir));
@ -464,7 +447,7 @@ void R_InitVaos(void)
vertexesSize = sizeof(tess.xyz[0]); vertexesSize = sizeof(tess.xyz[0]);
vertexesSize += sizeof(tess.normal[0]); vertexesSize += sizeof(tess.normal[0]);
vertexesSize += sizeof(tess.tangent[0]); vertexesSize += sizeof(tess.tangent[0]);
vertexesSize += sizeof(tess.vertexColors[0]); vertexesSize += sizeof(tess.color[0]);
vertexesSize += sizeof(tess.texCoords[0][0]) * 2; vertexesSize += sizeof(tess.texCoords[0][0]) * 2;
vertexesSize += sizeof(tess.lightdir[0]); vertexesSize += sizeof(tess.lightdir[0]);
vertexesSize *= SHADER_MAX_VERTEXES; vertexesSize *= SHADER_MAX_VERTEXES;
@ -496,7 +479,7 @@ void R_InitVaos(void)
tess.vao->attribs[ATTR_INDEX_TANGENT ].type = GL_SHORT; tess.vao->attribs[ATTR_INDEX_TANGENT ].type = GL_SHORT;
tess.vao->attribs[ATTR_INDEX_TEXCOORD ].type = GL_FLOAT; tess.vao->attribs[ATTR_INDEX_TEXCOORD ].type = GL_FLOAT;
tess.vao->attribs[ATTR_INDEX_LIGHTCOORD ].type = GL_FLOAT; tess.vao->attribs[ATTR_INDEX_LIGHTCOORD ].type = GL_FLOAT;
tess.vao->attribs[ATTR_INDEX_COLOR ].type = GL_FLOAT; tess.vao->attribs[ATTR_INDEX_COLOR ].type = GL_UNSIGNED_SHORT;
tess.vao->attribs[ATTR_INDEX_LIGHTDIRECTION].type = GL_SHORT; tess.vao->attribs[ATTR_INDEX_LIGHTDIRECTION].type = GL_SHORT;
tess.vao->attribs[ATTR_INDEX_POSITION ].normalized = GL_FALSE; tess.vao->attribs[ATTR_INDEX_POSITION ].normalized = GL_FALSE;
@ -504,7 +487,7 @@ void R_InitVaos(void)
tess.vao->attribs[ATTR_INDEX_TANGENT ].normalized = GL_TRUE; tess.vao->attribs[ATTR_INDEX_TANGENT ].normalized = GL_TRUE;
tess.vao->attribs[ATTR_INDEX_TEXCOORD ].normalized = GL_FALSE; tess.vao->attribs[ATTR_INDEX_TEXCOORD ].normalized = GL_FALSE;
tess.vao->attribs[ATTR_INDEX_LIGHTCOORD ].normalized = GL_FALSE; tess.vao->attribs[ATTR_INDEX_LIGHTCOORD ].normalized = GL_FALSE;
tess.vao->attribs[ATTR_INDEX_COLOR ].normalized = GL_FALSE; tess.vao->attribs[ATTR_INDEX_COLOR ].normalized = GL_TRUE;
tess.vao->attribs[ATTR_INDEX_LIGHTDIRECTION].normalized = GL_TRUE; tess.vao->attribs[ATTR_INDEX_LIGHTDIRECTION].normalized = GL_TRUE;
tess.vao->attribs[ATTR_INDEX_POSITION ].offset = offset; offset += sizeof(tess.xyz[0]) * SHADER_MAX_VERTEXES; tess.vao->attribs[ATTR_INDEX_POSITION ].offset = offset; offset += sizeof(tess.xyz[0]) * SHADER_MAX_VERTEXES;
@ -515,13 +498,13 @@ void R_InitVaos(void)
tess.vao->attribs[ATTR_INDEX_LIGHTCOORD ].offset = offset + sizeof(tess.texCoords[0][0]); tess.vao->attribs[ATTR_INDEX_LIGHTCOORD ].offset = offset + sizeof(tess.texCoords[0][0]);
offset += sizeof(tess.texCoords[0][0]) * 2 * SHADER_MAX_VERTEXES; offset += sizeof(tess.texCoords[0][0]) * 2 * SHADER_MAX_VERTEXES;
tess.vao->attribs[ATTR_INDEX_COLOR ].offset = offset; offset += sizeof(tess.vertexColors[0]) * SHADER_MAX_VERTEXES; tess.vao->attribs[ATTR_INDEX_COLOR ].offset = offset; offset += sizeof(tess.color[0]) * SHADER_MAX_VERTEXES;
tess.vao->attribs[ATTR_INDEX_LIGHTDIRECTION].offset = offset; tess.vao->attribs[ATTR_INDEX_LIGHTDIRECTION].offset = offset;
tess.vao->attribs[ATTR_INDEX_POSITION ].stride = sizeof(tess.xyz[0]); tess.vao->attribs[ATTR_INDEX_POSITION ].stride = sizeof(tess.xyz[0]);
tess.vao->attribs[ATTR_INDEX_NORMAL ].stride = sizeof(tess.normal[0]); tess.vao->attribs[ATTR_INDEX_NORMAL ].stride = sizeof(tess.normal[0]);
tess.vao->attribs[ATTR_INDEX_TANGENT ].stride = sizeof(tess.tangent[0]); tess.vao->attribs[ATTR_INDEX_TANGENT ].stride = sizeof(tess.tangent[0]);
tess.vao->attribs[ATTR_INDEX_COLOR ].stride = sizeof(tess.vertexColors[0]); tess.vao->attribs[ATTR_INDEX_COLOR ].stride = sizeof(tess.color[0]);
tess.vao->attribs[ATTR_INDEX_TEXCOORD ].stride = sizeof(tess.texCoords[0][0]) * 2; tess.vao->attribs[ATTR_INDEX_TEXCOORD ].stride = sizeof(tess.texCoords[0][0]) * 2;
tess.vao->attribs[ATTR_INDEX_LIGHTCOORD ].stride = sizeof(tess.texCoords[0][0]) * 2; tess.vao->attribs[ATTR_INDEX_LIGHTCOORD ].stride = sizeof(tess.texCoords[0][0]) * 2;
tess.vao->attribs[ATTR_INDEX_LIGHTDIRECTION].stride = sizeof(tess.lightdir[0]); tess.vao->attribs[ATTR_INDEX_LIGHTDIRECTION].stride = sizeof(tess.lightdir[0]);
@ -530,7 +513,7 @@ void R_InitVaos(void)
tess.attribPointers[ATTR_INDEX_TEXCOORD] = tess.texCoords; tess.attribPointers[ATTR_INDEX_TEXCOORD] = tess.texCoords;
tess.attribPointers[ATTR_INDEX_NORMAL] = tess.normal; tess.attribPointers[ATTR_INDEX_NORMAL] = tess.normal;
tess.attribPointers[ATTR_INDEX_TANGENT] = tess.tangent; tess.attribPointers[ATTR_INDEX_TANGENT] = tess.tangent;
tess.attribPointers[ATTR_INDEX_COLOR] = tess.vertexColors; tess.attribPointers[ATTR_INDEX_COLOR] = tess.color;
tess.attribPointers[ATTR_INDEX_LIGHTDIRECTION] = tess.lightdir; tess.attribPointers[ATTR_INDEX_LIGHTDIRECTION] = tess.lightdir;
Vao_SetVertexPointers(tess.vao); Vao_SetVertexPointers(tess.vao);