X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=gl_rmain.c;h=671786c8893d2ab9831143e4f3bcaa8d05fe1bbd;hb=78b6fb46fb00b5c74f08337becebc27e4e8688b8;hp=1556b95bafa4a2396418a9f7c9db198e99835d53;hpb=1fb7242bcaf4ab9f47253b8c41288a4a39b12ba1;p=xonotic%2Fdarkplaces.git diff --git a/gl_rmain.c b/gl_rmain.c index 1556b95b..671786c8 100644 --- a/gl_rmain.c +++ b/gl_rmain.c @@ -30,6 +30,10 @@ rtexturepool_t *r_main_texturepool; static int r_frame = 0; ///< used only by R_GetCurrentTexture +qboolean r_loadnormalmap; +qboolean r_loadgloss; +qboolean r_loadfog; + // // screen size info // @@ -50,8 +54,6 @@ cvar_t r_equalize_entities_minambient = {CVAR_SAVE, "r_equalize_entities_minambi cvar_t r_equalize_entities_by = {CVAR_SAVE, "r_equalize_entities_by", "0.7", "light equalizing: exponent of dynamics compression (0 = no compression, 1 = full compression)"}; cvar_t r_equalize_entities_to = {CVAR_SAVE, "r_equalize_entities_to", "0.8", "light equalizing: target light level"}; -cvar_t r_animcache = {CVAR_SAVE, "r_animcache", "1", "cache animation frames to save CPU usage, primarily optimizes shadows and reflections"}; - cvar_t r_depthfirst = {CVAR_SAVE, "r_depthfirst", "0", "renders a depth-only version of the scene before normal rendering begins to eliminate overdraw, values: 0 = off, 1 = world depth, 2 = world and model depth"}; cvar_t r_useinfinitefarclip = {CVAR_SAVE, "r_useinfinitefarclip", "1", "enables use of a special kind of projection matrix that has an extremely large farclip"}; cvar_t r_farclip_base = {0, "r_farclip_base", "65536", "farclip (furthest visible distance) for rendering when r_useinfinitefarclip is 0"}; @@ -71,7 +73,8 @@ cvar_t r_drawportals = {0, "r_drawportals", "0", "shows portals (separating poly cvar_t r_drawentities = {0, "r_drawentities","1", "draw entities (doors, players, projectiles, etc)"}; cvar_t r_drawviewmodel = {0, "r_drawviewmodel","1", "draw your weapon model"}; cvar_t r_cullentities_trace = {0, "r_cullentities_trace", "1", "probabistically cull invisible entities"}; -cvar_t r_cullentities_trace_samples = {0, "r_cullentities_trace_samples", "2", "number of samples to test for entity culling"}; +cvar_t r_cullentities_trace_samples = {0, "r_cullentities_trace_samples", "2", "number of samples to test for entity culling (in addition to center sample)"}; +cvar_t r_cullentities_trace_tempentitysamples = {0, "r_cullentities_trace_tempentitysamples", "-1", "number of samples to test for entity culling of temp entities (including all CSQC entities), -1 disables trace culling on these entities to prevent flicker (pvs still applies)"}; cvar_t r_cullentities_trace_enlarge = {0, "r_cullentities_trace_enlarge", "0", "box enlargement for entity culling"}; cvar_t r_cullentities_trace_delay = {0, "r_cullentities_trace_delay", "1", "number of seconds until the entity gets actually culled"}; cvar_t r_speeds = {0, "r_speeds","0", "displays rendering statistics and per-subsystem timings"}; @@ -102,9 +105,10 @@ cvar_t gl_fogstart = {0, "gl_fogstart", "0", "nehahra fog start distance (for Ne cvar_t gl_fogend = {0, "gl_fogend","0", "nehahra fog end distance (for Nehahra compatibility only)"}; cvar_t gl_skyclip = {0, "gl_skyclip", "4608", "nehahra farclip distance - the real fog end (for Nehahra compatibility only)"}; -cvar_t r_textureunits = {0, "r_textureunits", "32", "number of hardware texture units reported by driver (note: setting this to 1 turns off gl_combine)"}; +cvar_t r_textureunits = {0, "r_textureunits", "32", "number of texture units to use in GL 1.1 and GL 1.3 rendering paths"}; +static cvar_t gl_combine = {CVAR_READONLY, "gl_combine", "1", "indicates whether the OpenGL 1.3 rendering path is active"}; +static cvar_t r_glsl = {CVAR_READONLY, "r_glsl", "1", "indicates whether the OpenGL 2.0 rendering path is active"}; -cvar_t r_glsl = {CVAR_SAVE, "r_glsl", "1", "enables use of OpenGL 2.0 pixel shaders for lighting"}; cvar_t r_glsl_deluxemapping = {CVAR_SAVE, "r_glsl_deluxemapping", "1", "use per pixel lighting on deluxemap-compiled q3bsp maps (or a value of 2 forces deluxemap shading even without deluxemaps)"}; cvar_t r_glsl_offsetmapping = {CVAR_SAVE, "r_glsl_offsetmapping", "0", "offset mapping effect (also known as parallax mapping or virtual displacement mapping)"}; cvar_t r_glsl_offsetmapping_reliefmapping = {CVAR_SAVE, "r_glsl_offsetmapping_reliefmapping", "0", "relief mapping effect (higher quality)"}; @@ -114,7 +118,6 @@ cvar_t r_glsl_postprocess_uservec1 = {CVAR_SAVE, "r_glsl_postprocess_uservec1", cvar_t r_glsl_postprocess_uservec2 = {CVAR_SAVE, "r_glsl_postprocess_uservec2", "0 0 0 0", "a 4-component vector to pass as uservec2 to the postprocessing shader (only useful if default.glsl has been customized)"}; cvar_t r_glsl_postprocess_uservec3 = {CVAR_SAVE, "r_glsl_postprocess_uservec3", "0 0 0 0", "a 4-component vector to pass as uservec3 to the postprocessing shader (only useful if default.glsl has been customized)"}; cvar_t r_glsl_postprocess_uservec4 = {CVAR_SAVE, "r_glsl_postprocess_uservec4", "0 0 0 0", "a 4-component vector to pass as uservec4 to the postprocessing shader (only useful if default.glsl has been customized)"}; -cvar_t r_glsl_usegeneric = {CVAR_SAVE, "r_glsl_usegeneric", "1", "use shaders for rendering simple geometry (rather than conventional fixed-function rendering for this purpose)"}; cvar_t r_water = {CVAR_SAVE, "r_water", "0", "whether to use reflections and refraction on water surfaces (note: r_wateralpha must be set below 1)"}; cvar_t r_water_clippingplanebias = {CVAR_SAVE, "r_water_clippingplanebias", "1", "a rather technical setting which avoids black pixels around water edges"}; @@ -154,6 +157,8 @@ cvar_t r_track_sprites_scalew = {CVAR_SAVE, "r_track_sprites_scalew", "1", "widt cvar_t r_track_sprites_scaleh = {CVAR_SAVE, "r_track_sprites_scaleh", "1", "height scaling of tracked sprites"}; cvar_t r_glsl_saturation = {CVAR_SAVE, "r_glsl_saturation", "1", "saturation multiplier (only working in glsl!)"}; +cvar_t r_framedatasize = {CVAR_SAVE, "r_framedatasize", "1", "size of renderer data cache used during one frame (for skeletal animation caching, light processing, etc)"}; + extern cvar_t v_glslgamma; extern qboolean v_flipped_state; @@ -321,7 +326,7 @@ static void R_BuildNoTexture(void) } } } - r_texture_notexture = R_LoadTexture2D(r_main_texturepool, "notexture", 16, 16, &pix[0][0][0], TEXTYPE_BGRA, TEXF_MIPMAP | TEXF_PERSISTENT, NULL); + r_texture_notexture = R_LoadTexture2D(r_main_texturepool, "notexture", 16, 16, &pix[0][0][0], TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_MIPMAP | TEXF_PERSISTENT, NULL); } static void R_BuildWhiteCube(void) @@ -1872,7 +1877,7 @@ static void R_GLSL_CompilePermutation(r_glsl_permutation_t *p, unsigned int mode p->loc_Texture_ShadowMapRect = qglGetUniformLocationARB(p->program, "Texture_ShadowMapRect"); p->loc_Texture_ShadowMapCube = qglGetUniformLocationARB(p->program, "Texture_ShadowMapCube"); p->loc_Texture_ShadowMap2D = qglGetUniformLocationARB(p->program, "Texture_ShadowMap2D"); - p->loc_Texture_CubeProjection = qglGetUniformLocationARB(p->program, "Texture_CubeProjection"); + p->loc_Texture_CubeProjection = qglGetUniformLocationARB(p->program, "Texture_CubeProjection"); p->loc_FogColor = qglGetUniformLocationARB(p->program, "FogColor"); p->loc_LightPosition = qglGetUniformLocationARB(p->program, "LightPosition"); p->loc_EyePosition = qglGetUniformLocationARB(p->program, "EyePosition"); @@ -2022,10 +2027,10 @@ void R_SetupShader_SetPermutation(unsigned int mode, unsigned int permutation) } if (i >= SHADERPERMUTATION_COUNT) { - Con_Printf("OpenGL 2.0 shaders disabled - unable to find a working shader permutation fallback on this driver (set r_glsl 1 if you want to try again)\n"); - Cvar_SetValueQuick(&r_glsl, 0); - R_GLSL_Restart_f(); // unload shaders - return; // no bit left to clear + Con_Printf("Could not find a working OpenGL 2.0 shader for permutation %s %s\n", shadermodeinfo[mode].vertexfilename, shadermodeinfo[mode].pretext); + r_glsl_permutation = R_GLSL_FindPermutation(mode, permutation); + qglUseProgramObjectARB(0);CHECKGLERROR + return; // no bit left to clear, entire mode is broken } } } @@ -2036,63 +2041,56 @@ void R_SetupShader_SetPermutation(unsigned int mode, unsigned int permutation) void R_SetupGenericShader(qboolean usetexture) { - if (gl_support_fragment_shader) + switch(vid.renderpath) { - if (r_glsl.integer && r_glsl_usegeneric.integer) - R_SetupShader_SetPermutation(SHADERMODE_GENERIC, usetexture ? SHADERPERMUTATION_DIFFUSE : 0); - else if (r_glsl_permutation) - { - r_glsl_permutation = NULL; - qglUseProgramObjectARB(0);CHECKGLERROR - } + case RENDERPATH_GL20: + R_SetupShader_SetPermutation(SHADERMODE_GENERIC, usetexture ? SHADERPERMUTATION_DIFFUSE : 0); + break; + case RENDERPATH_GL13: + case RENDERPATH_GL11: + break; } } void R_SetupGenericTwoTextureShader(int texturemode) { - if (gl_support_fragment_shader) + switch (vid.renderpath) { - if (r_glsl.integer && r_glsl_usegeneric.integer) - R_SetupShader_SetPermutation(SHADERMODE_GENERIC, SHADERPERMUTATION_DIFFUSE | SHADERPERMUTATION_SPECULAR | (r_shadow_glossexact.integer ? SHADERPERMUTATION_EXACTSPECULARMATH : 0) | (texturemode == GL_MODULATE ? SHADERPERMUTATION_COLORMAPPING : (texturemode == GL_ADD ? SHADERPERMUTATION_GLOW : (texturemode == GL_DECAL ? SHADERPERMUTATION_VERTEXTEXTUREBLEND : 0)))); - else if (r_glsl_permutation) - { - r_glsl_permutation = NULL; - qglUseProgramObjectARB(0);CHECKGLERROR - } - } - if (!r_glsl_permutation) - { - if (texturemode == GL_DECAL && gl_combine.integer) - texturemode = GL_INTERPOLATE_ARB; - R_Mesh_TexCombine(1, texturemode, texturemode, 1, 1); + case RENDERPATH_GL20: + R_SetupShader_SetPermutation(SHADERMODE_GENERIC, SHADERPERMUTATION_DIFFUSE | SHADERPERMUTATION_SPECULAR | (r_shadow_glossexact.integer ? SHADERPERMUTATION_EXACTSPECULARMATH : 0) | (texturemode == GL_MODULATE ? SHADERPERMUTATION_COLORMAPPING : (texturemode == GL_ADD ? SHADERPERMUTATION_GLOW : (texturemode == GL_DECAL ? SHADERPERMUTATION_VERTEXTEXTUREBLEND : 0)))); + break; + case RENDERPATH_GL13: + case RENDERPATH_GL11: + R_Mesh_TexCombine(1, GL_DECAL, GL_DECAL, 1, 1); + break; } } void R_SetupDepthOrShadowShader(void) { - if (gl_support_fragment_shader) + switch (vid.renderpath) { - if (r_glsl.integer && r_glsl_usegeneric.integer) - R_SetupShader_SetPermutation(SHADERMODE_DEPTH_OR_SHADOW, 0); - else if (r_glsl_permutation) - { - r_glsl_permutation = NULL; - qglUseProgramObjectARB(0);CHECKGLERROR - } + case RENDERPATH_GL20: + R_SetupShader_SetPermutation(SHADERMODE_DEPTH_OR_SHADOW, 0); + break; + case RENDERPATH_GL13: + break; + case RENDERPATH_GL11: + break; } } void R_SetupShowDepthShader(void) { - if (gl_support_fragment_shader) + switch (vid.renderpath) { - if (r_glsl.integer && r_glsl_usegeneric.integer) - R_SetupShader_SetPermutation(SHADERMODE_SHOWDEPTH, 0); - else if (r_glsl_permutation) - { - r_glsl_permutation = NULL; - qglUseProgramObjectARB(0);CHECKGLERROR - } + case RENDERPATH_GL20: + R_SetupShader_SetPermutation(SHADERMODE_SHOWDEPTH, 0); + break; + case RENDERPATH_GL13: + break; + case RENDERPATH_GL11: + break; } } @@ -2511,15 +2509,8 @@ skinframe_t *R_SkinFrame_Find(const char *name, int textureflags, int comparewid skinframe->avgcolor[3] = avgcolor[4] / (255.0 * cnt); \ } -skinframe_t *R_SkinFrame_LoadExternal_CheckAlpha(const char *name, int textureflags, qboolean complain, qboolean *has_alpha) +skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboolean complain) { - // FIXME: it should be possible to disable loading various layers using - // cvars, to prevent wasted loading time and memory usage if the user does - // not want them - qboolean loadnormalmap = true; - qboolean loadgloss = true; - qboolean loadpantsandshirt = true; - qboolean loadglow = true; int j; unsigned char *pixels; unsigned char *bumppixels; @@ -2528,9 +2519,6 @@ skinframe_t *R_SkinFrame_LoadExternal_CheckAlpha(const char *name, int texturefl int basepixels_height; skinframe_t *skinframe; - if (has_alpha) - *has_alpha = false; - if (cls.state == ca_dedicated) return NULL; @@ -2560,6 +2548,7 @@ skinframe_t *R_SkinFrame_LoadExternal_CheckAlpha(const char *name, int texturefl skinframe->gloss = NULL; skinframe->glow = NULL; skinframe->fog = NULL; + skinframe->hasalpha = false; basepixels_width = image_width; basepixels_height = image_height; @@ -2568,13 +2557,16 @@ skinframe_t *R_SkinFrame_LoadExternal_CheckAlpha(const char *name, int texturefl if (textureflags & TEXF_ALPHA) { for (j = 3;j < basepixels_width * basepixels_height * 4;j += 4) + { if (basepixels[j] < 255) + { + skinframe->hasalpha = true; break; - if (j < basepixels_width * basepixels_height * 4) + } + } + if (r_loadfog && skinframe->hasalpha) { // has transparent pixels - if (has_alpha) - *has_alpha = true; pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4); for (j = 0;j < image_width * image_height * 4;j += 4) { @@ -2592,7 +2584,7 @@ skinframe_t *R_SkinFrame_LoadExternal_CheckAlpha(const char *name, int texturefl //Con_Printf("Texture %s has average colors %f %f %f alpha %f\n", name, skinframe->avgcolor[0], skinframe->avgcolor[1], skinframe->avgcolor[2], skinframe->avgcolor[3]); // _norm is the name used by tenebrae and has been adopted as standard - if (loadnormalmap) + if (r_loadnormalmap) { if ((pixels = loadimagepixelsbgra(va("%s_norm", skinframe->basename), false, false)) != NULL) { @@ -2619,10 +2611,10 @@ skinframe_t *R_SkinFrame_LoadExternal_CheckAlpha(const char *name, int texturefl // _luma is supported for tenebrae compatibility // (I think it's a very stupid name, but oh well) // _glow is the preferred name - if (loadglow && ((pixels = loadimagepixelsbgra(va("%s_glow", skinframe->basename), false, false)) != NULL || (pixels = loadimagepixelsbgra(va("%s_luma", skinframe->basename), false, false)) != NULL)) {skinframe->glow = R_LoadTexture2D (r_main_texturepool, va("%s_glow", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_glow.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;} - if (loadgloss && (pixels = loadimagepixelsbgra(va("%s_gloss", skinframe->basename), false, false)) != NULL) {skinframe->gloss = R_LoadTexture2D (r_main_texturepool, va("%s_gloss", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_gloss.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;} - if (loadpantsandshirt && (pixels = loadimagepixelsbgra(va("%s_pants", skinframe->basename), false, false)) != NULL) {skinframe->pants = R_LoadTexture2D (r_main_texturepool, va("%s_pants", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;} - if (loadpantsandshirt && (pixels = loadimagepixelsbgra(va("%s_shirt", skinframe->basename), false, false)) != NULL) {skinframe->shirt = R_LoadTexture2D (r_main_texturepool, va("%s_shirt", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;} + if ((pixels = loadimagepixelsbgra(va("%s_glow", skinframe->basename), false, false)) || (pixels = loadimagepixelsbgra(va("%s_luma", skinframe->basename), false, false))) {skinframe->glow = R_LoadTexture2D (r_main_texturepool, va("%s_glow", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_glow.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;} + if (r_loadgloss && (pixels = loadimagepixelsbgra(va("%s_gloss", skinframe->basename), false, false))) {skinframe->gloss = R_LoadTexture2D (r_main_texturepool, va("%s_gloss", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_gloss.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;} + if ((pixels = loadimagepixelsbgra(va("%s_pants", skinframe->basename), false, false))) {skinframe->pants = R_LoadTexture2D (r_main_texturepool, va("%s_pants", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;} + if ((pixels = loadimagepixelsbgra(va("%s_shirt", skinframe->basename), false, false))) {skinframe->shirt = R_LoadTexture2D (r_main_texturepool, va("%s_shirt", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;} if (basepixels) Mem_Free(basepixels); @@ -2630,25 +2622,6 @@ skinframe_t *R_SkinFrame_LoadExternal_CheckAlpha(const char *name, int texturefl return skinframe; } -skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboolean complain) -{ - return R_SkinFrame_LoadExternal_CheckAlpha(name, textureflags, complain, NULL); -} - -static rtexture_t *R_SkinFrame_TextureForSkinLayer(const unsigned char *in, int width, int height, const char *name, const unsigned int *palette, int textureflags, qboolean force) -{ - int i; - if (!force) - { - for (i = 0;i < width*height;i++) - if (((unsigned char *)&palette[in[i]])[3] > 0) - break; - if (i == width*height) - return NULL; - } - return R_LoadTexture2D (r_main_texturepool, name, width, height, in, TEXTYPE_PALETTE, textureflags, palette); -} - // this is only used by .spr32 sprites, HL .spr files, HL .bsp files skinframe_t *R_SkinFrame_LoadInternalBGRA(const char *name, int textureflags, const unsigned char *skindata, int width, int height) { @@ -2673,6 +2646,7 @@ skinframe_t *R_SkinFrame_LoadInternalBGRA(const char *name, int textureflags, co skinframe->gloss = NULL; skinframe->glow = NULL; skinframe->fog = NULL; + skinframe->hasalpha = false; // if no data was provided, then clearly the caller wanted to get a blank skinframe if (!skindata) @@ -2681,7 +2655,7 @@ skinframe_t *R_SkinFrame_LoadInternalBGRA(const char *name, int textureflags, co if (developer_loading.integer) Con_Printf("loading 32bit skin \"%s\"\n", name); - if (r_shadow_bumpscale_basetexture.value > 0) + if (r_loadnormalmap && r_shadow_bumpscale_basetexture.value > 0) { temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8); temp2 = temp1 + width * height * 4; @@ -2693,9 +2667,14 @@ skinframe_t *R_SkinFrame_LoadInternalBGRA(const char *name, int textureflags, co if (textureflags & TEXF_ALPHA) { for (i = 3;i < width * height * 4;i += 4) + { if (skindata[i] < 255) + { + skinframe->hasalpha = true; break; - if (i < width * height * 4) + } + } + if (r_loadfog && skinframe->hasalpha) { unsigned char *fogpixels = (unsigned char *)Mem_Alloc(tempmempool, width * height * 4); memcpy(fogpixels, skindata, width * height * 4); @@ -2715,8 +2694,7 @@ skinframe_t *R_SkinFrame_LoadInternalBGRA(const char *name, int textureflags, co skinframe_t *R_SkinFrame_LoadInternalQuake(const char *name, int textureflags, int loadpantsandshirt, int loadglowtexture, const unsigned char *skindata, int width, int height) { int i; - unsigned char *temp1, *temp2; - unsigned int *palette; + int featuresmask; skinframe_t *skinframe; if (cls.state == ca_dedicated) @@ -2727,8 +2705,6 @@ skinframe_t *R_SkinFrame_LoadInternalQuake(const char *name, int textureflags, i if (skinframe && skinframe->base) return skinframe; - palette = (loadglowtexture ? palette_bgra_nofullbrights : ((skinframe->textureflags & TEXF_ALPHA) ? palette_bgra_transparent : palette_bgra_complete)); - skinframe->stain = NULL; skinframe->merged = NULL; skinframe->base = r_texture_notexture; @@ -2738,6 +2714,7 @@ skinframe_t *R_SkinFrame_LoadInternalQuake(const char *name, int textureflags, i skinframe->gloss = NULL; skinframe->glow = NULL; skinframe->fog = NULL; + skinframe->hasalpha = false; // if no data was provided, then clearly the caller wanted to get a blank skinframe if (!skindata) @@ -2746,8 +2723,60 @@ skinframe_t *R_SkinFrame_LoadInternalQuake(const char *name, int textureflags, i if (developer_loading.integer) Con_Printf("loading quake skin \"%s\"\n", name); - if (r_shadow_bumpscale_basetexture.value > 0) + // we actually don't upload anything until the first use, because mdl skins frequently go unused, and are almost never used in both modes (colormapped and non-colormapped) + skinframe->qpixels = Mem_Alloc(r_main_mempool, width*height); + memcpy(skinframe->qpixels, skindata, width*height); + skinframe->qwidth = width; + skinframe->qheight = height; + + featuresmask = 0; + for (i = 0;i < width * height;i++) + featuresmask |= palette_featureflags[skindata[i]]; + + skinframe->hasalpha = false; + skinframe->qhascolormapping = loadpantsandshirt && (featuresmask & (PALETTEFEATURE_PANTS | PALETTEFEATURE_SHIRT)); + skinframe->qgeneratenmap = r_shadow_bumpscale_basetexture.value > 0; + skinframe->qgeneratemerged = true; + skinframe->qgeneratebase = skinframe->qhascolormapping; + skinframe->qgenerateglow = loadglowtexture && (featuresmask & PALETTEFEATURE_GLOW); + + R_SKINFRAME_LOAD_AVERAGE_COLORS(width * height, ((unsigned char *)palette_bgra_complete)[skindata[pix]*4 + comp]); + //Con_Printf("Texture %s has average colors %f %f %f alpha %f\n", name, skinframe->avgcolor[0], skinframe->avgcolor[1], skinframe->avgcolor[2], skinframe->avgcolor[3]); + + return skinframe; +} + +static void R_SkinFrame_GenerateTexturesFromQPixels(skinframe_t *skinframe, qboolean colormapped) +{ + int width; + int height; + unsigned char *skindata; + + if (!skinframe->qpixels) + return; + + if (!skinframe->qhascolormapping) + colormapped = false; + + if (colormapped) { + if (!skinframe->qgeneratebase) + return; + } + else + { + if (!skinframe->qgeneratemerged) + return; + } + + width = skinframe->qwidth; + height = skinframe->qheight; + skindata = skinframe->qpixels; + + if (skinframe->qgeneratenmap) + { + unsigned char *temp1, *temp2; + skinframe->qgeneratenmap = false; temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8); temp2 = temp1 + width * height * 4; // use either a custom palette or the quake palette @@ -2756,30 +2785,31 @@ skinframe_t *R_SkinFrame_LoadInternalQuake(const char *name, int textureflags, i skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va("%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_BGRA, skinframe->textureflags | TEXF_ALPHA, NULL); Mem_Free(temp1); } - // use either a custom palette, or the quake palette - skinframe->base = skinframe->merged = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_merged", skinframe->basename), palette, skinframe->textureflags, true); // all - if (loadglowtexture) - skinframe->glow = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_glow", skinframe->basename), palette_bgra_onlyfullbrights, skinframe->textureflags, false); // glow - if (loadpantsandshirt) + + if (skinframe->qgenerateglow) { - skinframe->pants = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_pants", skinframe->basename), palette_bgra_pantsaswhite, skinframe->textureflags, false); // pants - skinframe->shirt = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_shirt", skinframe->basename), palette_bgra_shirtaswhite, skinframe->textureflags, false); // shirt + skinframe->qgenerateglow = false; + skinframe->glow = R_LoadTexture2D(r_main_texturepool, va("%s_glow", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, palette_bgra_onlyfullbrights); // glow } - if (skinframe->pants || skinframe->shirt) - skinframe->base = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_nospecial", skinframe->basename), loadglowtexture ? palette_bgra_nocolormapnofullbrights : palette_bgra_nocolormap, skinframe->textureflags, false); // no special colors - if (textureflags & TEXF_ALPHA) + + if (colormapped) { - for (i = 0;i < width * height;i++) - if (((unsigned char *)palette_bgra_alpha)[skindata[i]*4+3] < 255) - break; - if (i < width * height) - skinframe->fog = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_fog", skinframe->basename), palette_bgra_alpha, skinframe->textureflags, true); // fog mask + skinframe->qgeneratebase = false; + skinframe->base = R_LoadTexture2D(r_main_texturepool, va("%s_nospecial", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, skinframe->glow ? palette_bgra_nocolormapnofullbrights : palette_bgra_nocolormap); + skinframe->pants = R_LoadTexture2D(r_main_texturepool, va("%s_pants", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, palette_bgra_pantsaswhite); + skinframe->shirt = R_LoadTexture2D(r_main_texturepool, va("%s_shirt", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, palette_bgra_shirtaswhite); + } + else + { + skinframe->qgeneratemerged = false; + skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, skinframe->glow ? palette_bgra_nofullbrights : palette_bgra_complete); } - R_SKINFRAME_LOAD_AVERAGE_COLORS(width * height, ((unsigned char *)palette)[skindata[pix]*4 + comp]); - //Con_Printf("Texture %s has average colors %f %f %f alpha %f\n", name, skinframe->avgcolor[0], skinframe->avgcolor[1], skinframe->avgcolor[2], skinframe->avgcolor[3]); - - return skinframe; + if (!skinframe->qgeneratemerged && !skinframe->qgeneratebase) + { + Mem_Free(skinframe->qpixels); + skinframe->qpixels = NULL; + } } skinframe_t *R_SkinFrame_LoadInternal8bit(const char *name, int textureflags, const unsigned char *skindata, int width, int height, const unsigned int *palette, const unsigned int *alphapalette) @@ -2804,6 +2834,7 @@ skinframe_t *R_SkinFrame_LoadInternal8bit(const char *name, int textureflags, co skinframe->gloss = NULL; skinframe->glow = NULL; skinframe->fog = NULL; + skinframe->hasalpha = false; // if no data was provided, then clearly the caller wanted to get a blank skinframe if (!skindata) @@ -2812,14 +2843,19 @@ skinframe_t *R_SkinFrame_LoadInternal8bit(const char *name, int textureflags, co if (developer_loading.integer) Con_Printf("loading embedded 8bit image \"%s\"\n", name); - skinframe->base = skinframe->merged = R_SkinFrame_TextureForSkinLayer(skindata, width, height, skinframe->basename, palette, skinframe->textureflags, true); + skinframe->base = skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, palette); if (textureflags & TEXF_ALPHA) { for (i = 0;i < width * height;i++) - if (((unsigned char *)alphapalette)[skindata[i]*4+3] < 255) + { + if (((unsigned char *)palette)[skindata[i]*4+3] < 255) + { + skinframe->hasalpha = true; break; - if (i < width * height) - skinframe->fog = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_fog", skinframe->basename), alphapalette, skinframe->textureflags, true); // fog mask + } + } + if (r_loadfog && skinframe->hasalpha) + skinframe->fog = R_LoadTexture2D(r_main_texturepool, va("%s_fog", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, alphapalette); } R_SKINFRAME_LOAD_AVERAGE_COLORS(width * height, ((unsigned char *)palette)[skindata[pix]*4 + comp]); @@ -2845,6 +2881,7 @@ skinframe_t *R_SkinFrame_LoadMissing(void) skinframe->gloss = NULL; skinframe->glow = NULL; skinframe->fog = NULL; + skinframe->hasalpha = false; skinframe->avgcolor[0] = rand() / RAND_MAX; skinframe->avgcolor[1] = rand() / RAND_MAX; @@ -2856,7 +2893,6 @@ skinframe_t *R_SkinFrame_LoadMissing(void) void R_Main_FreeViewCache(void) { -#ifdef VIEWCACHEDYNAMIC if (r_refdef.viewcache.entityvisible) Mem_Free(r_refdef.viewcache.entityvisible); if (r_refdef.viewcache.world_pvsbits) @@ -2866,31 +2902,78 @@ void R_Main_FreeViewCache(void) if (r_refdef.viewcache.world_surfacevisible) Mem_Free(r_refdef.viewcache.world_surfacevisible); memset(&r_refdef.viewcache, 0, sizeof(r_refdef.viewcache)); -#endif } -void R_Main_AllocViewCache(void) +void R_Main_ResizeViewCache(void) { -#ifdef VIEWCACHEDYNAMIC - memset(&r_refdef.viewcache, 0, sizeof(r_refdef.viewcache)); - r_refdef.viewcache.maxentities = r_refdef.scene.maxentities; - if (r_refdef.viewcache.maxentities) + int numentities = r_refdef.scene.numentities; + int numclusters = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->brush.num_pvsclusters : 1; + int numclusterbytes = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->brush.num_pvsclusterbytes : 1; + int numleafs = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->brush.num_leafs : 1; + int numsurfaces = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->num_surfaces : 1; + if (r_refdef.viewcache.maxentities < numentities) + { + r_refdef.viewcache.maxentities = numentities; + if (r_refdef.viewcache.entityvisible) + Mem_Free(r_refdef.viewcache.entityvisible); r_refdef.viewcache.entityvisible = Mem_Alloc(r_main_mempool, r_refdef.viewcache.maxentities); - if (cl.worldmodel) - { - r_refdef.viewcache.world_numclusters = cl.worldmodel->brush.num_pvsclusters; - r_refdef.viewcache.world_numleafs = cl.worldmodel->brush.num_leafs; - r_refdef.viewcache.world_numsurfaces = cl.worldmodel->num_surfaces; - r_refdef.viewcache.world_pvsbits = Mem_Alloc(r_main_mempool, (r_refdef.viewcache.world_numclusters+7)>>3); + } + if (r_refdef.viewcache.world_numclusters != numclusters) + { + r_refdef.viewcache.world_numclusters = numclusters; + r_refdef.viewcache.world_numclusterbytes = numclusterbytes; + if (r_refdef.viewcache.world_pvsbits) + Mem_Free(r_refdef.viewcache.world_pvsbits); + r_refdef.viewcache.world_pvsbits = Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numclusterbytes); + } + if (r_refdef.viewcache.world_numleafs != numleafs) + { + r_refdef.viewcache.world_numleafs = numleafs; + if (r_refdef.viewcache.world_leafvisible) + Mem_Free(r_refdef.viewcache.world_leafvisible); r_refdef.viewcache.world_leafvisible = Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numleafs); + } + if (r_refdef.viewcache.world_numsurfaces != numsurfaces) + { + r_refdef.viewcache.world_numsurfaces = numsurfaces; + if (r_refdef.viewcache.world_surfacevisible) + Mem_Free(r_refdef.viewcache.world_surfacevisible); r_refdef.viewcache.world_surfacevisible = Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numsurfaces); } -#endif } void gl_main_start(void) { - R_Main_AllocViewCache(); + switch(vid.renderpath) + { + case RENDERPATH_GL20: + Cvar_SetValueQuick(&r_textureunits, vid.texunits); + Cvar_SetValueQuick(&gl_combine, 1); + Cvar_SetValueQuick(&r_glsl, 1); + r_loadnormalmap = true; + r_loadgloss = true; + r_loadfog = false; + break; + case RENDERPATH_GL13: + Cvar_SetValueQuick(&r_textureunits, vid.texunits); + Cvar_SetValueQuick(&gl_combine, 1); + Cvar_SetValueQuick(&r_glsl, 0); + r_loadnormalmap = false; + r_loadgloss = false; + r_loadfog = true; + break; + case RENDERPATH_GL11: + Cvar_SetValueQuick(&r_textureunits, vid.texunits); + Cvar_SetValueQuick(&gl_combine, 0); + Cvar_SetValueQuick(&r_glsl, 0); + r_loadnormalmap = false; + r_loadgloss = false; + r_loadfog = true; + break; + } + + R_AnimCache_Free(); + R_FrameData_Reset(); r_numqueries = 0; r_maxqueries = 0; @@ -2907,7 +2990,7 @@ void gl_main_start(void) r_main_texturepool = R_AllocTexturePool(); R_BuildBlankTextures(); R_BuildNoTexture(); - if (gl_texturecubemap) + if (vid.support.arb_texture_cube_map) { R_BuildWhiteCube(); R_BuildNormalizationCube(); @@ -2927,6 +3010,9 @@ void gl_main_start(void) extern rtexture_t *loadingscreentexture; void gl_main_shutdown(void) { + R_AnimCache_Free(); + R_FrameData_Reset(); + R_Main_FreeViewCache(); if (r_maxqueries) @@ -2990,7 +3076,8 @@ void gl_main_newmap(void) CL_ParseEntityLump(cl.worldmodel->brush.entities); } R_Main_FreeViewCache(); - R_Main_AllocViewCache(); + + R_FrameData_Reset(); } void GL_Main_Init(void) @@ -3023,7 +3110,6 @@ void GL_Main_Init(void) Cvar_RegisterVariable(&r_equalize_entities_minambient); Cvar_RegisterVariable(&r_equalize_entities_by); Cvar_RegisterVariable(&r_equalize_entities_to); - Cvar_RegisterVariable(&r_animcache); Cvar_RegisterVariable(&r_depthfirst); Cvar_RegisterVariable(&r_useinfinitefarclip); Cvar_RegisterVariable(&r_farclip_base); @@ -3043,6 +3129,7 @@ void GL_Main_Init(void) Cvar_RegisterVariable(&r_drawentities); Cvar_RegisterVariable(&r_cullentities_trace); Cvar_RegisterVariable(&r_cullentities_trace_samples); + Cvar_RegisterVariable(&r_cullentities_trace_tempentitysamples); Cvar_RegisterVariable(&r_cullentities_trace_enlarge); Cvar_RegisterVariable(&r_cullentities_trace_delay); Cvar_RegisterVariable(&r_drawviewmodel); @@ -3065,6 +3152,7 @@ void GL_Main_Init(void) Cvar_RegisterVariable(&r_fog_exp2); Cvar_RegisterVariable(&r_drawfog); Cvar_RegisterVariable(&r_textureunits); + Cvar_RegisterVariable(&gl_combine); Cvar_RegisterVariable(&r_glsl); Cvar_RegisterVariable(&r_glsl_deluxemapping); Cvar_RegisterVariable(&r_glsl_offsetmapping); @@ -3075,7 +3163,6 @@ void GL_Main_Init(void) Cvar_RegisterVariable(&r_glsl_postprocess_uservec2); Cvar_RegisterVariable(&r_glsl_postprocess_uservec3); Cvar_RegisterVariable(&r_glsl_postprocess_uservec4); - Cvar_RegisterVariable(&r_glsl_usegeneric); Cvar_RegisterVariable(&r_water); Cvar_RegisterVariable(&r_water_resolutionmultiplier); Cvar_RegisterVariable(&r_water_clippingplanebias); @@ -3102,6 +3189,7 @@ void GL_Main_Init(void) Cvar_RegisterVariable(&r_test); Cvar_RegisterVariable(&r_batchmode); Cvar_RegisterVariable(&r_glsl_saturation); + Cvar_RegisterVariable(&r_framedatasize); if (gamemode == GAME_NEHAHRA || gamemode == GAME_TENEBRAE) Cvar_SetValue("r_fullbrights", 0); R_RegisterModule("GL_Main", gl_main_start, gl_main_shutdown, gl_main_newmap); @@ -3275,6 +3363,69 @@ int R_CullBoxCustomPlanes(const vec3_t mins, const vec3_t maxs, int numplanes, c //================================================================================== +// LordHavoc: this stores temporary data used within the same frame + +qboolean r_framedata_failed; +static size_t r_framedata_size; +static size_t r_framedata_current; +static void *r_framedata_base; + +void R_FrameData_Reset(void) +{ + if (r_framedata_base); + Mem_Free(r_framedata_base); + r_framedata_base = NULL; + r_framedata_size = 0; + r_framedata_current = 0; +} + +void R_FrameData_NewFrame(void) +{ + size_t wantedsize; + if (r_framedata_failed) + Cvar_SetValueQuick(&r_framedatasize, r_framedatasize.value * 1.25f); + wantedsize = (size_t)(r_framedatasize.value * 1024*1024); + wantedsize = bound(65536, wantedsize, 128*1024*1024); + if (r_framedata_size < wantedsize) + { + r_framedata_size = wantedsize; + if (!r_framedata_base) + r_framedata_base = Mem_Alloc(r_main_mempool, r_framedata_size); + } + r_framedata_current = 0; + r_framedata_failed = false; +} + +void *R_FrameData_Alloc(size_t size) +{ + void *data; + + // align to 16 byte boundary + size = (size + 15) & ~15; + data = r_framedata_base + r_framedata_current; + r_framedata_current += size; + + // check overflow + if (r_framedata_current > r_framedata_size) + r_framedata_failed = true; + + // return NULL on everything after a failure + if (r_framedata_failed) + return NULL; + + return data; +} + +void *R_FrameData_Store(size_t size, void *data) +{ + void *d = R_FrameData_Alloc(size); + if (d) + memcpy(d, data, size); + return d; +} + +//================================================================================== + // LordHavoc: animcache written by Echon, refactored and reformatted by me /** @@ -3289,9 +3440,6 @@ typedef struct r_animcache_entity_s float *normal3f; float *svector3f; float *tvector3f; - int maxvertices; - qboolean wantnormals; - qboolean wanttangents; } r_animcache_entity_t; @@ -3307,115 +3455,108 @@ static r_animcache_t r_animcachestate; void R_AnimCache_Free(void) { - int idx; - for (idx=0 ; idxmaxvertices >= numvertices) - return; - - // Release existing memory - if (cache->vertex3f) - Mem_Free(cache->vertex3f); - - // Pad by 1024 verts - cache->maxvertices = (numvertices + 1023) & ~1023; - arraySize = cache->maxvertices * 3; - - // Allocate, even if we don't need this memory in this instance it will get ignored and potentially used later - base = (float *)Mem_Alloc(r_main_mempool, arraySize * sizeof(float) * 4); - r_animcachestate.entity[cacheIdx].vertex3f = base; - r_animcachestate.entity[cacheIdx].normal3f = base + arraySize; - r_animcachestate.entity[cacheIdx].svector3f = base + arraySize*2; - r_animcachestate.entity[cacheIdx].tvector3f = base + arraySize*3; - -// Con_Printf("allocated cache for %i (%f KB)\n", cacheIdx, (arraySize*sizeof(float)*4)/1024.0f); -} - -void R_AnimCache_NewFrame(void) +void R_AnimCache_ClearCache(void) { int i; + entity_render_t *ent; - if (r_animcache.integer && r_drawentities.integer) - r_animcachestate.maxindex = sizeof(r_animcachestate.entity) / sizeof(r_animcachestate.entity[0]); - else if (r_animcachestate.maxindex) - R_AnimCache_Free(); - + r_animcachestate.maxindex = sizeof(r_animcachestate.entity) / sizeof(r_animcachestate.entity[0]); r_animcachestate.currentindex = 0; for (i = 0;i < r_refdef.scene.numentities;i++) - r_refdef.scene.entities[i]->animcacheindex = -1; + { + ent = r_refdef.scene.entities[i]; + ent->animcacheindex = -1; + } } qboolean R_AnimCache_GetEntity(entity_render_t *ent, qboolean wantnormals, qboolean wanttangents) { dp_model_t *model = ent->model; r_animcache_entity_t *c; + int numvertices; // see if it's already cached this frame if (ent->animcacheindex >= 0) { // add normals/tangents if needed - c = r_animcachestate.entity + ent->animcacheindex; - if (c->wantnormals) - wantnormals = false; - if (c->wanttangents) - wanttangents = false; if (wantnormals || wanttangents) - model->AnimateVertices(model, ent->frameblend, NULL, wantnormals ? c->normal3f : NULL, wanttangents ? c->svector3f : NULL, wanttangents ? c->tvector3f : NULL); + { + c = r_animcachestate.entity + ent->animcacheindex; + if (c->normal3f) + wantnormals = false; + if (c->svector3f) + wanttangents = false; + if (wantnormals || wanttangents) + { + numvertices = model->surfmesh.num_vertices; + if (wantnormals) + c->normal3f = R_FrameData_Alloc(sizeof(float[3])*numvertices); + if (wanttangents) + { + c->svector3f = R_FrameData_Alloc(sizeof(float[3])*numvertices); + c->tvector3f = R_FrameData_Alloc(sizeof(float[3])*numvertices); + } + if (!r_framedata_failed) + model->AnimateVertices(model, ent->frameblend, ent->skeleton, NULL, wantnormals ? c->normal3f : NULL, wanttangents ? c->svector3f : NULL, wanttangents ? c->tvector3f : NULL); + } + } } else { // see if this ent is worth caching if (r_animcachestate.maxindex <= r_animcachestate.currentindex) return false; - if (!model || !model->Draw || !model->surfmesh.isanimated || !model->AnimateVertices || (ent->frameblend[0].lerp == 1 && ent->frameblend[0].subframe == 0)) + if (!model || !model->Draw || !model->surfmesh.isanimated || !model->AnimateVertices || (ent->frameblend[0].lerp == 1 && ent->frameblend[0].subframe == 0 && !ent->skeleton)) return false; - // assign it a cache entry and make sure the arrays are big enough - R_AnimCache_ResizeEntityCache(r_animcachestate.currentindex, model->surfmesh.num_vertices); + // assign it a cache entry and get some temp memory ent->animcacheindex = r_animcachestate.currentindex++; c = r_animcachestate.entity + ent->animcacheindex; - c->wantnormals = wantnormals; - c->wanttangents = wanttangents; - model->AnimateVertices(model, ent->frameblend, c->vertex3f, wantnormals ? c->normal3f : NULL, wanttangents ? c->svector3f : NULL, wanttangents ? c->tvector3f : NULL); + numvertices = model->surfmesh.num_vertices; + memset(c, 0, sizeof(*c)); + c->vertex3f = R_FrameData_Alloc(sizeof(float[3])*numvertices); + if (wantnormals) + c->normal3f = R_FrameData_Alloc(sizeof(float[3])*numvertices); + if (wanttangents) + { + c->svector3f = R_FrameData_Alloc(sizeof(float[3])*numvertices); + c->tvector3f = R_FrameData_Alloc(sizeof(float[3])*numvertices); + } + if (!r_framedata_failed) + model->AnimateVertices(model, ent->frameblend, ent->skeleton, c->vertex3f, c->normal3f, c->svector3f, c->tvector3f); } - return true; + return !r_framedata_failed; } void R_AnimCache_CacheVisibleEntities(void) { int i; - qboolean wantnormals; - qboolean wanttangents; - - if (!r_animcachestate.maxindex) - return; + entity_render_t *ent; + qboolean wantnormals = !r_showsurfaces.integer; + qboolean wanttangents = !r_showsurfaces.integer; - wantnormals = !r_showsurfaces.integer; - wanttangents = !r_showsurfaces.integer && (r_glsl.integer || r_refdef.scene.rtworld || r_refdef.scene.rtdlight); + switch(vid.renderpath) + { + case RENDERPATH_GL20: + break; + case RENDERPATH_GL13: + case RENDERPATH_GL11: + wanttangents = false; + break; + } - // TODO: thread this? + // TODO: thread this for (i = 0;i < r_refdef.scene.numentities;i++) { if (!r_refdef.viewcache.entityvisible[i]) continue; - R_AnimCache_GetEntity(r_refdef.scene.entities[i], wantnormals, wanttangents); + ent = r_refdef.scene.entities[i]; + if (ent->animcacheindex >= 0) + continue; + R_AnimCache_GetEntity(ent, wantnormals, wanttangents); } } @@ -3517,7 +3658,7 @@ static qboolean R_CanSeeBox(int numsamples, vec_t enlarge, vec3_t eye, vec3_t en vec3_t start; vec3_t end; dp_model_t *model = r_refdef.scene.worldmodel; - + if (!model || !model->brush.TraceLineOfSight) return true; @@ -3549,7 +3690,9 @@ static qboolean R_CanSeeBox(int numsamples, vec_t enlarge, vec3_t eye, vec3_t en static void R_View_UpdateEntityVisible (void) { - int i, renderimask; + int i; + int renderimask; + int samples; entity_render_t *ent; if (!r_drawentities.integer) @@ -3575,7 +3718,10 @@ static void R_View_UpdateEntityVisible (void) ent = r_refdef.scene.entities[i]; if(r_refdef.viewcache.entityvisible[i] && !(ent->flags & (RENDER_VIEWMODEL | RENDER_NOCULL | RENDER_NODEPTHTEST)) && !(ent->model && (ent->model->name[0] == '*'))) { - if(R_CanSeeBox(r_cullentities_trace_samples.integer, r_cullentities_trace_enlarge.value, r_refdef.view.origin, ent->mins, ent->maxs)) + samples = ent->entitynumber ? r_cullentities_trace_samples.integer : r_cullentities_trace_tempentitysamples.integer; + if (samples < 0) + continue; // temp entities do pvs only + if(R_CanSeeBox(samples, r_cullentities_trace_enlarge.value, r_refdef.view.origin, ent->mins, ent->maxs)) ent->last_trace_visibility = realtime; if(ent->last_trace_visibility < realtime - r_cullentities_trace_delay.value) r_refdef.viewcache.entityvisible[i] = 0; @@ -3693,28 +3839,6 @@ static void R_DrawModelsAddWaterPlanes(void) } } -static void R_DrawModelDecals_Entity(entity_render_t *ent); -static void R_DrawModelDecals(void) -{ - int i; - entity_render_t *ent; - - R_DrawModelDecals_Entity(r_refdef.scene.worldentity); - - if (!r_drawentities.integer || r_showsurfaces.integer) - return; - - for (i = 0;i < r_refdef.scene.numentities;i++) - { - if (!r_refdef.viewcache.entityvisible[i]) - continue; - ent = r_refdef.scene.entities[i]; - r_refdef.stats.entities++; - if (ent->decalsystem.numdecals) - R_DrawModelDecals_Entity(ent); - } -} - static void R_View_SetFrustum(void) { int i; @@ -3872,6 +3996,7 @@ static void R_View_SetFrustum(void) void R_View_Update(void) { + R_Main_ResizeViewCache(); R_View_SetFrustum(); R_View_WorldVisibility(r_refdef.view.useclipplane); R_View_UpdateEntityVisible(); @@ -3898,7 +4023,7 @@ void R_SetupView(qboolean allowwaterclippingplane) if (!r_refdef.view.useperspective) R_Viewport_InitOrtho(&r_refdef.view.viewport, &r_refdef.view.matrix, r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height, -r_refdef.view.ortho_x, -r_refdef.view.ortho_y, r_refdef.view.ortho_x, r_refdef.view.ortho_y, -r_refdef.farclip, r_refdef.farclip, customclipplane); - else if (gl_stencil && r_useinfinitefarclip.integer) + else if (vid.stencil && r_useinfinitefarclip.integer) R_Viewport_InitPerspectiveInfinite(&r_refdef.view.viewport, &r_refdef.view.matrix, r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height, r_refdef.view.frustum_x, r_refdef.view.frustum_y, r_refdef.nearclip, customclipplane); else R_Viewport_InitPerspective(&r_refdef.view.viewport, &r_refdef.view.matrix, r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height, r_refdef.view.frustum_x, r_refdef.view.frustum_y, r_refdef.nearclip, r_refdef.farclip, customclipplane); @@ -3971,6 +4096,18 @@ static void R_Water_StartFrame(void) int waterwidth, waterheight, texturewidth, textureheight; r_waterstate_waterplane_t *p; + if (vid.width > (int)vid.maxtexturesize_2d || vid.height > (int)vid.maxtexturesize_2d) + return; + + switch(vid.renderpath) + { + case RENDERPATH_GL20: + break; + case RENDERPATH_GL13: + case RENDERPATH_GL11: + return; + } + // set waterwidth and waterheight to the water resolution that will be // used (often less than the screen resolution for faster rendering) waterwidth = (int)bound(1, vid.width * r_water_resolutionmultiplier.value, vid.width); @@ -3978,9 +4115,9 @@ static void R_Water_StartFrame(void) // calculate desired texture sizes // can't use water if the card does not support the texture size - if (!r_water.integer || !r_glsl.integer || !gl_support_fragment_shader || waterwidth > gl_max_texture_size || waterheight > gl_max_texture_size || r_showsurfaces.integer) + if (!r_water.integer || r_showsurfaces.integer) texturewidth = textureheight = waterwidth = waterheight = 0; - else if (gl_support_arb_texture_non_power_of_two) + else if (vid.support.arb_texture_non_power_of_two) { texturewidth = waterwidth; textureheight = waterheight; @@ -4204,16 +4341,25 @@ void R_Bloom_StartFrame(void) { int bloomtexturewidth, bloomtextureheight, screentexturewidth, screentextureheight; + switch(vid.renderpath) + { + case RENDERPATH_GL20: + break; + case RENDERPATH_GL13: + case RENDERPATH_GL11: + return; + } + // set bloomwidth and bloomheight to the bloom resolution that will be // used (often less than the screen resolution for faster rendering) r_bloomstate.bloomwidth = bound(1, r_bloom_resolution.integer, vid.height); r_bloomstate.bloomheight = r_bloomstate.bloomwidth * vid.height / vid.width; r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, vid.height); - r_bloomstate.bloomwidth = bound(1, r_bloomstate.bloomwidth, gl_max_texture_size); - r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, gl_max_texture_size); + r_bloomstate.bloomwidth = bound(1, r_bloomstate.bloomwidth, (int)vid.maxtexturesize_2d); + r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, (int)vid.maxtexturesize_2d); // calculate desired texture sizes - if (gl_support_arb_texture_non_power_of_two) + if (vid.support.arb_texture_non_power_of_two) { screentexturewidth = r_refdef.view.width; screentextureheight = r_refdef.view.height; @@ -4228,7 +4374,7 @@ void R_Bloom_StartFrame(void) for (bloomtextureheight = 1;bloomtextureheight < r_bloomstate.bloomheight;bloomtextureheight *= 2); } - if ((r_hdr.integer || r_bloom.integer || (!R_Stereo_Active() && (r_motionblur.value > 0 || r_damageblur.value > 0))) && ((r_bloom_resolution.integer < 4 || r_bloom_blur.value < 1 || r_bloom_blur.value >= 512) || r_refdef.view.width > gl_max_texture_size || r_refdef.view.height > gl_max_texture_size)) + if ((r_hdr.integer || r_bloom.integer || (!R_Stereo_Active() && (r_motionblur.value > 0 || r_damageblur.value > 0))) && ((r_bloom_resolution.integer < 4 || r_bloom_blur.value < 1 || r_bloom_blur.value >= 512) || r_refdef.view.width > (int)vid.maxtexturesize_2d || r_refdef.view.height > (int)vid.maxtexturesize_2d)) { Cvar_SetValueQuick(&r_hdr, 0); Cvar_SetValueQuick(&r_bloom, 0); @@ -4236,7 +4382,7 @@ void R_Bloom_StartFrame(void) Cvar_SetValueQuick(&r_damageblur, 0); } - if (!(r_glsl.integer && (r_glsl_postprocess.integer || (!R_Stereo_ColorMasking() && r_glsl_saturation.value != 1) || (v_glslgamma.integer && !vid_gammatables_trivial))) && !r_bloom.integer && !r_hdr.integer && (R_Stereo_Active() || (r_motionblur.value <= 0 && r_damageblur.value <= 0))) + if (!(r_glsl_postprocess.integer || (!R_Stereo_ColorMasking() && r_glsl_saturation.value != 1) || (v_glslgamma.integer && !vid_gammatables_trivial)) && !r_bloom.integer && !r_hdr.integer && (R_Stereo_Active() || (r_motionblur.value <= 0 && r_damageblur.value <= 0))) screentexturewidth = screentextureheight = 0; if (!r_hdr.integer && !r_bloom.integer) bloomtexturewidth = bloomtextureheight = 0; @@ -4423,7 +4569,7 @@ void R_Bloom_MakeTexture(void) // apply subtract last // (just like it would be in a GLSL shader) - if (r_bloom_colorsubtract.value > 0 && gl_support_ext_blend_subtract) + if (r_bloom_colorsubtract.value > 0 && vid.support.ext_blend_subtract) { GL_BlendFunc(GL_ONE, GL_ZERO); R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom)); @@ -4506,72 +4652,77 @@ void R_HDR_RenderBloomTexture(void) static void R_BlendView(void) { - if (r_bloomstate.texture_screen) - { - // make sure the buffer is available - if (r_bloom_blur.value < 1) { Cvar_SetValueQuick(&r_bloom_blur, 1); } - - R_ResetViewRendering2D(); - R_Mesh_VertexPointer(r_screenvertex3f, 0, 0); - R_Mesh_ColorPointer(NULL, 0, 0); - R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_screen)); - GL_ActiveTexture(0);CHECKGLERROR - - if(!R_Stereo_Active() && (r_motionblur.value > 0 || r_damageblur.value > 0)) - { - // declare variables - float speed; - static float avgspeed; - - speed = VectorLength(cl.movement_velocity); - - cl.motionbluralpha = bound(0, (cl.time - cl.oldtime) / max(0.001, r_motionblur_vcoeff.value), 1); - avgspeed = avgspeed * (1 - cl.motionbluralpha) + speed * cl.motionbluralpha; - - speed = (avgspeed - r_motionblur_vmin.value) / max(1, r_motionblur_vmax.value - r_motionblur_vmin.value); - speed = bound(0, speed, 1); - speed = speed * (1 - r_motionblur_bmin.value) + r_motionblur_bmin.value; - - // calculate values into a standard alpha - cl.motionbluralpha = 1 - exp(- - ( - (r_motionblur.value * speed / 80) - + - (r_damageblur.value * (cl.cshifts[CSHIFT_DAMAGE].percent / 1600)) - ) - / - max(0.0001, cl.time - cl.oldtime) // fps independent - ); - - cl.motionbluralpha *= lhrandom(1 - r_motionblur_randomize.value, 1 + r_motionblur_randomize.value); - cl.motionbluralpha = bound(0, cl.motionbluralpha, r_motionblur_maxblur.value); - // apply the blur - if (cl.motionbluralpha > 0) - { - R_SetupGenericShader(true); - GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); - GL_Color(1, 1, 1, cl.motionbluralpha); - R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_screen)); - R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0); - R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0); - r_refdef.stats.bloom_drawpixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height; - } - } - - // copy view into the screen texture - qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);CHECKGLERROR - r_refdef.stats.bloom_copypixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height; - } + unsigned int permutation; - if (r_glsl.integer && gl_support_fragment_shader && (r_bloomstate.texture_screen || r_bloomstate.texture_bloom)) + switch (vid.renderpath) { - unsigned int permutation = + case RENDERPATH_GL20: + permutation = (r_bloomstate.texture_bloom ? SHADERPERMUTATION_BLOOM : 0) | (r_refdef.viewblend[3] > 0 ? SHADERPERMUTATION_VIEWTINT : 0) | ((v_glslgamma.value && !vid_gammatables_trivial) ? SHADERPERMUTATION_GAMMARAMPS : 0) | (r_glsl_postprocess.integer ? SHADERPERMUTATION_POSTPROCESSING : 0) | ((!R_Stereo_ColorMasking() && r_glsl_saturation.value != 1) ? SHADERPERMUTATION_SATURATION : 0); + if (r_bloomstate.texture_screen) + { + // make sure the buffer is available + if (r_bloom_blur.value < 1) { Cvar_SetValueQuick(&r_bloom_blur, 1); } + + R_ResetViewRendering2D(); + R_Mesh_VertexPointer(r_screenvertex3f, 0, 0); + R_Mesh_ColorPointer(NULL, 0, 0); + R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_screen)); + GL_ActiveTexture(0);CHECKGLERROR + + if(!R_Stereo_Active() && (r_motionblur.value > 0 || r_damageblur.value > 0)) + { + // declare variables + float speed; + static float avgspeed; + + speed = VectorLength(cl.movement_velocity); + + cl.motionbluralpha = bound(0, (cl.time - cl.oldtime) / max(0.001, r_motionblur_vcoeff.value), 1); + avgspeed = avgspeed * (1 - cl.motionbluralpha) + speed * cl.motionbluralpha; + + speed = (avgspeed - r_motionblur_vmin.value) / max(1, r_motionblur_vmax.value - r_motionblur_vmin.value); + speed = bound(0, speed, 1); + speed = speed * (1 - r_motionblur_bmin.value) + r_motionblur_bmin.value; + + // calculate values into a standard alpha + cl.motionbluralpha = 1 - exp(- + ( + (r_motionblur.value * speed / 80) + + + (r_damageblur.value * (cl.cshifts[CSHIFT_DAMAGE].percent / 1600)) + ) + / + max(0.0001, cl.time - cl.oldtime) // fps independent + ); + + cl.motionbluralpha *= lhrandom(1 - r_motionblur_randomize.value, 1 + r_motionblur_randomize.value); + cl.motionbluralpha = bound(0, cl.motionbluralpha, r_motionblur_maxblur.value); + // apply the blur + if (cl.motionbluralpha > 0) + { + R_SetupGenericShader(true); + GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + GL_Color(1, 1, 1, cl.motionbluralpha); + R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_screen)); + R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0); + R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0); + r_refdef.stats.bloom_drawpixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height; + } + } + + // copy view into the screen texture + qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);CHECKGLERROR + r_refdef.stats.bloom_copypixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height; + } + else if (!r_bloomstate.texture_bloom) + break; // no screen processing, no bloom, skip it + if (r_bloomstate.texture_bloom && !r_bloomstate.hdr) { // render simple bloom effect @@ -4630,73 +4781,21 @@ static void R_BlendView(void) qglUniform1fARB(r_glsl_permutation->loc_Saturation, r_glsl_saturation.value); R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0); r_refdef.stats.bloom_drawpixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height; - return; - } - - - - if (r_bloomstate.texture_bloom && r_bloomstate.hdr) - { - // render high dynamic range bloom effect - // the bloom texture was made earlier this render, so we just need to - // blend it onto the screen... - R_ResetViewRendering2D(); - R_Mesh_VertexPointer(r_screenvertex3f, 0, 0); - R_Mesh_ColorPointer(NULL, 0, 0); - R_SetupGenericShader(true); - GL_Color(1, 1, 1, 1); - GL_BlendFunc(GL_ONE, GL_ONE); - R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom)); - R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0); - R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0); - r_refdef.stats.bloom_drawpixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height; - } - else if (r_bloomstate.texture_bloom) - { - // render simple bloom effect - // copy the screen and shrink it and darken it for the bloom process - R_Bloom_CopyBloomTexture(r_bloom_colorscale.value); - // make the bloom texture - R_Bloom_MakeTexture(); - // put the original screen image back in place and blend the bloom - // texture on it - R_ResetViewRendering2D(); - R_Mesh_VertexPointer(r_screenvertex3f, 0, 0); - R_Mesh_ColorPointer(NULL, 0, 0); - GL_Color(1, 1, 1, 1); - GL_BlendFunc(GL_ONE, GL_ZERO); - // do both in one pass if possible - R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom)); - R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0); - if (r_textureunits.integer >= 2 && gl_combine.integer) - { - R_SetupGenericTwoTextureShader(GL_ADD); - R_Mesh_TexBind(1, R_GetTexture(r_bloomstate.texture_screen)); - R_Mesh_TexCoordPointer(1, 2, r_bloomstate.screentexcoord2f, 0, 0); - } - else + break; + case RENDERPATH_GL13: + case RENDERPATH_GL11: + if (r_refdef.viewblend[3] >= (1.0f / 256.0f)) { - R_SetupGenericShader(true); + // apply a color tint to the whole view + R_ResetViewRendering2D(); + R_Mesh_VertexPointer(r_screenvertex3f, 0, 0); + R_Mesh_ColorPointer(NULL, 0, 0); + R_SetupGenericShader(false); + GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]); R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0); - r_refdef.stats.bloom_drawpixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height; - // now blend on the bloom texture - GL_BlendFunc(GL_ONE, GL_ONE); - R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_screen)); - R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0); } - R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0); - r_refdef.stats.bloom_drawpixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height; - } - if (r_refdef.viewblend[3] >= (1.0f / 256.0f)) - { - // apply a color tint to the whole view - R_ResetViewRendering2D(); - R_Mesh_VertexPointer(r_screenvertex3f, 0, 0); - R_Mesh_ColorPointer(NULL, 0, 0); - R_SetupGenericShader(false); - GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); - GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]); - R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0); + break; } } @@ -4746,9 +4845,9 @@ void R_UpdateVariables(void) r_refdef.shadowpolygonoffset = r_refdef.polygonoffset + r_shadow_polygonoffset.value * (r_shadow_frontsidecasting.integer ? 1 : -1); r_refdef.scene.rtworld = r_shadow_realtime_world.integer != 0; - r_refdef.scene.rtworldshadows = r_shadow_realtime_world_shadows.integer && gl_stencil; + r_refdef.scene.rtworldshadows = r_shadow_realtime_world_shadows.integer && vid.stencil; r_refdef.scene.rtdlight = (r_shadow_realtime_world.integer || r_shadow_realtime_dlight.integer) && !gl_flashblend.integer && r_dynamic.integer; - r_refdef.scene.rtdlightshadows = r_refdef.scene.rtdlight && r_shadow_realtime_dlight_shadows.integer && gl_stencil; + r_refdef.scene.rtdlightshadows = r_refdef.scene.rtdlight && r_shadow_realtime_dlight_shadows.integer && vid.stencil; r_refdef.lightmapintensity = r_refdef.scene.rtworld ? r_shadow_realtime_world_lightmaps.value : 1; if (r_showsurfaces.integer) { @@ -4816,39 +4915,47 @@ void R_UpdateVariables(void) else r_refdef.fogenabled = false; - if(r_glsl.integer && v_glslgamma.integer && !vid_gammatables_trivial) + switch(vid.renderpath) { - if(!r_texture_gammaramps || vid_gammatables_serial != r_texture_gammaramps_serial) + case RENDERPATH_GL20: + if(v_glslgamma.integer && !vid_gammatables_trivial) { - // build GLSL gamma texture + if(!r_texture_gammaramps || vid_gammatables_serial != r_texture_gammaramps_serial) + { + // build GLSL gamma texture #define RAMPWIDTH 256 - unsigned short ramp[RAMPWIDTH * 3]; - unsigned char rampbgr[RAMPWIDTH][4]; - int i; + unsigned short ramp[RAMPWIDTH * 3]; + unsigned char rampbgr[RAMPWIDTH][4]; + int i; - r_texture_gammaramps_serial = vid_gammatables_serial; + r_texture_gammaramps_serial = vid_gammatables_serial; - VID_BuildGammaTables(&ramp[0], RAMPWIDTH); - for(i = 0; i < RAMPWIDTH; ++i) - { - rampbgr[i][0] = (unsigned char) (ramp[i + 2 * RAMPWIDTH] * 255.0 / 65535.0 + 0.5); - rampbgr[i][1] = (unsigned char) (ramp[i + RAMPWIDTH] * 255.0 / 65535.0 + 0.5); - rampbgr[i][2] = (unsigned char) (ramp[i] * 255.0 / 65535.0 + 0.5); - rampbgr[i][3] = 0; - } - if (r_texture_gammaramps) - { - R_UpdateTexture(r_texture_gammaramps, &rampbgr[0][0], 0, 0, RAMPWIDTH, 1); - } - else - { - r_texture_gammaramps = R_LoadTexture2D(r_main_texturepool, "gammaramps", RAMPWIDTH, 1, &rampbgr[0][0], TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_PERSISTENT, NULL); + VID_BuildGammaTables(&ramp[0], RAMPWIDTH); + for(i = 0; i < RAMPWIDTH; ++i) + { + rampbgr[i][0] = (unsigned char) (ramp[i + 2 * RAMPWIDTH] * 255.0 / 65535.0 + 0.5); + rampbgr[i][1] = (unsigned char) (ramp[i + RAMPWIDTH] * 255.0 / 65535.0 + 0.5); + rampbgr[i][2] = (unsigned char) (ramp[i] * 255.0 / 65535.0 + 0.5); + rampbgr[i][3] = 0; + } + if (r_texture_gammaramps) + { + R_UpdateTexture(r_texture_gammaramps, &rampbgr[0][0], 0, 0, RAMPWIDTH, 1); + } + else + { + r_texture_gammaramps = R_LoadTexture2D(r_main_texturepool, "gammaramps", RAMPWIDTH, 1, &rampbgr[0][0], TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_PERSISTENT, NULL); + } } } - } - else - { - // remove GLSL gamma texture + else + { + // remove GLSL gamma texture + } + break; + case RENDERPATH_GL13: + case RENDERPATH_GL11: + break; } } @@ -4896,7 +5003,8 @@ void R_RenderView(void) r_frame++; // used only by R_GetCurrentTexture rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity - R_AnimCache_NewFrame(); + R_AnimCache_ClearCache(); + R_FrameData_NewFrame(); if (r_refdef.view.isoverlay) { @@ -4948,7 +5056,7 @@ void R_RenderView(void) r_refdef.view.clear = true; // this produces a bloom texture to be used in R_BlendView() later - if (r_hdr.integer) + if (r_hdr.integer && r_bloomstate.bloomwidth) R_HDR_RenderBloomTexture(); r_refdef.view.showdebug = true; @@ -5004,6 +5112,7 @@ extern void R_DrawPortals (void); extern cvar_t cl_locs_show; static void R_DrawLocs(void); static void R_DrawEntityBBoxes(void); +static void R_DrawModelDecals(void); extern cvar_t cl_decals_newsystem; void R_RenderScene(void) { @@ -5047,6 +5156,7 @@ void R_RenderScene(void) } R_AnimCache_CacheVisibleEntities(); + R_PrepareRTLights(); if (r_depthfirst.integer >= 1 && cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawDepth) { @@ -5816,6 +5926,8 @@ texture_t *R_GetCurrentTexture(texture_t *t) R_tcMod_ApplyToMatrix(&t->currentbackgroundtexmatrix, tcmod, t->currentmaterialflags); t->colormapping = VectorLength2(rsurface.colormap_pantscolor) + VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f); + if (t->currentskinframe->qpixels) + R_SkinFrame_GenerateTexturesFromQPixels(t->currentskinframe, t->colormapping); t->basetexture = (!t->colormapping && t->currentskinframe->merged) ? t->currentskinframe->merged : t->currentskinframe->base; t->glosstexture = r_texture_black; t->backgroundbasetexture = t->backgroundnumskinframes ? ((!t->colormapping && t->backgroundcurrentskinframe->merged) ? t->backgroundcurrentskinframe->merged : t->backgroundcurrentskinframe->base) : r_texture_white; @@ -5981,6 +6093,7 @@ void RSurf_ActiveWorldEntity(void) //if (rsurface.entity == r_refdef.scene.worldentity) // return; rsurface.entity = r_refdef.scene.worldentity; + rsurface.skeleton = NULL; rsurface.ent_skinnum = 0; rsurface.ent_qwskin = -1; rsurface.ent_shadertime = 0; @@ -6061,6 +6174,7 @@ void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, q //if (rsurface.entity == ent && (!model->surfmesh.isanimated || (!wantnormals && !wanttangents))) // return; rsurface.entity = (entity_render_t *)ent; + rsurface.skeleton = ent->skeleton; rsurface.ent_skinnum = ent->skinnum; rsurface.ent_qwskin = (ent->entitynumber <= cl.maxclients && ent->entitynumber >= 1 && cls.protocol == PROTOCOL_QUAKEWORLD && cl.scores[ent->entitynumber - 1].qw_skin[0] && !strcmp(ent->model->name, "progs/player.mdl")) ? (ent->entitynumber - 1) : -1; rsurface.ent_shadertime = ent->shadertime; @@ -6109,7 +6223,7 @@ void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, q rsurface.modelsvector3f = rsurface.array_modelsvector3f; rsurface.modeltvector3f = rsurface.array_modeltvector3f; rsurface.modelnormal3f = rsurface.array_modelnormal3f; - model->AnimateVertices(model, rsurface.frameblend, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, rsurface.array_modelsvector3f, rsurface.array_modeltvector3f); + model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, rsurface.array_modelsvector3f, rsurface.array_modeltvector3f); } else if (wantnormals) { @@ -6117,7 +6231,7 @@ void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, q rsurface.modelsvector3f = NULL; rsurface.modeltvector3f = NULL; rsurface.modelnormal3f = rsurface.array_modelnormal3f; - model->AnimateVertices(model, rsurface.frameblend, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, NULL, NULL); + model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, NULL, NULL); } else { @@ -6125,7 +6239,7 @@ void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, q rsurface.modelsvector3f = NULL; rsurface.modeltvector3f = NULL; rsurface.modelnormal3f = NULL; - model->AnimateVertices(model, rsurface.frameblend, rsurface.array_modelvertex3f, NULL, NULL, NULL); + model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, NULL, NULL, NULL); } rsurface.modelvertex3f_bufferobject = 0; rsurface.modelvertex3f_bufferoffset = 0; @@ -6188,6 +6302,7 @@ void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, q void RSurf_ActiveCustomEntity(const matrix4x4_t *matrix, const matrix4x4_t *inversematrix, int entflags, double shadertime, float r, float g, float b, float a, int numvertices, const float *vertex3f, const float *texcoord2f, const float *normal3f, const float *svector3f, const float *tvector3f, const float *color4f, int numtriangles, const int *element3i, const unsigned short *element3s, qboolean wantnormals, qboolean wanttangents) { rsurface.entity = r_refdef.scene.worldentity; + rsurface.skeleton = NULL; rsurface.ent_skinnum = 0; rsurface.ent_qwskin = -1; rsurface.ent_shadertime = shadertime; @@ -7845,13 +7960,22 @@ static void R_DrawWorldTextureSurfaceList(int texturenumsurfaces, const msurface CHECKGLERROR RSurf_SetupDepthAndCulling(); if (r_showsurfaces.integer == 3) + { R_DrawTextureSurfaceList_ShowSurfaces3(texturenumsurfaces, texturesurfacelist, writedepth); - else if (r_glsl.integer && gl_support_fragment_shader) + return; + } + switch (vid.renderpath) + { + case RENDERPATH_GL20: R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist, writedepth); - else if (gl_combine.integer && r_textureunits.integer >= 2) + break; + case RENDERPATH_GL13: R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist, writedepth); - else + break; + case RENDERPATH_GL11: R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist, writedepth); + break; + } CHECKGLERROR } @@ -7860,13 +7984,22 @@ static void R_DrawModelTextureSurfaceList(int texturenumsurfaces, const msurface CHECKGLERROR RSurf_SetupDepthAndCulling(); if (r_showsurfaces.integer == 3) + { R_DrawTextureSurfaceList_ShowSurfaces3(texturenumsurfaces, texturesurfacelist, writedepth); - else if (r_glsl.integer && gl_support_fragment_shader) + return; + } + switch (vid.renderpath) + { + case RENDERPATH_GL20: R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist, writedepth); - else if (gl_combine.integer && r_textureunits.integer >= 2) + break; + case RENDERPATH_GL13: R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist, writedepth); - else + break; + case RENDERPATH_GL11: R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist, writedepth); + break; + } CHECKGLERROR } @@ -7886,7 +8019,18 @@ static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const else if (r_showsurfaces.integer && r_showsurfaces.integer != 3) RSurf_ActiveModelEntity(ent, false, false); else - RSurf_ActiveModelEntity(ent, true, r_glsl.integer && gl_support_fragment_shader); + { + switch (vid.renderpath) + { + case RENDERPATH_GL20: + RSurf_ActiveModelEntity(ent, true, true); + break; + case RENDERPATH_GL13: + case RENDERPATH_GL11: + RSurf_ActiveModelEntity(ent, true, false); + break; + } + } for (i = 0;i < numsurfaces;i = j) { @@ -8203,12 +8347,8 @@ void R_DecalSystem_Reset(decalsystem_t *decalsystem) memset(decalsystem, 0, sizeof(*decalsystem)); } -void R_DecalSystem_SpawnTriangle(decalsystem_t *decalsystem, const float *v0, const float *v1, const float *v2, const float *t0, const float *t1, const float *t2, const float *c0, const float *c1, const float *c2, int triangleindex) +static void R_DecalSystem_SpawnTriangle(decalsystem_t *decalsystem, const float *v0, const float *v1, const float *v2, const float *t0, const float *t1, const float *t2, const float *c0, const float *c1, const float *c2, int triangleindex, int surfaceindex, int decalsequence) { - float *v3f; - float *tc2f; - float *c4f; - float ca; tridecal_t *decal; tridecal_t *decals; int i; @@ -8228,13 +8368,9 @@ void R_DecalSystem_SpawnTriangle(decalsystem_t *decalsystem, const float *v0, co decalsystem->element3i = (int *)(decalsystem->vertex3f + decalsystem->maxdecals*9); decalsystem->element3s = (useshortelements ? ((unsigned short *)(decalsystem->element3i + decalsystem->maxdecals*3)) : NULL); if (decalsystem->numdecals) - { memcpy(decalsystem->decals, old.decals, decalsystem->numdecals * sizeof(tridecal_t)); - memcpy(decalsystem->vertex3f, old.vertex3f, decalsystem->numdecals * sizeof(float[3][3])); - memcpy(decalsystem->texcoord2f, old.texcoord2f, decalsystem->numdecals * sizeof(float[3][2])); - memcpy(decalsystem->color4f, old.color4f, decalsystem->numdecals * sizeof(float[3][4])); - } - Mem_Free(old.decals); + if (old.decals) + Mem_Free(old.decals); for (i = 0;i < decalsystem->maxdecals*3;i++) decalsystem->element3i[i] = i; if (useshortelements) @@ -8246,10 +8382,7 @@ void R_DecalSystem_SpawnTriangle(decalsystem_t *decalsystem, const float *v0, co maxdecals = decalsystem->maxdecals; decals = decalsystem->decals; decal = decalsystem->decals + (i = decalsystem->freedecal++); - v3f = decalsystem->vertex3f + 9*i; - tc2f = decalsystem->texcoord2f + 6*i; - c4f = decalsystem->color4f + 12*i; - for (i = decalsystem->freedecal;i < maxdecals && decals[i].colors[0][3];i++) + for (i = decalsystem->freedecal;i < decalsystem->numdecals && decals[i].color4ub[0][3];i++) ; decalsystem->freedecal = i; if (decalsystem->numdecals <= i) @@ -8258,51 +8391,41 @@ void R_DecalSystem_SpawnTriangle(decalsystem_t *decalsystem, const float *v0, co // initialize the decal decal->lived = 0; decal->triangleindex = triangleindex; - decal->colors[0][0] = (unsigned char)(c0[0]*255.0f); - decal->colors[0][1] = (unsigned char)(c0[1]*255.0f); - decal->colors[0][2] = (unsigned char)(c0[2]*255.0f); - decal->colors[0][3] = 255; - decal->colors[1][0] = (unsigned char)(c1[0]*255.0f); - decal->colors[1][1] = (unsigned char)(c1[1]*255.0f); - decal->colors[1][2] = (unsigned char)(c1[2]*255.0f); - decal->colors[1][3] = 255; - decal->colors[2][0] = (unsigned char)(c2[0]*255.0f); - decal->colors[2][1] = (unsigned char)(c2[1]*255.0f); - decal->colors[2][2] = (unsigned char)(c2[2]*255.0f); - decal->colors[2][3] = 255; - v3f[0] = v0[0]; - v3f[1] = v0[1]; - v3f[2] = v0[2]; - v3f[3] = v1[0]; - v3f[4] = v1[1]; - v3f[5] = v1[2]; - v3f[6] = v2[0]; - v3f[7] = v2[1]; - v3f[8] = v2[2]; - tc2f[0] = t0[0]; - tc2f[1] = t0[1]; - tc2f[2] = t1[0]; - tc2f[3] = t1[1]; - tc2f[4] = t2[0]; - tc2f[5] = t2[1]; - ca = (1.0f/255.0f); - c4f[ 0] = decal->colors[0][0] * ca; - c4f[ 1] = decal->colors[0][1] * ca; - c4f[ 2] = decal->colors[0][2] * ca; - c4f[ 3] = 1; - c4f[ 4] = decal->colors[1][0] * ca; - c4f[ 5] = decal->colors[1][1] * ca; - c4f[ 6] = decal->colors[1][2] * ca; - c4f[ 7] = 1; - c4f[ 8] = decal->colors[2][0] * ca; - c4f[ 9] = decal->colors[2][1] * ca; - c4f[10] = decal->colors[2][2] * ca; - c4f[11] = 1; + decal->surfaceindex = surfaceindex; + decal->decalsequence = decalsequence; + decal->color4ub[0][0] = (unsigned char)(c0[0]*255.0f); + decal->color4ub[0][1] = (unsigned char)(c0[1]*255.0f); + decal->color4ub[0][2] = (unsigned char)(c0[2]*255.0f); + decal->color4ub[0][3] = 255; + decal->color4ub[1][0] = (unsigned char)(c1[0]*255.0f); + decal->color4ub[1][1] = (unsigned char)(c1[1]*255.0f); + decal->color4ub[1][2] = (unsigned char)(c1[2]*255.0f); + decal->color4ub[1][3] = 255; + decal->color4ub[2][0] = (unsigned char)(c2[0]*255.0f); + decal->color4ub[2][1] = (unsigned char)(c2[1]*255.0f); + decal->color4ub[2][2] = (unsigned char)(c2[2]*255.0f); + decal->color4ub[2][3] = 255; + decal->vertex3f[0][0] = v0[0]; + decal->vertex3f[0][1] = v0[1]; + decal->vertex3f[0][2] = v0[2]; + decal->vertex3f[1][0] = v1[0]; + decal->vertex3f[1][1] = v1[1]; + decal->vertex3f[1][2] = v1[2]; + decal->vertex3f[2][0] = v2[0]; + decal->vertex3f[2][1] = v2[1]; + decal->vertex3f[2][2] = v2[2]; + decal->texcoord2f[0][0] = t0[0]; + decal->texcoord2f[0][1] = t0[1]; + decal->texcoord2f[1][0] = t1[0]; + decal->texcoord2f[1][1] = t1[1]; + decal->texcoord2f[2][0] = t2[0]; + decal->texcoord2f[2][1] = t2[1]; } extern cvar_t cl_decals_bias; extern cvar_t cl_decals_models; -void R_DecalSystem_SplatEntity(entity_render_t *ent, const vec3_t worldorigin, const vec3_t worldnormal, float r, float g, float b, float a, float s1, float t1, float s2, float t2, float worldsize) +extern cvar_t cl_decals_newsystem_intensitymultiplier; +static void R_DecalSystem_SplatEntity(entity_render_t *ent, const vec3_t worldorigin, const vec3_t worldnormal, float r, float g, float b, float a, float s1, float t1, float s2, float t2, float worldsize, int decalsequence) { matrix4x4_t projection; decalsystem_t *decalsystem; @@ -8317,7 +8440,9 @@ void R_DecalSystem_SplatEntity(entity_render_t *ent, const vec3_t worldorigin, c int numtriangles; int numsurfacelist; int surfacelistindex; + int surfaceindex; int triangleindex; + int decalsurfaceindex; int cornerindex; int index; int numpoints; @@ -8422,17 +8547,17 @@ void R_DecalSystem_SplatEntity(entity_render_t *ent, const vec3_t worldorigin, c surfaces = model->data_surfaces; for (surfacelistindex = 0;surfacelistindex < numsurfacelist;surfacelistindex++) { - surface = surfaces + surfacelist[surfacelistindex]; + surfaceindex = surfacelist[surfacelistindex]; + surface = surfaces + surfaceindex; // skip transparent surfaces texture = surface->texture; if (texture->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_SKY | MATERIALFLAG_SHORTDEPTHRANGE | MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION)) continue; if (texture->surfaceflags & Q3SURFACEFLAG_NOMARKS) continue; - if (texture->currentalpha < 1) - continue; if (!dynamic && !BoxesOverlap(surface->mins, surface->maxs, localmins, localmaxs)) continue; + decalsurfaceindex = ent == r_refdef.scene.worldentity ? surfaceindex : -1; numvertices = surface->num_vertices; numtriangles = surface->num_triangles; for (triangleindex = 0, e = model->surfmesh.data_element3i + 3*surface->num_firsttriangle;triangleindex < numtriangles;triangleindex++, e += 3) @@ -8484,8 +8609,8 @@ void R_DecalSystem_SplatEntity(entity_render_t *ent, const vec3_t worldorigin, c tc[cornerindex][0] = (temp[1]+1.0f)*0.5f * (s2-s1) + s1; tc[cornerindex][1] = (temp[2]+1.0f)*0.5f * (t2-t1) + t1; // calculate distance fade from the projection origin - f = a * (1.0f-fabs(temp[0])); - f = max(0.0f, f); + f = a * (1.0f-fabs(temp[0])) * cl_decals_newsystem_intensitymultiplier.value; + f = bound(0.0f, f, 1.0f); c[cornerindex][0] = r * f; c[cornerindex][1] = g * f; c[cornerindex][2] = b * f; @@ -8493,21 +8618,25 @@ void R_DecalSystem_SplatEntity(entity_render_t *ent, const vec3_t worldorigin, c //VectorMA(v[cornerindex], cl_decals_bias.value, localnormal, v[cornerindex]); } if (dynamic) - R_DecalSystem_SpawnTriangle(decalsystem, v[0], v[1], v[2], tc[0], tc[1], tc[2], c[0], c[1], c[2], triangleindex); + R_DecalSystem_SpawnTriangle(decalsystem, v[0], v[1], v[2], tc[0], tc[1], tc[2], c[0], c[1], c[2], triangleindex+surface->num_firsttriangle, surfaceindex, decalsequence); else for (cornerindex = 0;cornerindex < numpoints-2;cornerindex++) - R_DecalSystem_SpawnTriangle(decalsystem, v[0], v[cornerindex+1], v[cornerindex+2], tc[0], tc[cornerindex+1], tc[cornerindex+2], c[0], c[cornerindex+1], c[cornerindex+2], -1); + R_DecalSystem_SpawnTriangle(decalsystem, v[0], v[cornerindex+1], v[cornerindex+2], tc[0], tc[cornerindex+1], tc[cornerindex+2], c[0], c[cornerindex+1], c[cornerindex+2], -1, surfaceindex, decalsequence); } } } -void R_DecalSystem_SplatEntities(const vec3_t worldorigin, const vec3_t worldnormal, float r, float g, float b, float a, float s1, float t1, float s2, float t2, float worldsize) +// do not call this outside of rendering code - use R_DecalSystem_SplatEntities instead +static void R_DecalSystem_ApplySplatEntities(const vec3_t worldorigin, const vec3_t worldnormal, float r, float g, float b, float a, float s1, float t1, float s2, float t2, float worldsize, int decalsequence) { int renderentityindex; float worldmins[3]; float worldmaxs[3]; entity_render_t *ent; + if (!cl_decals_newsystem.integer) + return; + worldmins[0] = worldorigin[0] - worldsize; worldmins[1] = worldorigin[1] - worldsize; worldmins[2] = worldorigin[2] - worldsize; @@ -8515,7 +8644,7 @@ void R_DecalSystem_SplatEntities(const vec3_t worldorigin, const vec3_t worldnor worldmaxs[1] = worldorigin[1] + worldsize; worldmaxs[2] = worldorigin[2] + worldsize; - R_DecalSystem_SplatEntity(r_refdef.scene.worldentity, worldorigin, worldnormal, r, g, b, a, s1, t1, s2, t2, worldsize); + R_DecalSystem_SplatEntity(r_refdef.scene.worldentity, worldorigin, worldnormal, r, g, b, a, s1, t1, s2, t2, worldsize, decalsequence); for (renderentityindex = 0;renderentityindex < r_refdef.scene.numentities;renderentityindex++) { @@ -8523,7 +8652,118 @@ void R_DecalSystem_SplatEntities(const vec3_t worldorigin, const vec3_t worldnor if (!BoxesOverlap(ent->mins, ent->maxs, worldmins, worldmaxs)) continue; - R_DecalSystem_SplatEntity(ent, worldorigin, worldnormal, r, g, b, a, s1, t1, s2, t2, worldsize); + R_DecalSystem_SplatEntity(ent, worldorigin, worldnormal, r, g, b, a, s1, t1, s2, t2, worldsize, decalsequence); + } +} + +typedef struct r_decalsystem_splatqueue_s +{ + vec3_t worldorigin; + vec3_t worldnormal; + float color[4]; + float tcrange[4]; + float worldsize; + int decalsequence; +} +r_decalsystem_splatqueue_t; + +int r_decalsystem_numqueued = 0; +#define MAX_DECALSYSTEM_QUEUE 1024 +r_decalsystem_splatqueue_t r_decalsystem_queue[MAX_DECALSYSTEM_QUEUE]; + +void R_DecalSystem_SplatEntities(const vec3_t worldorigin, const vec3_t worldnormal, float r, float g, float b, float a, float s1, float t1, float s2, float t2, float worldsize) +{ + r_decalsystem_splatqueue_t *queue; + + if (!cl_decals_newsystem.integer || r_decalsystem_numqueued == MAX_DECALSYSTEM_QUEUE) + return; + + queue = &r_decalsystem_queue[r_decalsystem_numqueued++]; + VectorCopy(worldorigin, queue->worldorigin); + VectorCopy(worldnormal, queue->worldnormal); + Vector4Set(queue->color, r, g, b, a); + Vector4Set(queue->tcrange, s1, t1, s2, t2); + queue->worldsize = worldsize; + queue->decalsequence = cl.decalsequence++; +} + +static void R_DecalSystem_ApplySplatEntitiesQueue(void) +{ + int i; + r_decalsystem_splatqueue_t *queue; + + for (i = 0, queue = r_decalsystem_queue;i < r_decalsystem_numqueued;i++, queue++) + R_DecalSystem_ApplySplatEntities(queue->worldorigin, queue->worldnormal, queue->color[0], queue->color[1], queue->color[2], queue->color[3], queue->tcrange[0], queue->tcrange[1], queue->tcrange[2], queue->tcrange[3], queue->worldsize, queue->decalsequence); + r_decalsystem_numqueued = 0; +} + +extern cvar_t cl_decals_max; +static void R_DrawModelDecals_FadeEntity(entity_render_t *ent) +{ + int i; + decalsystem_t *decalsystem = &ent->decalsystem; + int numdecals; + int killsequence; + tridecal_t *decal; + float frametime; + float lifetime; + + if (!decalsystem->numdecals) + return; + + if (r_showsurfaces.integer) + return; + + if (ent->model != decalsystem->model || ent->alpha < 1 || (ent->flags & RENDER_ADDITIVE)) + { + R_DecalSystem_Reset(decalsystem); + return; + } + + killsequence = cl.decalsequence - max(1, cl_decals_max.integer); + lifetime = cl_decals_time.value + cl_decals_fadetime.value; + + if (decalsystem->lastupdatetime) + frametime = (cl.time - decalsystem->lastupdatetime); + else + frametime = 0; + decalsystem->lastupdatetime = cl.time; + decal = decalsystem->decals; + numdecals = decalsystem->numdecals; + + for (i = 0, decal = decalsystem->decals;i < numdecals;i++, decal++) + { + if (decal->color4ub[0][3]) + { + decal->lived += frametime; + if (killsequence - decal->decalsequence > 0 || decal->lived >= lifetime) + { + memset(decal, 0, sizeof(*decal)); + if (decalsystem->freedecal > i) + decalsystem->freedecal = i; + } + } + } + decal = decalsystem->decals; + while (numdecals > 0 && !decal[numdecals-1].color4ub[0][3]) + numdecals--; + + // collapse the array by shuffling the tail decals into the gaps + for (;;) + { + while (decalsystem->freedecal < numdecals && decal[decalsystem->freedecal].color4ub[0][3]) + decalsystem->freedecal++; + if (decalsystem->freedecal == numdecals) + break; + decal[decalsystem->freedecal] = decal[--numdecals]; + } + + decalsystem->numdecals = numdecals; + + if (numdecals <= 0) + { + // if there are no decals left, reset decalsystem + R_DecalSystem_Reset(decalsystem); } } @@ -8534,15 +8774,18 @@ static void R_DrawModelDecals_Entity(entity_render_t *ent) decalsystem_t *decalsystem = &ent->decalsystem; int numdecals; tridecal_t *decal; - float frametime; float fadedelay; float faderate; float alpha; float *v3f; float *c4f; + float *t2f; const int *e; + const unsigned char *surfacevisible = r_refdef.viewcache.world_surfacevisible; + int numtris = 0; - if (!decalsystem->numdecals) + numdecals = decalsystem->numdecals; + if (!numdecals) return; if (r_showsurfaces.integer) @@ -8562,77 +8805,80 @@ static void R_DrawModelDecals_Entity(entity_render_t *ent) else RSurf_ActiveModelEntity(ent, false, false); - if (decalsystem->lastupdatetime) - frametime = cl.time - decalsystem->lastupdatetime; - else - frametime = 0; decalsystem->lastupdatetime = cl.time; decal = decalsystem->decals; - numdecals = decalsystem->numdecals; fadedelay = cl_decals_time.value; faderate = 1.0f / max(0.001f, cl_decals_fadetime.value); + // update vertex positions for animated models + v3f = decalsystem->vertex3f; + c4f = decalsystem->color4f; + t2f = decalsystem->texcoord2f; for (i = 0, decal = decalsystem->decals;i < numdecals;i++, decal++) { - if (!decal->colors[0][3]) + if (!decal->color4ub[0][3]) + continue; + + if (decal->surfaceindex >= 0 && !surfacevisible[decal->surfaceindex]) continue; - decal->lived += frametime; - if (decal->lived >= fadedelay) + // update color values for fading decals + if (decal->lived >= cl_decals_time.value) { alpha = 1 - faderate * (decal->lived - cl_decals_time.value); - if (alpha <= 0) - { - // kill the decal by zeroing vertex data - memset(decalsystem->vertex3f + 9*i, 0, sizeof(float[3][3])); - memset(decalsystem->texcoord2f + 6*i, 0, sizeof(float[3][2])); - memset(decalsystem->color4f + 12*i, 0, sizeof(float[3][4])); - memset(decal, 0, sizeof(*decal)); - if (decalsystem->freedecal > i) - decalsystem->freedecal = i; - continue; - } - - // update color values for fading decals alpha *= (1.0f/255.0f); - c4f = decalsystem->color4f + 12*i; - c4f[ 0] = decal->colors[0][0] * alpha; - c4f[ 1] = decal->colors[0][1] * alpha; - c4f[ 2] = decal->colors[0][2] * alpha; - c4f[ 3] = 1; - c4f[ 4] = decal->colors[1][0] * alpha; - c4f[ 5] = decal->colors[1][1] * alpha; - c4f[ 6] = decal->colors[1][2] * alpha; - c4f[ 7] = 1; - c4f[ 8] = decal->colors[2][0] * alpha; - c4f[ 9] = decal->colors[2][1] * alpha; - c4f[10] = decal->colors[2][2] * alpha; - c4f[11] = 1; } + else + alpha = 1.0f/255.0f; + + c4f[ 0] = decal->color4ub[0][0] * alpha; + c4f[ 1] = decal->color4ub[0][1] * alpha; + c4f[ 2] = decal->color4ub[0][2] * alpha; + c4f[ 3] = 1; + c4f[ 4] = decal->color4ub[1][0] * alpha; + c4f[ 5] = decal->color4ub[1][1] * alpha; + c4f[ 6] = decal->color4ub[1][2] * alpha; + c4f[ 7] = 1; + c4f[ 8] = decal->color4ub[2][0] * alpha; + c4f[ 9] = decal->color4ub[2][1] * alpha; + c4f[10] = decal->color4ub[2][2] * alpha; + c4f[11] = 1; + + t2f[0] = decal->texcoord2f[0][0]; + t2f[1] = decal->texcoord2f[0][1]; + t2f[2] = decal->texcoord2f[1][0]; + t2f[3] = decal->texcoord2f[1][1]; + t2f[4] = decal->texcoord2f[2][0]; + t2f[5] = decal->texcoord2f[2][1]; // update vertex positions for animated models if (decal->triangleindex >= 0 && decal->triangleindex < rsurface.modelnum_triangles) { e = rsurface.modelelement3i + 3*decal->triangleindex; - v3f = decalsystem->vertex3f + 9*i; VectorCopy(rsurface.vertex3f + 3*e[0], v3f); VectorCopy(rsurface.vertex3f + 3*e[1], v3f + 3); VectorCopy(rsurface.vertex3f + 3*e[2], v3f + 6); } - } + else + { + VectorCopy(decal->vertex3f[0], v3f); + VectorCopy(decal->vertex3f[1], v3f + 3); + VectorCopy(decal->vertex3f[2], v3f + 6); + } - // reduce numdecals if possible - while (numdecals > 0 && !decalsystem->decals[numdecals - 1].colors[0][3]) - numdecals--; - decalsystem->numdecals = numdecals; + v3f += 9; + c4f += 12; + t2f += 6; + numtris++; + } - if (numdecals > 0) + if (numtris > 0) { - r_refdef.stats.decals += numdecals; + r_refdef.stats.drawndecals += numtris; // now render the decals all at once // (this assumes they all use one particle font texture!) - RSurf_ActiveCustomEntity(&rsurface.matrix, &rsurface.inversematrix, rsurface.ent_flags, rsurface.ent_shadertime, 1, 1, 1, 1, numdecals*3, decalsystem->vertex3f, decalsystem->texcoord2f, NULL, NULL, NULL, decalsystem->color4f, numdecals, decalsystem->element3i, decalsystem->element3s, false, false); + RSurf_ActiveCustomEntity(&rsurface.matrix, &rsurface.inversematrix, rsurface.ent_flags, rsurface.ent_shadertime, 1, 1, 1, 1, numdecals*3, decalsystem->vertex3f, decalsystem->texcoord2f, NULL, NULL, NULL, decalsystem->color4f, numtris, decalsystem->element3i, decalsystem->element3s, false, false); R_Mesh_ResetTextureState(); R_Mesh_VertexPointer(decalsystem->vertex3f, 0, 0); R_Mesh_TexCoordPointer(0, 2, decalsystem->texcoord2f, 0, 0); @@ -8646,15 +8892,48 @@ static void R_DrawModelDecals_Entity(entity_render_t *ent) GL_BlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR); R_Mesh_TexBind(0, R_GetTexture(decalskinframe->base)); //R_Mesh_TexBind(0, R_GetTexture(r_texture_white)); - GL_LockArrays(0, numdecals * 3); - R_Mesh_Draw(0, numdecals * 3, 0, numdecals, decalsystem->element3i, decalsystem->element3s, 0, 0); + GL_LockArrays(0, numtris * 3); + R_Mesh_Draw(0, numtris * 3, 0, numtris, decalsystem->element3i, decalsystem->element3s, 0, 0); GL_LockArrays(0, 0); } +} - if (numdecals <= 0) +static void R_DrawModelDecals(void) +{ + int i, numdecals; + + // fade faster when there are too many decals + numdecals = r_refdef.scene.worldentity->decalsystem.numdecals; + for (i = 0;i < r_refdef.scene.numentities;i++) + numdecals += r_refdef.scene.entities[i]->decalsystem.numdecals; + + R_DrawModelDecals_FadeEntity(r_refdef.scene.worldentity); + for (i = 0;i < r_refdef.scene.numentities;i++) + if (r_refdef.scene.entities[i]->decalsystem.numdecals) + R_DrawModelDecals_FadeEntity(r_refdef.scene.entities[i]); + + R_DecalSystem_ApplySplatEntitiesQueue(); + + numdecals = r_refdef.scene.worldentity->decalsystem.numdecals; + for (i = 0;i < r_refdef.scene.numentities;i++) + numdecals += r_refdef.scene.entities[i]->decalsystem.numdecals; + + r_refdef.stats.totaldecals += numdecals; + + if (r_showsurfaces.integer) + return; + + R_DrawModelDecals_Entity(r_refdef.scene.worldentity); + + if (!r_drawentities.integer) + return; + + for (i = 0;i < r_refdef.scene.numentities;i++) { - // if there are no decals left, reset decalsystem - R_DecalSystem_Reset(decalsystem); + if (!r_refdef.viewcache.entityvisible[i]) + continue; + if (r_refdef.scene.entities[i]->decalsystem.numdecals) + R_DrawModelDecals_Entity(r_refdef.scene.entities[i]); } } @@ -8819,7 +9098,7 @@ void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean dep { r_maxsurfacelist = model->num_surfaces; if (r_surfacelist) - Mem_Free(r_surfacelist); + Mem_Free((msurface_t**)r_surfacelist); r_surfacelist = (const msurface_t **) Mem_Alloc(r_main_mempool, r_maxsurfacelist * sizeof(*r_surfacelist)); } @@ -8907,7 +9186,7 @@ void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean wr { r_maxsurfacelist = model->num_surfaces; if (r_surfacelist) - Mem_Free(r_surfacelist); + Mem_Free((msurface_t **)r_surfacelist); r_surfacelist = (const msurface_t **) Mem_Alloc(r_main_mempool, r_maxsurfacelist * sizeof(*r_surfacelist)); } @@ -8918,8 +9197,21 @@ void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean wr RSurf_ActiveWorldEntity(); else if (r_showsurfaces.integer && r_showsurfaces.integer != 3) RSurf_ActiveModelEntity(ent, false, false); + else if (depthonly) + RSurf_ActiveModelEntity(ent, false, false); else - RSurf_ActiveModelEntity(ent, true, r_glsl.integer && gl_support_fragment_shader && !depthonly); + { + switch (vid.renderpath) + { + case RENDERPATH_GL20: + RSurf_ActiveModelEntity(ent, true, true); + break; + case RENDERPATH_GL13: + case RENDERPATH_GL11: + RSurf_ActiveModelEntity(ent, true, false); + break; + } + } surfaces = model->data_surfaces; update = model->brushq1.lightmapupdateflags;