X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=r_shadow.c;h=33818cb1faa0b735ed6bbac3fa75139709c20fc3;hb=e91d7250f5ea81db64dc40f554c711b4ee5f89a8;hp=b4b04085543c20ae3b615b9929f168194ff1b768;hpb=fffe0ca6036ab33e870ff082e3d5dd7ad0ae17d7;p=xonotic%2Fdarkplaces.git diff --git a/r_shadow.c b/r_shadow.c index b4b04085..33818cb1 100644 --- a/r_shadow.c +++ b/r_shadow.c @@ -139,6 +139,7 @@ demonstrated by the game Doom3. #include "cl_collision.h" #include "portals.h" #include "image.h" +#include "dpsoftrast.h" #ifdef SUPPORTD3D #include @@ -163,18 +164,14 @@ typedef enum r_shadow_rendermode_e R_SHADOW_RENDERMODE_LIGHT_GLSL, R_SHADOW_RENDERMODE_VISIBLEVOLUMES, R_SHADOW_RENDERMODE_VISIBLELIGHTING, - R_SHADOW_RENDERMODE_SHADOWMAP2D, - R_SHADOW_RENDERMODE_SHADOWMAPRECTANGLE, - R_SHADOW_RENDERMODE_SHADOWMAPCUBESIDE, + R_SHADOW_RENDERMODE_SHADOWMAP2D } r_shadow_rendermode_t; typedef enum r_shadow_shadowmode_e { R_SHADOW_SHADOWMODE_STENCIL, - R_SHADOW_SHADOWMODE_SHADOWMAP2D, - R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE, - R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE + R_SHADOW_SHADOWMODE_SHADOWMAP2D } r_shadow_shadowmode_t; @@ -182,9 +179,7 @@ r_shadow_rendermode_t r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE; r_shadow_rendermode_t r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_NONE; r_shadow_rendermode_t r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_NONE; r_shadow_rendermode_t r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_NONE; -qboolean r_shadow_usingshadowmaprect; qboolean r_shadow_usingshadowmap2d; -qboolean r_shadow_usingshadowmapcube; qboolean r_shadow_usingshadowmaportho; int r_shadow_shadowmapside; float r_shadow_shadowmap_texturescale[2]; @@ -194,12 +189,9 @@ int r_shadow_drawbuffer; int r_shadow_readbuffer; #endif int r_shadow_cullface_front, r_shadow_cullface_back; -GLuint r_shadow_fborectangle; -GLuint r_shadow_fbocubeside[R_SHADOW_SHADOWMAP_NUMCUBEMAPS]; GLuint r_shadow_fbo2d; r_shadow_shadowmode_t r_shadow_shadowmode; int r_shadow_shadowmapfilterquality; -int r_shadow_shadowmaptexturetype; int r_shadow_shadowmapdepthbits; int r_shadow_shadowmapmaxsize; qboolean r_shadow_shadowmapvsdct; @@ -252,19 +244,19 @@ rtexture_t *r_shadow_attenuationgradienttexture; rtexture_t *r_shadow_attenuation2dtexture; rtexture_t *r_shadow_attenuation3dtexture; skinframe_t *r_shadow_lightcorona; -rtexture_t *r_shadow_shadowmaprectangletexture; rtexture_t *r_shadow_shadowmap2dtexture; -rtexture_t *r_shadow_shadowmapcubetexture[R_SHADOW_SHADOWMAP_NUMCUBEMAPS]; rtexture_t *r_shadow_shadowmap2dcolortexture; rtexture_t *r_shadow_shadowmapvsdcttexture; int r_shadow_shadowmapsize; // changes for each light based on distance int r_shadow_shadowmaplod; // changes for each light based on distance GLuint r_shadow_prepassgeometryfbo; -GLuint r_shadow_prepasslightingfbo; +GLuint r_shadow_prepasslightingdiffusespecularfbo; +GLuint r_shadow_prepasslightingdiffusefbo; int r_shadow_prepass_width; int r_shadow_prepass_height; rtexture_t *r_shadow_prepassgeometrydepthtexture; +rtexture_t *r_shadow_prepassgeometrydepthcolortexture; rtexture_t *r_shadow_prepassgeometrynormalmaptexture; rtexture_t *r_shadow_prepasslightingdiffusetexture; rtexture_t *r_shadow_prepasslightingspeculartexture; @@ -283,6 +275,7 @@ cvar_t r_shadow_debuglight = {0, "r_shadow_debuglight", "-1", "renders only one cvar_t r_shadow_deferred = {CVAR_SAVE, "r_shadow_deferred", "0", "uses image-based lighting instead of geometry-based lighting, the method used renders a depth image and a normalmap image, renders lights into separate diffuse and specular images, and then combines this into the normal rendering, requires r_shadow_shadowmapping"}; cvar_t r_shadow_deferred_8bitrange = {CVAR_SAVE, "r_shadow_deferred_8bitrange", "2", "dynamic range of image-based lighting when using 32bit color (does not apply to fp)"}; //cvar_t r_shadow_deferred_fp = {CVAR_SAVE, "r_shadow_deferred_fp", "0", "use 16bit (1) or 32bit (2) floating point for accumulation of image-based lighting"}; +cvar_t r_shadow_usebihculling = {0, "r_shadow_usebihculling", "1", "use BIH (Bounding Interval Hierarchy) for culling lit surfaces instead of BSP (Binary Space Partitioning)"}; cvar_t r_shadow_usenormalmap = {CVAR_SAVE, "r_shadow_usenormalmap", "1", "enables use of directional shading on lights"}; cvar_t r_shadow_gloss = {CVAR_SAVE, "r_shadow_gloss", "1", "0 disables gloss (specularity) rendering, 1 uses gloss if textures are found, 2 forces a flat metallic specular effect on everything without textures (similar to tenebrae)"}; cvar_t r_shadow_gloss2intensity = {0, "r_shadow_gloss2intensity", "0.125", "how bright the forced flat gloss should look if r_shadow_gloss is 2"}; @@ -306,10 +299,9 @@ cvar_t r_shadow_realtime_world_shadows = {CVAR_SAVE, "r_shadow_realtime_world_sh cvar_t r_shadow_realtime_world_compile = {0, "r_shadow_realtime_world_compile", "1", "enables compilation of world lights for higher performance rendering"}; cvar_t r_shadow_realtime_world_compileshadow = {0, "r_shadow_realtime_world_compileshadow", "1", "enables compilation of shadows from world lights for higher performance rendering"}; cvar_t r_shadow_realtime_world_compilesvbsp = {0, "r_shadow_realtime_world_compilesvbsp", "1", "enables svbsp optimization during compilation (slower than compileportalculling but more exact)"}; -cvar_t r_shadow_realtime_world_compileportalculling = {0, "r_shadow_realtime_world_compileportalculling", "0", "enables portal-based culling optimization during compilation (overrides compilesvbsp)"}; +cvar_t r_shadow_realtime_world_compileportalculling = {0, "r_shadow_realtime_world_compileportalculling", "1", "enables portal-based culling optimization during compilation (overrides compilesvbsp)"}; cvar_t r_shadow_scissor = {0, "r_shadow_scissor", "1", "use scissor optimization of light rendering (restricts rendering to the portion of the screen affected by the light)"}; cvar_t r_shadow_shadowmapping = {CVAR_SAVE, "r_shadow_shadowmapping", "0", "enables use of shadowmapping (depth texture sampling) instead of stencil shadow volumes, requires gl_fbo 1"}; -cvar_t r_shadow_shadowmapping_texturetype = {CVAR_SAVE, "r_shadow_shadowmapping_texturetype", "-1", "shadowmap texture types: -1 = auto-select, 0 = 2D, 1 = rectangle, 2 = cubemap"}; cvar_t r_shadow_shadowmapping_filterquality = {CVAR_SAVE, "r_shadow_shadowmapping_filterquality", "-1", "shadowmap filter modes: -1 = auto-select, 0 = no filtering, 1 = bilinear, 2 = bilinear 2x2 blur (fast), 3 = 3x3 blur (moderate), 4 = 4x4 blur (slow)"}; cvar_t r_shadow_shadowmapping_depthbits = {CVAR_SAVE, "r_shadow_shadowmapping_depthbits", "24", "requested minimum shadowmap texture depth bits"}; cvar_t r_shadow_shadowmapping_vsdct = {CVAR_SAVE, "r_shadow_shadowmapping_vsdct", "1", "enables use of virtual shadow depth cube texture"}; @@ -323,11 +315,38 @@ cvar_t r_shadow_shadowmapping_nearclip = {CVAR_SAVE, "r_shadow_shadowmapping_nea cvar_t r_shadow_shadowmapping_bias = {CVAR_SAVE, "r_shadow_shadowmapping_bias", "0.03", "shadowmap bias parameter (this is multiplied by nearclip * 1024 / lodsize)"}; cvar_t r_shadow_shadowmapping_polygonfactor = {CVAR_SAVE, "r_shadow_shadowmapping_polygonfactor", "2", "slope-dependent shadowmapping bias"}; cvar_t r_shadow_shadowmapping_polygonoffset = {CVAR_SAVE, "r_shadow_shadowmapping_polygonoffset", "0", "constant shadowmapping bias"}; +cvar_t r_shadow_sortsurfaces = {0, "r_shadow_sortsurfaces", "1", "improve performance by sorting illuminated surfaces by texture"}; cvar_t r_shadow_polygonfactor = {0, "r_shadow_polygonfactor", "0", "how much to enlarge shadow volume polygons when rendering (should be 0!)"}; cvar_t r_shadow_polygonoffset = {0, "r_shadow_polygonoffset", "1", "how much to push shadow volumes into the distance when rendering, to reduce chances of zfighting artifacts (should not be less than 0)"}; cvar_t r_shadow_texture3d = {0, "r_shadow_texture3d", "1", "use 3D voxel textures for spherical attenuation rather than cylindrical (does not affect OpenGL 2.0 render path)"}; +cvar_t r_shadow_particletrace = {CVAR_SAVE, "r_shadow_particletrace", "0", "perform particle tracing for indirect lighting (Global Illumination / radiosity), requires r_shadow_deferred 1, requires r_shadow_realtime_world 1, EXTREMELY SLOW"}; +cvar_t r_shadow_particletrace_intensity = {CVAR_SAVE, "r_shadow_particletrace_intensity", "128", "overall brightness of particle traced radiosity"}; +cvar_t r_shadow_particletrace_size = {CVAR_SAVE, "r_shadow_particletrace_size", "32", "particles produce bounce lights of this radius"}; +cvar_t r_shadow_particletrace_radiusscale = {CVAR_SAVE, "r_shadow_particletrace_radiusscale", "1", "particles stop at this fraction of light radius"}; +cvar_t r_shadow_particletrace_maxbounce = {CVAR_SAVE, "r_shadow_particletrace_maxbounce", "1", "maximum number of bounces for a particle (minimum is 1)"}; +cvar_t r_shadow_particletrace_bounceintensity = {CVAR_SAVE, "r_shadow_particletrace_bounceintensity", "1", "amount of energy carried over after each bounce"}; +cvar_t r_shadow_particletrace_particlespacing = {CVAR_SAVE, "r_shadow_particletrace_particlespacing", "0.25", "overlap setting in terms of particle size, this affects how many particles are used"}; +cvar_t r_shadow_particletrace_updatepercentage = {CVAR_SAVE, "r_shadow_particletrace_updatepercentage", "0.01", "update this fraction of the particles of a light each frame (0 = best performance)"}; +cvar_t r_shadow_bouncegrid = {CVAR_SAVE, "r_shadow_bouncegrid", "0", "perform particle tracing for indirect lighting (Global Illumination / radiosity) using a 3D texture covering the scene, requires r_shadow_realtime_world 1"}; +cvar_t r_shadow_bouncegrid_bounceanglediffuse = {CVAR_SAVE, "r_shadow_bouncegrid_bounceanglediffuse", "0", "use random bounce direction rather than true reflection, makes some corner areas dark"}; +cvar_t r_shadow_bouncegrid_dlightparticlemultiplier = {CVAR_SAVE, "r_shadow_bouncegrid_dlightparticlemultiplier", "0", "if set to a high value like 16 this can make dlights look great, but 0 is recommended for performance reasons"}; +cvar_t r_shadow_bouncegrid_hitmodels = {CVAR_SAVE, "r_shadow_bouncegrid_hitmodels", "0", "enables hitting character model geometry (SLOW)"}; +cvar_t r_shadow_bouncegrid_intensity = {CVAR_SAVE, "r_shadow_bouncegrid_intensity", "1", "overall brightness of bouncegrid texture"}; +cvar_t r_shadow_bouncegrid_lightradiusscale = {CVAR_SAVE, "r_shadow_bouncegrid_lightradiusscale", "2", "particles stop at this fraction of light radius (can be more than 1)"}; +cvar_t r_shadow_bouncegrid_maxbounce = {CVAR_SAVE, "r_shadow_bouncegrid_maxbounce", "3", "maximum number of bounces for a particle (minimum is 1)"}; +cvar_t r_shadow_bouncegrid_particlebounceintensity = {CVAR_SAVE, "r_shadow_bouncegrid_particlebounceintensity", "1", "amount of energy carried over after each bounce"}; +cvar_t r_shadow_bouncegrid_particleintensity = {CVAR_SAVE, "r_shadow_bouncegrid_particleintensity", "4", "brightness of particles contributing to bouncegrid texture"}; +cvar_t r_shadow_bouncegrid_particlespacing = {CVAR_SAVE, "r_shadow_bouncegrid_particlespacing", "32", "emit one particle per this many units (squared) of radius (squared)"}; +cvar_t r_shadow_bouncegrid_spacingx = {CVAR_SAVE, "r_shadow_bouncegrid_spacingx", "64", "unit size of bouncegrid pixel on X axis"}; +cvar_t r_shadow_bouncegrid_spacingy = {CVAR_SAVE, "r_shadow_bouncegrid_spacingy", "64", "unit size of bouncegrid pixel on Y axis"}; +cvar_t r_shadow_bouncegrid_spacingz = {CVAR_SAVE, "r_shadow_bouncegrid_spacingz", "64", "unit size of bouncegrid pixel on Z axis"}; +cvar_t r_shadow_bouncegrid_stablerandom = {CVAR_SAVE, "r_shadow_bouncegrid_stablerandom", "1", "make particle distribution consistent from frame to frame"}; +cvar_t r_shadow_bouncegrid_updateinterval = {CVAR_SAVE, "r_shadow_bouncegrid_updateinterval", "0", "update bouncegrid texture once per this many seconds, useful values are 0, 0.05, or 1000000"}; +cvar_t r_shadow_bouncegrid_x = {CVAR_SAVE, "r_shadow_bouncegrid_x", "64", "maximum texture size of bouncegrid on X axis"}; +cvar_t r_shadow_bouncegrid_y = {CVAR_SAVE, "r_shadow_bouncegrid_y", "64", "maximum texture size of bouncegrid on Y axis"}; +cvar_t r_shadow_bouncegrid_z = {CVAR_SAVE, "r_shadow_bouncegrid_z", "32", "maximum texture size of bouncegrid on Z axis"}; cvar_t r_coronas = {CVAR_SAVE, "r_coronas", "1", "brightness of corona flare effects around certain lights, 0 disables corona effects"}; -cvar_t r_coronas_occlusionsizescale = {CVAR_SAVE, "r_coronas_occlusionsizescale", "0.1", "size of light source for corona occlusion checksm the proportion of hidden pixels controls corona intensity"}; +cvar_t r_coronas_occlusionsizescale = {CVAR_SAVE, "r_coronas_occlusionsizescale", "0.1", "size of light source for corona occlusion checksum the proportion of hidden pixels controls corona intensity"}; cvar_t r_coronas_occlusionquery = {CVAR_SAVE, "r_coronas_occlusionquery", "1", "use GL_ARB_occlusion_query extension if supported (fades coronas according to visibility)"}; cvar_t gl_flashblend = {CVAR_SAVE, "gl_flashblend", "0", "render bright coronas for dynamic lights instead of actual lighting, fast but ugly"}; cvar_t gl_ext_separatestencil = {0, "gl_ext_separatestencil", "1", "make use of OpenGL 2.0 glStencilOpSeparate or GL_ATI_separate_stencil extension"}; @@ -339,6 +358,15 @@ cvar_t r_editlights_cursorpushoff = {0, "r_editlights_cursorpushoff", "4", "how cvar_t r_editlights_cursorgrid = {0, "r_editlights_cursorgrid", "4", "snaps cursor to this grid size"}; cvar_t r_editlights_quakelightsizescale = {CVAR_SAVE, "r_editlights_quakelightsizescale", "1", "changes size of light entities loaded from a map"}; +rtexture_t *r_shadow_bouncegridtexture; +matrix4x4_t r_shadow_bouncegridmatrix; +vec_t r_shadow_bouncegridintensity; +static double r_shadow_bouncegridtime; +static int r_shadow_bouncegridresolution[3]; +static int r_shadow_bouncegridnumpixels; +static unsigned char *r_shadow_bouncegridpixels; +static unsigned short *r_shadow_bouncegridhighpixels; + // note the table actually includes one more value, just to avoid the need to clamp the distance index due to minor math error #define ATTENTABLESIZE 256 // 1D gradient, 2D circle and 3D sphere attenuation textures @@ -380,9 +408,8 @@ skinframe_t *r_editlights_sprselection; void R_Shadow_SetShadowMode(void) { r_shadow_shadowmapmaxsize = bound(1, r_shadow_shadowmapping_maxsize.integer, (int)vid.maxtexturesize_2d / 4); - r_shadow_shadowmapvsdct = r_shadow_shadowmapping_vsdct.integer != 0; + r_shadow_shadowmapvsdct = r_shadow_shadowmapping_vsdct.integer != 0 && vid.renderpath == RENDERPATH_GL20; r_shadow_shadowmapfilterquality = r_shadow_shadowmapping_filterquality.integer; - r_shadow_shadowmaptexturetype = r_shadow_shadowmapping_texturetype.integer; r_shadow_shadowmapdepthbits = r_shadow_shadowmapping_depthbits.integer; r_shadow_shadowmapborder = bound(0, r_shadow_shadowmapping_bordersize.integer, 16); r_shadow_shadowmaplod = -1; @@ -428,37 +455,12 @@ void R_Shadow_SetShadowMode(void) break; } } - switch (r_shadow_shadowmaptexturetype) - { - case 0: - r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAP2D; - break; - case 1: - r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE; - break; - case 2: - r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE; - break; - default: - if((vid.support.amd_texture_texture4 || vid.support.arb_texture_gather) && r_shadow_shadowmappcf && !r_shadow_shadowmapsampler) - r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAP2D; - else if(vid.support.arb_texture_rectangle) - r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE; - else - r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAP2D; - break; - } - // Cg has very little choice in depth texture sampling - if (vid.cgcontext) - { - r_shadow_shadowmapsampler = false; - r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAP2D; - } + r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAP2D; break; - case RENDERPATH_CGGL: case RENDERPATH_D3D9: case RENDERPATH_D3D10: case RENDERPATH_D3D11: + case RENDERPATH_SOFT: r_shadow_shadowmapsampler = false; r_shadow_shadowmappcf = 1; r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAP2D; @@ -467,6 +469,8 @@ void R_Shadow_SetShadowMode(void) break; case RENDERPATH_GL11: break; + case RENDERPATH_GLES2: + break; } } } @@ -476,8 +480,6 @@ qboolean R_Shadow_ShadowMappingEnabled(void) switch (r_shadow_shadowmode) { case R_SHADOW_SHADOWMODE_SHADOWMAP2D: - case R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE: - case R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE: return true; default: return false; @@ -486,33 +488,16 @@ qboolean R_Shadow_ShadowMappingEnabled(void) void R_Shadow_FreeShadowMaps(void) { - int i; - R_Shadow_SetShadowMode(); - R_Mesh_DestroyFramebufferObject(r_shadow_fborectangle); - R_Mesh_DestroyFramebufferObject(r_shadow_fbo2d); - for (i = 0;i < R_SHADOW_SHADOWMAP_NUMCUBEMAPS;i++) - R_Mesh_DestroyFramebufferObject(r_shadow_fbocubeside[i]); - r_shadow_fborectangle = 0; r_shadow_fbo2d = 0; - memset(r_shadow_fbocubeside, 0, sizeof(r_shadow_fbocubeside)); - - if (r_shadow_shadowmaprectangletexture) - R_FreeTexture(r_shadow_shadowmaprectangletexture); - r_shadow_shadowmaprectangletexture = NULL; if (r_shadow_shadowmap2dtexture) R_FreeTexture(r_shadow_shadowmap2dtexture); r_shadow_shadowmap2dtexture = NULL; - for (i = 0;i < R_SHADOW_SHADOWMAP_NUMCUBEMAPS;i++) - if (r_shadow_shadowmapcubetexture[i]) - R_FreeTexture(r_shadow_shadowmapcubetexture[i]); - memset(r_shadow_shadowmapcubetexture, 0, sizeof(r_shadow_shadowmapcubetexture)); - if (r_shadow_shadowmap2dcolortexture) R_FreeTexture(r_shadow_shadowmap2dcolortexture); r_shadow_shadowmap2dcolortexture = NULL; @@ -525,27 +510,26 @@ void R_Shadow_FreeShadowMaps(void) void r_shadow_start(void) { // allocate vertex processing arrays + r_shadow_bouncegridpixels = NULL; + r_shadow_bouncegridhighpixels = NULL; + r_shadow_bouncegridnumpixels = 0; + r_shadow_bouncegridtexture = NULL; r_shadow_attenuationgradienttexture = NULL; r_shadow_attenuation2dtexture = NULL; r_shadow_attenuation3dtexture = NULL; r_shadow_shadowmode = R_SHADOW_SHADOWMODE_STENCIL; - r_shadow_shadowmaprectangletexture = NULL; r_shadow_shadowmap2dtexture = NULL; - memset(r_shadow_shadowmapcubetexture, 0, sizeof(r_shadow_shadowmapcubetexture)); r_shadow_shadowmap2dcolortexture = NULL; r_shadow_shadowmapvsdcttexture = NULL; r_shadow_shadowmapmaxsize = 0; r_shadow_shadowmapsize = 0; r_shadow_shadowmaplod = 0; r_shadow_shadowmapfilterquality = -1; - r_shadow_shadowmaptexturetype = -1; r_shadow_shadowmapdepthbits = 0; r_shadow_shadowmapvsdct = false; r_shadow_shadowmapsampler = false; r_shadow_shadowmappcf = 0; - r_shadow_fborectangle = 0; r_shadow_fbo2d = 0; - memset(r_shadow_fbocubeside, 0, sizeof(r_shadow_fbocubeside)); R_Shadow_FreeShadowMaps(); @@ -601,6 +585,10 @@ void r_shadow_shutdown(void) r_shadow_prepass_width = r_shadow_prepass_height = 0; CHECKGLERROR + r_shadow_bouncegridtexture = NULL; + r_shadow_bouncegridpixels = NULL; + r_shadow_bouncegridhighpixels = NULL; + r_shadow_bouncegridnumpixels = 0; r_shadow_attenuationgradienttexture = NULL; r_shadow_attenuation2dtexture = NULL; r_shadow_attenuation3dtexture = NULL; @@ -668,6 +656,7 @@ void r_shadow_shutdown(void) void r_shadow_newmap(void) { + if (r_shadow_bouncegridtexture) R_FreeTexture(r_shadow_bouncegridtexture);r_shadow_bouncegridtexture = NULL; if (r_shadow_lightcorona) R_SkinFrame_MarkUsed(r_shadow_lightcorona); if (r_editlights_sprcursor) R_SkinFrame_MarkUsed(r_editlights_sprcursor); if (r_editlights_sprlight) R_SkinFrame_MarkUsed(r_editlights_sprlight); @@ -683,6 +672,7 @@ void R_Shadow_Init(void) { Cvar_RegisterVariable(&r_shadow_bumpscale_basetexture); Cvar_RegisterVariable(&r_shadow_bumpscale_bumpmap); + Cvar_RegisterVariable(&r_shadow_usebihculling); Cvar_RegisterVariable(&r_shadow_usenormalmap); Cvar_RegisterVariable(&r_shadow_debuglight); Cvar_RegisterVariable(&r_shadow_deferred); @@ -714,7 +704,6 @@ void R_Shadow_Init(void) Cvar_RegisterVariable(&r_shadow_scissor); Cvar_RegisterVariable(&r_shadow_shadowmapping); Cvar_RegisterVariable(&r_shadow_shadowmapping_vsdct); - Cvar_RegisterVariable(&r_shadow_shadowmapping_texturetype); Cvar_RegisterVariable(&r_shadow_shadowmapping_filterquality); Cvar_RegisterVariable(&r_shadow_shadowmapping_depthbits); Cvar_RegisterVariable(&r_shadow_shadowmapping_precision); @@ -727,20 +716,42 @@ void R_Shadow_Init(void) Cvar_RegisterVariable(&r_shadow_shadowmapping_bias); Cvar_RegisterVariable(&r_shadow_shadowmapping_polygonfactor); Cvar_RegisterVariable(&r_shadow_shadowmapping_polygonoffset); + Cvar_RegisterVariable(&r_shadow_sortsurfaces); Cvar_RegisterVariable(&r_shadow_polygonfactor); Cvar_RegisterVariable(&r_shadow_polygonoffset); Cvar_RegisterVariable(&r_shadow_texture3d); + Cvar_RegisterVariable(&r_shadow_particletrace); + Cvar_RegisterVariable(&r_shadow_particletrace_intensity); + Cvar_RegisterVariable(&r_shadow_particletrace_size); + Cvar_RegisterVariable(&r_shadow_particletrace_radiusscale); + Cvar_RegisterVariable(&r_shadow_particletrace_maxbounce); + Cvar_RegisterVariable(&r_shadow_particletrace_bounceintensity); + Cvar_RegisterVariable(&r_shadow_particletrace_particlespacing); + Cvar_RegisterVariable(&r_shadow_particletrace_updatepercentage); + Cvar_RegisterVariable(&r_shadow_bouncegrid); + Cvar_RegisterVariable(&r_shadow_bouncegrid_bounceanglediffuse); + Cvar_RegisterVariable(&r_shadow_bouncegrid_dlightparticlemultiplier); + Cvar_RegisterVariable(&r_shadow_bouncegrid_hitmodels); + Cvar_RegisterVariable(&r_shadow_bouncegrid_intensity); + Cvar_RegisterVariable(&r_shadow_bouncegrid_lightradiusscale); + Cvar_RegisterVariable(&r_shadow_bouncegrid_maxbounce); + Cvar_RegisterVariable(&r_shadow_bouncegrid_particlebounceintensity); + Cvar_RegisterVariable(&r_shadow_bouncegrid_particleintensity); + Cvar_RegisterVariable(&r_shadow_bouncegrid_particlespacing); + Cvar_RegisterVariable(&r_shadow_bouncegrid_spacingx); + Cvar_RegisterVariable(&r_shadow_bouncegrid_spacingy); + Cvar_RegisterVariable(&r_shadow_bouncegrid_spacingz); + Cvar_RegisterVariable(&r_shadow_bouncegrid_stablerandom); + Cvar_RegisterVariable(&r_shadow_bouncegrid_updateinterval); + Cvar_RegisterVariable(&r_shadow_bouncegrid_x); + Cvar_RegisterVariable(&r_shadow_bouncegrid_y); + Cvar_RegisterVariable(&r_shadow_bouncegrid_z); Cvar_RegisterVariable(&r_coronas); Cvar_RegisterVariable(&r_coronas_occlusionsizescale); Cvar_RegisterVariable(&r_coronas_occlusionquery); Cvar_RegisterVariable(&gl_flashblend); Cvar_RegisterVariable(&gl_ext_separatestencil); Cvar_RegisterVariable(&gl_ext_stenciltwoside); - if (gamemode == GAME_TENEBRAE) - { - Cvar_SetValue("r_shadow_gloss", 2); - Cvar_SetValue("r_shadow_bumpscale_basetexture", 4); - } R_Shadow_EditLights_Init(); Mem_ExpandableArray_NewArray(&r_shadow_worldlightsarray, r_main_mempool, sizeof(dlight_t), 128); maxshadowtriangles = 0; @@ -1333,7 +1344,7 @@ void R_Shadow_VolumeFromList(int numverts, int numtris, const float *invertex3f, else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_VISIBLEVOLUMES) { tris = R_Shadow_ConstructShadowVolume_ZFail(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris); - R_Mesh_PrepareVertices_Position_Arrays(outverts, shadowvertex3f); + R_Mesh_PrepareVertices_Vertex3f(outverts, shadowvertex3f, NULL); R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, NULL, NULL, 0); } else @@ -1367,7 +1378,7 @@ void R_Shadow_VolumeFromList(int numverts, int numtris, const float *invertex3f, GL_CullFace(r_refdef.view.cullface_back); R_SetStencil(true, 255, GL_KEEP, GL_INCR, GL_KEEP, GL_ALWAYS, 128, 255); } - R_Mesh_PrepareVertices_Position_Arrays(outverts, shadowvertex3f); + R_Mesh_PrepareVertices_Vertex3f(outverts, shadowvertex3f, NULL); R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, NULL, NULL, 0); } } @@ -1903,8 +1914,6 @@ void R_Shadow_ValidateCvars(void) Cvar_SetValueQuick(&gl_ext_stenciltwoside, 0); } -//static const r_vertexposition_t resetvertexposition[3] = {{0, 0, 0}}; - void R_Shadow_RenderMode_Begin(void) { #if 0 @@ -1921,7 +1930,6 @@ void R_Shadow_RenderMode_Begin(void) CHECKGLERROR R_Mesh_ResetTextureState(); -// R_Mesh_PrepareVertices_Position(0, resetvertexposition, NULL); GL_BlendFunc(GL_ONE, GL_ZERO); GL_DepthRange(0, 1); GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset); @@ -1951,10 +1959,11 @@ void R_Shadow_RenderMode_Begin(void) switch(vid.renderpath) { case RENDERPATH_GL20: - case RENDERPATH_CGGL: case RENDERPATH_D3D9: case RENDERPATH_D3D10: case RENDERPATH_D3D11: + case RENDERPATH_SOFT: + case RENDERPATH_GLES2: r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_GLSL; break; case RENDERPATH_GL13: @@ -1992,7 +2001,6 @@ void R_Shadow_RenderMode_Reset(void) R_SetViewport(&r_refdef.view.viewport); GL_Scissor(r_shadow_lightscissor[0], r_shadow_lightscissor[1], r_shadow_lightscissor[2], r_shadow_lightscissor[3]); R_Mesh_ResetTextureState(); -// R_Mesh_PrepareVertices_Position(0, resetvertexposition, NULL); GL_DepthRange(0, 1); GL_DepthTest(true); GL_DepthMask(false); @@ -2005,8 +2013,6 @@ void R_Shadow_RenderMode_Reset(void) GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1); GL_BlendFunc(GL_ONE, GL_ZERO); R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1); - r_shadow_usingshadowmaprect = false; - r_shadow_usingshadowmapcube = false; r_shadow_usingshadowmap2d = false; r_shadow_usingshadowmaportho = false; R_SetStencil(false, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_ALWAYS, 128, 255); @@ -2086,20 +2092,6 @@ static void R_Shadow_MakeShadowMap(int side, int size) break; } break; - case R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE: - if (r_shadow_shadowmaprectangletexture) return; - r_shadow_shadowmaprectangletexture = R_LoadTextureShadowMapRectangle(r_shadow_texturepool, "shadowmap", size*2, size*3, r_shadow_shadowmapdepthbits, r_shadow_shadowmapsampler); - r_shadow_fborectangle = R_Mesh_CreateFramebufferObject(r_shadow_shadowmaprectangletexture, NULL, NULL, NULL, NULL); - break; - case R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE: - if (r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]) return; - r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod] = R_LoadTextureShadowMapCube(r_shadow_texturepool, "shadowmapcube", size, r_shadow_shadowmapdepthbits, r_shadow_shadowmapsampler); - // special trick to get an empty fbo we configure ourselves... - r_shadow_fbocubeside[r_shadow_shadowmaplod] = R_Mesh_CreateFramebufferObject(NULL, NULL, NULL, NULL, NULL); - R_Mesh_SetRenderTargets(r_shadow_fbocubeside[r_shadow_shadowmaplod], NULL, NULL, NULL, NULL, NULL); - if (qglFramebufferTexture2DEXT) - qglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB + side, R_GetTexture(r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]), 0);CHECKGLERROR - break; default: return; } @@ -2121,13 +2113,13 @@ static void R_Shadow_MakeShadowMap(int side, int size) } } -static float testcolor[4] = {0,1,0,1}; void R_Shadow_RenderMode_ShadowMap(int side, int clear, int size) { float nearclip, farclip, bias; r_viewport_t viewport; int flipped; GLuint fbo = 0; + float clearcolor[4]; nearclip = r_shadow_shadowmapping_nearclip.value / rsurface.rtlight->radius; farclip = 1.0f; bias = r_shadow_shadowmapping_bias.value * nearclip * (1024.0f / size);// * rsurface.rtlight->radius; @@ -2135,58 +2127,24 @@ void R_Shadow_RenderMode_ShadowMap(int side, int clear, int size) r_shadow_shadowmap_parameters[3] = 0.5f + 0.5f * (farclip + nearclip) / (farclip - nearclip); r_shadow_shadowmapside = side; r_shadow_shadowmapsize = size; - switch (r_shadow_shadowmode) - { - case R_SHADOW_SHADOWMODE_SHADOWMAP2D: - r_shadow_shadowmap_parameters[0] = 0.5f * (size - r_shadow_shadowmapborder); - r_shadow_shadowmap_parameters[2] = r_shadow_shadowmapvsdct ? 2.5f*size : size; - R_Viewport_InitRectSideView(&viewport, &rsurface.rtlight->matrix_lighttoworld, side, size, r_shadow_shadowmapborder, nearclip, farclip, NULL); - if (r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAP2D) goto init_done; - - // complex unrolled cube approach (more flexible) - if (r_shadow_shadowmapvsdct && !r_shadow_shadowmapvsdcttexture) - R_Shadow_MakeVSDCT(); - if (!r_shadow_shadowmap2dtexture) - R_Shadow_MakeShadowMap(side, r_shadow_shadowmapmaxsize); - if (r_shadow_shadowmap2dtexture) fbo = r_shadow_fbo2d; - r_shadow_shadowmap_texturescale[0] = 1.0f / R_TextureWidth(r_shadow_shadowmap2dtexture); - r_shadow_shadowmap_texturescale[1] = 1.0f / R_TextureHeight(r_shadow_shadowmap2dtexture); - r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAP2D; - break; - case R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE: - r_shadow_shadowmap_parameters[0] = 0.5f * (size - r_shadow_shadowmapborder); - r_shadow_shadowmap_parameters[2] = r_shadow_shadowmapvsdct ? 2.5f*size : size; - R_Viewport_InitRectSideView(&viewport, &rsurface.rtlight->matrix_lighttoworld, side, size, r_shadow_shadowmapborder, nearclip, farclip, NULL); - if (r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAPRECTANGLE) goto init_done; - - // complex unrolled cube approach (more flexible) - if (r_shadow_shadowmapvsdct && !r_shadow_shadowmapvsdcttexture) - R_Shadow_MakeVSDCT(); - if (!r_shadow_shadowmaprectangletexture) - R_Shadow_MakeShadowMap(side, r_shadow_shadowmapmaxsize); - if(r_shadow_shadowmaprectangletexture) fbo = r_shadow_fborectangle; - r_shadow_shadowmap_texturescale[0] = 1.0f; - r_shadow_shadowmap_texturescale[1] = 1.0f; - r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAPRECTANGLE; - break; - case R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE: - r_shadow_shadowmap_parameters[0] = 1.0f; - r_shadow_shadowmap_parameters[2] = 1.0f; - R_Viewport_InitCubeSideView(&viewport, &rsurface.rtlight->matrix_lighttoworld, side, size, nearclip, farclip, NULL); - if (r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAPCUBESIDE) goto init_done; - - // simple cube approach - if (!r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]) - R_Shadow_MakeShadowMap(side, size); - if (r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]) fbo = r_shadow_fbocubeside[r_shadow_shadowmaplod]; - r_shadow_shadowmap_texturescale[0] = 0.0f; - r_shadow_shadowmap_texturescale[1] = 0.0f; - r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAPCUBESIDE; - break; - default: - break; - } + r_shadow_shadowmap_parameters[0] = 0.5f * (size - r_shadow_shadowmapborder); + r_shadow_shadowmap_parameters[2] = r_shadow_shadowmapvsdct ? 2.5f*size : size; + R_Viewport_InitRectSideView(&viewport, &rsurface.rtlight->matrix_lighttoworld, side, size, r_shadow_shadowmapborder, nearclip, farclip, NULL); + if (r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAP2D) goto init_done; + + // complex unrolled cube approach (more flexible) + if (r_shadow_shadowmapvsdct && !r_shadow_shadowmapvsdcttexture) + R_Shadow_MakeVSDCT(); + if (!r_shadow_shadowmap2dtexture) + R_Shadow_MakeShadowMap(side, r_shadow_shadowmapmaxsize); + if (r_shadow_shadowmap2dtexture) fbo = r_shadow_fbo2d; + r_shadow_shadowmap_texturescale[0] = 1.0f / R_TextureWidth(r_shadow_shadowmap2dtexture); + r_shadow_shadowmap_texturescale[1] = 1.0f / R_TextureHeight(r_shadow_shadowmap2dtexture); + r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAP2D; + + R_Mesh_ResetTextureState(); + R_Mesh_ResetRenderTargets(); R_Shadow_RenderMode_Reset(); if (fbo) { @@ -2201,79 +2159,62 @@ void R_Shadow_RenderMode_ShadowMap(int side, int clear, int size) init_done: R_SetViewport(&viewport); - switch (r_shadow_rendermode) + flipped = (side & 1) ^ (side >> 2); + r_refdef.view.cullface_front = flipped ? r_shadow_cullface_back : r_shadow_cullface_front; + r_refdef.view.cullface_back = flipped ? r_shadow_cullface_front : r_shadow_cullface_back; + switch(vid.renderpath) { - case R_SHADOW_RENDERMODE_SHADOWMAP2D: - case R_SHADOW_RENDERMODE_SHADOWMAPRECTANGLE: - flipped = (side & 1) ^ (side >> 2); - r_refdef.view.cullface_front = flipped ? r_shadow_cullface_back : r_shadow_cullface_front; - r_refdef.view.cullface_back = flipped ? r_shadow_cullface_front : r_shadow_cullface_back; - switch(vid.renderpath) + case RENDERPATH_GL11: + case RENDERPATH_GL13: + case RENDERPATH_GL20: + case RENDERPATH_SOFT: + case RENDERPATH_GLES2: + GL_CullFace(r_refdef.view.cullface_back); + // OpenGL lets us scissor larger than the viewport, so go ahead and clear all views at once + if ((clear & ((2 << side) - 1)) == (1 << side)) // only clear if the side is the first in the mask { - case RENDERPATH_GL11: - case RENDERPATH_GL13: - case RENDERPATH_GL20: - case RENDERPATH_CGGL: - GL_CullFace(r_refdef.view.cullface_back); - // OpenGL lets us scissor larger than the viewport, so go ahead and clear all views at once - if ((clear & ((2 << side) - 1)) == (1 << side)) // only clear if the side is the first in the mask - { - // get tightest scissor rectangle that encloses all viewports in the clear mask - int x1 = clear & 0x15 ? 0 : size; - int x2 = clear & 0x2A ? 2 * size : size; - int y1 = clear & 0x03 ? 0 : (clear & 0xC ? size : 2 * size); - int y2 = clear & 0x30 ? 3 * size : (clear & 0xC ? 2 * size : size); - GL_Scissor(x1, y1, x2 - x1, y2 - y1); - GL_Clear(GL_DEPTH_BUFFER_BIT, NULL, 1.0f, 0); - } - GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height); - break; - case RENDERPATH_D3D9: - // completely different meaning than in OpenGL path - r_shadow_shadowmap_parameters[1] = 0; - r_shadow_shadowmap_parameters[3] = -bias; - // we invert the cull mode because we flip the projection matrix - // NOTE: this actually does nothing because the DrawShadowMap code sets it to doublesided... - GL_CullFace(r_refdef.view.cullface_front); - // D3D considers it an error to use a scissor larger than the viewport... clear just this view - GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height); - if (r_shadow_shadowmapsampler) - { - GL_ColorMask(0,0,0,0); - if (clear) - GL_Clear(GL_DEPTH_BUFFER_BIT, testcolor, 1.0f, 0); - } - else - { - GL_ColorMask(1,1,1,1); - if (clear) - GL_Clear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT, testcolor, 1.0f, 0); - } - break; - case RENDERPATH_D3D10: - case RENDERPATH_D3D11: - // D3D considers it an error to use a scissor larger than the viewport... clear just this view - GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height); - GL_ColorMask(0,0,0,0); - if (clear) - GL_Clear(GL_DEPTH_BUFFER_BIT, NULL, 1.0f, 0); - break; + // get tightest scissor rectangle that encloses all viewports in the clear mask + int x1 = clear & 0x15 ? 0 : size; + int x2 = clear & 0x2A ? 2 * size : size; + int y1 = clear & 0x03 ? 0 : (clear & 0xC ? size : 2 * size); + int y2 = clear & 0x30 ? 3 * size : (clear & 0xC ? 2 * size : size); + GL_Scissor(x1, y1, x2 - x1, y2 - y1); + GL_Clear(GL_DEPTH_BUFFER_BIT, NULL, 1.0f, 0); } - break; - case R_SHADOW_RENDERMODE_SHADOWMAPCUBESIDE: - if (qglFramebufferTexture2DEXT) - qglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB + side, R_GetTexture(r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]), 0);CHECKGLERROR GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height); - if (clear) - GL_Clear(GL_DEPTH_BUFFER_BIT, NULL, 1.0f, 0); break; - default: + case RENDERPATH_D3D9: + case RENDERPATH_D3D10: + case RENDERPATH_D3D11: + Vector4Set(clearcolor, 1,1,1,1); + // completely different meaning than in OpenGL path + r_shadow_shadowmap_parameters[1] = 0; + r_shadow_shadowmap_parameters[3] = -bias; + // we invert the cull mode because we flip the projection matrix + // NOTE: this actually does nothing because the DrawShadowMap code sets it to doublesided... + GL_CullFace(r_refdef.view.cullface_front); + // D3D considers it an error to use a scissor larger than the viewport... clear just this view + GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height); + if (r_shadow_shadowmapsampler) + { + GL_ColorMask(0,0,0,0); + if (clear) + GL_Clear(GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0); + } + else + { + GL_ColorMask(1,1,1,1); + if (clear) + GL_Clear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT, clearcolor, 1.0f, 0); + } break; } } void R_Shadow_RenderMode_Lighting(qboolean stenciltest, qboolean transparent, qboolean shadowmapping) { + R_Mesh_ResetTextureState(); + R_Mesh_ResetRenderTargets(); if (transparent) { r_shadow_lightscissor[0] = r_refdef.view.viewport.x; @@ -2288,23 +2229,7 @@ void R_Shadow_RenderMode_Lighting(qboolean stenciltest, qboolean transparent, qb // do global setup needed for the chosen lighting mode if (r_shadow_rendermode == R_SHADOW_RENDERMODE_LIGHT_GLSL) GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 0); - if (shadowmapping) - { - switch (r_shadow_shadowmode) - { - case R_SHADOW_SHADOWMODE_SHADOWMAP2D: - r_shadow_usingshadowmap2d = true; - break; - case R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE: - r_shadow_usingshadowmaprect = true; - break; - case R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE: - r_shadow_usingshadowmapcube = true; - break; - default: - break; - } - } + r_shadow_usingshadowmap2d = shadowmapping; r_shadow_rendermode = r_shadow_lightingrendermode; // only draw light where this geometry was already rendered AND the // stencil is 128 (values other than this mean shadow) @@ -2349,25 +2274,9 @@ void R_Shadow_RenderMode_DrawDeferredLight(qboolean stenciltest, qboolean shadow // only draw light where this geometry was already rendered AND the // stencil is 128 (values other than this mean shadow) R_SetStencil(stenciltest, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_EQUAL, 128, 255); - R_Mesh_SetRenderTargets(r_shadow_prepasslightingfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL); + R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusespecularfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL); - if (shadowmapping) - { - switch (r_shadow_shadowmode) - { - case R_SHADOW_SHADOWMODE_SHADOWMAP2D: - r_shadow_usingshadowmap2d = true; - break; - case R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE: - r_shadow_usingshadowmaprect = true; - break; - case R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE: - r_shadow_usingshadowmapcube = true; - break; - default: - break; - } - } + r_shadow_usingshadowmap2d = shadowmapping; // render the lighting R_SetupShader_DeferredLight(rsurface.rtlight); @@ -2380,10 +2289,501 @@ void R_Shadow_RenderMode_DrawDeferredLight(qboolean stenciltest, qboolean shadow GL_DepthTest(true); GL_DepthFunc(GL_GREATER); GL_CullFace(r_refdef.view.cullface_back); - R_Mesh_PrepareVertices_Position_Arrays(8, vertex3f); + R_Mesh_PrepareVertices_Vertex3f(8, vertex3f, NULL); R_Mesh_Draw(0, 8, 0, 12, NULL, NULL, 0, bboxelements, NULL, 0); } +static void R_Shadow_UpdateBounceGridTexture(void) +{ +#define MAXBOUNCEGRIDPARTICLESPERLIGHT 1048576 + dlight_t *light; + int flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE; + int bouncecount; + int c[3]; + int hitsupercontentsmask; + int maxbounce; + int numpixels; + int pixelindex; + int resolution[3]; + int shootparticles; + int shotparticles; + int tex[3]; + trace_t cliptrace; + unsigned char *pixel; + unsigned char *pixels; + unsigned short *highpixel; + unsigned short *highpixels; + unsigned int lightindex; + unsigned int range; + unsigned int range1; + unsigned int range2; + unsigned int seed = (unsigned int)(realtime * 1000.0f); + vec3_t shotcolor; + vec3_t baseshotcolor; + vec3_t clipend; + vec3_t clipstart; + vec3_t clipdiff; + vec3_t ispacing; + vec3_t maxs; + vec3_t mins; + vec3_t size; + vec3_t spacing; + vec3_t lightcolor; + vec_t radius; + vec_t s; + vec_t lightintensity; + float m[16]; + qboolean isstatic = r_shadow_bouncegrid_updateinterval.value > 1.0f; + rtlight_t *rtlight; + if (!r_shadow_bouncegrid.integer || !vid.support.ext_texture_3d) + { + if (r_shadow_bouncegridtexture) + { + R_FreeTexture(r_shadow_bouncegridtexture); + r_shadow_bouncegridtexture = NULL; + } + if (r_shadow_bouncegridpixels) + Mem_Free(r_shadow_bouncegridpixels); + r_shadow_bouncegridpixels = NULL; + if (r_shadow_bouncegridhighpixels) + Mem_Free(r_shadow_bouncegridhighpixels); + r_shadow_bouncegridhighpixels = NULL; + r_shadow_bouncegridnumpixels = 0; + return; + } + if (r_refdef.scene.worldmodel && isstatic) + { + VectorSet(spacing, bound(1, r_shadow_bouncegrid_spacingx.value, 512), bound(1, r_shadow_bouncegrid_spacingy.value, 512), bound(1, r_shadow_bouncegrid_spacingz.value, 512)); + VectorMA(r_refdef.scene.worldmodel->normalmins, -2.0f, spacing, mins); + VectorMA(r_refdef.scene.worldmodel->normalmaxs, 2.0f, spacing, maxs); + VectorSubtract(maxs, mins, size); + resolution[0] = (int)floor(size[0] / spacing[0] + 0.5f); + resolution[1] = (int)floor(size[1] / spacing[1] + 0.5f); + resolution[2] = (int)floor(size[2] / spacing[2] + 0.5f); + resolution[0] = min(resolution[0], bound(4, r_shadow_bouncegrid_x.integer, (int)vid.maxtexturesize_3d)); + resolution[1] = min(resolution[1], bound(4, r_shadow_bouncegrid_y.integer, (int)vid.maxtexturesize_3d)); + resolution[2] = min(resolution[2], bound(4, r_shadow_bouncegrid_z.integer, (int)vid.maxtexturesize_3d)); + spacing[0] = size[0] / resolution[0]; + spacing[1] = size[1] / resolution[1]; + spacing[2] = size[2] / resolution[2]; + ispacing[0] = 1.0f / spacing[0]; + ispacing[1] = 1.0f / spacing[1]; + ispacing[2] = 1.0f / spacing[2]; + } + else + { + VectorSet(resolution, bound(4, r_shadow_bouncegrid_x.integer, (int)vid.maxtexturesize_3d), bound(4, r_shadow_bouncegrid_y.integer, (int)vid.maxtexturesize_3d), bound(4, r_shadow_bouncegrid_z.integer, (int)vid.maxtexturesize_3d)); + VectorSet(spacing, bound(1, r_shadow_bouncegrid_spacingx.value, 512), bound(1, r_shadow_bouncegrid_spacingy.value, 512), bound(1, r_shadow_bouncegrid_spacingz.value, 512)); + VectorMultiply(resolution, spacing, size); + ispacing[0] = 1.0f / spacing[0]; + ispacing[1] = 1.0f / spacing[1]; + ispacing[2] = 1.0f / spacing[2]; + mins[0] = floor(r_refdef.view.origin[0] * ispacing[0] + 0.5f) * spacing[0] - 0.5f * size[0]; + mins[1] = floor(r_refdef.view.origin[1] * ispacing[1] + 0.5f) * spacing[1] - 0.5f * size[1]; + mins[2] = floor(r_refdef.view.origin[2] * ispacing[2] + 0.5f) * spacing[2] - 0.5f * size[2]; + VectorAdd(mins, size, maxs); + } + r_shadow_bouncegridintensity = r_shadow_bouncegrid_intensity.value; + if (r_shadow_bouncegridtexture && realtime < r_shadow_bouncegridtime + r_shadow_bouncegrid_updateinterval.value && resolution[0] == r_shadow_bouncegridresolution[0] && resolution[1] == r_shadow_bouncegridresolution[1] && resolution[2] == r_shadow_bouncegridresolution[2]) + return; + // we're going to update the bouncegrid, update the matrix... + memset(m, 0, sizeof(m)); + m[0] = 1.0f / size[0]; + m[3] = -mins[0] * m[0]; + m[5] = 1.0f / size[1]; + m[7] = -mins[1] * m[5]; + m[10] = 1.0f / size[2]; + m[11] = -mins[2] * m[10]; + m[15] = 1.0f; + Matrix4x4_FromArrayFloatD3D(&r_shadow_bouncegridmatrix, m); + numpixels = resolution[0]*resolution[1]*resolution[2]; + // reallocate pixels for this update if needed... + if (r_shadow_bouncegridnumpixels != numpixels || !r_shadow_bouncegridpixels || !r_shadow_bouncegridhighpixels) + { + r_shadow_bouncegridpixels = (unsigned char *)Mem_Realloc(r_main_mempool, r_shadow_bouncegridpixels, numpixels * sizeof(unsigned char[4])); + r_shadow_bouncegridhighpixels = (unsigned short *)Mem_Realloc(r_main_mempool, r_shadow_bouncegridhighpixels, numpixels * sizeof(unsigned short[4])); + } + r_shadow_bouncegridnumpixels = numpixels; + pixels = r_shadow_bouncegridpixels; + highpixels = r_shadow_bouncegridhighpixels; + memset(pixels, 0, numpixels * sizeof(unsigned char[4])); + memset(highpixels, 0, numpixels * sizeof(unsigned short[3])); + // figure out what we want to interact with + if (r_shadow_bouncegrid_hitmodels.integer) + hitsupercontentsmask = SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_LIQUIDSMASK; + else + hitsupercontentsmask = SUPERCONTENTS_SOLID | SUPERCONTENTS_LIQUIDSMASK; + maxbounce = bound(1, r_shadow_bouncegrid_maxbounce.integer, 16); + // iterate world rtlights + range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked + range1 = isstatic ? 0 : r_refdef.scene.numlights; + range2 = range + range1; + for (lightindex = 0;lightindex < range2;lightindex++) + { + if (isstatic) + { + light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex); + if (!light || !(light->flags & flag)) + continue; + rtlight = &light->rtlight; + // when static, we skip styled lights because they tend to change... + if (rtlight->style > 0) + continue; + VectorScale(rtlight->color, (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale) * (rtlight->style >= 0 ? r_refdef.scene.rtlightstylevalue[rtlight->style] : 1), lightcolor); + } + else + { + if (lightindex < range) + { + light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex); + rtlight = &light->rtlight; + } + else + rtlight = r_refdef.scene.lights[lightindex - range]; + // draw only visible lights (major speedup) + if (!rtlight->draw) + continue; + VectorScale(rtlight->currentcolor, rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale, lightcolor); + } + if (!VectorLength2(lightcolor)) + continue; + // shoot particles from this light + // use a calculation for the number of particles that will not + // vary with lightstyle, otherwise we get randomized particle + // distribution, the seeded random is only consistent for a + // consistent number of particles on this light... + radius = rtlight->radius * bound(0.0001f, r_shadow_bouncegrid_lightradiusscale.value, 1024.0f); + s = rtlight->radius / bound(1.0f, r_shadow_bouncegrid_particlespacing.value, 1048576.0f); + lightintensity = VectorLength(rtlight->color) * rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale; + if (lightindex >= range) + lightintensity *= r_shadow_bouncegrid_dlightparticlemultiplier.value; + shootparticles = (int)bound(0, lightintensity * s *s, MAXBOUNCEGRIDPARTICLESPERLIGHT); + if (!shootparticles) + continue; + s = 65535.0f * r_shadow_bouncegrid_particleintensity.value / shootparticles; + VectorScale(lightcolor, s, baseshotcolor); + if (VectorLength2(baseshotcolor) < 3.0f) + break; + r_refdef.stats.bouncegrid_lights++; + r_refdef.stats.bouncegrid_particles += shootparticles; + for (shotparticles = 0;shotparticles < shootparticles;shotparticles++) + { + if (r_shadow_bouncegrid_stablerandom.integer > 0) + seed = lightindex * 11937 + shotparticles; + VectorCopy(baseshotcolor, shotcolor); + VectorCopy(rtlight->shadoworigin, clipstart); + if (r_shadow_bouncegrid_stablerandom.integer < 0) + VectorRandom(clipend); + else + VectorCheeseRandom(clipend); + VectorMA(clipstart, radius, clipend, clipend); + for (bouncecount = 0;;bouncecount++) + { + r_refdef.stats.bouncegrid_traces++; + cliptrace = CL_TraceLine(clipstart, clipend, r_shadow_bouncegrid_hitmodels.integer ? MOVE_HITMODEL : MOVE_NOMONSTERS, NULL, hitsupercontentsmask, true, false, NULL, true); + //Collision_ClipLineToWorld(&cliptrace, cl.worldmodel, clipstart, clipend, hitsupercontentsmask); + if (cliptrace.fraction >= 1.0f) + break; + r_refdef.stats.bouncegrid_hits++; + if (bouncecount > 0) + { + r_refdef.stats.bouncegrid_splats++; + // figure out which texture pixel this is in + tex[0] = (int)((cliptrace.endpos[0] - mins[0]) * ispacing[0]); + tex[1] = (int)((cliptrace.endpos[1] - mins[1]) * ispacing[1]); + tex[2] = (int)((cliptrace.endpos[2] - mins[2]) * ispacing[2]); + if (tex[0] >= 1 && tex[1] >= 1 && tex[2] >= 1 && tex[0] < resolution[0] - 1 && tex[1] < resolution[1] - 1 && tex[2] < resolution[2] - 1) + { + // it is within bounds... + pixelindex = ((tex[2]*resolution[1]+tex[1])*resolution[0]+tex[0]); + pixel = pixels + 4 * pixelindex; + highpixel = highpixels + 3 * pixelindex; + // add to the high precision pixel color + c[0] = highpixel[0] + (int)shotcolor[2]; + c[1] = highpixel[1] + (int)shotcolor[1]; + c[2] = highpixel[2] + (int)shotcolor[0]; + highpixel[0] = (unsigned short)min(c[0], 65535); + highpixel[1] = (unsigned short)min(c[1], 65535); + highpixel[2] = (unsigned short)min(c[2], 65535); + // update the low precision pixel color + pixel[0] = highpixel[0] >> 8; + pixel[1] = highpixel[1] >> 8; + pixel[2] = highpixel[2] >> 8; + pixel[3] = 255; + } + } + if (bouncecount >= maxbounce) + break; + // scale down shot color by bounce intensity and texture color (or 50% if no texture reported) + VectorScale(shotcolor, r_shadow_bouncegrid_particlebounceintensity.value, shotcolor); + if (cliptrace.hittexture && cliptrace.hittexture->currentskinframe) + VectorMultiply(shotcolor, rsurface.texture->currentskinframe->avgcolor, shotcolor); + else + VectorScale(shotcolor, 0.5f->avgcolor, shotcolor); + if (VectorLength2(shotcolor) < 3.0f) + break; + r_refdef.stats.bouncegrid_bounces++; + if (r_shadow_bouncegrid_bounceanglediffuse.integer) + { + // random direction, primarily along plane normal + s = VectorDistance(cliptrace.endpos, clipend); + if (r_shadow_bouncegrid_stablerandom.integer < 0) + VectorRandom(clipend); + else + VectorCheeseRandom(clipend); + VectorMA(cliptrace.plane.normal, 0.95f, clipend, clipend); + VectorNormalize(clipend); + VectorScale(clipend, s, clipend); + } + else + { + // reflect the remaining portion of the line across plane normal + VectorSubtract(clipend, cliptrace.endpos, clipdiff); + VectorReflect(clipdiff, 1.0, cliptrace.plane.normal, clipend); + } + // calculate the new line start and end + VectorCopy(cliptrace.endpos, clipstart); + VectorAdd(clipstart, clipend, clipend); + } + } + } + if (r_shadow_bouncegridtexture && r_shadow_bouncegridresolution[0] == resolution[0] && r_shadow_bouncegridresolution[1] == resolution[1] && r_shadow_bouncegridresolution[2] == resolution[2]) + R_UpdateTexture(r_shadow_bouncegridtexture, pixels, 0, 0, 0, resolution[0], resolution[1], resolution[2]); + else + { + VectorCopy(resolution, r_shadow_bouncegridresolution); + if (r_shadow_bouncegridtexture) + R_FreeTexture(r_shadow_bouncegridtexture); + r_shadow_bouncegridtexture = R_LoadTexture3D(r_shadow_texturepool, "bouncegrid", resolution[0], resolution[1], resolution[2], pixels, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCELINEAR, 0, NULL); + } + r_shadow_bouncegridtime = realtime; +} + +#define MAXPARTICLESPERLIGHT 262144 +#define MAXLIGHTSPERDRAW 1024 + +static void R_Shadow_RenderParticlesForLight(rtlight_t *rtlight) +{ + int batchcount; + int i; + int j; + int bouncecount; + int hitsupercontentsmask; + int n; + int shotparticles; + int shootparticles = 0; + int bouncelimit; + int maxbounce; + unsigned int seed = 0; + static unsigned short bouncelight_elements[MAXLIGHTSPERDRAW*36]; + static float vertex3f[MAXLIGHTSPERDRAW*24]; + static float lightorigin4f[MAXLIGHTSPERDRAW*32]; + static float color4f[MAXLIGHTSPERDRAW*32]; + float scaledpoints[8][3]; + float *v3f; + float *lo4f; + float *c4f; + rtlight_particle_t *p; + vec_t wantparticles = 0; + vec_t s; + vec_t radius; + vec_t particlesize; + vec_t iparticlesize; +// vec3_t offset; +// vec3_t right; +// vec3_t up; + vec4_t org; + vec4_t color; + vec3_t currentcolor; + vec3_t clipstart; + vec3_t clipend; + vec3_t shotcolor; + trace_t cliptrace; + if (!rtlight->draw || !rtlight->isstatic || !r_shadow_usingdeferredprepass) + return; + if (r_shadow_particletrace.integer) + { + radius = rtlight->radius * bound(0.0001f, r_shadow_particletrace_radiusscale.value, 1.0f) - r_shadow_particletrace_size.value; + s = rtlight->radius / bound(1.0f, r_shadow_particletrace_particlespacing.value * r_shadow_particletrace_size.value, 1048576.0f); + wantparticles = s*s; + n = (int)bound(0, wantparticles, MAXPARTICLESPERLIGHT); + } + else + n = 0; + shootparticles = (int)(n * r_shadow_particletrace_updatepercentage.value); + if ((n && !rtlight->particlecache_particles) || rtlight->particlecache_maxparticles != n) + { + if (rtlight->particlecache_particles) + Mem_Free(rtlight->particlecache_particles); + rtlight->particlecache_particles = NULL; + rtlight->particlecache_numparticles = 0; + rtlight->particlecache_maxparticles = n; + rtlight->particlecache_updateparticle = 0; + if (rtlight->particlecache_maxparticles) + rtlight->particlecache_particles = (rtlight_particle_t *)Mem_Alloc(r_main_mempool, rtlight->particlecache_maxparticles * sizeof(*rtlight->particlecache_particles)); + shootparticles = n * 16; + } + + if (!rtlight->particlecache_maxparticles) + return; + +// if (rtlight->particlecache_numparticles < rtlight->particlecache_maxparticles) +// shootparticles = rtlight->particlecache_maxparticles; + +// if (rtlight->particlecache_numparticles >= rtlight->particlecache_maxparticles) +// shootparticles = 0; + + maxbounce = bound(1, r_shadow_particletrace_maxbounce.integer, 16); + //r_refdef.stats.lights_bouncelightsupdated += shootparticles; + for (shotparticles = 0;shotparticles < shootparticles;shotparticles++) + { + seed = rtlight->particlecache_updateparticle; + VectorSet(shotcolor, 1.0f, 1.0f, 1.0f); + VectorCopy(rtlight->shadoworigin, clipstart); + VectorRandom(clipend); + VectorMA(clipstart, radius, clipend, clipend); + hitsupercontentsmask = SUPERCONTENTS_SOLID | SUPERCONTENTS_LIQUIDSMASK; + bouncelimit = 1 + (rtlight->particlecache_updateparticle % maxbounce); + for (bouncecount = 0;;bouncecount++) + { + cliptrace = CL_TraceLine(clipstart, clipend, MOVE_NOMONSTERS, NULL, hitsupercontentsmask, true, false, NULL, true); + //Collision_ClipLineToWorld(&cliptrace, cl.worldmodel, clipstart, clipend, hitsupercontentsmask); + if (cliptrace.fraction >= 1.0f) + break; + if (VectorLength2(shotcolor) < (1.0f / 262144.0f)) + break; + if (bouncecount >= bouncelimit) + { + VectorCopy(cliptrace.endpos, rtlight->particlecache_particles[rtlight->particlecache_updateparticle].origin); + VectorCopy(shotcolor, rtlight->particlecache_particles[rtlight->particlecache_updateparticle].color); + rtlight->particlecache_updateparticle++; + if (rtlight->particlecache_numparticles < rtlight->particlecache_updateparticle) + rtlight->particlecache_numparticles = rtlight->particlecache_updateparticle; + if (rtlight->particlecache_updateparticle >= rtlight->particlecache_maxparticles) + { + rtlight->particlecache_updateparticle = 0; + shotparticles = shootparticles; + } + break; + } + // scale down shot color by bounce intensity and texture color + VectorScale(shotcolor, r_shadow_particletrace_bounceintensity.value, shotcolor); + if (cliptrace.hittexture && cliptrace.hittexture->currentskinframe) + VectorMultiply(shotcolor, rsurface.texture->currentskinframe->avgcolor, shotcolor); + // reflect the remaining portion of the line across plane normal + //VectorSubtract(clipend, cliptrace.endpos, clipdiff); + //VectorReflect(clipdiff, 1.0, cliptrace.plane.normal, clipend); + // random direction, primarily along plane normal + s = VectorDistance(cliptrace.endpos, clipend); + VectorRandom(clipend); + VectorMA(cliptrace.plane.normal, 0.95f, clipend, clipend); + VectorNormalize(clipend); + VectorScale(clipend, s, clipend); + // calculate the new line start and end + VectorCopy(cliptrace.endpos, clipstart); + VectorAdd(clipstart, clipend, clipend); + } + } + + if (!rtlight->particlecache_numparticles) + return; + + // render the particles as deferred lights +// do global setup needed for the chosen lighting mode + R_Shadow_RenderMode_Reset(); + r_shadow_rendermode = r_shadow_lightingrendermode; + r_shadow_usingshadowmap2d = false; + R_EntityMatrix(&identitymatrix); + GL_BlendFunc(GL_SRC_ALPHA, GL_ONE); + // only draw light where this geometry was already rendered AND the + // stencil is 128 (values other than this mean shadow) + R_SetStencil(false, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_EQUAL, 128, 255); + R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusefbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, NULL, NULL, NULL); + R_SetupShader_DeferredBounceLight(); + GL_ColorMask(1,1,1,1); + GL_DepthMask(false); + GL_DepthRange(0, 1); + GL_PolygonOffset(0, 0); + GL_DepthTest(true); + GL_DepthFunc(GL_GREATER); + GL_CullFace(r_refdef.view.cullface_back); + s = r_shadow_particletrace_intensity.value / (float)rtlight->particlecache_numparticles; + VectorScale(rtlight->currentcolor, s, currentcolor); + particlesize = bound(0.0001f, r_shadow_particletrace_size.value, 1024.0f); + iparticlesize = 1.0f / particlesize; +// VectorScale(r_refdef.view.forward, particlesize, offset); +// VectorScale(r_refdef.view.left, -particlesize, right); +// VectorScale(r_refdef.view.up, particlesize, up); + org[3] = iparticlesize; + color[3] = 1.0f; + v3f = vertex3f; + lo4f = lightorigin4f; + c4f = color4f; + batchcount = 0; + if (!bouncelight_elements[1]) + for (i = 0;i < MAXLIGHTSPERDRAW;i++) + for (j = 0;j < 36;j++) + bouncelight_elements[i*36+j] = i*8+bboxelements[j]; + for (j = 0;j < 8;j++) + VectorScale(bboxpoints[j], particlesize, scaledpoints[j]); + //r_refdef.stats.lights_bouncelightscounted += rtlight->particlecache_numparticles; + for (j = 0, p = rtlight->particlecache_particles, n = rtlight->particlecache_numparticles;j < n;j++, p++) + { + VectorCopy(p->origin, org); + // org[3] is set above + VectorMultiply(p->color, currentcolor, color); + // color[3] is set above + VectorAdd(scaledpoints[0], org, v3f + 0); + VectorAdd(scaledpoints[1], org, v3f + 3); + VectorAdd(scaledpoints[2], org, v3f + 6); + VectorAdd(scaledpoints[3], org, v3f + 9); + VectorAdd(scaledpoints[4], org, v3f + 12); + VectorAdd(scaledpoints[5], org, v3f + 15); + VectorAdd(scaledpoints[6], org, v3f + 18); + VectorAdd(scaledpoints[7], org, v3f + 21); + Vector4Copy(org, lo4f + 0); + Vector4Copy(org, lo4f + 4); + Vector4Copy(org, lo4f + 8); + Vector4Copy(org, lo4f + 12); + Vector4Copy(org, lo4f + 16); + Vector4Copy(org, lo4f + 20); + Vector4Copy(org, lo4f + 24); + Vector4Copy(org, lo4f + 28); + Vector4Copy(color, c4f + 0); + Vector4Copy(color, c4f + 4); + Vector4Copy(color, c4f + 8); + Vector4Copy(color, c4f + 12); + Vector4Copy(color, c4f + 16); + Vector4Copy(color, c4f + 20); + Vector4Copy(color, c4f + 24); + Vector4Copy(color, c4f + 28); + v3f += 24; + lo4f += 32; + c4f += 32; + batchcount++; + if (batchcount >= MAXLIGHTSPERDRAW) + { + //r_refdef.stats.lights_bouncelightsdrawn += batchcount; + R_Mesh_PrepareVertices_BounceLight_Arrays(batchcount*8, vertex3f, color4f, lightorigin4f); + R_Mesh_Draw(0, batchcount*8, 0, batchcount*12, NULL, NULL, 0, bouncelight_elements, NULL, 0); + v3f = vertex3f; + lo4f = lightorigin4f; + c4f = color4f; + batchcount = 0; + } + } + if (batchcount) + { + //r_refdef.stats.lights_bouncelightsdrawn += batchcount; + R_Mesh_PrepareVertices_BounceLight_Arrays(batchcount*8, vertex3f, color4f, lightorigin4f); + R_Mesh_Draw(0, batchcount*8, 0, batchcount*12, NULL, NULL, 0, bouncelight_elements, NULL, 0); + v3f = vertex3f; + lo4f = lightorigin4f; + c4f = color4f; + batchcount = 0; + } +} + void R_Shadow_RenderMode_VisibleShadowVolumes(void) { R_Shadow_RenderMode_Reset(); @@ -2439,131 +2839,21 @@ int bboxedges[12][2] = qboolean R_Shadow_ScissorForBBox(const float *mins, const float *maxs) { - int i, ix1, iy1, ix2, iy2; - float x1, y1, x2, y2; - vec4_t v, v2; - float vertex[20][3]; - int j, k; - vec4_t plane4f; - int numvertices; - float corner[8][4]; - float dist[8]; - int sign[8]; - float f; - - r_shadow_lightscissor[0] = r_refdef.view.viewport.x; - r_shadow_lightscissor[1] = r_refdef.view.viewport.y; - r_shadow_lightscissor[2] = r_refdef.view.viewport.width; - r_shadow_lightscissor[3] = r_refdef.view.viewport.height; - if (!r_shadow_scissor.integer) - return false; - - // if view is inside the light box, just say yes it's visible - if (BoxesOverlap(r_refdef.view.origin, r_refdef.view.origin, mins, maxs)) - return false; - - x1 = y1 = x2 = y2 = 0; - - // transform all corners that are infront of the nearclip plane - VectorNegate(r_refdef.view.frustum[4].normal, plane4f); - plane4f[3] = r_refdef.view.frustum[4].dist; - numvertices = 0; - for (i = 0;i < 8;i++) - { - Vector4Set(corner[i], (i & 1) ? maxs[0] : mins[0], (i & 2) ? maxs[1] : mins[1], (i & 4) ? maxs[2] : mins[2], 1); - dist[i] = DotProduct4(corner[i], plane4f); - sign[i] = dist[i] > 0; - if (!sign[i]) - { - VectorCopy(corner[i], vertex[numvertices]); - numvertices++; - } - } - // if some points are behind the nearclip, add clipped edge points to make - // sure that the scissor boundary is complete - if (numvertices > 0 && numvertices < 8) { - // add clipped edge points - for (i = 0;i < 12;i++) - { - j = bboxedges[i][0]; - k = bboxedges[i][1]; - if (sign[j] != sign[k]) - { - f = dist[j] / (dist[j] - dist[k]); - VectorLerp(corner[j], f, corner[k], vertex[numvertices]); - numvertices++; - } - } - } - - // if we have no points to check, the light is behind the view plane - if (!numvertices) - return true; - - // if we have some points to transform, check what screen area is covered - x1 = y1 = x2 = y2 = 0; - v[3] = 1.0f; - //Con_Printf("%i vertices to transform...\n", numvertices); - for (i = 0;i < numvertices;i++) - { - VectorCopy(vertex[i], v); - R_Viewport_TransformToScreen(&r_refdef.view.viewport, v, v2); - //Con_Printf("%.3f %.3f %.3f %.3f transformed to %.3f %.3f %.3f %.3f\n", v[0], v[1], v[2], v[3], v2[0], v2[1], v2[2], v2[3]); - if (i) - { - if (x1 > v2[0]) x1 = v2[0]; - if (x2 < v2[0]) x2 = v2[0]; - if (y1 > v2[1]) y1 = v2[1]; - if (y2 < v2[1]) y2 = v2[1]; - } - else - { - x1 = x2 = v2[0]; - y1 = y2 = v2[1]; - } - } - - // now convert the scissor rectangle to integer screen coordinates - ix1 = (int)(x1 - 1.0f); - iy1 = vid.height - (int)(y2 - 1.0f); - ix2 = (int)(x2 + 1.0f); - iy2 = vid.height - (int)(y1 + 1.0f); - //Con_Printf("%f %f %f %f\n", x1, y1, x2, y2); - - // clamp it to the screen - if (ix1 < r_refdef.view.viewport.x) ix1 = r_refdef.view.viewport.x; - if (iy1 < r_refdef.view.viewport.y) iy1 = r_refdef.view.viewport.y; - if (ix2 > r_refdef.view.viewport.x + r_refdef.view.viewport.width) ix2 = r_refdef.view.viewport.x + r_refdef.view.viewport.width; - if (iy2 > r_refdef.view.viewport.y + r_refdef.view.viewport.height) iy2 = r_refdef.view.viewport.y + r_refdef.view.viewport.height; - - // if it is inside out, it's not visible - if (ix2 <= ix1 || iy2 <= iy1) - return true; - - // the light area is visible, set up the scissor rectangle - r_shadow_lightscissor[0] = ix1; - r_shadow_lightscissor[1] = iy1; - r_shadow_lightscissor[2] = ix2 - ix1; - r_shadow_lightscissor[3] = iy2 - iy1; - - // D3D Y coordinate is top to bottom, OpenGL is bottom to top, fix the D3D one - switch(vid.renderpath) - { - case RENDERPATH_D3D9: - case RENDERPATH_D3D10: - case RENDERPATH_D3D11: - r_shadow_lightscissor[1] = vid.height - r_shadow_lightscissor[1] - r_shadow_lightscissor[3]; - break; - case RENDERPATH_GL11: - case RENDERPATH_GL13: - case RENDERPATH_GL20: - case RENDERPATH_CGGL: - break; + r_shadow_lightscissor[0] = r_refdef.view.viewport.x; + r_shadow_lightscissor[1] = r_refdef.view.viewport.y; + r_shadow_lightscissor[2] = r_refdef.view.viewport.width; + r_shadow_lightscissor[3] = r_refdef.view.viewport.height; + return false; } - - r_refdef.stats.lights_scissored++; + if(R_ScissorForBBox(mins, maxs, r_shadow_lightscissor)) + return true; // invisible + if(r_shadow_lightscissor[0] != r_refdef.view.viewport.x + || r_shadow_lightscissor[1] != r_refdef.view.viewport.y + || r_shadow_lightscissor[2] != r_refdef.view.viewport.width + || r_shadow_lightscissor[3] != r_refdef.view.viewport.height) + r_refdef.stats.lights_scissored++; return false; } @@ -2580,7 +2870,7 @@ static void R_Shadow_RenderLighting_Light_Vertex_Shading(int firstvertex, int nu case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN: if (VectorLength2(diffusecolor) > 0) { - for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, normal3f = rsurface.batchnormal3f + 3*firstvertex, color4f = rsurface.array_passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, normal3f += 3, color4f += 4) + for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, normal3f = rsurface.batchnormal3f + 3*firstvertex, color4f = rsurface.passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, normal3f += 3, color4f += 4) { Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v); Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n); @@ -2602,7 +2892,7 @@ static void R_Shadow_RenderLighting_Light_Vertex_Shading(int firstvertex, int nu } else { - for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, color4f = rsurface.array_passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, color4f += 4) + for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, color4f = rsurface.passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, color4f += 4) { VectorCopy(ambientcolor, color4f); if (r_refdef.fogenabled) @@ -2619,7 +2909,7 @@ static void R_Shadow_RenderLighting_Light_Vertex_Shading(int firstvertex, int nu case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN: if (VectorLength2(diffusecolor) > 0) { - for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, normal3f = rsurface.batchnormal3f + 3*firstvertex, color4f = rsurface.array_passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, normal3f += 3, color4f += 4) + for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, normal3f = rsurface.batchnormal3f + 3*firstvertex, color4f = rsurface.passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, normal3f += 3, color4f += 4) { Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v); if ((dist = fabs(v[2])) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)])) @@ -2652,7 +2942,7 @@ static void R_Shadow_RenderLighting_Light_Vertex_Shading(int firstvertex, int nu } else { - for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, color4f = rsurface.array_passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, color4f += 4) + for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, color4f = rsurface.passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, color4f += 4) { Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v); if ((dist = fabs(v[2])) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)])) @@ -2676,7 +2966,7 @@ static void R_Shadow_RenderLighting_Light_Vertex_Shading(int firstvertex, int nu case R_SHADOW_RENDERMODE_LIGHT_VERTEX: if (VectorLength2(diffusecolor) > 0) { - for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, normal3f = rsurface.batchnormal3f + 3*firstvertex, color4f = rsurface.array_passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, normal3f += 3, color4f += 4) + for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, normal3f = rsurface.batchnormal3f + 3*firstvertex, color4f = rsurface.passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, normal3f += 3, color4f += 4) { Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v); if ((dist = VectorLength(v)) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)])) @@ -2710,7 +3000,7 @@ static void R_Shadow_RenderLighting_Light_Vertex_Shading(int firstvertex, int nu } else { - for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, color4f = rsurface.array_passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, color4f += 4) + for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, color4f = rsurface.passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, color4f += 4) { Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v); if ((dist = VectorLength(v)) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)])) @@ -2784,7 +3074,7 @@ static void R_Shadow_RenderLighting_Light_Vertex_Pass(int firstvertex, int numve // renders them at once for (i = 0, e = element3i;i < numtriangles;i++, e += 3) { - if (VectorLength2(rsurface.array_passcolor4f + e[0] * 4) + VectorLength2(rsurface.array_passcolor4f + e[1] * 4) + VectorLength2(rsurface.array_passcolor4f + e[2] * 4) >= 0.01) + if (VectorLength2(rsurface.passcolor4f + e[0] * 4) + VectorLength2(rsurface.passcolor4f + e[1] * 4) + VectorLength2(rsurface.passcolor4f + e[2] * 4) >= 0.01) { if (newnumtriangles) { @@ -2827,7 +3117,7 @@ static void R_Shadow_RenderLighting_Light_Vertex_Pass(int firstvertex, int numve // handling of negative colors // (some old drivers even have improper handling of >1 color) stop = true; - for (i = 0, c = rsurface.array_passcolor4f + 4 * firstvertex;i < numvertices;i++, c += 4) + for (i = 0, c = rsurface.passcolor4f + 4 * firstvertex;i < numvertices;i++, c += 4) { if (c[0] > 1 || c[1] > 1 || c[2] > 1) { @@ -2867,9 +3157,10 @@ static void R_Shadow_RenderLighting_Light_Vertex(int texturenumsurfaces, const m diffusecolorpants[0] = diffusecolorbase[0] * surfacepants[0];diffusecolorpants[1] = diffusecolorbase[1] * surfacepants[1];diffusecolorpants[2] = diffusecolorbase[2] * surfacepants[2]; ambientcolorshirt[0] = ambientcolorbase[0] * surfaceshirt[0];ambientcolorshirt[1] = ambientcolorbase[1] * surfaceshirt[1];ambientcolorshirt[2] = ambientcolorbase[2] * surfaceshirt[2]; diffusecolorshirt[0] = diffusecolorbase[0] * surfaceshirt[0];diffusecolorshirt[1] = diffusecolorbase[1] * surfaceshirt[1];diffusecolorshirt[2] = diffusecolorbase[2] * surfaceshirt[2]; - RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | (diffusescale > 0 ? BATCHNEED_ARRAY_NORMAL : 0) | BATCHNEED_ARRAY_TEXCOORD, texturenumsurfaces, texturesurfacelist); + RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | (diffusescale > 0 ? BATCHNEED_ARRAY_NORMAL : 0) | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist); + rsurface.passcolor4f = (float *)R_FrameData_Alloc((rsurface.batchfirstvertex + rsurface.batchnumvertices) * sizeof(float[4])); R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset); - R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.array_passcolor4f, 0, 0); + R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, 0, 0); R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset); R_Mesh_TexBind(0, basetexture); R_Mesh_TexMatrix(0, &rsurface.texture->currenttexmatrix); @@ -2940,7 +3231,7 @@ void R_Shadow_RenderLighting(int texturenumsurfaces, const msurface_t **textures case RENDERPATH_GL11: case RENDERPATH_GL13: case RENDERPATH_GL20: - case RENDERPATH_CGGL: + case RENDERPATH_GLES2: qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT); break; case RENDERPATH_D3D9: @@ -2954,6 +3245,9 @@ void R_Shadow_RenderLighting(int texturenumsurfaces, const msurface_t **textures case RENDERPATH_D3D11: Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); break; + case RENDERPATH_SOFT: + DPSOFTRAST_BlendSubtract(true); + break; } } RSurf_SetupDepthAndCulling(); @@ -2983,7 +3277,7 @@ void R_Shadow_RenderLighting(int texturenumsurfaces, const msurface_t **textures case RENDERPATH_GL11: case RENDERPATH_GL13: case RENDERPATH_GL20: - case RENDERPATH_CGGL: + case RENDERPATH_GLES2: qglBlendEquationEXT(GL_FUNC_ADD_EXT); break; case RENDERPATH_D3D9: @@ -2997,6 +3291,9 @@ void R_Shadow_RenderLighting(int texturenumsurfaces, const msurface_t **textures case RENDERPATH_D3D11: Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); break; + case RENDERPATH_SOFT: + DPSOFTRAST_BlendSubtract(false); + break; } } } @@ -3076,7 +3373,9 @@ void R_RTLight_Compile(rtlight_t *rtlight) { // this variable must be set for the CompileShadowVolume/CompileShadowMap code r_shadow_compilingrtlight = rtlight; + R_FrameData_SetMark(); model->GetLightInfo(ent, rtlight->shadoworigin, rtlight->radius, rtlight->cullmins, rtlight->cullmaxs, r_shadow_buffer_leaflist, r_shadow_buffer_leafpvs, &numleafs, r_shadow_buffer_surfacelist, r_shadow_buffer_surfacepvs, &numsurfaces, r_shadow_buffer_shadowtrispvs, r_shadow_buffer_lighttrispvs, r_shadow_buffer_visitingleafpvs, 0, NULL); + R_FrameData_ReturnToMark(); numleafpvsbytes = (model->brush.num_leafs + 7) >> 3; numshadowtrispvsbytes = ((model->brush.shadowmesh ? model->brush.shadowmesh->numtriangles : model->surfmesh.num_triangles) + 7) >> 3; numlighttrispvsbytes = (model->surfmesh.num_triangles + 7) >> 3; @@ -3101,11 +3400,10 @@ void R_RTLight_Compile(rtlight_t *rtlight) memcpy(rtlight->static_shadowtrispvs, r_shadow_buffer_shadowtrispvs, rtlight->static_numshadowtrispvsbytes); if (rtlight->static_numlighttrispvsbytes) memcpy(rtlight->static_lighttrispvs, r_shadow_buffer_lighttrispvs, rtlight->static_numlighttrispvsbytes); + R_FrameData_SetMark(); switch (rtlight->shadowmode) { case R_SHADOW_SHADOWMODE_SHADOWMAP2D: - case R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE: - case R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE: if (model->CompileShadowMap && rtlight->shadow) model->CompileShadowMap(ent, rtlight->shadoworigin, NULL, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist); break; @@ -3114,6 +3412,7 @@ void R_RTLight_Compile(rtlight_t *rtlight) model->CompileShadowVolume(ent, rtlight->shadoworigin, NULL, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist); break; } + R_FrameData_ReturnToMark(); // now we're done compiling the rtlight r_shadow_compilingrtlight = NULL; } @@ -3369,17 +3668,20 @@ void R_Shadow_DrawWorldShadow_ShadowMap(int numsurfaces, int *surfacelist, const { CHECKGLERROR GL_CullFace(GL_NONE); - mesh = rsurface.rtlight->static_meshchain_shadow_shadowmap; - for (;mesh;mesh = mesh->next) - { + mesh = rsurface.rtlight->static_meshchain_shadow_shadowmap; + for (;mesh;mesh = mesh->next) + { if (!mesh->sidetotals[r_shadow_shadowmapside]) continue; - r_refdef.stats.lights_shadowtriangles += mesh->sidetotals[r_shadow_shadowmapside]; - R_Mesh_PrepareVertices_Position(mesh->numverts, mesh->vertexposition, mesh->vertexpositionbuffer); - R_Mesh_Draw(0, mesh->numverts, mesh->sideoffsets[r_shadow_shadowmapside], mesh->sidetotals[r_shadow_shadowmapside], mesh->element3i, mesh->element3i_indexbuffer, mesh->element3i_bufferoffset, mesh->element3s, mesh->element3s_indexbuffer, mesh->element3s_bufferoffset); - } - CHECKGLERROR - } + r_refdef.stats.lights_shadowtriangles += mesh->sidetotals[r_shadow_shadowmapside]; + if (mesh->vertex3fbuffer) + R_Mesh_PrepareVertices_Vertex3f(mesh->numverts, mesh->vertex3f, mesh->vertex3fbuffer); + else + R_Mesh_PrepareVertices_Vertex3f(mesh->numverts, mesh->vertex3f, mesh->vbo_vertexbuffer); + R_Mesh_Draw(0, mesh->numverts, mesh->sideoffsets[r_shadow_shadowmapside], mesh->sidetotals[r_shadow_shadowmapside], mesh->element3i, mesh->element3i_indexbuffer, mesh->element3i_bufferoffset, mesh->element3s, mesh->element3s_indexbuffer, mesh->element3s_bufferoffset); + } + CHECKGLERROR + } else if (r_refdef.scene.worldentity->model) r_refdef.scene.worldmodel->DrawShadowMap(r_shadow_shadowmapside, r_refdef.scene.worldentity, rsurface.rtlight->shadoworigin, NULL, rsurface.rtlight->radius, numsurfaces, surfacelist, surfacesides, rsurface.rtlight->cached_cullmins, rsurface.rtlight->cached_cullmaxs); @@ -3394,6 +3696,10 @@ void R_Shadow_DrawWorldShadow_ShadowVolume(int numsurfaces, int *surfacelist, co int surfacelistindex; msurface_t *surface; + // if triangle neighbors are disabled, shadowvolumes are disabled + if (r_refdef.scene.worldmodel->brush.shadowmesh ? !r_refdef.scene.worldmodel->brush.shadowmesh->neighbor3i : !r_refdef.scene.worldmodel->surfmesh.data_neighbor3i) + return; + RSurf_ActiveWorldEntity(); if (rsurface.rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer) @@ -3408,7 +3714,10 @@ void R_Shadow_DrawWorldShadow_ShadowVolume(int numsurfaces, int *surfacelist, co for (;mesh;mesh = mesh->next) { r_refdef.stats.lights_shadowtriangles += mesh->numtriangles; - R_Mesh_PrepareVertices_Position(mesh->numverts, mesh->vertexposition, mesh->vertexpositionbuffer); + if (mesh->vertex3fbuffer) + R_Mesh_PrepareVertices_Vertex3f(mesh->numverts, mesh->vertex3f, mesh->vertex3fbuffer); + else + R_Mesh_PrepareVertices_Vertex3f(mesh->numverts, mesh->vertex3f, mesh->vbo_vertexbuffer); if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZPASS_STENCIL) { // increment stencil if frontface is infront of depthbuffer @@ -3447,7 +3756,9 @@ void R_Shadow_DrawWorldShadow_ShadowVolume(int numsurfaces, int *surfacelist, co R_Shadow_VolumeFromList(r_refdef.scene.worldmodel->brush.shadowmesh->numverts, r_refdef.scene.worldmodel->brush.shadowmesh->numtriangles, r_refdef.scene.worldmodel->brush.shadowmesh->vertex3f, r_refdef.scene.worldmodel->brush.shadowmesh->element3i, r_refdef.scene.worldmodel->brush.shadowmesh->neighbor3i, rsurface.rtlight->shadoworigin, NULL, rsurface.rtlight->radius + r_refdef.scene.worldmodel->radius*2 + r_shadow_projectdistance.value, numshadowmark, shadowmarklist, r_refdef.scene.worldmodel->normalmins, r_refdef.scene.worldmodel->normalmaxs); } else if (numsurfaces) + { r_refdef.scene.worldmodel->DrawShadowVolume(r_refdef.scene.worldentity, rsurface.rtlight->shadoworigin, NULL, rsurface.rtlight->radius, numsurfaces, surfacelist, rsurface.rtlight->cached_cullmins, rsurface.rtlight->cached_cullmaxs); + } rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity } @@ -3469,8 +3780,6 @@ void R_Shadow_DrawEntityShadow(entity_render_t *ent) switch (r_shadow_rendermode) { case R_SHADOW_RENDERMODE_SHADOWMAP2D: - case R_SHADOW_RENDERMODE_SHADOWMAPRECTANGLE: - case R_SHADOW_RENDERMODE_SHADOWMAPCUBESIDE: ent->model->DrawShadowMap(r_shadow_shadowmapside, ent, relativeshadoworigin, NULL, relativeshadowradius, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, NULL, relativeshadowmins, relativeshadowmaxs); break; default: @@ -3484,7 +3793,6 @@ void R_Shadow_SetupEntityLight(const entity_render_t *ent) { // set up properties for rendering light onto this entity RSurf_ActiveModelEntity(ent, true, true, false); - GL_AlphaTest(false); Matrix4x4_Concat(&rsurface.entitytolight, &rsurface.rtlight->matrix_worldtolight, &ent->matrix); Matrix4x4_Concat(&rsurface.entitytoattenuationxyz, &matrix_attenuationxyz, &rsurface.entitytolight); Matrix4x4_Concat(&rsurface.entitytoattenuationz, &matrix_attenuationz, &rsurface.entitytolight); @@ -3498,7 +3806,6 @@ void R_Shadow_DrawWorldLight(int numsurfaces, int *surfacelist, const unsigned c // set up properties for rendering light onto this entity RSurf_ActiveWorldEntity(); - GL_AlphaTest(false); rsurface.entitytolight = rsurface.rtlight->matrix_worldtolight; Matrix4x4_Concat(&rsurface.entitytoattenuationxyz, &matrix_attenuationxyz, &rsurface.entitytolight); Matrix4x4_Concat(&rsurface.entitytoattenuationz, &matrix_attenuationz, &rsurface.entitytolight); @@ -3781,10 +4088,6 @@ void R_Shadow_DrawLight(rtlight_t *rtlight) if (!rtlight->draw) return; - // if R_FrameData_Store ran out of space we skip anything dependent on it - if (r_framedata_failed) - return; - numlightentities = rtlight->cached_numlightentities; numlightentities_noselfshadow = rtlight->cached_numlightentities_noselfshadow; numshadowentities = rtlight->cached_numshadowentities; @@ -3847,7 +4150,7 @@ void R_Shadow_DrawLight(rtlight_t *rtlight) //lodlinear = (int)(r_shadow_shadowmapping_lod_bias.value + r_shadow_shadowmapping_lod_scale.value * rtlight->radius / max(1.0f, distance)); lodlinear = bound(r_shadow_shadowmapping_minsize.integer, lodlinear, r_shadow_shadowmapmaxsize); - if (castshadows && (r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAP2D || r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE || r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE)) + if (castshadows && r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAP2D) { float borderbias; int side; @@ -3862,10 +4165,7 @@ void R_Shadow_DrawLight(rtlight_t *rtlight) if ((r_shadow_shadowmapmaxsize >> i) > lodlinear) r_shadow_shadowmaplod = i; - if (r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE) - size = max(1, r_shadow_shadowmapmaxsize >> r_shadow_shadowmaplod); - else - size = bound(r_shadow_shadowmapborder, lodlinear, r_shadow_shadowmapmaxsize); + size = bound(r_shadow_shadowmapborder, lodlinear, r_shadow_shadowmapmaxsize); borderbias = r_shadow_shadowmapborder / (float)(size - r_shadow_shadowmapborder); @@ -3992,13 +4292,16 @@ void R_Shadow_DrawLight(rtlight_t *rtlight) if (r_shadow_usingdeferredprepass) { // when rendering deferred lighting, we simply rasterize the box - if (castshadows && (r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAP2D || r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE || r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE)) + if (castshadows && r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAP2D) R_Shadow_RenderMode_DrawDeferredLight(false, true); else if (castshadows && vid.stencil) R_Shadow_RenderMode_DrawDeferredLight(true, false); else R_Shadow_RenderMode_DrawDeferredLight(false, false); } + + if (r_shadow_particletrace.integer) + R_Shadow_RenderParticlesForLight(rtlight); } static void R_Shadow_FreeDeferred(void) @@ -4006,13 +4309,20 @@ static void R_Shadow_FreeDeferred(void) R_Mesh_DestroyFramebufferObject(r_shadow_prepassgeometryfbo); r_shadow_prepassgeometryfbo = 0; - R_Mesh_DestroyFramebufferObject(r_shadow_prepasslightingfbo); - r_shadow_prepasslightingfbo = 0; + R_Mesh_DestroyFramebufferObject(r_shadow_prepasslightingdiffusespecularfbo); + r_shadow_prepasslightingdiffusespecularfbo = 0; + + R_Mesh_DestroyFramebufferObject(r_shadow_prepasslightingdiffusefbo); + r_shadow_prepasslightingdiffusefbo = 0; if (r_shadow_prepassgeometrydepthtexture) R_FreeTexture(r_shadow_prepassgeometrydepthtexture); r_shadow_prepassgeometrydepthtexture = NULL; + if (r_shadow_prepassgeometrydepthcolortexture) + R_FreeTexture(r_shadow_prepassgeometrydepthcolortexture); + r_shadow_prepassgeometrydepthcolortexture = NULL; + if (r_shadow_prepassgeometrynormalmaptexture) R_FreeTexture(r_shadow_prepassgeometrynormalmaptexture); r_shadow_prepassgeometrynormalmaptexture = NULL; @@ -4037,16 +4347,15 @@ void R_Shadow_DrawPrepass(void) entity_render_t *ent; float clearcolor[4]; - GL_AlphaTest(false); R_Mesh_ResetTextureState(); GL_DepthMask(true); GL_ColorMask(1,1,1,1); GL_BlendFunc(GL_ONE, GL_ZERO); GL_Color(1,1,1,1); GL_DepthTest(true); - R_Mesh_SetRenderTargets(r_shadow_prepassgeometryfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepassgeometrynormalmaptexture, NULL, NULL, NULL); + R_Mesh_SetRenderTargets(r_shadow_prepassgeometryfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepassgeometrynormalmaptexture, r_shadow_prepassgeometrydepthcolortexture, NULL, NULL); Vector4Set(clearcolor, 0.5f,0.5f,0.5f,1.0f); - GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT, clearcolor, 1.0f, 0); + GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0); if (r_timereport_active) R_TimeReport("prepasscleargeom"); @@ -4071,7 +4380,7 @@ void R_Shadow_DrawPrepass(void) GL_ColorMask(1,1,1,1); GL_Color(1,1,1,1); GL_DepthTest(true); - R_Mesh_SetRenderTargets(r_shadow_prepasslightingfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL); + R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusespecularfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL); Vector4Set(clearcolor, 0, 0, 0, 0); GL_Clear(GL_COLOR_BUFFER_BIT, clearcolor, 1.0f, 0); if (r_timereport_active) @@ -4084,7 +4393,7 @@ void R_Shadow_DrawPrepass(void) { lightindex = r_shadow_debuglight.integer; light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex); - if (light && (light->flags & flag)) + if (light && (light->flags & flag) && light->rtlight.draw) R_Shadow_DrawLight(&light->rtlight); } else @@ -4093,13 +4402,14 @@ void R_Shadow_DrawPrepass(void) for (lightindex = 0;lightindex < range;lightindex++) { light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex); - if (light && (light->flags & flag)) + if (light && (light->flags & flag) && light->rtlight.draw) R_Shadow_DrawLight(&light->rtlight); } } if (r_refdef.scene.rtdlight) for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++) - R_Shadow_DrawLight(r_refdef.scene.lights[lnum]); + if (r_refdef.scene.lights[lnum]->draw) + R_Shadow_DrawLight(r_refdef.scene.lights[lnum]); R_Mesh_ResetRenderTargets(); @@ -4122,8 +4432,7 @@ void R_Shadow_PrepareLights(void) if (r_shadow_shadowmapmaxsize != bound(1, r_shadow_shadowmapping_maxsize.integer, (int)vid.maxtexturesize_2d / 4) || (r_shadow_shadowmode != R_SHADOW_SHADOWMODE_STENCIL) != (r_shadow_shadowmapping.integer || r_shadow_deferred.integer) || - r_shadow_shadowmapvsdct != (r_shadow_shadowmapping_vsdct.integer != 0) || - r_shadow_shadowmaptexturetype != r_shadow_shadowmapping_texturetype.integer || + r_shadow_shadowmapvsdct != (r_shadow_shadowmapping_vsdct.integer != 0 && vid.renderpath == RENDERPATH_GL20) || r_shadow_shadowmapfilterquality != r_shadow_shadowmapping_filterquality.integer || r_shadow_shadowmapdepthbits != r_shadow_shadowmapping_depthbits.integer || r_shadow_shadowmapborder != bound(0, r_shadow_shadowmapping_bordersize.integer, 16)) @@ -4134,10 +4443,11 @@ void R_Shadow_PrepareLights(void) switch (vid.renderpath) { case RENDERPATH_GL20: - case RENDERPATH_CGGL: case RENDERPATH_D3D9: case RENDERPATH_D3D10: case RENDERPATH_D3D11: + case RENDERPATH_SOFT: + case RENDERPATH_GLES2: if (!r_shadow_deferred.integer || r_shadow_shadowmode == R_SHADOW_SHADOWMODE_STENCIL || !vid.support.ext_framebuffer_object || vid.maxdrawbuffers < 2) { r_shadow_usingdeferredprepass = false; @@ -4155,13 +4465,21 @@ void R_Shadow_PrepareLights(void) r_shadow_prepass_width = vid.width; r_shadow_prepass_height = vid.height; r_shadow_prepassgeometrydepthtexture = R_LoadTextureShadowMap2D(r_shadow_texturepool, "prepassgeometrydepthmap", vid.width, vid.height, 24, false); + switch (vid.renderpath) + { + case RENDERPATH_D3D9: + r_shadow_prepassgeometrydepthcolortexture = R_LoadTexture2D(r_shadow_texturepool, "prepassgeometrydepthcolormap", vid.width, vid.height, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, -1, NULL); + break; + default: + break; + } r_shadow_prepassgeometrynormalmaptexture = R_LoadTexture2D(r_shadow_texturepool, "prepassgeometrynormalmap", vid.width, vid.height, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, -1, NULL); r_shadow_prepasslightingdiffusetexture = R_LoadTexture2D(r_shadow_texturepool, "prepasslightingdiffuse", vid.width, vid.height, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, -1, NULL); r_shadow_prepasslightingspeculartexture = R_LoadTexture2D(r_shadow_texturepool, "prepasslightingspecular", vid.width, vid.height, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, -1, NULL); // set up the geometry pass fbo (depth + normalmap) r_shadow_prepassgeometryfbo = R_Mesh_CreateFramebufferObject(r_shadow_prepassgeometrydepthtexture, r_shadow_prepassgeometrynormalmaptexture, NULL, NULL, NULL); - R_Mesh_SetRenderTargets(r_shadow_prepassgeometryfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepassgeometrynormalmaptexture, NULL, NULL, NULL); + R_Mesh_SetRenderTargets(r_shadow_prepassgeometryfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepassgeometrynormalmaptexture, r_shadow_prepassgeometrydepthcolortexture, NULL, NULL); // render depth into one texture and normalmap into the other if (qglDrawBuffersARB) { @@ -4177,8 +4495,8 @@ void R_Shadow_PrepareLights(void) } // set up the lighting pass fbo (diffuse + specular) - r_shadow_prepasslightingfbo = R_Mesh_CreateFramebufferObject(r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL); - R_Mesh_SetRenderTargets(r_shadow_prepasslightingfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL); + r_shadow_prepasslightingdiffusespecularfbo = R_Mesh_CreateFramebufferObject(r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL); + R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusespecularfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL); // render diffuse into one texture and specular into another, // with depth and normalmap bound as textures, // with depth bound as attachment as well @@ -4194,6 +4512,25 @@ void R_Shadow_PrepareLights(void) r_shadow_usingdeferredprepass = false; } } + + // set up the lighting pass fbo (diffuse) + r_shadow_prepasslightingdiffusefbo = R_Mesh_CreateFramebufferObject(r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, NULL, NULL, NULL); + R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusefbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, NULL, NULL, NULL); + // render diffuse into one texture, + // with depth and normalmap bound as textures, + // with depth bound as attachment as well + if (qglDrawBuffersARB) + { + qglDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);CHECKGLERROR + qglReadBuffer(GL_NONE);CHECKGLERROR + status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);CHECKGLERROR + if (status != GL_FRAMEBUFFER_COMPLETE_EXT) + { + Con_Printf("R_PrepareRTLights: glCheckFramebufferStatusEXT returned %i\n", status); + Cvar_SetValueQuick(&r_shadow_deferred, 0); + r_shadow_usingdeferredprepass = false; + } + } } break; case RENDERPATH_GL13: @@ -4239,6 +4576,8 @@ void R_Shadow_PrepareLights(void) if (r_editlights.integer) R_Shadow_DrawLightSprites(); + + R_Shadow_UpdateBounceGridTexture(); } void R_Shadow_DrawLights(void) @@ -4302,7 +4641,6 @@ void R_Shadow_PrepareModelShadows(void) switch (r_shadow_shadowmode) { case R_SHADOW_SHADOWMODE_SHADOWMAP2D: - case R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE: if (r_shadows.integer >= 2) break; // fall through @@ -4380,7 +4718,6 @@ void R_DrawModelShadowMaps(void) switch (r_shadow_shadowmode) { case R_SHADOW_SHADOWMODE_SHADOWMAP2D: - case R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE: break; default: return; @@ -4400,14 +4737,6 @@ void R_DrawModelShadowMaps(void) r_shadow_shadowmap_texturescale[1] = 1.0f / R_TextureHeight(r_shadow_shadowmap2dtexture); r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAP2D; break; - case R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE: - if (!r_shadow_shadowmaprectangletexture) - R_Shadow_MakeShadowMap(0, r_shadow_shadowmapmaxsize); - fbo = r_shadow_fborectangle; - r_shadow_shadowmap_texturescale[0] = 1.0f; - r_shadow_shadowmap_texturescale[1] = 1.0f; - r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAPRECTANGLE; - break; default: break; } @@ -4452,26 +4781,33 @@ void R_DrawModelShadowMaps(void) R_Viewport_InitOrtho(&viewport, &cameramatrix, 0, 0, size, size, 0, 0, 1, 1, 0, -1, NULL); VectorMA(shadoworigin, (1.0f - fabs(dot1)) * radius, shadowforward, shadoworigin); - -#if 0 - R_Mesh_ResetRenderTargets(); - R_SetupShader_ShowDepth(); -#else - R_Mesh_SetRenderTargets(fbo, r_shadow_shadowmap2dtexture, NULL, NULL, NULL, NULL); + + R_Mesh_SetRenderTargets(fbo, r_shadow_shadowmap2dtexture, r_shadow_shadowmap2dcolortexture, NULL, NULL, NULL); R_SetupShader_DepthOrShadow(); -#endif GL_PolygonOffset(r_shadow_shadowmapping_polygonfactor.value, r_shadow_shadowmapping_polygonoffset.value); GL_DepthMask(true); GL_DepthTest(true); R_SetViewport(&viewport); GL_Scissor(viewport.x, viewport.y, min(viewport.width + r_shadow_shadowmapborder, 2*r_shadow_shadowmapmaxsize), viewport.height + r_shadow_shadowmapborder); Vector4Set(clearcolor, 1,1,1,1); + // in D3D9 we have to render to a color texture shadowmap + // in GL we render directly to a depth texture only + if (r_shadow_shadowmap2dtexture) + GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0); + else + GL_Clear(GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0); + // render into a slightly restricted region so that the borders of the + // shadowmap area fade away, rather than streaking across everything + // outside the usable area + GL_Scissor(viewport.x + r_shadow_shadowmapborder, viewport.y + r_shadow_shadowmapborder, viewport.width - 2*r_shadow_shadowmapborder, viewport.height - 2*r_shadow_shadowmapborder); + #if 0 + // debugging + R_Mesh_ResetRenderTargets(); + R_SetupShader_ShowDepth(); + GL_ColorMask(1,1,1,1); GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0); -#else - GL_Clear(GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0); #endif - GL_Scissor(viewport.x + r_shadow_shadowmapborder, viewport.y + r_shadow_shadowmapborder, viewport.width - 2*r_shadow_shadowmapborder, viewport.height - 2*r_shadow_shadowmapborder); for (i = 0;i < r_refdef.scene.numentities;i++) { @@ -4497,6 +4833,19 @@ void R_DrawModelShadowMaps(void) } } +#if 0 + if (r_test.integer) + { + unsigned char *rawpixels = Z_Malloc(viewport.width*viewport.height*4); + CHECKGLERROR + qglReadPixels(viewport.x, viewport.y, viewport.width, viewport.height, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, rawpixels); + CHECKGLERROR + Image_WriteTGABGRA("r_shadows_2.tga", viewport.width, viewport.height, rawpixels); + Cvar_SetValueQuick(&r_test, 0); + Z_Free(rawpixels); + } +#endif + R_Shadow_RenderMode_End(); Matrix4x4_Concat(&mvpmatrix, &r_refdef.view.viewport.projectmatrix, &r_refdef.view.viewport.viewmatrix); @@ -4506,15 +4855,37 @@ void R_DrawModelShadowMaps(void) Matrix4x4_Concat(&texmatrix, &scalematrix, &shadowmatrix); Matrix4x4_Concat(&r_shadow_shadowmapmatrix, &texmatrix, &invmvpmatrix); + switch (vid.renderpath) + { + case RENDERPATH_GL11: + case RENDERPATH_GL13: + case RENDERPATH_GL20: + case RENDERPATH_SOFT: + case RENDERPATH_GLES2: + break; + case RENDERPATH_D3D9: + case RENDERPATH_D3D10: + case RENDERPATH_D3D11: +#ifdef OPENGL_ORIENTATION + r_shadow_shadowmapmatrix.m[0][0] *= -1.0f; + r_shadow_shadowmapmatrix.m[0][1] *= -1.0f; + r_shadow_shadowmapmatrix.m[0][2] *= -1.0f; + r_shadow_shadowmapmatrix.m[0][3] *= -1.0f; +#else + r_shadow_shadowmapmatrix.m[0][0] *= -1.0f; + r_shadow_shadowmapmatrix.m[1][0] *= -1.0f; + r_shadow_shadowmapmatrix.m[2][0] *= -1.0f; + r_shadow_shadowmapmatrix.m[3][0] *= -1.0f; +#endif + break; + } + r_shadow_usingshadowmaportho = true; switch (r_shadow_shadowmode) { case R_SHADOW_SHADOWMODE_SHADOWMAP2D: r_shadow_usingshadowmap2d = true; break; - case R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE: - r_shadow_usingshadowmaprect = true; - break; default: break; } @@ -4666,19 +5037,19 @@ void R_BeginCoronaQuery(rtlight_t *rtlight, float scale, qboolean usequery) case RENDERPATH_GL20: case RENDERPATH_GL13: case RENDERPATH_GL11: - case RENDERPATH_CGGL: + case RENDERPATH_GLES2: CHECKGLERROR // NOTE: GL_DEPTH_TEST must be enabled or ATI won't count samples, so use GL_DepthFunc instead qglBeginQueryARB(GL_SAMPLES_PASSED_ARB, rtlight->corona_queryindex_allpixels); GL_DepthFunc(GL_ALWAYS); R_CalcSprite_Vertex3f(vertex3f, centerorigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale); - R_Mesh_PrepareVertices_Position_Arrays(4, vertex3f); + R_Mesh_PrepareVertices_Vertex3f(4, vertex3f, NULL); R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0); qglEndQueryARB(GL_SAMPLES_PASSED_ARB); GL_DepthFunc(GL_LEQUAL); qglBeginQueryARB(GL_SAMPLES_PASSED_ARB, rtlight->corona_queryindex_visiblepixels); R_CalcSprite_Vertex3f(vertex3f, rtlight->shadoworigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale); - R_Mesh_PrepareVertices_Position_Arrays(4, vertex3f); + R_Mesh_PrepareVertices_Vertex3f(4, vertex3f, NULL); R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0); qglEndQueryARB(GL_SAMPLES_PASSED_ARB); CHECKGLERROR @@ -4692,6 +5063,9 @@ void R_BeginCoronaQuery(rtlight_t *rtlight, float scale, qboolean usequery) case RENDERPATH_D3D11: Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); break; + case RENDERPATH_SOFT: + //Con_DPrintf("FIXME SOFT %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); + break; } } rtlight->corona_visibility = bound(0, (zdist - 32) / 32, 1); @@ -4711,7 +5085,7 @@ void R_DrawCorona(rtlight_t *rtlight, float cscale, float scale) case RENDERPATH_GL20: case RENDERPATH_GL13: case RENDERPATH_GL11: - case RENDERPATH_CGGL: + case RENDERPATH_GLES2: CHECKGLERROR qglGetQueryObjectivARB(rtlight->corona_queryindex_visiblepixels, GL_QUERY_RESULT_ARB, &visiblepixels); qglGetQueryObjectivARB(rtlight->corona_queryindex_allpixels, GL_QUERY_RESULT_ARB, &allpixels); @@ -4726,6 +5100,9 @@ void R_DrawCorona(rtlight_t *rtlight, float cscale, float scale) case RENDERPATH_D3D11: Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); break; + case RENDERPATH_SOFT: + //Con_DPrintf("FIXME SOFT %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); + break; } //Con_Printf("%i of %i pixels\n", (int)visiblepixels, (int)allpixels); if (visiblepixels < 1 || allpixels < 1) @@ -4752,7 +5129,7 @@ void R_DrawCorona(rtlight_t *rtlight, float cscale, float scale) case RENDERPATH_GL11: case RENDERPATH_GL13: case RENDERPATH_GL20: - case RENDERPATH_CGGL: + case RENDERPATH_GLES2: qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT); break; case RENDERPATH_D3D9: @@ -4766,6 +5143,9 @@ void R_DrawCorona(rtlight_t *rtlight, float cscale, float scale) case RENDERPATH_D3D11: Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); break; + case RENDERPATH_SOFT: + DPSOFTRAST_BlendSubtract(true); + break; } } R_CalcSprite_Vertex3f(vertex3f, rtlight->shadoworigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale); @@ -4778,7 +5158,7 @@ void R_DrawCorona(rtlight_t *rtlight, float cscale, float scale) case RENDERPATH_GL11: case RENDERPATH_GL13: case RENDERPATH_GL20: - case RENDERPATH_CGGL: + case RENDERPATH_GLES2: qglBlendEquationEXT(GL_FUNC_ADD_EXT); break; case RENDERPATH_D3D9: @@ -4792,6 +5172,9 @@ void R_DrawCorona(rtlight_t *rtlight, float cscale, float scale) case RENDERPATH_D3D11: Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); break; + case RENDERPATH_SOFT: + DPSOFTRAST_BlendSubtract(false); + break; } } } @@ -4823,7 +5206,7 @@ void R_Shadow_DrawCoronas(void) case RENDERPATH_GL11: case RENDERPATH_GL13: case RENDERPATH_GL20: - case RENDERPATH_CGGL: + case RENDERPATH_GLES2: usequery = vid.support.arb_occlusion_query && r_coronas_occlusionquery.integer; if (usequery) { @@ -4859,6 +5242,10 @@ void R_Shadow_DrawCoronas(void) case RENDERPATH_D3D11: Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); break; + case RENDERPATH_SOFT: + usequery = false; + //Con_DPrintf("FIXME SOFT %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); + break; } for (lightindex = 0;lightindex < range;lightindex++) { @@ -6229,31 +6616,140 @@ LIGHT SAMPLING ============================================================================= */ -void R_CompleteLightPoint(vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal, const vec3_t p, int dynamic) +void R_CompleteLightPoint(vec3_t ambient, vec3_t diffuse, vec3_t lightdir, const vec3_t p, const int flags) { - VectorClear(diffusecolor); - VectorClear(diffusenormal); + int i, numlights, flag; + rtlight_t *light; + dlight_t *dlight; + float relativepoint[3]; + float color[3]; + float dir[3]; + float dist; + float dist2; + float intensity; + float sample[5*3]; + float lightradius2; - if (!r_fullbright.integer && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.LightPoint) + if (r_fullbright.integer) { - ambientcolor[0] = ambientcolor[1] = ambientcolor[2] = r_refdef.scene.ambient; - r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, p, ambientcolor, diffusecolor, diffusenormal); + VectorSet(ambient, 1, 1, 1); + VectorClear(diffuse); + VectorClear(lightdir); + return; } - else - VectorSet(ambientcolor, 1, 1, 1); - if (dynamic) + if (flags & LP_LIGHTMAP) + { + VectorSet(ambient, r_refdef.scene.ambient, r_refdef.scene.ambient, r_refdef.scene.ambient); + VectorClear(diffuse); + VectorClear(lightdir); + if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.LightPoint) + r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, p, ambient, diffuse, lightdir); + return; + } + + memset(sample, 0, sizeof(sample)); + VectorSet(sample, r_refdef.scene.ambient, r_refdef.scene.ambient, r_refdef.scene.ambient); + + if ((flags & LP_LIGHTMAP) && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.LightPoint) { - int i; - float f, v[3]; - rtlight_t *light; + vec3_t tempambient; + VectorClear(tempambient); + VectorClear(color); + VectorClear(relativepoint); + r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, p, tempambient, color, relativepoint); + VectorScale(tempambient, r_refdef.lightmapintensity, tempambient); + VectorScale(color, r_refdef.lightmapintensity, color); + VectorAdd(sample, tempambient, sample); + VectorMA(sample , 0.5f , color, sample ); + VectorMA(sample + 3, relativepoint[0], color, sample + 3); + VectorMA(sample + 6, relativepoint[1], color, sample + 6); + VectorMA(sample + 9, relativepoint[2], color, sample + 9); + // calculate a weighted average light direction as well + intensity = VectorLength(color); + VectorMA(sample + 12, intensity, relativepoint, sample + 12); + } + + if (flags & LP_RTWORLD) + { + flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE; + numlights = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); + for (i = 0; i < numlights; i++) + { + dlight = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, i); + if (!dlight) + continue; + light = &dlight->rtlight; + if (!(light->flags & flag)) + continue; + // sample + lightradius2 = light->radius * light->radius; + VectorSubtract(light->shadoworigin, p, relativepoint); + dist2 = VectorLength2(relativepoint); + if (dist2 >= lightradius2) + continue; + dist = sqrt(dist2) / light->radius; + intensity = min(1.0f, (1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) * r_shadow_lightintensityscale.value; + if (intensity <= 0.0f) + continue; + if (light->shadow && CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false).fraction < 1) + continue; + // scale down intensity to add to both ambient and diffuse + //intensity *= 0.5f; + VectorNormalize(relativepoint); + VectorScale(light->currentcolor, intensity, color); + VectorMA(sample , 0.5f , color, sample ); + VectorMA(sample + 3, relativepoint[0], color, sample + 3); + VectorMA(sample + 6, relativepoint[1], color, sample + 6); + VectorMA(sample + 9, relativepoint[2], color, sample + 9); + // calculate a weighted average light direction as well + intensity *= VectorLength(color); + VectorMA(sample + 12, intensity, relativepoint, sample + 12); + } + } + + if (flags & LP_DYNLIGHT) + { + // sample dlights for (i = 0;i < r_refdef.scene.numlights;i++) { light = r_refdef.scene.lights[i]; - Matrix4x4_Transform(&light->matrix_worldtolight, p, v); - f = 1 - VectorLength2(v); - if (f > 0 && CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false).fraction == 1) - VectorMA(ambientcolor, f, light->currentcolor, ambientcolor); + // sample + lightradius2 = light->radius * light->radius; + VectorSubtract(light->shadoworigin, p, relativepoint); + dist2 = VectorLength2(relativepoint); + if (dist2 >= lightradius2) + continue; + dist = sqrt(dist2) / light->radius; + intensity = (1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist) * r_shadow_lightintensityscale.value; + if (intensity <= 0.0f) + continue; + if (light->shadow && CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false).fraction < 1) + continue; + // scale down intensity to add to both ambient and diffuse + //intensity *= 0.5f; + VectorNormalize(relativepoint); + VectorScale(light->currentcolor, intensity, color); + VectorMA(sample , 0.5f , color, sample ); + VectorMA(sample + 3, relativepoint[0], color, sample + 3); + VectorMA(sample + 6, relativepoint[1], color, sample + 6); + VectorMA(sample + 9, relativepoint[2], color, sample + 9); + // calculate a weighted average light direction as well + intensity *= VectorLength(color); + VectorMA(sample + 12, intensity, relativepoint, sample + 12); } } + + // calculate the direction we'll use to reduce the sample to a directional light source + VectorCopy(sample + 12, dir); + //VectorSet(dir, sample[3] + sample[4] + sample[5], sample[6] + sample[7] + sample[8], sample[9] + sample[10] + sample[11]); + VectorNormalize(dir); + // extract the diffuse color along the chosen direction and scale it + diffuse[0] = (dir[0]*sample[3] + dir[1]*sample[6] + dir[2]*sample[ 9] + sample[ 0]); + diffuse[1] = (dir[0]*sample[4] + dir[1]*sample[7] + dir[2]*sample[10] + sample[ 1]); + diffuse[2] = (dir[0]*sample[5] + dir[1]*sample[8] + dir[2]*sample[11] + sample[ 2]); + // subtract some of diffuse from ambient + VectorMA(sample, -0.333f, diffuse, ambient); + // store the normalized lightdir + VectorCopy(dir, lightdir); }