X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=gl_rmain.c;h=2ae94ca0b10750c2a74f4b49a2255950b5cf0747;hp=0234fdfb76bf4c3d18d44a889dd8e2a4e9c44261;hb=e5bd7b58a64bc25738028180da3c1990824d75ec;hpb=09f884dd87cbb5b3da9e261d8c0841cdb9365c5b diff --git a/gl_rmain.c b/gl_rmain.c index 0234fdfb..2ae94ca0 100644 --- a/gl_rmain.c +++ b/gl_rmain.c @@ -28,6 +28,11 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. #include "csprogs.h" #include "cl_video.h" +#ifdef SUPPORTD3D +#include +extern LPDIRECT3DDEVICE9 vid_d3d9dev; +#endif + mempool_t *r_main_mempool; rtexturepool_t *r_main_texturepool; @@ -76,6 +81,7 @@ cvar_t r_showcollisionbrushes_polygonoffset = {0, "r_showcollisionbrushes_polygo cvar_t r_showdisabledepthtest = {0, "r_showdisabledepthtest", "0", "disables depth testing on r_show* cvars, allowing you to see what hidden geometry the graphics card is processing"}; cvar_t r_drawportals = {0, "r_drawportals", "0", "shows portals (separating polygons) in world interior in quake1 maps"}; cvar_t r_drawentities = {0, "r_drawentities","1", "draw entities (doors, players, projectiles, etc)"}; +cvar_t r_draw2d = {0, "r_draw2d","1", "draw 2D stuff (dangerous to turn off)"}; cvar_t r_drawworld = {0, "r_drawworld","1", "draw world (most static stuff)"}; cvar_t r_drawviewmodel = {0, "r_drawviewmodel","1", "draw your weapon model"}; cvar_t r_drawexteriormodel = {0, "r_drawexteriormodel","1", "draw your player model (e.g. in chase cam, reflections)"}; @@ -86,6 +92,11 @@ cvar_t r_cullentities_trace_enlarge = {0, "r_cullentities_trace_enlarge", "0", " cvar_t r_cullentities_trace_delay = {0, "r_cullentities_trace_delay", "1", "number of seconds until the entity gets actually culled"}; cvar_t r_speeds = {0, "r_speeds","0", "displays rendering statistics and per-subsystem timings"}; cvar_t r_fullbright = {0, "r_fullbright","0", "makes map very bright and renders faster"}; + +cvar_t r_fakelight = {0, "r_fakelight","0", "render 'fake' lighting instead of real lightmaps"}; +cvar_t r_fakelight_intensity = {0, "r_fakelight_intensity","0.75", "fakelight intensity modifier"}; +#define FAKELIGHT_ENABLED (r_fakelight.integer >= 2 || (r_fakelight.integer && r_refdef.scene.worldmodel && !r_refdef.scene.worldmodel->lit)) + cvar_t r_wateralpha = {CVAR_SAVE, "r_wateralpha","1", "opacity of water polygons"}; cvar_t r_dynamic = {CVAR_SAVE, "r_dynamic","1", "enables dynamic lights (rocket glow and such)"}; cvar_t r_fullbrights = {CVAR_SAVE, "r_fullbrights", "1", "enables glowing pixels in quake textures (changes need r_restart to take effect)"}; @@ -137,12 +148,17 @@ cvar_t r_glsl_postprocess_uservec1 = {CVAR_SAVE, "r_glsl_postprocess_uservec1", cvar_t r_glsl_postprocess_uservec2 = {CVAR_SAVE, "r_glsl_postprocess_uservec2", "0 0 0 0", "a 4-component vector to pass as uservec2 to the postprocessing shader (only useful if default.glsl has been customized)"}; cvar_t r_glsl_postprocess_uservec3 = {CVAR_SAVE, "r_glsl_postprocess_uservec3", "0 0 0 0", "a 4-component vector to pass as uservec3 to the postprocessing shader (only useful if default.glsl has been customized)"}; cvar_t r_glsl_postprocess_uservec4 = {CVAR_SAVE, "r_glsl_postprocess_uservec4", "0 0 0 0", "a 4-component vector to pass as uservec4 to the postprocessing shader (only useful if default.glsl has been customized)"}; +cvar_t r_glsl_postprocess_uservec1_enable = {CVAR_SAVE, "r_glsl_postprocess_uservec1_enable", "1", "enables postprocessing uservec1 usage, creates USERVEC1 define (only useful if default.glsl has been customized)"}; +cvar_t r_glsl_postprocess_uservec2_enable = {CVAR_SAVE, "r_glsl_postprocess_uservec2_enable", "1", "enables postprocessing uservec2 usage, creates USERVEC1 define (only useful if default.glsl has been customized)"}; +cvar_t r_glsl_postprocess_uservec3_enable = {CVAR_SAVE, "r_glsl_postprocess_uservec3_enable", "1", "enables postprocessing uservec3 usage, creates USERVEC1 define (only useful if default.glsl has been customized)"}; +cvar_t r_glsl_postprocess_uservec4_enable = {CVAR_SAVE, "r_glsl_postprocess_uservec4_enable", "1", "enables postprocessing uservec4 usage, creates USERVEC1 define (only useful if default.glsl has been customized)"}; cvar_t r_water = {CVAR_SAVE, "r_water", "0", "whether to use reflections and refraction on water surfaces (note: r_wateralpha must be set below 1)"}; cvar_t r_water_clippingplanebias = {CVAR_SAVE, "r_water_clippingplanebias", "1", "a rather technical setting which avoids black pixels around water edges"}; cvar_t r_water_resolutionmultiplier = {CVAR_SAVE, "r_water_resolutionmultiplier", "0.5", "multiplier for screen resolution when rendering refracted/reflected scenes, 1 is full quality, lower values are faster"}; cvar_t r_water_refractdistort = {CVAR_SAVE, "r_water_refractdistort", "0.01", "how much water refractions shimmer"}; cvar_t r_water_reflectdistort = {CVAR_SAVE, "r_water_reflectdistort", "0.01", "how much water reflections shimmer"}; +cvar_t r_water_scissormode = {0, "r_water_scissormode", "3", "scissor (1) or cull (2) or both (3) water renders"}; cvar_t r_lerpsprites = {CVAR_SAVE, "r_lerpsprites", "0", "enables animation smoothing on sprites"}; cvar_t r_lerpmodels = {CVAR_SAVE, "r_lerpmodels", "1", "enables animation smoothing on models"}; @@ -177,6 +193,7 @@ cvar_t r_overheadsprites_perspective = {CVAR_SAVE, "r_overheadsprites_perspectiv cvar_t r_overheadsprites_pushback = {CVAR_SAVE, "r_overheadsprites_pushback", "16", "how far to pull the SPR_OVERHEAD sprites toward the eye (used to avoid intersections with 3D models)"}; cvar_t r_glsl_saturation = {CVAR_SAVE, "r_glsl_saturation", "1", "saturation multiplier (only working in glsl!)"}; +cvar_t r_glsl_saturation_redcompensate = {CVAR_SAVE, "r_glsl_saturation_redcompensate", "0", "a 'vampire sight' addition to desaturation effect, does compensation for red color, r_glsl_restart is required"}; cvar_t r_framedatasize = {CVAR_SAVE, "r_framedatasize", "1", "size of renderer data cache used during one frame (for skeletal animation caching, light processing, etc)"}; @@ -251,6 +268,8 @@ static r_qwskincache_t *r_qwskincache; static int r_qwskincache_size; /// vertex coordinates for a quad that covers the screen exactly +extern const float r_screenvertex3f[12]; +extern const float r_d3dscreenvertex3f[12]; const float r_screenvertex3f[12] = { 0, 0, 0, @@ -258,6 +277,13 @@ const float r_screenvertex3f[12] = 1, 1, 0, 0, 1, 0 }; +const float r_d3dscreenvertex3f[12] = +{ + 0, 1, 0, + 1, 1, 0, + 1, 0, 0, + 0, 0, 0 +}; void R_ModulateColors(float *in, float *out, int verts, float r, float g, float b) { @@ -376,7 +402,7 @@ static void R_BuildNormalizationCube(void) vec_t s, t, intensity; #define NORMSIZE 64 unsigned char *data; - data = Mem_Alloc(tempmempool, 6*NORMSIZE*NORMSIZE*4); + data = (unsigned char *)Mem_Alloc(tempmempool, 6*NORMSIZE*NORMSIZE*4); for (side = 0;side < 6;side++) { for (y = 0;y < NORMSIZE;y++) @@ -482,8 +508,8 @@ static void R_BuildFogTexture(void) } else { - r_texture_fogattenuation = R_LoadTexture2D(r_main_texturepool, "fogattenuation", FOGWIDTH, 1, &data1[0][0], TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_PERSISTENT | TEXF_ALLOWUPDATES, -1, NULL); - //r_texture_fogintensity = R_LoadTexture2D(r_main_texturepool, "fogintensity", FOGWIDTH, 1, &data2[0][0], TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_ALLOWUPDATES, NULL); + r_texture_fogattenuation = R_LoadTexture2D(r_main_texturepool, "fogattenuation", FOGWIDTH, 1, &data1[0][0], TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_PERSISTENT, -1, NULL); + //r_texture_fogintensity = R_LoadTexture2D(r_main_texturepool, "fogintensity", FOGWIDTH, 1, &data2[0][0], TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP, NULL); } } @@ -516,8 +542,8 @@ static void R_BuildFogHeightTexture(void) } size = image_width; r_refdef.fog_height_tablesize = size; - r_refdef.fog_height_table1d = Mem_Alloc(r_main_mempool, size * 4); - r_refdef.fog_height_table2d = Mem_Alloc(r_main_mempool, size * size * 4); + r_refdef.fog_height_table1d = (unsigned char *)Mem_Alloc(r_main_mempool, size * 4); + r_refdef.fog_height_table2d = (unsigned char *)Mem_Alloc(r_main_mempool, size * size * 4); memcpy(r_refdef.fog_height_table1d, inpixels, size * 4); Mem_Free(inpixels); // LordHavoc: now the magic - what is that table2d for? it is a cooked @@ -568,14 +594,10 @@ static const char *builtinshaderstring = "#if defined(MODE_LIGHTMAP) || defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n" "#define USELIGHTMAP\n" "#endif\n" -"#if defined(USESPECULAR) || defined(USEOFFSETMAPPING) || defined(USEREFLECTCUBE)\n" +"#if defined(USESPECULAR) || defined(USEOFFSETMAPPING) || defined(USEREFLECTCUBE) || defined(MODE_FAKELIGHT)\n" "#define USEEYEVECTOR\n" "#endif\n" "\n" -"#if defined(USESHADOWMAPRECT) || defined(MODE_DEFERREDLIGHTSOURCE) || defined(USEDEFERREDLIGHTMAP)\n" -"# extension GL_ARB_texture_rectangle : enable\n" -"#endif\n" -"\n" "#ifdef USESHADOWMAP2D\n" "# ifdef GL_EXT_gpu_shader4\n" "# extension GL_EXT_gpu_shader4 : enable\n" @@ -589,10 +611,6 @@ static const char *builtinshaderstring = "# endif\n" "#endif\n" "\n" -"#ifdef USESHADOWMAPCUBE\n" -"# extension GL_EXT_gpu_shader4 : enable\n" -"#endif\n" -"\n" "//#ifdef USESHADOWSAMPLER\n" "//# extension GL_ARB_shadow : enable\n" "//#endif\n" @@ -664,6 +682,7 @@ static const char *builtinshaderstring = "uniform sampler2D Texture_First;\n" "#ifdef USEBLOOM\n" "uniform sampler2D Texture_Second;\n" +"uniform vec4 BloomColorSubtract;\n" "#endif\n" "#ifdef USEGAMMARAMPS\n" "uniform sampler2D Texture_GammaRamps;\n" @@ -685,7 +704,7 @@ static const char *builtinshaderstring = "{\n" " gl_FragColor = texture2D(Texture_First, TexCoord1);\n" "#ifdef USEBLOOM\n" -" gl_FragColor += texture2D(Texture_Second, TexCoord2);\n" +" gl_FragColor += max(vec4(0,0,0,0), texture2D(Texture_Second, TexCoord2) - BloomColorSubtract);\n" "#endif\n" "#ifdef USEVIEWTINT\n" " gl_FragColor = mix(gl_FragColor, ViewTintColor, ViewTintColor.a);\n" @@ -735,8 +754,16 @@ static const char *builtinshaderstring = "#ifdef USESATURATION\n" " //apply saturation BEFORE gamma ramps, so v_glslgamma value does not matter\n" " float y = dot(gl_FragColor.rgb, vec3(0.299, 0.587, 0.114));\n" -" //gl_FragColor = vec3(y) + (gl_FragColor.rgb - vec3(y)) * Saturation;\n" -" gl_FragColor.rgb = mix(vec3(y), gl_FragColor.rgb, Saturation);\n" +" // 'vampire sight' effect, wheres red is compensated\n" +" #ifdef SATURATION_REDCOMPENSATE\n" +" float rboost = max(0.0, (gl_FragColor.r - max(gl_FragColor.g, gl_FragColor.b))*(1.0 - Saturation));\n" +" gl_FragColor.rgb = mix(vec3(y), gl_FragColor.rgb, Saturation);\n" +" gl_FragColor.r += rboost;\n" +" #else\n" +" // normal desaturation\n" +" //gl_FragColor = vec3(y) + (gl_FragColor.rgb - vec3(y)) * Saturation;\n" +" gl_FragColor.rgb = mix(vec3(y), gl_FragColor.rgb, Saturation);\n" +" #endif\n" "#endif\n" "\n" "#ifdef USEGAMMARAMPS\n" @@ -782,7 +809,11 @@ static const char *builtinshaderstring = "\n" "void main(void)\n" "{\n" +"#ifdef USEVIEWTINT\n" " gl_FragColor = gl_Color;\n" +"#else\n" +" gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);\n" +"#endif\n" "#ifdef USEDIFFUSE\n" " gl_FragColor *= texture2D(Texture_First, TexCoord1);\n" "#endif\n" @@ -879,7 +910,7 @@ static const char *builtinshaderstring = " f *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(-0.01, 0.01)).rgb) / 0.05);\n" " f *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(-0.01, -0.01)).rgb) / 0.05);\n" " ScreenTexCoord = mix(SafeScreenTexCoord, ScreenTexCoord, f);\n" -" gl_FragColor = texture2D(Texture_Refraction, ScreenTexCoord) * RefractColor;\n" +" gl_FragColor = vec4(texture2D(Texture_Refraction, ScreenTexCoord).rgb, 1.0) * RefractColor;\n" "}\n" "#endif\n" "#else // !MODE_REFRACTION\n" @@ -919,6 +950,10 @@ static const char *builtinshaderstring = "uniform vec4 ReflectColor;\n" "uniform float ReflectFactor;\n" "uniform float ReflectOffset;\n" +"uniform float ClientTime;\n" +"#ifdef USENORMALMAPSCROLLBLEND\n" +"uniform vec2 NormalmapScrollBlend;\n" +"#endif\n" "\n" "void main(void)\n" "{\n" @@ -926,24 +961,32 @@ static const char *builtinshaderstring = " //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n" " vec4 SafeScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n" " //SafeScreenTexCoord = gl_FragCoord.xyxy * vec4(1.0 / 1920.0, 1.0 / 1200.0, 1.0 / 1920.0, 1.0 / 1200.0);\n" -" vec4 ScreenTexCoord = SafeScreenTexCoord + vec2(normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5))).xyxy * DistortScaleRefractReflect;\n" +" // slight water animation via 2 layer scrolling (todo: tweak)\n" +" #ifdef USENORMALMAPSCROLLBLEND\n" +" vec3 normal = texture2D(Texture_Normal, (TexCoord + vec2(0.08, 0.08)*ClientTime*NormalmapScrollBlend.x*0.5)*NormalmapScrollBlend.y).rgb - vec3(1.0);\n" +" normal += texture2D(Texture_Normal, (TexCoord + vec2(-0.06, -0.09)*ClientTime*NormalmapScrollBlend.x)*NormalmapScrollBlend.y*0.75).rgb;\n" +" vec4 ScreenTexCoord = SafeScreenTexCoord + vec2(normalize(normal) + vec3(0.15)).xyxy * DistortScaleRefractReflect;\n" +" #else\n" +" vec4 ScreenTexCoord = SafeScreenTexCoord + vec2(normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5))).xyxy * DistortScaleRefractReflect;\n" +" #endif\n" " // FIXME temporary hack to detect the case that the reflection\n" " // gets blackened at edges due to leaving the area that contains actual\n" " // content.\n" " // Remove this 'ack once we have a better way to stop this thing from\n" " // 'appening.\n" -" float f = min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(0.01, 0.01)).rgb) / 0.05);\n" -" f *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(0.01, -0.01)).rgb) / 0.05);\n" -" f *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(-0.01, 0.01)).rgb) / 0.05);\n" -" f *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(-0.01, -0.01)).rgb) / 0.05);\n" -" ScreenTexCoord.xy = mix(SafeScreenTexCoord.xy, ScreenTexCoord.xy, f);\n" -" f = min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(0.01, 0.01)).rgb) / 0.05);\n" -" f *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(0.01, -0.01)).rgb) / 0.05);\n" -" f *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(-0.01, 0.01)).rgb) / 0.05);\n" -" f *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(-0.01, -0.01)).rgb) / 0.05);\n" +" float f1 = min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(0.005, 0.01)).rgb) / 0.002);\n" +" f1 *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(0.005, -0.01)).rgb) / 0.002);\n" +" f1 *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(-0.005, 0.01)).rgb) / 0.002);\n" +" f1 *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(-0.005, -0.01)).rgb) / 0.002);\n" +" ScreenTexCoord.xy = mix(SafeScreenTexCoord.xy, ScreenTexCoord.xy, f1);\n" +" float f = min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(0.005, 0.005)).rgb) / 0.002);\n" +" f *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(0.005, -0.005)).rgb) / 0.002);\n" +" f *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(-0.005, 0.005)).rgb) / 0.002);\n" +" f *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(-0.005, -0.005)).rgb) / 0.002);\n" " ScreenTexCoord.zw = mix(SafeScreenTexCoord.zw, ScreenTexCoord.zw, f);\n" " float Fresnel = pow(min(1.0, 1.0 - float(normalize(EyeVector).z)), 2.0) * ReflectFactor + ReflectOffset;\n" -" gl_FragColor = mix(texture2D(Texture_Refraction, ScreenTexCoord.xy) * RefractColor, texture2D(Texture_Reflection, ScreenTexCoord.zw) * ReflectColor, Fresnel);\n" +" gl_FragColor = mix(vec4(texture2D(Texture_Refraction, ScreenTexCoord.xy).rgb, 1) * RefractColor, vec4(texture2D(Texture_Reflection, ScreenTexCoord.zw).rgb, 1) * ReflectColor, Fresnel);\n" +" gl_FragColor.a = f1 + 0.5;\n" "}\n" "#endif\n" "#else // !MODE_WATER\n" @@ -1113,15 +1156,14 @@ static const char *builtinshaderstring = " RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.0625 - 0.03125);\n" " return RT.xy;\n" "#else\n" -" // 3 sample offset mapping (only 3 samples because of ATI Radeon 9500-9800/X300 limits)\n" +" // 2 sample offset mapping (only 2 samples because of ATI Radeon 9500-9800/X300 limits)\n" " // this basically moves forward the full distance, and then backs up based\n" " // on height of samples\n" " //vec2 OffsetVector = vec2(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * vec2(-1, 1));\n" " //vec2 OffsetVector = vec2(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-1, 1));\n" " vec2 OffsetVector = vec2(normalize(EyeVector).xy * OffsetMapping_Scale * vec2(-1, 1));\n" " TexCoord += OffsetVector;\n" -" OffsetVector *= 0.333;\n" -" TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n" +" OffsetVector *= 0.5;\n" " TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n" " TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n" " return TexCoord;\n" @@ -1136,14 +1178,6 @@ static const char *builtinshaderstring = "\n" "#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE) || defined(USESHADOWMAPORTHO)\n" "\n" -"#ifdef USESHADOWMAPRECT\n" -"# ifdef USESHADOWSAMPLER\n" -"uniform sampler2DRectShadow Texture_ShadowMapRect;\n" -"# else\n" -"uniform sampler2DRect Texture_ShadowMapRect;\n" -"# endif\n" -"#endif\n" -"\n" "#ifdef USESHADOWMAP2D\n" "# ifdef USESHADOWSAMPLER\n" "uniform sampler2DShadow Texture_ShadowMap2D;\n" @@ -1156,20 +1190,12 @@ static const char *builtinshaderstring = "uniform samplerCube Texture_CubeProjection;\n" "#endif\n" "\n" -"#ifdef USESHADOWMAPCUBE\n" -"# ifdef USESHADOWSAMPLER\n" -"uniform samplerCubeShadow Texture_ShadowMapCube;\n" -"# else\n" -"uniform samplerCube Texture_ShadowMapCube;\n" -"# endif\n" -"#endif\n" -"\n" -"#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D) || defined(USESHADOWMAPCUBE)\n" +"#if defined(USESHADOWMAP2D)\n" "uniform vec2 ShadowMap_TextureScale;\n" "uniform vec4 ShadowMap_Parameters;\n" "#endif\n" "\n" -"#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D)\n" +"#if defined(USESHADOWMAP2D)\n" "# ifdef USESHADOWMAPORTHO\n" "# define GetShadowMapTC2D(dir) (min(dir, ShadowMap_Parameters.xyz))\n" "# else\n" @@ -1194,63 +1220,7 @@ static const char *builtinshaderstring = "}\n" "# endif\n" "# endif\n" -"#endif // defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D)\n" -"\n" -"#ifdef USESHADOWMAPCUBE\n" -"vec4 GetShadowMapTCCube(vec3 dir)\n" -"{\n" -" vec3 adir = abs(dir);\n" -" return vec4(dir, ShadowMap_Parameters.w + ShadowMap_Parameters.y / max(max(adir.x, adir.y), adir.z));\n" -"}\n" -"#endif\n" -"\n" -"# ifdef USESHADOWMAPRECT\n" -"float ShadowMapCompare(vec3 dir)\n" -"{\n" -" vec3 shadowmaptc = GetShadowMapTC2D(dir);\n" -" float f;\n" -"# ifdef USESHADOWSAMPLER\n" -"\n" -"# ifdef USESHADOWMAPPCF\n" -"# define texval(x, y) shadow2DRect(Texture_ShadowMapRect, shadowmaptc + vec3(x, y, 0.0)).r\n" -" f = dot(vec4(0.25), vec4(texval(-0.4, 1.0), texval(-1.0, -0.4), texval(0.4, -1.0), texval(1.0, 0.4)));\n" -"# else\n" -" f = shadow2DRect(Texture_ShadowMapRect, shadowmaptc).r;\n" -"# endif\n" -"\n" -"# else\n" -"\n" -"# ifdef USESHADOWMAPPCF\n" -"# if USESHADOWMAPPCF > 1\n" -"# define texval(x, y) texture2DRect(Texture_ShadowMapRect, center + vec2(x, y)).r\n" -" vec2 center = shadowmaptc.xy - 0.5, offset = fract(center);\n" -" vec4 row1 = step(shadowmaptc.z, vec4(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0), texval( 2.0, -1.0)));\n" -" vec4 row2 = step(shadowmaptc.z, vec4(texval(-1.0, 0.0), texval( 0.0, 0.0), texval( 1.0, 0.0), texval( 2.0, 0.0)));\n" -" vec4 row3 = step(shadowmaptc.z, vec4(texval(-1.0, 1.0), texval( 0.0, 1.0), texval( 1.0, 1.0), texval( 2.0, 1.0)));\n" -" vec4 row4 = step(shadowmaptc.z, vec4(texval(-1.0, 2.0), texval( 0.0, 2.0), texval( 1.0, 2.0), texval( 2.0, 2.0)));\n" -" vec4 cols = row2 + row3 + mix(row1, row4, offset.y);\n" -" f = dot(mix(cols.xyz, cols.yzw, offset.x), vec3(1.0/9.0));\n" -"# else\n" -"# define texval(x, y) texture2DRect(Texture_ShadowMapRect, shadowmaptc.xy + vec2(x, y)).r\n" -" vec2 offset = fract(shadowmaptc.xy);\n" -" vec3 row1 = step(shadowmaptc.z, vec3(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0)));\n" -" vec3 row2 = step(shadowmaptc.z, vec3(texval(-1.0, 0.0), texval( 0.0, 0.0), texval( 1.0, 0.0)));\n" -" vec3 row3 = step(shadowmaptc.z, vec3(texval(-1.0, 1.0), texval( 0.0, 1.0), texval( 1.0, 1.0)));\n" -" vec3 cols = row2 + mix(row1, row3, offset.y);\n" -" f = dot(mix(cols.xy, cols.yz, offset.x), vec2(0.25));\n" -"# endif\n" -"# else\n" -" f = step(shadowmaptc.z, texture2DRect(Texture_ShadowMapRect, shadowmaptc.xy).r);\n" -"# endif\n" -"\n" -"# endif\n" -"# ifdef USESHADOWMAPORTHO\n" -" return mix(ShadowMap_Parameters.w, 1.0, f);\n" -"# else\n" -" return f;\n" -"# endif\n" -"}\n" -"# endif\n" +"#endif // defined(USESHADOWMAP2D)\n" "\n" "# ifdef USESHADOWMAP2D\n" "float ShadowMapCompare(vec3 dir)\n" @@ -1339,21 +1309,6 @@ static const char *builtinshaderstring = "# endif\n" "}\n" "# endif\n" -"\n" -"# ifdef USESHADOWMAPCUBE\n" -"float ShadowMapCompare(vec3 dir)\n" -"{\n" -" // apply depth texture cubemap as light filter\n" -" vec4 shadowmaptc = GetShadowMapTCCube(dir);\n" -" float f;\n" -"# ifdef USESHADOWSAMPLER\n" -" f = shadowCube(Texture_ShadowMapCube, shadowmaptc).r;\n" -"# else\n" -" f = step(shadowmaptc.w, textureCube(Texture_ShadowMapCube, shadowmaptc.xyz).r);\n" -"# endif\n" -" return f;\n" -"}\n" -"# endif\n" "#endif // !defined(MODE_LIGHTSOURCE) && !defined(MODE_DEFERREDLIGHTSOURCE) && !defined(USESHADOWMAPORTHO)\n" "#endif // FRAGMENT_SHADER\n" "\n" @@ -1480,7 +1435,7 @@ static const char *builtinshaderstring = "# endif\n" "#endif\n" "\n" -"#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAPCUBE) || defined(USESHADOWMAP2D)\n" +"#if defined(USESHADOWMAP2D)\n" " fade *= ShadowMapCompare(CubeVector);\n" "#endif\n" "\n" @@ -1694,7 +1649,7 @@ static const char *builtinshaderstring = "#endif\n" " color.rgb *= LightColor;\n" " color.rgb *= myhalf(texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0)));\n" -"#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAPCUBE) || defined(USESHADOWMAP2D)\n" +"#if defined(USESHADOWMAP2D)\n" " color.rgb *= ShadowMapCompare(CubeVector);\n" "#endif\n" "# ifdef USECUBEFILTER\n" @@ -1743,6 +1698,15 @@ static const char *builtinshaderstring = "\n" "\n" "\n" +"#ifdef MODE_FAKELIGHT\n" +"#define SHADING\n" +"myhalf3 lightnormal = myhalf3(normalize(EyeVector));\n" +"myhalf3 lightcolor = myhalf3(1.0);\n" +"#endif // MODE_FAKELIGHT\n" +"\n" +"\n" +"\n" +"\n" "#ifdef MODE_LIGHTMAP\n" " color.rgb = diffusetex * (Color_Ambient + myhalf3(texture2D(Texture_Lightmap, TexCoordLightmap)) * Color_Diffuse);\n" "#endif // MODE_LIGHTMAP\n" @@ -1875,24 +1839,47 @@ const char *builtincgshaderstring = "#if defined(MODE_LIGHTMAP) || defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n" "#define USELIGHTMAP\n" "#endif\n" -"#if defined(USESPECULAR) || defined(USEOFFSETMAPPING) || defined(USEREFLECTCUBE)\n" +"#if defined(USESPECULAR) || defined(USEOFFSETMAPPING) || defined(USEREFLECTCUBE) || defined(MODE_FAKELIGHT)\n" "#define USEEYEVECTOR\n" "#endif\n" "\n" "#ifdef FRAGMENT_SHADER\n" +"#ifdef HLSL\n" +"//#undef USESHADOWMAPPCF\n" +"//#define texDepth2D(tex,texcoord) tex2D(tex,texcoord).r\n" +"#define texDepth2D(tex,texcoord) dot(tex2D(tex,texcoord).rgb, float3(1.0, 255.0/65536.0, 255.0/16777216.0))\n" +"#else\n" "#define texDepth2D(tex,texcoord) tex2D(tex,texcoord).r\n" "#endif\n" +"#endif\n" "\n" "#ifdef MODE_DEPTH_OR_SHADOW\n" "#ifdef VERTEX_SHADER\n" "void main\n" "(\n" "float4 gl_Vertex : POSITION,\n" -"uniform float4x4 ModelViewProjectionMatrix,\n" -"out float4 gl_Position : POSITION\n" +"uniform float4x4 ModelViewProjectionMatrix : register(c8),\n" +"out float4 gl_Position : POSITION,\n" +"out float Depth : TEXCOORD0\n" ")\n" "{\n" " gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n" +" Depth = gl_Position.z;\n" +"}\n" +"#endif\n" +"\n" +"#ifdef FRAGMENT_SHADER\n" +"void main\n" +"(\n" +"float Depth : TEXCOORD0,\n" +"out float4 gl_FragColor : COLOR\n" +")\n" +"{\n" +"// float4 temp = float4(Depth,Depth*(65536.0/255.0),Depth*(16777216.0/255.0),0.0);\n" +" float4 temp = float4(Depth,Depth*256.0,Depth*65536.0,0.0);\n" +" temp.yz -= floor(temp.yz);\n" +" gl_FragColor = temp;\n" +"// gl_FragColor = float4(Depth,0,0,0);\n" "}\n" "#endif\n" "#else // !MODE_DEPTH_ORSHADOW\n" @@ -1905,7 +1892,7 @@ const char *builtincgshaderstring = "void main\n" "(\n" "float4 gl_Vertex : POSITION,\n" -"uniform float4x4 ModelViewProjectionMatrix,\n" +"uniform float4x4 ModelViewProjectionMatrix : register(c8),\n" "out float4 gl_Position : POSITION,\n" "out float4 gl_FrontColor : COLOR0\n" ")\n" @@ -1936,9 +1923,9 @@ const char *builtincgshaderstring = "void main\n" "(\n" "float4 gl_Vertex : POSITION,\n" -"uniform float4x4 ModelViewProjectionMatrix,\n" +"uniform float4x4 ModelViewProjectionMatrix : register(c8),\n" "float4 gl_MultiTexCoord0 : TEXCOORD0,\n" -"float4 gl_MultiTexCoord1 : TEXCOORD4,\n" +"float4 gl_MultiTexCoord4 : TEXCOORD4,\n" "out float4 gl_Position : POSITION,\n" "out float2 TexCoord1 : TEXCOORD0,\n" "out float2 TexCoord2 : TEXCOORD1\n" @@ -1947,7 +1934,7 @@ const char *builtincgshaderstring = " gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n" " TexCoord1 = gl_MultiTexCoord0.xy;\n" "#ifdef USEBLOOM\n" -" TexCoord2 = gl_MultiTexCoord1.xy;\n" +" TexCoord2 = gl_MultiTexCoord4.xy;\n" "#endif\n" "}\n" "#endif\n" @@ -1957,31 +1944,32 @@ const char *builtincgshaderstring = "(\n" "float2 TexCoord1 : TEXCOORD0,\n" "float2 TexCoord2 : TEXCOORD1,\n" -"uniform sampler2D Texture_First,\n" +"uniform sampler Texture_First : register(s0),\n" "#ifdef USEBLOOM\n" -"uniform sampler2D Texture_Second,\n" +"uniform sampler Texture_Second : register(s1),\n" "#endif\n" "#ifdef USEGAMMARAMPS\n" -"uniform sampler2D Texture_GammaRamps,\n" +"uniform sampler Texture_GammaRamps : register(s2),\n" "#endif\n" "#ifdef USESATURATION\n" -"uniform float Saturation,\n" +"uniform float Saturation : register(c30),\n" "#endif\n" "#ifdef USEVIEWTINT\n" -"uniform float4 ViewTintColor,\n" -"#endif\n" -"uniform float4 UserVec1,\n" -"uniform float4 UserVec2,\n" -"uniform float4 UserVec3,\n" -"uniform float4 UserVec4,\n" -"uniform float ClientTime,\n" -"uniform float2 PixelSize,\n" +"uniform float4 ViewTintColor : register(c41),\n" +"#endif\n" +"uniform float4 UserVec1 : register(c37),\n" +"uniform float4 UserVec2 : register(c38),\n" +"uniform float4 UserVec3 : register(c39),\n" +"uniform float4 UserVec4 : register(c40),\n" +"uniform float ClientTime : register(c2),\n" +"uniform float2 PixelSize : register(c25),\n" +"uniform float4 BloomColorSubtract : register(c43),\n" "out float4 gl_FragColor : COLOR\n" ")\n" "{\n" " gl_FragColor = tex2D(Texture_First, TexCoord1);\n" "#ifdef USEBLOOM\n" -" gl_FragColor += tex2D(Texture_Second, TexCoord2);\n" +" gl_FragColor += max(float4(0,0,0,0), tex2D(Texture_Second, TexCoord2) - BloomColorSubtract);\n" "#endif\n" "#ifdef USEVIEWTINT\n" " gl_FragColor = lerp(gl_FragColor, ViewTintColor, ViewTintColor.a);\n" @@ -1990,19 +1978,57 @@ const char *builtincgshaderstring = "#ifdef USEPOSTPROCESSING\n" "// do r_glsl_dumpshader, edit glsl/default.glsl, and replace this by your own postprocessing if you want\n" "// this code does a blur with the radius specified in the first component of r_glsl_postprocess_uservec1 and blends it using the second component\n" +" float sobel = 1.0;\n" +" // float2 ts = textureSize(Texture_First, 0);\n" +" // float2 px = float2(1/ts.x, 1/ts.y);\n" +" float2 px = PixelSize;\n" +" float3 x1 = tex2D(Texture_First, TexCoord1 + float2(-px.x, px.y)).rgb;\n" +" float3 x2 = tex2D(Texture_First, TexCoord1 + float2(-px.x, 0.0)).rgb;\n" +" float3 x3 = tex2D(Texture_First, TexCoord1 + float2(-px.x,-px.y)).rgb;\n" +" float3 x4 = tex2D(Texture_First, TexCoord1 + float2( px.x, px.y)).rgb;\n" +" float3 x5 = tex2D(Texture_First, TexCoord1 + float2( px.x, 0.0)).rgb;\n" +" float3 x6 = tex2D(Texture_First, TexCoord1 + float2( px.x,-px.y)).rgb;\n" +" float3 y1 = tex2D(Texture_First, TexCoord1 + float2( px.x,-px.y)).rgb;\n" +" float3 y2 = tex2D(Texture_First, TexCoord1 + float2( 0.0,-px.y)).rgb;\n" +" float3 y3 = tex2D(Texture_First, TexCoord1 + float2(-px.x,-px.y)).rgb;\n" +" float3 y4 = tex2D(Texture_First, TexCoord1 + float2( px.x, px.y)).rgb;\n" +" float3 y5 = tex2D(Texture_First, TexCoord1 + float2( 0.0, px.y)).rgb;\n" +" float3 y6 = tex2D(Texture_First, TexCoord1 + float2(-px.x, px.y)).rgb;\n" +" float px1 = -1.0 * dot(float3(0.3, 0.59, 0.11), x1);\n" +" float px2 = -2.0 * dot(float3(0.3, 0.59, 0.11), x2);\n" +" float px3 = -1.0 * dot(float3(0.3, 0.59, 0.11), x3);\n" +" float px4 = 1.0 * dot(float3(0.3, 0.59, 0.11), x4);\n" +" float px5 = 2.0 * dot(float3(0.3, 0.59, 0.11), x5);\n" +" float px6 = 1.0 * dot(float3(0.3, 0.59, 0.11), x6);\n" +" float py1 = -1.0 * dot(float3(0.3, 0.59, 0.11), y1);\n" +" float py2 = -2.0 * dot(float3(0.3, 0.59, 0.11), y2);\n" +" float py3 = -1.0 * dot(float3(0.3, 0.59, 0.11), y3);\n" +" float py4 = 1.0 * dot(float3(0.3, 0.59, 0.11), y4);\n" +" float py5 = 2.0 * dot(float3(0.3, 0.59, 0.11), y5);\n" +" float py6 = 1.0 * dot(float3(0.3, 0.59, 0.11), y6);\n" +" sobel = 0.25 * abs(px1 + px2 + px3 + px4 + px5 + px6) + 0.25 * abs(py1 + py2 + py3 + py4 + py5 + py6);\n" " gl_FragColor += tex2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*float2(-0.987688, -0.156434)) * UserVec1.y;\n" " gl_FragColor += tex2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*float2(-0.156434, -0.891007)) * UserVec1.y;\n" " gl_FragColor += tex2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*float2( 0.891007, -0.453990)) * UserVec1.y;\n" " gl_FragColor += tex2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*float2( 0.707107, 0.707107)) * UserVec1.y;\n" " gl_FragColor += tex2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*float2(-0.453990, 0.891007)) * UserVec1.y;\n" -" gl_FragColor /= (1 + 5 * UserVec1.y);\n" +" gl_FragColor /= (1.0 + 5.0 * UserVec1.y);\n" +" gl_FragColor.rgb = gl_FragColor.rgb * (1.0 + UserVec2.x) + float3(1,1,1)*max(0.0, sobel - UserVec2.z)*UserVec2.y;\n" "#endif\n" "\n" "#ifdef USESATURATION\n" " //apply saturation BEFORE gamma ramps, so v_glslgamma value does not matter\n" " float y = dot(gl_FragColor.rgb, float3(0.299, 0.587, 0.114));\n" -" //gl_FragColor = float3(y) + (gl_FragColor.rgb - float3(y)) * Saturation;\n" -" gl_FragColor.rgb = lerp(float3(y), gl_FragColor.rgb, Saturation);\n" +" // 'vampire sight' effect, wheres red is compensated\n" +" #ifdef SATURATION_REDCOMPENSATE\n" +" float rboost = max(0.0, (gl_FragColor.r - max(gl_FragColor.g, gl_FragColor.b))*(1.0 - Saturation));\n" +" gl_FragColor.rgb = mix(float3(y,y,y), gl_FragColor.rgb, Saturation);\n" +" gl_FragColor.r += r;\n" +" #else\n" +" // normal desaturation\n" +" //gl_FragColor = float3(y,y,y) + (gl_FragColor.rgb - float3(y)) * Saturation;\n" +" gl_FragColor.rgb = lerp(float3(y,y,y), gl_FragColor.rgb, Saturation);\n" +" #endif\n" "#endif\n" "\n" "#ifdef USEGAMMARAMPS\n" @@ -2022,17 +2048,25 @@ const char *builtincgshaderstring = "void main\n" "(\n" "float4 gl_Vertex : POSITION,\n" -"uniform float4x4 ModelViewProjectionMatrix,\n" +"uniform float4x4 ModelViewProjectionMatrix : register(c8),\n" "float4 gl_Color : COLOR0,\n" "float4 gl_MultiTexCoord0 : TEXCOORD0,\n" "float4 gl_MultiTexCoord1 : TEXCOORD1,\n" "out float4 gl_Position : POSITION,\n" -"out float4 gl_FrontColor : COLOR,\n" +"#ifdef USEDIFFUSE\n" "out float2 TexCoord1 : TEXCOORD0,\n" -"out float2 TexCoord2 : TEXCOORD1\n" +"#endif\n" +"#ifdef USESPECULAR\n" +"out float2 TexCoord2 : TEXCOORD1,\n" +"#endif\n" +"out float4 gl_FrontColor : COLOR\n" ")\n" "{\n" -" gl_FrontColor = gl_Color;\n" +"#ifdef HLSL\n" +" gl_FrontColor = gl_Color.bgra; // NOTE: D3DCOLOR is backwards\n" +"#else\n" +" gl_FrontColor = gl_Color; // Cg is forward\n" +"#endif\n" "#ifdef USEDIFFUSE\n" " TexCoord1 = gl_MultiTexCoord0.xy;\n" "#endif\n" @@ -2047,19 +2081,23 @@ const char *builtincgshaderstring = "\n" "void main\n" "(\n" -"float4 gl_FrontColor : COLOR,\n" +"float4 gl_FrontColor : COLOR0,\n" "float2 TexCoord1 : TEXCOORD0,\n" "float2 TexCoord2 : TEXCOORD1,\n" "#ifdef USEDIFFUSE\n" -"uniform sampler2D Texture_First,\n" +"uniform sampler Texture_First : register(s0),\n" "#endif\n" "#ifdef USESPECULAR\n" -"uniform sampler2D Texture_Second,\n" +"uniform sampler Texture_Second : register(s1),\n" "#endif\n" "out float4 gl_FragColor : COLOR\n" ")\n" "{\n" +"#ifdef USEVIEWTINT\n" " gl_FragColor = gl_FrontColor;\n" +"#else\n" +" gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);\n" +"#endif\n" "#ifdef USEDIFFUSE\n" " gl_FragColor *= tex2D(Texture_First, TexCoord1);\n" "#endif\n" @@ -2088,7 +2126,7 @@ const char *builtincgshaderstring = "void main\n" "(\n" "float4 gl_Vertex : POSITION,\n" -"uniform float4x4 ModelViewProjectionMatrix,\n" +"uniform float4x4 ModelViewProjectionMatrix : register(c8),\n" "float4 gl_MultiTexCoord0 : TEXCOORD0,\n" "out float4 gl_Position : POSITION,\n" "out float2 TexCoord : TEXCOORD0\n" @@ -2104,8 +2142,8 @@ const char *builtincgshaderstring = "void main\n" "(\n" "float2 TexCoord : TEXCOORD0,\n" -"uniform sampler2D Texture_First,\n" -"uniform float4 BloomBlur_Parameters,\n" +"uniform sampler Texture_First : register(s0),\n" +"uniform float4 BloomBlur_Parameters : register(c1),\n" "out float4 gl_FragColor : COLOR\n" ")\n" "{\n" @@ -2127,17 +2165,17 @@ const char *builtincgshaderstring = "void main\n" "(\n" "float4 gl_Vertex : POSITION,\n" -"uniform float4x4 ModelViewProjectionMatrix,\n" +"uniform float4x4 ModelViewProjectionMatrix : register(c8),\n" "float4 gl_MultiTexCoord0 : TEXCOORD0,\n" -"uniform float4x4 TexMatrix,\n" -"uniform float3 EyePosition,\n" +"uniform float4x4 TexMatrix : register(c0),\n" +"uniform float3 EyePosition : register(c24),\n" "out float4 gl_Position : POSITION,\n" "out float2 TexCoord : TEXCOORD0,\n" "out float3 EyeVector : TEXCOORD1,\n" "out float4 ModelViewProjectionPosition : TEXCOORD2\n" ")\n" "{\n" -" TexCoord = float2(mul(TexMatrix, gl_MultiTexCoord0));\n" +" TexCoord = mul(TexMatrix, gl_MultiTexCoord0).xy;\n" " gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n" " ModelViewProjectionPosition = gl_Position;\n" "}\n" @@ -2149,20 +2187,20 @@ const char *builtincgshaderstring = "float2 TexCoord : TEXCOORD0,\n" "float3 EyeVector : TEXCOORD1,\n" "float4 ModelViewProjectionPosition : TEXCOORD2,\n" -"uniform sampler2D Texture_Normal,\n" -"uniform sampler2D Texture_Refraction,\n" -"uniform sampler2D Texture_Reflection,\n" -"uniform float4 DistortScaleRefractReflect,\n" -"uniform float4 ScreenScaleRefractReflect,\n" -"uniform float4 ScreenCenterRefractReflect,\n" -"uniform float4 RefractColor,\n" +"uniform sampler Texture_Normal : register(s0),\n" +"uniform sampler Texture_Refraction : register(s3),\n" +"uniform sampler Texture_Reflection : register(s7),\n" +"uniform float4 DistortScaleRefractReflect : register(c14),\n" +"uniform float4 ScreenScaleRefractReflect : register(c32),\n" +"uniform float4 ScreenCenterRefractReflect : register(c31),\n" +"uniform float4 RefractColor : register(c29),\n" "out float4 gl_FragColor : COLOR\n" ")\n" "{\n" " float2 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect.xy * (1.0 / ModelViewProjectionPosition.w);\n" -" //float2 ScreenTexCoord = (ModelViewProjectionPosition.xy + normalize(float3(tex2D(Texture_Normal, TexCoord)) - float3(0.5)).xy * DistortScaleRefractReflect.xy * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n" +" //float2 ScreenTexCoord = (ModelViewProjectionPosition.xy + normalize(tex2D(Texture_Normal, TexCoord).rgb - float3(0.5,0.5,0.5)).xy * DistortScaleRefractReflect.xy * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n" " float2 SafeScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n" -" float2 ScreenTexCoord = SafeScreenTexCoord + float2(normalize(float3(tex2D(Texture_Normal, TexCoord)) - float3(0.5))).xy * DistortScaleRefractReflect.xy;\n" +" float2 ScreenTexCoord = SafeScreenTexCoord + normalize(tex2D(Texture_Normal, TexCoord).rgb - float3(0.5,0.5,0.5)).xy * DistortScaleRefractReflect.xy;\n" " // FIXME temporary hack to detect the case that the reflection\n" " // gets blackened at edges due to leaving the area that contains actual\n" " // content.\n" @@ -2173,7 +2211,7 @@ const char *builtincgshaderstring = " f *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord + float2(-0.01, 0.01)).rgb) / 0.05);\n" " f *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord + float2(-0.01, -0.01)).rgb) / 0.05);\n" " ScreenTexCoord = lerp(SafeScreenTexCoord, ScreenTexCoord, f);\n" -" gl_FragColor = tex2D(Texture_Refraction, ScreenTexCoord) * RefractColor;\n" +" gl_FragColor = float4(tex2D(Texture_Refraction, ScreenTexCoord).rgb, 1) * RefractColor;\n" "}\n" "#endif\n" "#else // !MODE_REFRACTION\n" @@ -2187,17 +2225,20 @@ const char *builtincgshaderstring = "void main\n" "(\n" "float4 gl_Vertex : POSITION,\n" -"uniform float4x4 ModelViewProjectionMatrix,\n" +"uniform float4x4 ModelViewProjectionMatrix : register(c8),\n" "float4 gl_MultiTexCoord0 : TEXCOORD0,\n" -"uniform float4x4 TexMatrix,\n" -"uniform float3 EyePosition,\n" +"float4 gl_MultiTexCoord1 : TEXCOORD1,\n" +"float4 gl_MultiTexCoord2 : TEXCOORD2,\n" +"float4 gl_MultiTexCoord3 : TEXCOORD3,\n" +"uniform float4x4 TexMatrix : register(c0),\n" +"uniform float3 EyePosition : register(c24),\n" "out float4 gl_Position : POSITION,\n" "out float2 TexCoord : TEXCOORD0,\n" "out float3 EyeVector : TEXCOORD1,\n" "out float4 ModelViewProjectionPosition : TEXCOORD2\n" ")\n" "{\n" -" TexCoord = float2(mul(TexMatrix, gl_MultiTexCoord0));\n" +" TexCoord = mul(TexMatrix, gl_MultiTexCoord0).xy;\n" " float3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n" " EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n" " EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n" @@ -2213,23 +2254,24 @@ const char *builtincgshaderstring = "float2 TexCoord : TEXCOORD0,\n" "float3 EyeVector : TEXCOORD1,\n" "float4 ModelViewProjectionPosition : TEXCOORD2,\n" -"uniform sampler2D Texture_Normal,\n" -"uniform sampler2D Texture_Refraction,\n" -"uniform sampler2D Texture_Reflection,\n" -"uniform float4 DistortScaleRefractReflect,\n" -"uniform float4 ScreenScaleRefractReflect,\n" -"uniform float4 ScreenCenterRefractReflect,\n" -"uniform float4 RefractColor,\n" -"uniform float4 ReflectColor,\n" -"uniform float ReflectFactor,\n" -"uniform float ReflectOffset,\n" +"uniform sampler Texture_Normal : register(s0),\n" +"uniform sampler Texture_Refraction : register(s3),\n" +"uniform sampler Texture_Reflection : register(s7),\n" +"uniform float4 DistortScaleRefractReflect : register(c14),\n" +"uniform float4 ScreenScaleRefractReflect : register(c32),\n" +"uniform float4 ScreenCenterRefractReflect : register(c31),\n" +"uniform float4 RefractColor : register(c29),\n" +"uniform float4 ReflectColor : register(c26),\n" +"uniform float ReflectFactor : register(c27),\n" +"uniform float ReflectOffset : register(c28),\n" "out float4 gl_FragColor : COLOR\n" ")\n" "{\n" " float4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n" -" //float4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(float3(tex2D(Texture_Normal, TexCoord)) - float3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n" +" //float4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(tex2D(Texture_Normal, TexCoord).rgb - float3(0.5,0.5,0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n" " float4 SafeScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n" -" float4 ScreenTexCoord = SafeScreenTexCoord + float2(normalize(float3(tex2D(Texture_Normal, TexCoord)) - float3(0.5))).xyxy * DistortScaleRefractReflect;\n" +" //SafeScreenTexCoord = gl_FragCoord.xyxy * float4(1.0 / 1920.0, 1.0 / 1200.0, 1.0 / 1920.0, 1.0 / 1200.0);\n" +" float4 ScreenTexCoord = SafeScreenTexCoord + float2(normalize(tex2D(Texture_Normal, TexCoord).rgb - float3(0.5,0.5,0.5)).xy).xyxy * DistortScaleRefractReflect;\n" " // FIXME temporary hack to detect the case that the reflection\n" " // gets blackened at edges due to leaving the area that contains actual\n" " // content.\n" @@ -2246,7 +2288,7 @@ const char *builtincgshaderstring = " f *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord.zw + float2(-0.01, -0.01)).rgb) / 0.05);\n" " ScreenTexCoord.zw = lerp(SafeScreenTexCoord.zw, ScreenTexCoord.zw, f);\n" " float Fresnel = pow(min(1.0, 1.0 - float(normalize(EyeVector).z)), 2.0) * ReflectFactor + ReflectOffset;\n" -" gl_FragColor = lerp(tex2D(Texture_Refraction, ScreenTexCoord.xy) * RefractColor, tex2D(Texture_Reflection, ScreenTexCoord.zw) * ReflectColor, Fresnel);\n" +" gl_FragColor = lerp(float4(tex2D(Texture_Refraction, ScreenTexCoord.xy).rgb, 1) * RefractColor, float4(tex2D(Texture_Reflection, ScreenTexCoord.zw).rgb, 1) * ReflectColor, Fresnel);\n" "}\n" "#endif\n" "#else // !MODE_WATER\n" @@ -2260,7 +2302,7 @@ const char *builtincgshaderstring = "#ifdef FRAGMENT_SHADER\n" "\n" "#ifdef USEFOG\n" -"float3 FogVertex(float3 surfacecolor, float3 FogColor, float3 EyeVectorModelSpace, float FogPlaneVertexDist, float FogRangeRecip, float FogPlaneViewDist, float FogHeightFade, sampler2D Texture_FogMask, sampler2D Texture_FogHeightTexture)\n" +"float3 FogVertex(float3 surfacecolor, float3 FogColor, float3 EyeVectorModelSpace, float FogPlaneVertexDist, float FogRangeRecip, float FogPlaneViewDist, float FogHeightFade, sampler Texture_FogMask, sampler Texture_FogHeightTexture)\n" "{\n" " float fogfrac;\n" "#ifdef USEFOGHEIGHTTEXTURE\n" @@ -2279,7 +2321,7 @@ const char *builtincgshaderstring = "#endif\n" "\n" "#ifdef USEOFFSETMAPPING\n" -"float2 OffsetMapping(float2 TexCoord, float OffsetMapping_Scale, float3 EyeVector, sampler2D Texture_Normal)\n" +"float2 OffsetMapping(float2 TexCoord, float OffsetMapping_Scale, float3 EyeVector, sampler Texture_Normal)\n" "{\n" "#ifdef USEOFFSETMAPPING_RELIEFMAPPING\n" " // 14 sample relief mapping: linear search and then binary search\n" @@ -2324,7 +2366,7 @@ const char *builtincgshaderstring = "#endif // USEOFFSETMAPPING\n" "\n" "#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE) || defined(USESHADOWMAPORTHO)\n" -"#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D)\n" +"#if defined(USESHADOWMAP2D)\n" "# ifdef USESHADOWMAPORTHO\n" "# define GetShadowMapTC2D(dir, ShadowMap_Parameters) (min(dir, ShadowMap_Parameters.xyz))\n" "# else\n" @@ -2344,82 +2386,22 @@ const char *builtincgshaderstring = " float4 proj = float4(dir, 2.5);\n" " if (adir.x > ma) { ma = adir.x; proj = float4(dir.zyx, 0.5); }\n" " if (adir.y > ma) { ma = adir.y; proj = float4(dir.xzy, 1.5); }\n" +"#ifdef HLSL\n" +" return float3(proj.xy * ShadowMap_Parameters.x / ma + float2(0.5,0.5) + float2(proj.z < 0.0 ? 1.5 : 0.5, proj.w) * ShadowMap_Parameters.z, ma + 64 * ShadowMap_Parameters.w);\n" +"#else\n" " float2 aparams = ShadowMap_Parameters.xy / ma;\n" " return float3(proj.xy * aparams.x + float2(proj.z < 0.0 ? 1.5 : 0.5, proj.w) * ShadowMap_Parameters.z, aparams.y + ShadowMap_Parameters.w);\n" -"}\n" -"# endif\n" -"# endif\n" -"#endif // defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D)\n" -"\n" -"#ifdef USESHADOWMAPCUBE\n" -"float4 GetShadowMapTCCube(float3 dir, float4 ShadowMap_Parameters)\n" -"{\n" -" float3 adir = abs(dir);\n" -" return float4(dir, ShadowMap_Parameters.w + ShadowMap_Parameters.y / max(max(adir.x, adir.y), adir.z));\n" -"}\n" -"#endif\n" -"\n" -"# ifdef USESHADOWMAPRECT\n" -"#ifdef USESHADOWMAPVSDCT\n" -"float ShadowMapCompare(float3 dir, samplerRECT Texture_ShadowMapRect, float4 ShadowMap_Parameters, samplerCUBE Texture_CubeProjection)\n" -"#else\n" -"float ShadowMapCompare(float3 dir, samplerRECT Texture_ShadowMapRect, float4 ShadowMap_Parameters)\n" "#endif\n" -"{\n" -"#ifdef USESHADOWMAPVSDCT\n" -" float3 shadowmaptc = GetShadowMapTC2D(dir, ShadowMap_Parameters, Texture_CubeProjection);\n" -"#else\n" -" float3 shadowmaptc = GetShadowMapTC2D(dir, ShadowMap_Parameters);\n" -"#endif\n" -" float f;\n" -"# ifdef USESHADOWSAMPLER\n" -"\n" -"# ifdef USESHADOWMAPPCF\n" -"# define texval(x, y) shadow2DRect(Texture_ShadowMapRect, shadowmaptc + float3(x, y, 0.0)).r\n" -" f = dot(float4(0.25), float4(texval(-0.4, 1.0), texval(-1.0, -0.4), texval(0.4, -1.0), texval(1.0, 0.4)));\n" -"# else\n" -" f = shadow2DRect(Texture_ShadowMapRect, shadowmaptc).r;\n" -"# endif\n" -"\n" -"# else\n" -"\n" -"# ifdef USESHADOWMAPPCF\n" -"# if USESHADOWMAPPCF > 1\n" -"# define texval(x, y) texRECT(Texture_ShadowMapRect, center + float2(x, y)).r\n" -" float2 center = shadowmaptc.xy - 0.5, offset = frac(center);\n" -" float4 row1 = step(shadowmaptc.z, float4(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0), texval( 2.0, -1.0)));\n" -" float4 row2 = step(shadowmaptc.z, float4(texval(-1.0, 0.0), texval( 0.0, 0.0), texval( 1.0, 0.0), texval( 2.0, 0.0)));\n" -" float4 row3 = step(shadowmaptc.z, float4(texval(-1.0, 1.0), texval( 0.0, 1.0), texval( 1.0, 1.0), texval( 2.0, 1.0)));\n" -" float4 row4 = step(shadowmaptc.z, float4(texval(-1.0, 2.0), texval( 0.0, 2.0), texval( 1.0, 2.0), texval( 2.0, 2.0)));\n" -" float4 cols = row2 + row3 + lerp(row1, row4, offset.y);\n" -" f = dot(lerp(cols.xyz, cols.yzw, offset.x), float3(1.0/9.0));\n" -"# else\n" -"# define texval(x, y) texRECT(Texture_ShadowMapRect, shadowmaptc.xy + float2(x, y)).r\n" -" float2 offset = frac(shadowmaptc.xy);\n" -" float3 row1 = step(shadowmaptc.z, float3(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0)));\n" -" float3 row2 = step(shadowmaptc.z, float3(texval(-1.0, 0.0), texval( 0.0, 0.0), texval( 1.0, 0.0)));\n" -" float3 row3 = step(shadowmaptc.z, float3(texval(-1.0, 1.0), texval( 0.0, 1.0), texval( 1.0, 1.0)));\n" -" float3 cols = row2 + lerp(row1, row3, offset.y);\n" -" f = dot(lerp(cols.xy, cols.yz, offset.x), float2(0.25));\n" -"# endif\n" -"# else\n" -" f = step(shadowmaptc.z, texRECT(Texture_ShadowMapRect, shadowmaptc.xy).r);\n" -"# endif\n" -"\n" -"# endif\n" -"# ifdef USESHADOWMAPORTHO\n" -" return lerp(ShadowMap_Parameters.w, 1.0, f);\n" -"# else\n" -" return f;\n" -"# endif\n" "}\n" +"# endif\n" "# endif\n" +"#endif // defined(USESHADOWMAP2D)\n" "\n" "# ifdef USESHADOWMAP2D\n" "#ifdef USESHADOWMAPVSDCT\n" -"float ShadowMapCompare(float3 dir, sampler2D Texture_ShadowMap2D, float4 ShadowMap_Parameters, float2 ShadowMap_TextureScale, samplerCUBE Texture_CubeProjection)\n" +"float ShadowMapCompare(float3 dir, sampler Texture_ShadowMap2D, float4 ShadowMap_Parameters, float2 ShadowMap_TextureScale, samplerCUBE Texture_CubeProjection)\n" "#else\n" -"float ShadowMapCompare(float3 dir, sampler2D Texture_ShadowMap2D, float4 ShadowMap_Parameters, float2 ShadowMap_TextureScale)\n" +"float ShadowMapCompare(float3 dir, sampler Texture_ShadowMap2D, float4 ShadowMap_Parameters, float2 ShadowMap_TextureScale)\n" "#endif\n" "{\n" "#ifdef USESHADOWMAPVSDCT\n" @@ -2427,55 +2409,80 @@ const char *builtincgshaderstring = "#else\n" " float3 shadowmaptc = GetShadowMapTC2D(dir, ShadowMap_Parameters);\n" "#endif\n" -" float f;\n" +" float f;\n" "\n" "# ifdef USESHADOWSAMPLER\n" "# ifdef USESHADOWMAPPCF\n" -"# define texval(x, y) shadow2D(Texture_ShadowMap2D, float3(center + float2(x, y)*ShadowMap_TextureScale, shadowmaptc.z)).r \n" -" float2 center = shadowmaptc.xy*ShadowMap_TextureScale;\n" -" f = dot(float4(0.25), float4(texval(-0.4, 1.0), texval(-1.0, -0.4), texval(0.4, -1.0), texval(1.0, 0.4)));\n" +"# define texval(x, y) tex2Dproj(Texture_ShadowMap2D, float4(center + float2(x, y)*ShadowMap_TextureScale, shadowmaptc.z, 1.0)).r \n" +" float2 center = shadowmaptc.xy*ShadowMap_TextureScale;\n" +" f = dot(float4(0.25,0.25,0.25,0.25), float4(texval(-0.4, 1.0), texval(-1.0, -0.4), texval(0.4, -1.0), texval(1.0, 0.4)));\n" "# else\n" -" f = shadow2D(Texture_ShadowMap2D, float3(shadowmaptc.xy*ShadowMap_TextureScale, shadowmaptc.z)).r;\n" +" f = tex2Dproj(Texture_ShadowMap2D, float4(shadowmaptc.xy*ShadowMap_TextureScale, shadowmaptc.z, 1.0)).r;\n" "# endif\n" "# else\n" "# ifdef USESHADOWMAPPCF\n" "# if defined(GL_ARB_texture_gather) || defined(GL_AMD_texture_texture4)\n" "# ifdef GL_ARB_texture_gather\n" -"# define texval(x, y) textureGatherOffset(Texture_ShadowMap2D, center, ivec(x, y))\n" +"# define texval(x, y) textureGatherOffset(Texture_ShadowMap2D, center, int2(x, y))\n" "# else\n" -"# define texval(x, y) texture4(Texture_ShadowMap2D, center + float2(x,y)*ShadowMap_TextureScale)\n" +"# define texval(x, y) texture4(Texture_ShadowMap2D, center + float2(x, y)*ShadowMap_TextureScale)\n" +"# endif\n" +" float2 offset = frac(shadowmaptc.xy - 0.5), center = (shadowmaptc.xy - offset)*ShadowMap_TextureScale;\n" +"# if USESHADOWMAPPCF > 1\n" +" float4 group1 = step(shadowmaptc.z, texval(-2.0, -2.0));\n" +" float4 group2 = step(shadowmaptc.z, texval( 0.0, -2.0));\n" +" float4 group3 = step(shadowmaptc.z, texval( 2.0, -2.0));\n" +" float4 group4 = step(shadowmaptc.z, texval(-2.0, 0.0));\n" +" float4 group5 = step(shadowmaptc.z, texval( 0.0, 0.0));\n" +" float4 group6 = step(shadowmaptc.z, texval( 2.0, 0.0));\n" +" float4 group7 = step(shadowmaptc.z, texval(-2.0, 2.0));\n" +" float4 group8 = step(shadowmaptc.z, texval( 0.0, 2.0));\n" +" float4 group9 = step(shadowmaptc.z, texval( 2.0, 2.0));\n" +" float4 locols = float4(group1.ab, group3.ab);\n" +" float4 hicols = float4(group7.rg, group9.rg);\n" +" locols.yz += group2.ab;\n" +" hicols.yz += group8.rg;\n" +" float4 midcols = float4(group1.rg, group3.rg) + float4(group7.ab, group9.ab) +\n" +" float4(group4.rg, group6.rg) + float4(group4.ab, group6.ab) +\n" +" lerp(locols, hicols, offset.y);\n" +" float4 cols = group5 + float4(group2.rg, group8.ab);\n" +" cols.xyz += lerp(midcols.xyz, midcols.yzw, offset.x);\n" +" f = dot(cols, float4(1.0/25.0));\n" +"# else\n" +" float4 group1 = step(shadowmaptc.z, texval(-1.0, -1.0));\n" +" float4 group2 = step(shadowmaptc.z, texval( 1.0, -1.0));\n" +" float4 group3 = step(shadowmaptc.z, texval(-1.0, 1.0));\n" +" float4 group4 = step(shadowmaptc.z, texval( 1.0, 1.0));\n" +" float4 cols = float4(group1.rg, group2.rg) + float4(group3.ab, group4.ab) +\n" +" lerp(float4(group1.ab, group2.ab), float4(group3.rg, group4.rg), offset.y);\n" +" f = dot(lerp(cols.xyz, cols.yzw, offset.x), float3(1.0/9.0));\n" "# endif\n" -" float2 center = shadowmaptc.xy - 0.5, offset = frac(center);\n" -" center *= ShadowMap_TextureScale;\n" -" float4 group1 = step(shadowmaptc.z, texval(-1.0, -1.0));\n" -" float4 group2 = step(shadowmaptc.z, texval( 1.0, -1.0));\n" -" float4 group3 = step(shadowmaptc.z, texval(-1.0, 1.0));\n" -" float4 group4 = step(shadowmaptc.z, texval( 1.0, 1.0));\n" -" float4 cols = float4(group1.rg, group2.rg) + float4(group3.ab, group4.ab) +\n" -" lerp(float4(group1.ab, group2.ab), float4(group3.rg, group4.rg), offset.y);\n" -" f = dot(lerp(cols.xyz, cols.yzw, offset.x), float3(1.0/9.0));\n" "# else\n" -"# define texval(x, y) texDepth2D(Texture_ShadowMap2D, center + float2(x, y)*ShadowMap_TextureScale) \n" +"# ifdef GL_EXT_gpu_shader4\n" +"# define texval(x, y) tex2DOffset(Texture_ShadowMap2D, center, int2(x, y)).r\n" +"# else\n" +"# define texval(x, y) texDepth2D(Texture_ShadowMap2D, center + float2(x, y)*ShadowMap_TextureScale).r \n" +"# endif\n" "# if USESHADOWMAPPCF > 1\n" -" float2 center = shadowmaptc.xy - 0.5, offset = frac(center);\n" -" center *= ShadowMap_TextureScale;\n" -" float4 row1 = step(shadowmaptc.z, float4(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0), texval( 2.0, -1.0)));\n" -" float4 row2 = step(shadowmaptc.z, float4(texval(-1.0, 0.0), texval( 0.0, 0.0), texval( 1.0, 0.0), texval( 2.0, 0.0)));\n" -" float4 row3 = step(shadowmaptc.z, float4(texval(-1.0, 1.0), texval( 0.0, 1.0), texval( 1.0, 1.0), texval( 2.0, 1.0)));\n" -" float4 row4 = step(shadowmaptc.z, float4(texval(-1.0, 2.0), texval( 0.0, 2.0), texval( 1.0, 2.0), texval( 2.0, 2.0)));\n" -" float4 cols = row2 + row3 + lerp(row1, row4, offset.y);\n" -" f = dot(lerp(cols.xyz, cols.yzw, offset.x), float3(1.0/9.0));\n" +" float2 center = shadowmaptc.xy - 0.5, offset = frac(center);\n" +" center *= ShadowMap_TextureScale;\n" +" float4 row1 = step(shadowmaptc.z, float4(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0), texval( 2.0, -1.0)));\n" +" float4 row2 = step(shadowmaptc.z, float4(texval(-1.0, 0.0), texval( 0.0, 0.0), texval( 1.0, 0.0), texval( 2.0, 0.0)));\n" +" float4 row3 = step(shadowmaptc.z, float4(texval(-1.0, 1.0), texval( 0.0, 1.0), texval( 1.0, 1.0), texval( 2.0, 1.0)));\n" +" float4 row4 = step(shadowmaptc.z, float4(texval(-1.0, 2.0), texval( 0.0, 2.0), texval( 1.0, 2.0), texval( 2.0, 2.0)));\n" +" float4 cols = row2 + row3 + lerp(row1, row4, offset.y);\n" +" f = dot(lerp(cols.xyz, cols.yzw, offset.x), float3(1.0/9.0));\n" "# else\n" -" float2 center = shadowmaptc.xy*ShadowMap_TextureScale, offset = frac(shadowmaptc.xy);\n" -" float3 row1 = step(shadowmaptc.z, float3(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0)));\n" -" float3 row2 = step(shadowmaptc.z, float3(texval(-1.0, 0.0), texval( 0.0, 0.0), texval( 1.0, 0.0)));\n" -" float3 row3 = step(shadowmaptc.z, float3(texval(-1.0, 1.0), texval( 0.0, 1.0), texval( 1.0, 1.0)));\n" -" float3 cols = row2 + lerp(row1, row3, offset.y);\n" -" f = dot(lerp(cols.xy, cols.yz, offset.x), float2(0.25));\n" +" float2 center = shadowmaptc.xy*ShadowMap_TextureScale, offset = frac(shadowmaptc.xy);\n" +" float3 row1 = step(shadowmaptc.z, float3(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0)));\n" +" float3 row2 = step(shadowmaptc.z, float3(texval(-1.0, 0.0), texval( 0.0, 0.0), texval( 1.0, 0.0)));\n" +" float3 row3 = step(shadowmaptc.z, float3(texval(-1.0, 1.0), texval( 0.0, 1.0), texval( 1.0, 1.0)));\n" +" float3 cols = row2 + lerp(row1, row3, offset.y);\n" +" f = dot(lerp(cols.xy, cols.yz, offset.x), float2(0.25,0.25));\n" "# endif\n" "# endif\n" "# else\n" -" f = step(shadowmaptc.z, tex2D(Texture_ShadowMap2D, shadowmaptc.xy*ShadowMap_TextureScale).r);\n" +" f = step(shadowmaptc.z, tex2D(Texture_ShadowMap2D, shadowmaptc.xy*ShadowMap_TextureScale).r);\n" "# endif\n" "# endif\n" "# ifdef USESHADOWMAPORTHO\n" @@ -2485,22 +2492,7 @@ const char *builtincgshaderstring = "# endif\n" "}\n" "# endif\n" -"\n" -"# ifdef USESHADOWMAPCUBE\n" -"float ShadowMapCompare(float3 dir, samplerCUBE Texture_ShadowMapCube, float4 ShadowMap_Parameters)\n" -"{\n" -" // apply depth texture cubemap as light filter\n" -" float4 shadowmaptc = GetShadowMapTCCube(dir, ShadowMap_Parameters);\n" -" float f;\n" -"# ifdef USESHADOWSAMPLER\n" -" f = shadowCube(Texture_ShadowMapCube, shadowmaptc).r;\n" -"# else\n" -" f = step(shadowmaptc.w, texCUBE(Texture_ShadowMapCube, shadowmaptc.xyz).r);\n" -"# endif\n" -" return f;\n" -"}\n" -"# endif\n" -"#endif // !defined(MODE_LIGHTSOURCE) && !defined(MODE_DEFERREDLIGHTSOURCE)\n" +"#endif // !defined(MODE_LIGHTSOURCE) && !defined(MODE_DEFERREDLIGHTSOURCE) && !defined(USESHADOWMAPORTHO)\n" "#endif // FRAGMENT_SHADER\n" "\n" "\n" @@ -2511,7 +2503,7 @@ const char *builtincgshaderstring = "void main\n" "(\n" "float4 gl_Vertex : POSITION,\n" -"uniform float4x4 ModelViewProjectionMatrix,\n" +"uniform float4x4 ModelViewProjectionMatrix : register(c8),\n" "#ifdef USEVERTEXTEXTUREBLEND\n" "float4 gl_Color : COLOR0,\n" "#endif\n" @@ -2519,28 +2511,34 @@ const char *builtincgshaderstring = "float4 gl_MultiTexCoord1 : TEXCOORD1,\n" "float4 gl_MultiTexCoord2 : TEXCOORD2,\n" "float4 gl_MultiTexCoord3 : TEXCOORD3,\n" -"uniform float4x4 TexMatrix,\n" +"uniform float4x4 TexMatrix : register(c0),\n" "#ifdef USEVERTEXTEXTUREBLEND\n" -"uniform float4x4 BackgroundTexMatrix,\n" +"uniform float4x4 BackgroundTexMatrix : register(c4),\n" "#endif\n" -"uniform float4x4 ModelViewMatrix,\n" +"uniform float4x4 ModelViewMatrix : register(c12),\n" "#ifdef USEOFFSETMAPPING\n" -"uniform float3 EyePosition,\n" +"uniform float3 EyePosition : register(c24),\n" "#endif\n" "out float4 gl_Position : POSITION,\n" +"#ifdef USEVERTEXTEXTUREBLEND\n" "out float4 gl_FrontColor : COLOR,\n" +"#endif\n" "out float4 TexCoordBoth : TEXCOORD0,\n" "#ifdef USEOFFSETMAPPING\n" "out float3 EyeVector : TEXCOORD2,\n" "#endif\n" "out float3 VectorS : TEXCOORD5, // direction of S texcoord (sometimes crudely called tangent)\n" "out float3 VectorT : TEXCOORD6, // direction of T texcoord (sometimes crudely called binormal)\n" -"out float3 VectorR : TEXCOORD7 // direction of R texcoord (surface normal)\n" +"out float4 VectorR : TEXCOORD7 // direction of R texcoord (surface normal), Depth value\n" ")\n" "{\n" " TexCoordBoth = mul(TexMatrix, gl_MultiTexCoord0);\n" "#ifdef USEVERTEXTEXTUREBLEND\n" -" gl_FrontColor = gl_Color;\n" +"#ifdef HLSL\n" +" gl_FrontColor = gl_Color.bgra; // NOTE: D3DCOLOR is backwards\n" +"#else\n" +" gl_FrontColor = gl_Color; // Cg is forward\n" +"#endif\n" " TexCoordBoth.zw = float2(Backgroundmul(TexMatrix, gl_MultiTexCoord0));\n" "#endif\n" "\n" @@ -2554,8 +2552,9 @@ const char *builtincgshaderstring = "\n" " VectorS = mul(ModelViewMatrix, float4(gl_MultiTexCoord1.xyz, 0)).xyz;\n" " VectorT = mul(ModelViewMatrix, float4(gl_MultiTexCoord2.xyz, 0)).xyz;\n" -" VectorR = mul(ModelViewMatrix, float4(gl_MultiTexCoord3.xyz, 0)).xyz;\n" +" VectorR.xyz = mul(ModelViewMatrix, float4(gl_MultiTexCoord3.xyz, 0)).xyz;\n" " gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n" +" VectorR.w = gl_Position.z;\n" "}\n" "#endif // VERTEX_SHADER\n" "\n" @@ -2566,21 +2565,26 @@ const char *builtincgshaderstring = "float3 EyeVector : TEXCOORD2,\n" "float3 VectorS : TEXCOORD5, // direction of S texcoord (sometimes crudely called tangent)\n" "float3 VectorT : TEXCOORD6, // direction of T texcoord (sometimes crudely called binormal)\n" -"float3 VectorR : TEXCOORD7, // direction of R texcoord (surface normal)\n" -"uniform sampler2D Texture_Normal,\n" +"float4 VectorR : TEXCOORD7, // direction of R texcoord (surface normal), Depth value\n" +"uniform sampler Texture_Normal : register(s0),\n" "#ifdef USEALPHAKILL\n" -"uniform sampler2D Texture_Color,\n" +"uniform sampler Texture_Color : register(s1),\n" "#endif\n" -"uniform sampler2D Texture_Gloss,\n" +"uniform sampler Texture_Gloss : register(s2),\n" "#ifdef USEVERTEXTEXTUREBLEND\n" -"uniform sampler2D Texture_SecondaryNormal,\n" -"uniform sampler2D Texture_SecondaryGloss,\n" +"uniform sampler Texture_SecondaryNormal : register(s4),\n" +"uniform sampler Texture_SecondaryGloss : register(s6),\n" "#endif\n" "#ifdef USEOFFSETMAPPING\n" -"uniform float OffsetMapping_Scale,\n" +"uniform float OffsetMapping_Scale : register(c24),\n" "#endif\n" -"uniform half SpecularPower,\n" +"uniform half SpecularPower : register(c36),\n" +"#ifdef HLSL\n" +"out float4 gl_FragData0 : COLOR0,\n" +"out float4 gl_FragData1 : COLOR1\n" +"#else\n" "out float4 gl_FragColor : COLOR\n" +"#endif\n" ")\n" "{\n" " float2 TexCoord = TexCoordBoth.xy;\n" @@ -2603,14 +2607,23 @@ const char *builtincgshaderstring = "#endif\n" "\n" "#ifdef USEVERTEXTEXTUREBLEND\n" -" float3 surfacenormal = lerp(float3(tex2D(Texture_SecondaryNormal, TexCoord2)), float3(tex2D(Texture_Normal, TexCoord)), terrainblend) - float3(0.5, 0.5, 0.5);\n" -" float a = lerp(tex2D(Texture_SecondaryGloss, TexCoord2), tex2D(Texture_Gloss, TexCoord).a, terrainblend);\n" +" float3 surfacenormal = lerp(tex2D(Texture_SecondaryNormal, TexCoord2).rgb, tex2D(Texture_Normal, TexCoord).rgb, terrainblend) - float3(0.5, 0.5, 0.5);\n" +" float a = lerp(tex2D(Texture_SecondaryGloss, TexCoord2).a, tex2D(Texture_Gloss, TexCoord).a, terrainblend);\n" "#else\n" -" float3 surfacenormal = float3(tex2D(Texture_Normal, TexCoord)) - float3(0.5, 0.5, 0.5);\n" +" float3 surfacenormal = tex2D(Texture_Normal, TexCoord).rgb - float3(0.5, 0.5, 0.5);\n" " float a = tex2D(Texture_Gloss, TexCoord).a;\n" "#endif\n" "\n" -" gl_FragColor = float4(normalize(surfacenormal.x * VectorS + surfacenormal.y * VectorT + surfacenormal.z * VectorR) * 0.5 + float3(0.5, 0.5, 0.5), 1);\n" +"#ifdef HLSL\n" +" gl_FragData0 = float4(normalize(surfacenormal.x * VectorS + surfacenormal.y * VectorT + surfacenormal.z * VectorR.xyz) * 0.5 + float3(0.5, 0.5, 0.5), a);\n" +" float Depth = VectorR.w / 256.0;\n" +" float4 depthcolor = float4(Depth,Depth*65536.0/255.0,Depth*16777216.0/255.0,0.0);\n" +"// float4 depthcolor = float4(Depth,Depth*256.0,Depth*65536.0,0.0);\n" +" depthcolor.yz -= floor(depthcolor.yz);\n" +" gl_FragData1 = depthcolor;\n" +"#else\n" +" gl_FragColor = float4(normalize(surfacenormal.x * VectorS + surfacenormal.y * VectorT + surfacenormal.z * VectorR) * 0.5 + float3(0.5, 0.5, 0.5), a);\n" +"#endif\n" "}\n" "#endif // FRAGMENT_SHADER\n" "#else // !MODE_DEFERREDGEOMETRY\n" @@ -2623,8 +2636,8 @@ const char *builtincgshaderstring = "void main\n" "(\n" "float4 gl_Vertex : POSITION,\n" -"uniform float4x4 ModelViewProjectionMatrix,\n" -"uniform float4x4 ModelViewMatrix,\n" +"uniform float4x4 ModelViewProjectionMatrix : register(c8),\n" +"uniform float4x4 ModelViewMatrix : register(c12),\n" "out float4 gl_Position : POSITION,\n" "out float4 ModelViewPosition : TEXCOORD0\n" ")\n" @@ -2637,57 +2650,45 @@ const char *builtincgshaderstring = "#ifdef FRAGMENT_SHADER\n" "void main\n" "(\n" +"#ifdef HLSL\n" +"float2 Pixel : VPOS,\n" +"#else\n" "float2 Pixel : WPOS,\n" +"#endif\n" "float4 ModelViewPosition : TEXCOORD0,\n" -"uniform float4x4 ViewToLight,\n" -"uniform float2 ScreenToDepth, // ScreenToDepth = float2(Far / (Far - Near), Far * Near / (Near - Far));\n" -"uniform float3 LightPosition,\n" -"uniform half2 PixelToScreenTexCoord,\n" -"uniform half3 DeferredColor_Ambient,\n" -"uniform half3 DeferredColor_Diffuse,\n" +"uniform float4x4 ViewToLight : register(c44),\n" +"uniform float2 ScreenToDepth : register(c33), // ScreenToDepth = float2(Far / (Far - Near), Far * Near / (Near - Far));\n" +"uniform float3 LightPosition : register(c23),\n" +"uniform half2 PixelToScreenTexCoord : register(c42),\n" +"uniform half3 DeferredColor_Ambient : register(c9),\n" +"uniform half3 DeferredColor_Diffuse : register(c10),\n" "#ifdef USESPECULAR\n" -"uniform half3 DeferredColor_Specular,\n" -"uniform half SpecularPower,\n" +"uniform half3 DeferredColor_Specular : register(c11),\n" +"uniform half SpecularPower : register(c36),\n" "#endif\n" -"uniform sampler2D Texture_Attenuation,\n" -"uniform sampler2D Texture_ScreenDepth,\n" -"uniform sampler2D Texture_ScreenNormalMap,\n" +"uniform sampler Texture_Attenuation : register(s9),\n" +"uniform sampler Texture_ScreenDepth : register(s13),\n" +"uniform sampler Texture_ScreenNormalMap : register(s14),\n" "\n" "#ifdef USECUBEFILTER\n" -"uniform samplerCUBE Texture_Cube,\n" -"#endif\n" -"\n" -"#ifdef USESHADOWMAPRECT\n" -"# ifdef USESHADOWSAMPLER\n" -"uniform samplerRECTShadow Texture_ShadowMapRect,\n" -"# else\n" -"uniform samplerRECT Texture_ShadowMapRect,\n" -"# endif\n" +"uniform samplerCUBE Texture_Cube : register(s10),\n" "#endif\n" "\n" "#ifdef USESHADOWMAP2D\n" "# ifdef USESHADOWSAMPLER\n" -"uniform sampler2DShadow Texture_ShadowMap2D,\n" +"uniform sampler Texture_ShadowMap2D : register(s15),\n" "# else\n" -"uniform sampler2D Texture_ShadowMap2D,\n" +"uniform sampler Texture_ShadowMap2D : register(s15),\n" "# endif\n" "#endif\n" "\n" "#ifdef USESHADOWMAPVSDCT\n" -"uniform samplerCUBE Texture_CubeProjection,\n" -"#endif\n" -"\n" -"#ifdef USESHADOWMAPCUBE\n" -"# ifdef USESHADOWSAMPLER\n" -"uniform samplerCUBEShadow Texture_ShadowMapCube,\n" -"# else\n" -"uniform samplerCUBE Texture_ShadowMapCube,\n" -"# endif\n" +"uniform samplerCUBE Texture_CubeProjection : register(s12),\n" "#endif\n" "\n" -"#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D) || defined(USESHADOWMAPCUBE)\n" -"uniform float2 ShadowMap_TextureScale,\n" -"uniform float4 ShadowMap_Parameters,\n" +"#if defined(USESHADOWMAP2D)\n" +"uniform float2 ShadowMap_TextureScale : register(c35),\n" +"uniform float4 ShadowMap_Parameters : register(c34),\n" "#endif\n" "\n" "out float4 gl_FragData0 : COLOR0,\n" @@ -2698,17 +2699,21 @@ const char *builtincgshaderstring = " float2 ScreenTexCoord = Pixel * PixelToScreenTexCoord;\n" " //ScreenTexCoord.y = ScreenTexCoord.y * -1 + 1; // Cg is opposite?\n" " float3 position;\n" +"#ifdef HLSL\n" +" position.z = texDepth2D(Texture_ScreenDepth, ScreenTexCoord) * 256.0;\n" +"#else\n" " position.z = ScreenToDepth.y / (texDepth2D(Texture_ScreenDepth, ScreenTexCoord) + ScreenToDepth.x);\n" +"#endif\n" " position.xy = ModelViewPosition.xy * (position.z / ModelViewPosition.z);\n" " // decode viewspace pixel normal\n" -" half4 normalmap = tex2D(Texture_ScreenNormalMap, ScreenTexCoord);\n" -" half3 surfacenormal = normalize(normalmap.rgb - half3(0.5,0.5,0.5));\n" +" half4 normalmap = half4(tex2D(Texture_ScreenNormalMap, ScreenTexCoord));\n" +" half3 surfacenormal = half3(normalize(normalmap.rgb - half3(0.5,0.5,0.5)));\n" " // surfacenormal = pixel normal in viewspace\n" " // LightVector = pixel to light in viewspace\n" " // CubeVector = position in lightspace\n" " // eyevector = pixel to view in viewspace\n" -" float3 CubeVector = float3(mul(ViewToLight, float4(position,1)));\n" -" half fade = half(tex2D(Texture_Attenuation, float2(length(CubeVector), 0.0)));\n" +" float3 CubeVector = mul(ViewToLight, float4(position,1)).xyz;\n" +" half fade = half(tex2D(Texture_Attenuation, float2(length(CubeVector), 0.0)).r);\n" "#ifdef USEDIFFUSE\n" " // calculate diffuse shading\n" " half3 lightnormal = half3(normalize(LightPosition - position));\n" @@ -2718,29 +2723,19 @@ const char *builtincgshaderstring = " // calculate directional shading\n" " float3 eyevector = position * -1.0;\n" "# ifdef USEEXACTSPECULARMATH\n" -" half specular = pow(half(max(float(dot(reflect(lightnormal, surfacenormal), normalize(eyevector)))*-1.0, 0.0)), SpecularPower * normalmap.a);\n" +" half specular = half(pow(half(max(float(dot(reflect(lightnormal, surfacenormal), normalize(eyevector)))*-1.0, 0.0)), SpecularPower * normalmap.a));\n" "# else\n" -" half3 specularnormal = normalize(lightnormal + half3(normalize(eyevector)));\n" -" half specular = pow(half(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * normalmap.a);\n" +" half3 specularnormal = half3(normalize(lightnormal + half3(normalize(eyevector))));\n" +" half specular = half(pow(half(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * normalmap.a));\n" "# endif\n" "#endif\n" "\n" -"#if defined(USESHADOWMAP2D) || defined(USESHADOWMAPRECT) || defined(USESHADOWMAPCUBE)\n" -" fade *= ShadowMapCompare(CubeVector,\n" -"# if defined(USESHADOWMAP2D)\n" -"Texture_ShadowMap2D, ShadowMap_Parameters, ShadowMap_TextureScale\n" -"# endif\n" -"# if defined(USESHADOWMAPRECT)\n" -"Texture_ShadowMapRect, ShadowMap_Parameters\n" -"# endif\n" -"# if defined(USESHADOWMAPCUBE)\n" -"Texture_ShadowMapCube, ShadowMap_Parameters\n" -"# endif\n" -"\n" +"#if defined(USESHADOWMAP2D)\n" +" fade *= half(ShadowMapCompare(CubeVector, Texture_ShadowMap2D, ShadowMap_Parameters, ShadowMap_TextureScale\n" "#ifdef USESHADOWMAPVSDCT\n" ", Texture_CubeProjection\n" "#endif\n" -" );\n" +" ));\n" "#endif\n" "\n" "#ifdef USEDIFFUSE\n" @@ -2770,7 +2765,7 @@ const char *builtincgshaderstring = "void main\n" "(\n" "float4 gl_Vertex : POSITION,\n" -"uniform float4x4 ModelViewProjectionMatrix,\n" +"uniform float4x4 ModelViewProjectionMatrix : register(c8),\n" "#if defined(USEVERTEXTEXTUREBLEND) || defined(MODE_VERTEXCOLOR)\n" "float4 gl_Color : COLOR0,\n" "#endif\n" @@ -2780,29 +2775,30 @@ const char *builtincgshaderstring = "float4 gl_MultiTexCoord3 : TEXCOORD3,\n" "float4 gl_MultiTexCoord4 : TEXCOORD4,\n" "\n" -"uniform float3 EyePosition,\n" -"uniform float4x4 TexMatrix,\n" +"uniform float3 EyePosition : register(c24),\n" +"uniform float4x4 TexMatrix : register(c0),\n" "#ifdef USEVERTEXTEXTUREBLEND\n" -"uniform float4x4 BackgroundTexMatrix,\n" +"uniform float4x4 BackgroundTexMatrix : register(c4),\n" "#endif\n" "#ifdef MODE_LIGHTSOURCE\n" -"uniform float4x4 ModelToLight,\n" +"uniform float4x4 ModelToLight : register(c20),\n" "#endif\n" "#ifdef MODE_LIGHTSOURCE\n" -"uniform float3 LightPosition,\n" +"uniform float3 LightPosition : register(c27),\n" "#endif\n" "#ifdef MODE_LIGHTDIRECTION\n" -"uniform float3 LightDir,\n" +"uniform float3 LightDir : register(c26),\n" "#endif\n" -"uniform float4 FogPlane,\n" +"uniform float4 FogPlane : register(c25),\n" "#ifdef MODE_DEFERREDLIGHTSOURCE\n" -"uniform float3 LightPosition,\n" +"uniform float3 LightPosition : register(c27),\n" "#endif\n" "#ifdef USESHADOWMAPORTHO\n" -"uniform float4x4 ShadowMapMatrix,\n" +"uniform float4x4 ShadowMapMatrix : register(c16),\n" "#endif\n" -"\n" +"#if defined(MODE_VERTEXCOLOR) || defined(USEVERTEXTEXTUREBLEND)\n" "out float4 gl_FrontColor : COLOR,\n" +"#endif\n" "out float4 TexCoordBoth : TEXCOORD0,\n" "#ifdef USELIGHTMAP\n" "out float2 TexCoordLightmap : TEXCOORD1,\n" @@ -2816,7 +2812,7 @@ const char *builtincgshaderstring = "#ifdef USEFOG\n" "out float4 EyeVectorModelSpaceFogPlaneVertexDist : TEXCOORD4,\n" "#endif\n" -"#if defined(MODE_LIGHTSOURCE) || defined(MODE_LIGHTDIRECTION)\n" +"#if defined(MODE_LIGHTDIRECTION) && defined(USEDIFFUSE) || defined(USEDIFFUSE)\n" "out float3 LightVector : TEXCOORD1,\n" "#endif\n" "#ifdef MODE_LIGHTSOURCE\n" @@ -2834,7 +2830,11 @@ const char *builtincgshaderstring = ")\n" "{\n" "#if defined(MODE_VERTEXCOLOR) || defined(USEVERTEXTEXTUREBLEND)\n" -" gl_FrontColor = gl_Color;\n" +"#ifdef HLSL\n" +" gl_FrontColor = gl_Color.bgra; // NOTE: D3DCOLOR is backwards\n" +"#else\n" +" gl_FrontColor = gl_Color; // Cg is forward\n" +"#endif\n" "#endif\n" " // copy the surface texcoord\n" " TexCoordBoth = mul(TexMatrix, gl_MultiTexCoord0);\n" @@ -2842,13 +2842,13 @@ const char *builtincgshaderstring = " TexCoordBoth.zw = mul(BackgroundTexMatrix, gl_MultiTexCoord0).xy;\n" "#endif\n" "#ifdef USELIGHTMAP\n" -" TexCoordLightmap = float2(gl_MultiTexCoord4);\n" +" TexCoordLightmap = gl_MultiTexCoord4.xy;\n" "#endif\n" "\n" "#ifdef MODE_LIGHTSOURCE\n" " // transform vertex position into light attenuation/cubemap space\n" " // (-1 to +1 across the light box)\n" -" CubeVector = float3(mul(ModelToLight, gl_Vertex));\n" +" CubeVector = mul(ModelToLight, gl_Vertex).xyz;\n" "\n" "# ifdef USEDIFFUSE\n" " // transform unnormalized light direction into tangent space\n" @@ -2890,7 +2890,7 @@ const char *builtincgshaderstring = " gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n" "\n" "#ifdef USESHADOWMAPORTHO\n" -" ShadowMapTC = float3(mul(ShadowMapMatrix, gl_Position));\n" +" ShadowMapTC = mul(ShadowMapMatrix, gl_Position).xyz;\n" "#endif\n" "\n" "#ifdef USEREFLECTION\n" @@ -2906,8 +2906,12 @@ const char *builtincgshaderstring = "void main\n" "(\n" "#ifdef USEDEFERREDLIGHTMAP\n" +"#ifdef HLSL\n" +"float2 Pixel : VPOS,\n" +"#else\n" "float2 Pixel : WPOS,\n" "#endif\n" +"#endif\n" "float4 gl_FrontColor : COLOR,\n" "float4 TexCoordBoth : TEXCOORD0,\n" "#ifdef USELIGHTMAP\n" @@ -2940,135 +2944,121 @@ const char *builtincgshaderstring = "float3 ShadowMapTC : TEXCOORD3, // CONFLICTS WITH USEREFLECTION!\n" "#endif\n" "\n" -"uniform sampler2D Texture_Normal,\n" -"uniform sampler2D Texture_Color,\n" +"uniform sampler Texture_Normal : register(s0),\n" +"uniform sampler Texture_Color : register(s1),\n" "#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n" -"uniform sampler2D Texture_Gloss,\n" +"uniform sampler Texture_Gloss : register(s2),\n" "#endif\n" "#ifdef USEGLOW\n" -"uniform sampler2D Texture_Glow,\n" +"uniform sampler Texture_Glow : register(s3),\n" "#endif\n" "#ifdef USEVERTEXTEXTUREBLEND\n" -"uniform sampler2D Texture_SecondaryNormal,\n" -"uniform sampler2D Texture_SecondaryColor,\n" +"uniform sampler Texture_SecondaryNormal : register(s4),\n" +"uniform sampler Texture_SecondaryColor : register(s5),\n" "#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n" -"uniform sampler2D Texture_SecondaryGloss,\n" +"uniform sampler Texture_SecondaryGloss : register(s6),\n" "#endif\n" "#ifdef USEGLOW\n" -"uniform sampler2D Texture_SecondaryGlow,\n" +"uniform sampler Texture_SecondaryGlow : register(s7),\n" "#endif\n" "#endif\n" "#ifdef USECOLORMAPPING\n" -"uniform sampler2D Texture_Pants,\n" -"uniform sampler2D Texture_Shirt,\n" +"uniform sampler Texture_Pants : register(s4),\n" +"uniform sampler Texture_Shirt : register(s7),\n" "#endif\n" "#ifdef USEFOG\n" -"uniform sampler2D Texture_FogHeightTexture,\n" -"uniform sampler2D Texture_FogMask,\n" +"uniform sampler Texture_FogHeightTexture : register(s14),\n" +"uniform sampler Texture_FogMask : register(s8),\n" "#endif\n" "#ifdef USELIGHTMAP\n" -"uniform sampler2D Texture_Lightmap,\n" +"uniform sampler Texture_Lightmap : register(s9),\n" "#endif\n" "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n" -"uniform sampler2D Texture_Deluxemap,\n" +"uniform sampler Texture_Deluxemap : register(s10),\n" "#endif\n" "#ifdef USEREFLECTION\n" -"uniform sampler2D Texture_Reflection,\n" +"uniform sampler Texture_Reflection : register(s7),\n" "#endif\n" "\n" "#ifdef MODE_DEFERREDLIGHTSOURCE\n" -"uniform sampler2D Texture_ScreenDepth,\n" -"uniform sampler2D Texture_ScreenNormalMap,\n" +"uniform sampler Texture_ScreenDepth : register(s13),\n" +"uniform sampler Texture_ScreenNormalMap : register(s14),\n" "#endif\n" "#ifdef USEDEFERREDLIGHTMAP\n" -"uniform sampler2D Texture_ScreenDiffuse,\n" -"uniform sampler2D Texture_ScreenSpecular,\n" +"uniform sampler Texture_ScreenDepth : register(s13),\n" +"uniform sampler Texture_ScreenNormalMap : register(s14),\n" +"uniform sampler Texture_ScreenDiffuse : register(s11),\n" +"uniform sampler Texture_ScreenSpecular : register(s12),\n" "#endif\n" "\n" "#ifdef USECOLORMAPPING\n" -"uniform half3 Color_Pants,\n" -"uniform half3 Color_Shirt,\n" +"uniform half3 Color_Pants : register(c7),\n" +"uniform half3 Color_Shirt : register(c8),\n" "#endif\n" "#ifdef USEFOG\n" -"uniform float3 FogColor,\n" -"uniform float FogRangeRecip,\n" -"uniform float FogPlaneViewDist,\n" -"uniform float FogHeightFade,\n" +"uniform float3 FogColor : register(c16),\n" +"uniform float FogRangeRecip : register(c20),\n" +"uniform float FogPlaneViewDist : register(c19),\n" +"uniform float FogHeightFade : register(c17),\n" "#endif\n" "\n" "#ifdef USEOFFSETMAPPING\n" -"uniform float OffsetMapping_Scale,\n" +"uniform float OffsetMapping_Scale : register(c24),\n" "#endif\n" "\n" "#ifdef USEDEFERREDLIGHTMAP\n" -"uniform half2 PixelToScreenTexCoord,\n" -"uniform half3 DeferredMod_Diffuse,\n" -"uniform half3 DeferredMod_Specular,\n" -"#endif\n" -"uniform half3 Color_Ambient,\n" -"uniform half3 Color_Diffuse,\n" -"uniform half3 Color_Specular,\n" -"uniform half SpecularPower,\n" +"uniform half2 PixelToScreenTexCoord : register(c42),\n" +"uniform half3 DeferredMod_Diffuse : register(c12),\n" +"uniform half3 DeferredMod_Specular : register(c13),\n" +"#endif\n" +"uniform half3 Color_Ambient : register(c3),\n" +"uniform half3 Color_Diffuse : register(c4),\n" +"uniform half3 Color_Specular : register(c5),\n" +"uniform half SpecularPower : register(c36),\n" "#ifdef USEGLOW\n" -"uniform half3 Color_Glow,\n" +"uniform half3 Color_Glow : register(c6),\n" "#endif\n" -"uniform half Alpha,\n" +"uniform half Alpha : register(c0),\n" "#ifdef USEREFLECTION\n" -"uniform float4 DistortScaleRefractReflect,\n" -"uniform float4 ScreenScaleRefractReflect,\n" -"uniform float4 ScreenCenterRefractReflect,\n" -"uniform half4 ReflectColor,\n" +"uniform float4 DistortScaleRefractReflect : register(c14),\n" +"uniform float4 ScreenScaleRefractReflect : register(c32),\n" +"uniform float4 ScreenCenterRefractReflect : register(c31),\n" +"uniform half4 ReflectColor : register(c26),\n" "#endif\n" "#ifdef USEREFLECTCUBE\n" -"uniform float4x4 ModelToReflectCube,\n" -"uniform sampler2D Texture_ReflectMask,\n" -"uniform samplerCUBE Texture_ReflectCube,\n" +"uniform float4x4 ModelToReflectCube : register(c48),\n" +"uniform sampler Texture_ReflectMask : register(s5),\n" +"uniform samplerCUBE Texture_ReflectCube : register(s6),\n" "#endif\n" "#ifdef MODE_LIGHTDIRECTION\n" -"uniform half3 LightColor,\n" +"uniform half3 LightColor : register(c21),\n" "#endif\n" "#ifdef MODE_LIGHTSOURCE\n" -"uniform half3 LightColor,\n" +"uniform half3 LightColor : register(c21),\n" "#endif\n" "\n" "#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE)\n" -"uniform sampler2D Texture_Attenuation,\n" -"uniform samplerCUBE Texture_Cube,\n" +"uniform sampler Texture_Attenuation : register(s9),\n" +"uniform samplerCUBE Texture_Cube : register(s10),\n" "#endif\n" "\n" "#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE) || defined(USESHADOWMAPORTHO)\n" "\n" -"#ifdef USESHADOWMAPRECT\n" -"# ifdef USESHADOWSAMPLER\n" -"uniform samplerRECTShadow Texture_ShadowMapRect,\n" -"# else\n" -"uniform samplerRECT Texture_ShadowMapRect,\n" -"# endif\n" -"#endif\n" -"\n" "#ifdef USESHADOWMAP2D\n" "# ifdef USESHADOWSAMPLER\n" -"uniform sampler2DShadow Texture_ShadowMap2D,\n" +"uniform sampler Texture_ShadowMap2D : register(s15),\n" "# else\n" -"uniform sampler2D Texture_ShadowMap2D,\n" +"uniform sampler Texture_ShadowMap2D : register(s15),\n" "# endif\n" "#endif\n" "\n" "#ifdef USESHADOWMAPVSDCT\n" -"uniform samplerCUBE Texture_CubeProjection,\n" -"#endif\n" -"\n" -"#ifdef USESHADOWMAPCUBE\n" -"# ifdef USESHADOWSAMPLER\n" -"uniform samplerCUBEShadow Texture_ShadowMapCube,\n" -"# else\n" -"uniform samplerCUBE Texture_ShadowMapCube,\n" -"# endif\n" +"uniform samplerCUBE Texture_CubeProjection : register(s12),\n" "#endif\n" "\n" -"#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D) || defined(USESHADOWMAPCUBE)\n" -"uniform float2 ShadowMap_TextureScale,\n" -"uniform float4 ShadowMap_Parameters,\n" +"#if defined(USESHADOWMAP2D)\n" +"uniform float2 ShadowMap_TextureScale : register(c35),\n" +"uniform float4 ShadowMap_Parameters : register(c34),\n" "#endif\n" "#endif // !defined(MODE_LIGHTSOURCE) && !defined(MODE_DEFERREDLIGHTSOURCE) && !defined(USESHADOWMAPORTHO)\n" "\n" @@ -3093,29 +3083,29 @@ const char *builtincgshaderstring = "#endif\n" " color.a *= Alpha;\n" "#ifdef USECOLORMAPPING\n" -" color.rgb += half3(tex2D(Texture_Pants, TexCoord)) * Color_Pants + half3(tex2D(Texture_Shirt, TexCoord)) * Color_Shirt;\n" +" color.rgb += half3(tex2D(Texture_Pants, TexCoord).rgb) * Color_Pants + half3(tex2D(Texture_Shirt, TexCoord).rgb) * Color_Shirt;\n" "#endif\n" "#ifdef USEVERTEXTEXTUREBLEND\n" -" float terrainblend = clamp(half(gl_FrontColor.a) * color.a * 2.0 - 0.5, half(0.0), half(1.0));\n" +" half terrainblend = clamp(half(gl_FrontColor.a) * color.a * 2.0 - 0.5, half(0.0), half(1.0));\n" " //half terrainblend = min(half(gl_FrontColor.a) * color.a * 2.0, half(1.0));\n" " //half terrainblend = half(gl_FrontColor.a) * color.a > 0.5;\n" -" color.rgb = half3(lerp(float3(tex2D(Texture_SecondaryColor, TexCoord2)), float3(color.rgb), terrainblend));\n" +" color.rgb = half3(lerp(tex2D(Texture_SecondaryColor, TexCoord2).rgb, float3(color.rgb), terrainblend));\n" " color.a = 1.0;\n" -" //color = lerp(half4(1, 0, 0, 1), color, terrainblend);\n" +" //color = half4(lerp(float4(1, 0, 0, 1), color, terrainblend));\n" "#endif\n" "\n" " // get the surface normal\n" "#ifdef USEVERTEXTEXTUREBLEND\n" -" half3 surfacenormal = normalize(half3(lerp(float3(tex2D(Texture_SecondaryNormal, TexCoord2)), float3(tex2D(Texture_Normal, TexCoord)), terrainblend)) - half3(0.5, 0.5, 0.5));\n" +" half3 surfacenormal = normalize(half3(lerp(tex2D(Texture_SecondaryNormal, TexCoord2).rgb, tex2D(Texture_Normal, TexCoord).rgb, terrainblend)) - half3(0.5, 0.5, 0.5));\n" "#else\n" -" half3 surfacenormal = normalize(half3(tex2D(Texture_Normal, TexCoord)) - half3(0.5, 0.5, 0.5));\n" +" half3 surfacenormal = half3(normalize(half3(tex2D(Texture_Normal, TexCoord).rgb) - half3(0.5, 0.5, 0.5)));\n" "#endif\n" "\n" " // get the material colors\n" " half3 diffusetex = color.rgb;\n" "#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n" "# ifdef USEVERTEXTEXTUREBLEND\n" -" half4 glosstex = half4(lerp(float4(tex2D(Texture_SecondaryGloss, TexCoord2)), float4(tex2D(Texture_Gloss, TexCoord)), terrainblend));\n" +" half4 glosstex = half4(lerp(tex2D(Texture_SecondaryGloss, TexCoord2), tex2D(Texture_Gloss, TexCoord), terrainblend));\n" "# else\n" " half4 glosstex = half4(tex2D(Texture_Gloss, TexCoord));\n" "# endif\n" @@ -3124,8 +3114,8 @@ const char *builtincgshaderstring = "#ifdef USEREFLECTCUBE\n" " float3 TangentReflectVector = reflect(-EyeVector, surfacenormal);\n" " float3 ModelReflectVector = TangentReflectVector.x * VectorS + TangentReflectVector.y * VectorT + TangentReflectVector.z * VectorR;\n" -" float3 ReflectCubeTexCoord = float3(mul(ModelToReflectCube, float4(ModelReflectVector, 0)));\n" -" diffusetex += half3(tex2D(Texture_ReflectMask, TexCoord)) * half3(texCUBE(Texture_ReflectCube, ReflectCubeTexCoord));\n" +" float3 ReflectCubeTexCoord = mul(ModelToReflectCube, float4(ModelReflectVector, 0)).xyz;\n" +" diffusetex += half3(tex2D(Texture_ReflectMask, TexCoord).rgb) * half3(texCUBE(Texture_ReflectCube, ReflectCubeTexCoord).rgb);\n" "#endif\n" "\n" "\n" @@ -3139,10 +3129,10 @@ const char *builtincgshaderstring = " color.rgb = diffusetex * (Color_Ambient + diffuse * Color_Diffuse);\n" "#ifdef USESPECULAR\n" "#ifdef USEEXACTSPECULARMATH\n" -" half specular = pow(half(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a);\n" +" half specular = half(pow(half(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a));\n" "#else\n" -" half3 specularnormal = normalize(lightnormal + half3(normalize(EyeVector)));\n" -" half specular = pow(half(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a);\n" +" half3 specularnormal = half3(normalize(lightnormal + half3(normalize(EyeVector))));\n" +" half specular = half(pow(half(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a));\n" "#endif\n" " color.rgb += glosstex.rgb * (specular * Color_Specular);\n" "#endif\n" @@ -3150,28 +3140,41 @@ const char *builtincgshaderstring = " color.rgb = diffusetex * Color_Ambient;\n" "#endif\n" " color.rgb *= LightColor;\n" -" color.rgb *= half(tex2D(Texture_Attenuation, float2(length(CubeVector), 0.0)));\n" -"#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAPCUBE) || defined(USESHADOWMAP2D)\n" -" color.rgb *= ShadowMapCompare(CubeVector,\n" -"# if defined(USESHADOWMAP2D)\n" -"Texture_ShadowMap2D, ShadowMap_Parameters, ShadowMap_TextureScale\n" -"# endif\n" -"# if defined(USESHADOWMAPRECT)\n" -"Texture_ShadowMapRect, ShadowMap_Parameters\n" -"# endif\n" -"# if defined(USESHADOWMAPCUBE)\n" -"Texture_ShadowMapCube, ShadowMap_Parameters\n" -"# endif\n" -"\n" +" color.rgb *= half(tex2D(Texture_Attenuation, float2(length(CubeVector), 0.0)).r);\n" +"#if defined(USESHADOWMAP2D)\n" +" color.rgb *= half(ShadowMapCompare(CubeVector, Texture_ShadowMap2D, ShadowMap_Parameters, ShadowMap_TextureScale\n" "#ifdef USESHADOWMAPVSDCT\n" ", Texture_CubeProjection\n" "#endif\n" -" );\n" +" ));\n" "\n" "#endif\n" "# ifdef USECUBEFILTER\n" -" color.rgb *= half3(texCUBE(Texture_Cube, CubeVector));\n" +" color.rgb *= half3(texCUBE(Texture_Cube, CubeVector).rgb);\n" "# endif\n" +"\n" +"#ifdef USESHADOWMAP2D\n" +"#ifdef USESHADOWMAPVSDCT\n" +"// float3 shadowmaptc = GetShadowMapTC2D(CubeVector, ShadowMap_Parameters, Texture_CubeProjection);\n" +"#else\n" +"// float3 shadowmaptc = GetShadowMapTC2D(CubeVector, ShadowMap_Parameters);\n" +"#endif\n" +"// color.rgb = half3(tex2D(Texture_ShadowMap2D, float2(0.1,0.1)).rgb);\n" +"// color.rgb = half3(tex2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale).rgb);\n" +"// color.rgb = half3(shadowmaptc.xyz * float3(ShadowMap_TextureScale,1.0));\n" +"// color.r = half(texDepth2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale));\n" +"// color.rgb = half3(tex2D(Texture_ShadowMap2D, float2(0.1,0.1)).rgb);\n" +"// color.rgb = half3(tex2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale).rgb);\n" +"// color.rgb = half3(shadowmaptc.xyz * float3(ShadowMap_TextureScale,1.0));\n" +"// color.r = half(texDepth2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale));\n" +"// color.r = half(shadowmaptc.z - texDepth2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale));\n" +"// color.r = half(shadowmaptc.z);\n" +"// color.r = half(texDepth2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale));\n" +"// color.r = half(shadowmaptc.z);\n" +"// color.r = 1;\n" +"// color.rgb = abs(CubeVector);\n" +"#endif\n" +"// color.rgb = half3(1,1,1);\n" "#endif // MODE_LIGHTSOURCE\n" "\n" "\n" @@ -3187,8 +3190,8 @@ const char *builtincgshaderstring = "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n" "#define SHADING\n" " // deluxemap lightmapping using light vectors in modelspace (q3map2 -light -deluxe)\n" -" half3 lightnormal_modelspace = half3(tex2D(Texture_Deluxemap, TexCoordLightmap)) * 2.0 + half3(-1.0, -1.0, -1.0);\n" -" half3 lightcolor = half3(tex2D(Texture_Lightmap, TexCoordLightmap));\n" +" half3 lightnormal_modelspace = half3(tex2D(Texture_Deluxemap, TexCoordLightmap).rgb) * 2.0 + half3(-1.0, -1.0, -1.0);\n" +" half3 lightcolor = half3(tex2D(Texture_Lightmap, TexCoordLightmap).rgb);\n" " // convert modelspace light vector to tangentspace\n" " half3 lightnormal;\n" " lightnormal.x = dot(lightnormal_modelspace, half3(VectorS));\n" @@ -3208,15 +3211,24 @@ const char *builtincgshaderstring = "#ifdef MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n" "#define SHADING\n" " // deluxemap lightmapping using light vectors in tangentspace (hmap2 -light)\n" -" half3 lightnormal = half3(tex2D(Texture_Deluxemap, TexCoordLightmap)) * 2.0 + half3(-1.0, -1.0, -1.0);\n" -" half3 lightcolor = half3(tex2D(Texture_Lightmap, TexCoordLightmap));\n" +" half3 lightnormal = half3(tex2D(Texture_Deluxemap, TexCoordLightmap).rgb) * 2.0 + half3(-1.0, -1.0, -1.0);\n" +" half3 lightcolor = half3(tex2D(Texture_Lightmap, TexCoordLightmap).rgb);\n" "#endif\n" "\n" "\n" "\n" "\n" +"#ifdef MODE_FAKELIGHT\n" +"#define SHADING\n" +"half3 lightnormal = half3(normalize(EyeVector));\n" +"half3 lightcolor = half3(1.0,1.0,1.0);\n" +"#endif // MODE_FAKELIGHT\n" +"\n" +"\n" +"\n" +"\n" "#ifdef MODE_LIGHTMAP\n" -" color.rgb = diffusetex * (Color_Ambient + half3(tex2D(Texture_Lightmap, TexCoordLightmap)) * Color_Diffuse);\n" +" color.rgb = diffusetex * (Color_Ambient + half3(tex2D(Texture_Lightmap, TexCoordLightmap).rgb) * Color_Diffuse);\n" "#endif // MODE_LIGHTMAP\n" "#ifdef MODE_VERTEXCOLOR\n" " color.rgb = diffusetex * (Color_Ambient + half3(gl_FrontColor.rgb) * Color_Diffuse);\n" @@ -3233,10 +3245,10 @@ const char *builtincgshaderstring = " half diffuse = half(max(float(dot(surfacenormal, lightnormal)), 0.0));\n" "# ifdef USESPECULAR\n" "# ifdef USEEXACTSPECULARMATH\n" -" half specular = pow(half(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a);\n" +" half specular = half(pow(half(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a));\n" "# else\n" -" half3 specularnormal = normalize(lightnormal + half3(normalize(EyeVector)));\n" -" half specular = pow(half(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a);\n" +" half3 specularnormal = half3(normalize(lightnormal + half3(normalize(EyeVector))));\n" +" half specular = half(pow(half(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a));\n" "# endif\n" " color.rgb = diffusetex * Color_Ambient + (diffusetex * Color_Diffuse * diffuse + glosstex.rgb * Color_Specular * specular) * lightcolor;\n" "# else\n" @@ -3248,27 +3260,22 @@ const char *builtincgshaderstring = "#endif\n" "\n" "#ifdef USESHADOWMAPORTHO\n" -" color.rgb *= ShadowMapCompare(ShadowMapTC,\n" -"# if defined(USESHADOWMAP2D)\n" -"Texture_ShadowMap2D, ShadowMap_Parameters, ShadowMap_TextureScale\n" -"# endif\n" -"# if defined(USESHADOWMAPRECT)\n" -"Texture_ShadowMapRect, ShadowMap_Parameters\n" -"# endif\n" -" );\n" +" color.rgb *= half(ShadowMapCompare(ShadowMapTC, Texture_ShadowMap2D, ShadowMap_Parameters, ShadowMap_TextureScale));\n" "#endif\n" "\n" "#ifdef USEDEFERREDLIGHTMAP\n" " float2 ScreenTexCoord = Pixel * PixelToScreenTexCoord;\n" -" color.rgb += diffusetex * half3(tex2D(Texture_ScreenDiffuse, ScreenTexCoord)) * DeferredMod_Diffuse;\n" -" color.rgb += glosstex.rgb * half3(tex2D(Texture_ScreenSpecular, ScreenTexCoord)) * DeferredMod_Specular;\n" +" color.rgb += diffusetex * half3(tex2D(Texture_ScreenDiffuse, ScreenTexCoord).rgb) * DeferredMod_Diffuse;\n" +" color.rgb += glosstex.rgb * half3(tex2D(Texture_ScreenSpecular, ScreenTexCoord).rgb) * DeferredMod_Specular;\n" +"// color.rgb = half3(tex2D(Texture_ScreenDepth, ScreenTexCoord).rgb);\n" +"// color.r = half(texDepth2D(Texture_ScreenDepth, ScreenTexCoord)) * 1.0;\n" "#endif\n" "\n" "#ifdef USEGLOW\n" "#ifdef USEVERTEXTEXTUREBLEND\n" -" color.rgb += lerp(half3(tex2D(Texture_SecondaryGlow, TexCoord2)), half3(tex2D(Texture_Glow, TexCoord)), terrainblend) * Color_Glow;\n" +" color.rgb += half3(lerp(tex2D(Texture_SecondaryGlow, TexCoord2).rgb, tex2D(Texture_Glow, TexCoord).rgb, terrainblend)) * Color_Glow;\n" "#else\n" -" color.rgb += half3(tex2D(Texture_Glow, TexCoord)) * Color_Glow;\n" +" color.rgb += half3(tex2D(Texture_Glow, TexCoord).rgb) * Color_Glow;\n" "#endif\n" "#endif\n" "\n" @@ -3279,9 +3286,9 @@ const char *builtincgshaderstring = " // reflection must come last because it already contains exactly the correct fog (the reflection render preserves camera distance from the plane, it only flips the side) and ContrastBoost/SceneBrightness\n" "#ifdef USEREFLECTION\n" " float4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n" -" //float4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(half3(tex2D(Texture_Normal, TexCoord)) - half3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n" +" //float4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(half3(tex2D(Texture_Normal, TexCoord).rgb) - half3(0.5,0.5,0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n" " float2 SafeScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW.zw + ScreenCenterRefractReflect.zw;\n" -" float2 ScreenTexCoord = SafeScreenTexCoord + float3(normalize(half3(tex2D(Texture_Normal, TexCoord)) - half3(0.5))).xy * DistortScaleRefractReflect.zw;\n" +" float2 ScreenTexCoord = SafeScreenTexCoord + float3(normalize(half3(tex2D(Texture_Normal, TexCoord).rgb) - half3(0.5,0.5,0.5))).xy * DistortScaleRefractReflect.zw;\n" " // FIXME temporary hack to detect the case that the reflection\n" " // gets blackened at edges due to leaving the area that contains actual\n" " // content.\n" @@ -3292,7 +3299,7 @@ const char *builtincgshaderstring = " f *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord + float2(-0.01, 0.01)).rgb) / 0.05);\n" " f *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord + float2(-0.01, -0.01)).rgb) / 0.05);\n" " ScreenTexCoord = lerp(SafeScreenTexCoord, ScreenTexCoord, f);\n" -" color.rgb = lerp(color.rgb, half3(tex2D(Texture_Reflection, ScreenTexCoord)) * ReflectColor.rgb, ReflectColor.a);\n" +" color.rgb = lerp(color.rgb, half3(tex2D(Texture_Reflection, ScreenTexCoord).rgb) * ReflectColor.rgb, ReflectColor.a);\n" "#endif\n" "\n" " gl_FragColor = float4(color);\n" @@ -3312,6 +3319,7 @@ const char *builtincgshaderstring = char *glslshaderstring = NULL; char *cgshaderstring = NULL; +char *hlslshaderstring = NULL; //======================================================================================================================================================= @@ -3336,7 +3344,7 @@ typedef enum shaderpermutation_e { SHADERPERMUTATION_DIFFUSE = 1<<0, ///< (lightsource) whether to use directional shading SHADERPERMUTATION_VERTEXTEXTUREBLEND = 1<<1, ///< indicates this is a two-layer material blend based on vertex alpha (q3bsp) - SHADERPERMUTATION_VIEWTINT = 1<<2, ///< view tint (postprocessing only) + SHADERPERMUTATION_VIEWTINT = 1<<2, ///< view tint (postprocessing only), use vertex colors (generic only) SHADERPERMUTATION_COLORMAPPING = 1<<3, ///< indicates this is a colormapped skin SHADERPERMUTATION_SATURATION = 1<<4, ///< saturation (postprocessing only) SHADERPERMUTATION_FOGINSIDE = 1<<5, ///< tint the color by fog color or black if using additive blend mode @@ -3348,23 +3356,21 @@ typedef enum shaderpermutation_e SHADERPERMUTATION_BLOOM = 1<<11, ///< bloom (postprocessing only) SHADERPERMUTATION_SPECULAR = 1<<12, ///< (lightsource or deluxemapping) render specular effects SHADERPERMUTATION_POSTPROCESSING = 1<<13, ///< user defined postprocessing (postprocessing only) - SHADERPERMUTATION_EXACTSPECULARMATH = 1<<14, ///< (lightsource or deluxemapping) use exact reflection map for specular effects, as opposed to the usual OpenGL approximation - SHADERPERMUTATION_REFLECTION = 1<<15, ///< normalmap-perturbed reflection of the scene infront of the surface, preformed as an overlay on the surface - SHADERPERMUTATION_OFFSETMAPPING = 1<<16, ///< adjust texcoords to roughly simulate a displacement mapped surface - SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING = 1<<17, ///< adjust texcoords to accurately simulate a displacement mapped surface (requires OFFSETMAPPING to also be set!) - SHADERPERMUTATION_SHADOWMAPRECT = 1<<18, ///< (lightsource) use shadowmap rectangle texture as light filter - SHADERPERMUTATION_SHADOWMAPCUBE = 1<<19, ///< (lightsource) use shadowmap cubemap texture as light filter - SHADERPERMUTATION_SHADOWMAP2D = 1<<20, ///< (lightsource) use shadowmap rectangle texture as light filter - SHADERPERMUTATION_SHADOWMAPPCF = 1<<21, ///< (lightsource) use percentage closer filtering on shadowmap test results - SHADERPERMUTATION_SHADOWMAPPCF2 = 1<<22, ///< (lightsource) use higher quality percentage closer filtering on shadowmap test results - SHADERPERMUTATION_SHADOWSAMPLER = 1<<23, ///< (lightsource) use hardware shadowmap test - SHADERPERMUTATION_SHADOWMAPVSDCT = 1<<24, ///< (lightsource) use virtual shadow depth cube texture for shadowmap indexing - SHADERPERMUTATION_SHADOWMAPORTHO = 1<<25, //< (lightsource) use orthographic shadowmap projection - SHADERPERMUTATION_DEFERREDLIGHTMAP = 1<<26, ///< (lightmap) read Texture_ScreenDiffuse/Specular textures and add them on top of lightmapping - SHADERPERMUTATION_ALPHAKILL = 1<<27, ///< (deferredgeometry) discard pixel if diffuse texture alpha below 0.5 - SHADERPERMUTATION_REFLECTCUBE = 1<<28, ///< fake reflections using global cubemap (not HDRI light probe) - SHADERPERMUTATION_LIMIT = 1<<29, ///< size of permutations array - SHADERPERMUTATION_COUNT = 29 ///< size of shaderpermutationinfo array + SHADERPERMUTATION_REFLECTION = 1<<14, ///< normalmap-perturbed reflection of the scene infront of the surface, preformed as an overlay on the surface + SHADERPERMUTATION_OFFSETMAPPING = 1<<15, ///< adjust texcoords to roughly simulate a displacement mapped surface + SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING = 1<<16, ///< adjust texcoords to accurately simulate a displacement mapped surface (requires OFFSETMAPPING to also be set!) + SHADERPERMUTATION_SHADOWMAP2D = 1<<17, ///< (lightsource) use shadowmap texture as light filter + SHADERPERMUTATION_SHADOWMAPPCF = 1<<18, ///< (lightsource) use percentage closer filtering on shadowmap test results + SHADERPERMUTATION_SHADOWMAPPCF2 = 1<<19, ///< (lightsource) use higher quality percentage closer filtering on shadowmap test results + SHADERPERMUTATION_SHADOWSAMPLER = 1<<20, ///< (lightsource) use hardware shadowmap test + SHADERPERMUTATION_SHADOWMAPVSDCT = 1<<21, ///< (lightsource) use virtual shadow depth cube texture for shadowmap indexing + SHADERPERMUTATION_SHADOWMAPORTHO = 1<<22, //< (lightsource) use orthographic shadowmap projection + SHADERPERMUTATION_DEFERREDLIGHTMAP = 1<<23, ///< (lightmap) read Texture_ScreenDiffuse/Specular textures and add them on top of lightmapping + SHADERPERMUTATION_ALPHAKILL = 1<<24, ///< (deferredgeometry) discard pixel if diffuse texture alpha below 0.5 + SHADERPERMUTATION_REFLECTCUBE = 1<<25, ///< fake reflections using global cubemap (not HDRI light probe) + SHADERPERMUTATION_NORMALMAPSCROLLBLEND = 1<<26, // (water) counter-direction normalmaps scrolling + SHADERPERMUTATION_LIMIT = 1<<27, ///< size of permutations array + SHADERPERMUTATION_COUNT = 27 ///< size of shaderpermutationinfo array } shaderpermutation_t; @@ -3385,12 +3391,9 @@ shaderpermutationinfo_t shaderpermutationinfo[SHADERPERMUTATION_COUNT] = {"#define USEBLOOM\n", " bloom"}, {"#define USESPECULAR\n", " specular"}, {"#define USEPOSTPROCESSING\n", " postprocessing"}, - {"#define USEEXACTSPECULARMATH\n", " exactspecularmath"}, {"#define USEREFLECTION\n", " reflection"}, {"#define USEOFFSETMAPPING\n", " offsetmapping"}, {"#define USEOFFSETMAPPING_RELIEFMAPPING\n", " reliefmapping"}, - {"#define USESHADOWMAPRECT\n", " shadowmaprect"}, - {"#define USESHADOWMAPCUBE\n", " shadowmapcube"}, {"#define USESHADOWMAP2D\n", " shadowmap2d"}, {"#define USESHADOWMAPPCF 1\n", " shadowmappcf"}, {"#define USESHADOWMAPPCF 2\n", " shadowmappcf2"}, @@ -3400,9 +3403,10 @@ shaderpermutationinfo_t shaderpermutationinfo[SHADERPERMUTATION_COUNT] = {"#define USEDEFERREDLIGHTMAP\n", " deferredlightmap"}, {"#define USEALPHAKILL\n", " alphakill"}, {"#define USEREFLECTCUBE\n", " reflectcube"}, + {"#define USENORMALMAPSCROLLBLEND\n", " normalmapscrollblend"}, }; -/// this enum is multiplied by SHADERPERMUTATION_MODEBASE +// this enum selects which of the glslshadermodeinfo entries should be used typedef enum shadermode_e { SHADERMODE_GENERIC, ///< (particles/HUD/etc) vertex color, optionally multiplied by one texture @@ -3411,6 +3415,7 @@ typedef enum shadermode_e SHADERMODE_FLATCOLOR, ///< (lightmap) modulate texture by uniform color (q1bsp, q3bsp) SHADERMODE_VERTEXCOLOR, ///< (lightmap) modulate texture by vertex colors (q3bsp) SHADERMODE_LIGHTMAP, ///< (lightmap) modulate texture by lightmap texture (q1bsp, q3bsp) + SHADERMODE_FAKELIGHT, ///< (fakelight) modulate texture by "fake" lighting (no lightmaps, no nothing) SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE, ///< (lightmap) use directional pixel shading from texture containing modelspace light directions (q3bsp deluxemap) SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE, ///< (lightmap) use directional pixel shading from texture containing tangentspace light directions (q1bsp deluxemap) SHADERMODE_LIGHTDIRECTION, ///< (lightmap) use directional pixel shading from fixed light direction (q3bsp) @@ -3433,6 +3438,7 @@ shadermodeinfo_t glslshadermodeinfo[SHADERMODE_COUNT] = {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_FLATCOLOR\n", " flatcolor"}, {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_VERTEXCOLOR\n", " vertexcolor"}, {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTMAP\n", " lightmap"}, + {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_FAKELIGHT\n", " fakelight"}, {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"}, {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"}, {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTDIRECTION\n", " lightdirection"}, @@ -3449,10 +3455,11 @@ shadermodeinfo_t cgshadermodeinfo[SHADERMODE_COUNT] = { {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_GENERIC\n", " generic"}, {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_POSTPROCESS\n", " postprocess"}, - {"cg/default.cg", NULL, NULL , "#define MODE_DEPTH_OR_SHADOW\n", " depth"}, + {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_DEPTH_OR_SHADOW\n", " depth/shadow"}, {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_FLATCOLOR\n", " flatcolor"}, {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_VERTEXCOLOR\n", " vertexcolor"}, {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTMAP\n", " lightmap"}, + {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_FAKELIGHT\n", " fakelight"}, {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"}, {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"}, {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTDIRECTION\n", " lightdirection"}, @@ -3465,6 +3472,28 @@ shadermodeinfo_t cgshadermodeinfo[SHADERMODE_COUNT] = }; #endif +#ifdef SUPPORTD3D +shadermodeinfo_t hlslshadermodeinfo[SHADERMODE_COUNT] = +{ + {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_GENERIC\n", " generic"}, + {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_POSTPROCESS\n", " postprocess"}, + {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_DEPTH_OR_SHADOW\n", " depth/shadow"}, + {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_FLATCOLOR\n", " flatcolor"}, + {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_VERTEXCOLOR\n", " vertexcolor"}, + {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_LIGHTMAP\n", " lightmap"}, + {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_FAKELIGHT\n", " fakelight"}, + {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"}, + {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"}, + {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_LIGHTDIRECTION\n", " lightdirection"}, + {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_LIGHTSOURCE\n", " lightsource"}, + {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_REFRACTION\n", " refraction"}, + {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_WATER\n", " water"}, + {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_SHOWDEPTH\n", " showdepth"}, + {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_DEFERREDGEOMETRY\n", " deferredgeometry"}, + {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_DEFERREDLIGHTSOURCE\n", " deferredlightsource"}, +}; +#endif + struct r_glsl_permutation_s; typedef struct r_glsl_permutation_s { @@ -3499,8 +3528,6 @@ typedef struct r_glsl_permutation_s int loc_Texture_Cube; int loc_Texture_Refraction; int loc_Texture_Reflection; - int loc_Texture_ShadowMapRect; - int loc_Texture_ShadowMapCube; int loc_Texture_ShadowMap2D; int loc_Texture_CubeProjection; int loc_Texture_ScreenDepth; @@ -3559,12 +3586,76 @@ typedef struct r_glsl_permutation_s int loc_ModelViewMatrix; int loc_PixelToScreenTexCoord; int loc_ModelToReflectCube; - int loc_ShadowMapMatrix; + int loc_ShadowMapMatrix; + int loc_BloomColorSubtract; + int loc_NormalmapScrollBlend; } r_glsl_permutation_t; #define SHADERPERMUTATION_HASHSIZE 256 + +// non-degradable "lightweight" shader parameters to keep the permutations simpler +// these can NOT degrade! only use for simple stuff +enum +{ + SHADERSTATICPARM_SATURATION_REDCOMPENSATE = 0, ///< red compensation filter for saturation + SHADERSTATICPARM_EXACTSPECULARMATH = 1, ///< (lightsource or deluxemapping) use exact reflection map for specular effects, as opposed to the usual OpenGL approximation + SHADERSTATICPARM_POSTPROCESS_USERVEC1 = 2, ///< postprocess uservec1 is enabled + SHADERSTATICPARM_POSTPROCESS_USERVEC2 = 3, ///< postprocess uservec2 is enabled + SHADERSTATICPARM_POSTPROCESS_USERVEC3 = 4, ///< postprocess uservec3 is enabled + SHADERSTATICPARM_POSTPROCESS_USERVEC4 = 5 ///< postprocess uservec4 is enabled +}; +#define SHADERSTATICPARMS_COUNT 6 + +static const char *shaderstaticparmstrings_list[SHADERSTATICPARMS_COUNT]; +static int shaderstaticparms_count = 0; + +static unsigned int r_compileshader_staticparms[(SHADERSTATICPARMS_COUNT + 0x1F) >> 5] = {0}; +#define R_COMPILESHADER_STATICPARM_ENABLE(p) r_compileshader_staticparms[(p) >> 5] |= (1 << ((p) & 0x1F)) +qboolean R_CompileShader_CheckStaticParms(void) +{ + static int r_compileshader_staticparms_save[1]; + memcpy(r_compileshader_staticparms_save, r_compileshader_staticparms, sizeof(r_compileshader_staticparms)); + memset(r_compileshader_staticparms, 0, sizeof(r_compileshader_staticparms)); + + // detect all + if (r_glsl_saturation_redcompensate.integer) + R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_SATURATION_REDCOMPENSATE); + if (r_shadow_glossexact.integer) + R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_EXACTSPECULARMATH); + if (r_glsl_postprocess.integer) + { + if (r_glsl_postprocess_uservec1_enable.integer) + R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_POSTPROCESS_USERVEC1); + if (r_glsl_postprocess_uservec2_enable.integer) + R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_POSTPROCESS_USERVEC2); + if (r_glsl_postprocess_uservec3_enable.integer) + R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_POSTPROCESS_USERVEC3); + if (r_glsl_postprocess_uservec4_enable.integer) + R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_POSTPROCESS_USERVEC4); + } + return memcmp(r_compileshader_staticparms, r_compileshader_staticparms_save, sizeof(r_compileshader_staticparms)) != 0; +} + +#define R_COMPILESHADER_STATICPARM_EMIT(p, n) \ + if(r_compileshader_staticparms[(p) >> 5] & (1 << ((p) & 0x1F))) \ + shaderstaticparmstrings_list[shaderstaticparms_count++] = "#define " n "\n"; \ + else \ + shaderstaticparmstrings_list[shaderstaticparms_count++] = "\n" +void R_CompileShader_AddStaticParms(unsigned int mode, unsigned int permutation) +{ + shaderstaticparms_count = 0; + + // emit all + R_COMPILESHADER_STATICPARM_EMIT(SHADERSTATICPARM_SATURATION_REDCOMPENSATE, "SATURATION_REDCOMPENSATE"); + R_COMPILESHADER_STATICPARM_EMIT(SHADERSTATICPARM_EXACTSPECULARMATH, "USEEXACTSPECULARMATH"); + R_COMPILESHADER_STATICPARM_EMIT(SHADERSTATICPARM_POSTPROCESS_USERVEC1, "USERVEC1"); + R_COMPILESHADER_STATICPARM_EMIT(SHADERSTATICPARM_POSTPROCESS_USERVEC2, "USERVEC2"); + R_COMPILESHADER_STATICPARM_EMIT(SHADERSTATICPARM_POSTPROCESS_USERVEC3, "USERVEC3"); + R_COMPILESHADER_STATICPARM_EMIT(SHADERSTATICPARM_POSTPROCESS_USERVEC4, "USERVEC4"); +} + /// information about each possible shader permutation r_glsl_permutation_t *r_glsl_permutationhash[SHADERMODE_COUNT][SHADERPERMUTATION_HASHSIZE]; /// currently selected permutation @@ -3630,14 +3721,14 @@ static void R_GLSL_CompilePermutation(r_glsl_permutation_t *p, unsigned int mode { int i; shadermodeinfo_t *modeinfo = glslshadermodeinfo + mode; + char *vertexstring, *geometrystring, *fragmentstring; + char permutationname[256]; int vertstrings_count = 0; int geomstrings_count = 0; int fragstrings_count = 0; - char *vertexstring, *geometrystring, *fragmentstring; - const char *vertstrings_list[32+3]; - const char *geomstrings_list[32+3]; - const char *fragstrings_list[32+3]; - char permutationname[256]; + const char *vertstrings_list[32+3+SHADERSTATICPARMS_COUNT+1]; + const char *geomstrings_list[32+3+SHADERSTATICPARMS_COUNT+1]; + const char *fragstrings_list[32+3+SHADERSTATICPARMS_COUNT+1]; if (p->compiled) return; @@ -3682,6 +3773,15 @@ static void R_GLSL_CompilePermutation(r_glsl_permutation_t *p, unsigned int mode } } + // add static parms + R_CompileShader_AddStaticParms(mode, permutation); + memcpy((char *)(vertstrings_list + vertstrings_count), shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count); + vertstrings_count += shaderstaticparms_count; + memcpy((char *)(geomstrings_list + geomstrings_count), shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count); + geomstrings_count += shaderstaticparms_count; + memcpy((char *)(fragstrings_list + fragstrings_count), shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count); + fragstrings_count += shaderstaticparms_count; + // now append the shader text itself vertstrings_list[vertstrings_count++] = vertexstring; geomstrings_list[geomstrings_count++] = geometrystring; @@ -3726,8 +3826,6 @@ static void R_GLSL_CompilePermutation(r_glsl_permutation_t *p, unsigned int mode p->loc_Texture_Cube = qglGetUniformLocationARB(p->program, "Texture_Cube"); p->loc_Texture_Refraction = qglGetUniformLocationARB(p->program, "Texture_Refraction"); p->loc_Texture_Reflection = qglGetUniformLocationARB(p->program, "Texture_Reflection"); - p->loc_Texture_ShadowMapRect = qglGetUniformLocationARB(p->program, "Texture_ShadowMapRect"); - p->loc_Texture_ShadowMapCube = qglGetUniformLocationARB(p->program, "Texture_ShadowMapCube"); p->loc_Texture_ShadowMap2D = qglGetUniformLocationARB(p->program, "Texture_ShadowMap2D"); p->loc_Texture_CubeProjection = qglGetUniformLocationARB(p->program, "Texture_CubeProjection"); p->loc_Texture_ScreenDepth = qglGetUniformLocationARB(p->program, "Texture_ScreenDepth"); @@ -3786,7 +3884,9 @@ static void R_GLSL_CompilePermutation(r_glsl_permutation_t *p, unsigned int mode p->loc_ModelViewProjectionMatrix = qglGetUniformLocationARB(p->program, "ModelViewProjectionMatrix"); p->loc_PixelToScreenTexCoord = qglGetUniformLocationARB(p->program, "PixelToScreenTexCoord"); p->loc_ModelToReflectCube = qglGetUniformLocationARB(p->program, "ModelToReflectCube"); - p->loc_ShadowMapMatrix = qglGetUniformLocationARB(p->program, "ShadowMapMatrix"); + p->loc_ShadowMapMatrix = qglGetUniformLocationARB(p->program, "ShadowMapMatrix"); + p->loc_BloomColorSubtract = qglGetUniformLocationARB(p->program, "BloomColorSubtract"); + p->loc_NormalmapScrollBlend = qglGetUniformLocationARB(p->program, "NormalmapScrollBlend"); // initialize the samplers to refer to the texture units we use if (p->loc_Texture_First >= 0) qglUniform1iARB(p->loc_Texture_First , GL20TU_FIRST); if (p->loc_Texture_Second >= 0) qglUniform1iARB(p->loc_Texture_Second , GL20TU_SECOND); @@ -3809,9 +3909,7 @@ static void R_GLSL_CompilePermutation(r_glsl_permutation_t *p, unsigned int mode if (p->loc_Texture_Cube >= 0) qglUniform1iARB(p->loc_Texture_Cube , GL20TU_CUBE); if (p->loc_Texture_Refraction >= 0) qglUniform1iARB(p->loc_Texture_Refraction , GL20TU_REFRACTION); if (p->loc_Texture_Reflection >= 0) qglUniform1iARB(p->loc_Texture_Reflection , GL20TU_REFLECTION); - if (p->loc_Texture_ShadowMapRect >= 0) qglUniform1iARB(p->loc_Texture_ShadowMapRect , permutation & SHADERPERMUTATION_SHADOWMAPORTHO ? GL20TU_SHADOWMAPORTHORECT : GL20TU_SHADOWMAPRECT); - if (p->loc_Texture_ShadowMapCube >= 0) qglUniform1iARB(p->loc_Texture_ShadowMapCube , GL20TU_SHADOWMAPCUBE); - if (p->loc_Texture_ShadowMap2D >= 0) qglUniform1iARB(p->loc_Texture_ShadowMap2D , permutation & SHADERPERMUTATION_SHADOWMAPORTHO ? GL20TU_SHADOWMAPORTHO2D : GL20TU_SHADOWMAP2D); + if (p->loc_Texture_ShadowMap2D >= 0) qglUniform1iARB(p->loc_Texture_ShadowMap2D , GL20TU_SHADOWMAP2D); if (p->loc_Texture_CubeProjection >= 0) qglUniform1iARB(p->loc_Texture_CubeProjection , GL20TU_CUBEPROJECTION); if (p->loc_Texture_ScreenDepth >= 0) qglUniform1iARB(p->loc_Texture_ScreenDepth , GL20TU_SCREENDEPTH); if (p->loc_Texture_ScreenNormalMap >= 0) qglUniform1iARB(p->loc_Texture_ScreenNormalMap, GL20TU_SCREENNORMALMAP); @@ -3926,8 +4024,6 @@ typedef struct r_cg_permutation_s CGparameter fp_Texture_Cube; CGparameter fp_Texture_Refraction; CGparameter fp_Texture_Reflection; - CGparameter fp_Texture_ShadowMapRect; - CGparameter fp_Texture_ShadowMapCube; CGparameter fp_Texture_ShadowMap2D; CGparameter fp_Texture_CubeProjection; CGparameter fp_Texture_ScreenDepth; @@ -3981,6 +4077,8 @@ typedef struct r_cg_permutation_s CGparameter fp_ViewToLight; CGparameter fp_PixelToScreenTexCoord; CGparameter fp_ModelToReflectCube; + CGparameter fp_BloomColorSubtract; + CGparameter fp_NormalmapScrollBlend; } r_cg_permutation_t; @@ -4056,19 +4154,22 @@ static void R_CG_CompilePermutation(r_cg_permutation_t *p, unsigned int mode, un { int i; shadermodeinfo_t *modeinfo = cgshadermodeinfo + mode; - int vertstrings_count = 0, vertstring_length = 0; - int geomstrings_count = 0, geomstring_length = 0; - int fragstrings_count = 0, fragstring_length = 0; + int vertstring_length = 0; + int geomstring_length = 0; + int fragstring_length = 0; char *t; char *vertexstring, *geometrystring, *fragmentstring; char *vertstring, *geomstring, *fragstring; - const char *vertstrings_list[32+3]; - const char *geomstrings_list[32+3]; - const char *fragstrings_list[32+3]; char permutationname[256]; char cachename[256]; CGprofile vertexProfile; CGprofile fragmentProfile; + int vertstrings_count = 0; + int geomstrings_count = 0; + int fragstrings_count = 0; + const char *vertstrings_list[32+3+SHADERSTATICPARMS_COUNT+1]; + const char *geomstrings_list[32+3+SHADERSTATICPARMS_COUNT+1]; + const char *fragstrings_list[32+3+SHADERSTATICPARMS_COUNT+1]; if (p->compiled) return; @@ -4118,6 +4219,15 @@ static void R_CG_CompilePermutation(r_cg_permutation_t *p, unsigned int mode, un } } + // add static parms + R_CompileShader_AddStaticParms(mode, permutation); + memcpy(vertstrings_list + vertstrings_count, shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count); + vertstrings_count += shaderstaticparms_count; + memcpy(geomstrings_list + geomstrings_count, shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count); + geomstrings_count += shaderstaticparms_count; + memcpy(fragstrings_list + fragstrings_count, shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count); + fragstrings_count += shaderstaticparms_count; + // replace spaces in the cachename with _ characters for (i = 0;cachename[i];i++) if (cachename[i] == ' ') @@ -4225,8 +4335,6 @@ static void R_CG_CompilePermutation(r_cg_permutation_t *p, unsigned int mode, un p->fp_Texture_Cube = cgGetNamedParameter(p->fprogram, "Texture_Cube"); p->fp_Texture_Refraction = cgGetNamedParameter(p->fprogram, "Texture_Refraction"); p->fp_Texture_Reflection = cgGetNamedParameter(p->fprogram, "Texture_Reflection"); - p->fp_Texture_ShadowMapRect = cgGetNamedParameter(p->fprogram, "Texture_ShadowMapRect"); - p->fp_Texture_ShadowMapCube = cgGetNamedParameter(p->fprogram, "Texture_ShadowMapCube"); p->fp_Texture_ShadowMap2D = cgGetNamedParameter(p->fprogram, "Texture_ShadowMap2D"); p->fp_Texture_CubeProjection = cgGetNamedParameter(p->fprogram, "Texture_CubeProjection"); p->fp_Texture_ScreenDepth = cgGetNamedParameter(p->fprogram, "Texture_ScreenDepth"); @@ -4280,6 +4388,8 @@ static void R_CG_CompilePermutation(r_cg_permutation_t *p, unsigned int mode, un p->fp_ViewToLight = cgGetNamedParameter(p->fprogram, "ViewToLight"); p->fp_PixelToScreenTexCoord = cgGetNamedParameter(p->fprogram, "PixelToScreenTexCoord"); p->fp_ModelToReflectCube = cgGetNamedParameter(p->fprogram, "ModelToReflectCube"); + p->fp_BloomColorSubtract = cgGetNamedParameter(p->fprogram, "BloomColorSubtract"); + p->fp_NormalmapScrollBlend = cgGetNamedParameter(p->fprogram, "NormalmapScrollBlend"); CHECKCGERROR } @@ -4365,16 +4475,516 @@ void R_SetupShader_SetPermutationCG(unsigned int mode, unsigned int permutation) cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR } } - CHECKCGERROR - if (r_cg_permutation->vp_ModelViewProjectionMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewProjectionMatrix, gl_modelviewprojection16f);CHECKCGERROR - if (r_cg_permutation->vp_ModelViewMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewMatrix, gl_modelview16f);CHECKCGERROR - if (r_cg_permutation->fp_ClientTime) cgGLSetParameter1f(r_cg_permutation->fp_ClientTime, cl.time);CHECKCGERROR -} - -void CG_BindTexture(CGparameter param, rtexture_t *tex) -{ - cgGLSetTextureParameter(param, R_GetTexture(tex)); - cgGLEnableTextureParameter(param); + CHECKCGERROR + if (r_cg_permutation->vp_ModelViewProjectionMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewProjectionMatrix, gl_modelviewprojection16f);CHECKCGERROR + if (r_cg_permutation->vp_ModelViewMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewMatrix, gl_modelview16f);CHECKCGERROR + if (r_cg_permutation->fp_ClientTime) cgGLSetParameter1f(r_cg_permutation->fp_ClientTime, cl.time);CHECKCGERROR +} + +void CG_BindTexture(CGparameter param, rtexture_t *tex) +{ + cgGLSetTextureParameter(param, R_GetTexture(tex)); + cgGLEnableTextureParameter(param); +} +#endif + +#ifdef SUPPORTD3D + +#ifdef SUPPORTD3D +#include +extern LPDIRECT3DDEVICE9 vid_d3d9dev; +extern D3DCAPS9 vid_d3d9caps; +#endif + +struct r_hlsl_permutation_s; +typedef struct r_hlsl_permutation_s +{ + /// hash lookup data + struct r_hlsl_permutation_s *hashnext; + unsigned int mode; + unsigned int permutation; + + /// indicates if we have tried compiling this permutation already + qboolean compiled; + /// NULL if compilation failed + IDirect3DVertexShader9 *vertexshader; + IDirect3DPixelShader9 *pixelshader; +} +r_hlsl_permutation_t; + +typedef enum D3DVSREGISTER_e +{ + D3DVSREGISTER_TexMatrix = 0, // float4x4 + D3DVSREGISTER_BackgroundTexMatrix = 4, // float4x4 + D3DVSREGISTER_ModelViewProjectionMatrix = 8, // float4x4 + D3DVSREGISTER_ModelViewMatrix = 12, // float4x4 + D3DVSREGISTER_ShadowMapMatrix = 16, // float4x4 + D3DVSREGISTER_ModelToLight = 20, // float4x4 + D3DVSREGISTER_EyePosition = 24, + D3DVSREGISTER_FogPlane = 25, + D3DVSREGISTER_LightDir = 26, + D3DVSREGISTER_LightPosition = 27, +} +D3DVSREGISTER_t; + +typedef enum D3DPSREGISTER_e +{ + D3DPSREGISTER_Alpha = 0, + D3DPSREGISTER_BloomBlur_Parameters = 1, + D3DPSREGISTER_ClientTime = 2, + D3DPSREGISTER_Color_Ambient = 3, + D3DPSREGISTER_Color_Diffuse = 4, + D3DPSREGISTER_Color_Specular = 5, + D3DPSREGISTER_Color_Glow = 6, + D3DPSREGISTER_Color_Pants = 7, + D3DPSREGISTER_Color_Shirt = 8, + D3DPSREGISTER_DeferredColor_Ambient = 9, + D3DPSREGISTER_DeferredColor_Diffuse = 10, + D3DPSREGISTER_DeferredColor_Specular = 11, + D3DPSREGISTER_DeferredMod_Diffuse = 12, + D3DPSREGISTER_DeferredMod_Specular = 13, + D3DPSREGISTER_DistortScaleRefractReflect = 14, + D3DPSREGISTER_EyePosition = 15, // unused + D3DPSREGISTER_FogColor = 16, + D3DPSREGISTER_FogHeightFade = 17, + D3DPSREGISTER_FogPlane = 18, + D3DPSREGISTER_FogPlaneViewDist = 19, + D3DPSREGISTER_FogRangeRecip = 20, + D3DPSREGISTER_LightColor = 21, + D3DPSREGISTER_LightDir = 22, // unused + D3DPSREGISTER_LightPosition = 23, + D3DPSREGISTER_OffsetMapping_Scale = 24, + D3DPSREGISTER_PixelSize = 25, + D3DPSREGISTER_ReflectColor = 26, + D3DPSREGISTER_ReflectFactor = 27, + D3DPSREGISTER_ReflectOffset = 28, + D3DPSREGISTER_RefractColor = 29, + D3DPSREGISTER_Saturation = 30, + D3DPSREGISTER_ScreenCenterRefractReflect = 31, + D3DPSREGISTER_ScreenScaleRefractReflect = 32, + D3DPSREGISTER_ScreenToDepth = 33, + D3DPSREGISTER_ShadowMap_Parameters = 34, + D3DPSREGISTER_ShadowMap_TextureScale = 35, + D3DPSREGISTER_SpecularPower = 36, + D3DPSREGISTER_UserVec1 = 37, + D3DPSREGISTER_UserVec2 = 38, + D3DPSREGISTER_UserVec3 = 39, + D3DPSREGISTER_UserVec4 = 40, + D3DPSREGISTER_ViewTintColor = 41, + D3DPSREGISTER_PixelToScreenTexCoord = 42, + D3DPSREGISTER_BloomColorSubtract = 43, + D3DPSREGISTER_ViewToLight = 44, // float4x4 + D3DPSREGISTER_ModelToReflectCube = 48, // float4x4 + D3DPSREGISTER_NormalmapScrollBlend = 52, + // next at 53 +} +D3DPSREGISTER_t; + +/// information about each possible shader permutation +r_hlsl_permutation_t *r_hlsl_permutationhash[SHADERMODE_COUNT][SHADERPERMUTATION_HASHSIZE]; +/// currently selected permutation +r_hlsl_permutation_t *r_hlsl_permutation; +/// storage for permutations linked in the hash table +memexpandablearray_t r_hlsl_permutationarray; + +static r_hlsl_permutation_t *R_HLSL_FindPermutation(unsigned int mode, unsigned int permutation) +{ + //unsigned int hashdepth = 0; + unsigned int hashindex = (permutation * 0x1021) & (SHADERPERMUTATION_HASHSIZE - 1); + r_hlsl_permutation_t *p; + for (p = r_hlsl_permutationhash[mode][hashindex];p;p = p->hashnext) + { + if (p->mode == mode && p->permutation == permutation) + { + //if (hashdepth > 10) + // Con_Printf("R_HLSL_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth); + return p; + } + //hashdepth++; + } + p = (r_hlsl_permutation_t*)Mem_ExpandableArray_AllocRecord(&r_hlsl_permutationarray); + p->mode = mode; + p->permutation = permutation; + p->hashnext = r_hlsl_permutationhash[mode][hashindex]; + r_hlsl_permutationhash[mode][hashindex] = p; + //if (hashdepth > 10) + // Con_Printf("R_HLSL_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth); + return p; +} + +static char *R_HLSL_GetText(const char *filename, qboolean printfromdisknotice) +{ + char *shaderstring; + if (!filename || !filename[0]) + return NULL; + if (!strcmp(filename, "hlsl/default.hlsl")) + { + if (!hlslshaderstring) + { + hlslshaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL); + if (hlslshaderstring) + Con_DPrintf("Loading shaders from file %s...\n", filename); + else + hlslshaderstring = (char *)builtincgshaderstring; + } + shaderstring = (char *) Mem_Alloc(r_main_mempool, strlen(hlslshaderstring) + 1); + memcpy(shaderstring, hlslshaderstring, strlen(hlslshaderstring) + 1); + return shaderstring; + } + shaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL); + if (shaderstring) + { + if (printfromdisknotice) + Con_DPrintf("from disk %s... ", filename); + return shaderstring; + } + return shaderstring; +} + +#include +//#include +//#include + +static void R_HLSL_CacheShader(r_hlsl_permutation_t *p, const char *cachename, const char *vertstring, const char *fragstring) +{ + DWORD *vsbin = NULL; + DWORD *psbin = NULL; + fs_offset_t vsbinsize; + fs_offset_t psbinsize; +// IDirect3DVertexShader9 *vs = NULL; +// IDirect3DPixelShader9 *ps = NULL; + ID3DXBuffer *vslog = NULL; + ID3DXBuffer *vsbuffer = NULL; + ID3DXConstantTable *vsconstanttable = NULL; + ID3DXBuffer *pslog = NULL; + ID3DXBuffer *psbuffer = NULL; + ID3DXConstantTable *psconstanttable = NULL; + int vsresult = 0; + int psresult = 0; + char temp[MAX_INPUTLINE]; + const char *vsversion = "vs_3_0", *psversion = "ps_3_0"; + qboolean debugshader = gl_paranoid.integer != 0; + if (p->permutation & SHADERPERMUTATION_OFFSETMAPPING) {vsversion = "vs_3_0";psversion = "ps_3_0";} + if (p->permutation & SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING) {vsversion = "vs_3_0";psversion = "ps_3_0";} + if (!debugshader) + { + vsbin = (DWORD *)FS_LoadFile(va("%s.vsbin", cachename), r_main_mempool, true, &vsbinsize); + psbin = (DWORD *)FS_LoadFile(va("%s.psbin", cachename), r_main_mempool, true, &psbinsize); + } + if ((!vsbin && vertstring) || (!psbin && fragstring)) + { + const char* dllnames_d3dx9 [] = + { + "d3dx9_43.dll", + "d3dx9_42.dll", + "d3dx9_41.dll", + "d3dx9_40.dll", + "d3dx9_39.dll", + "d3dx9_38.dll", + "d3dx9_37.dll", + "d3dx9_36.dll", + "d3dx9_35.dll", + "d3dx9_34.dll", + "d3dx9_33.dll", + "d3dx9_32.dll", + "d3dx9_31.dll", + "d3dx9_30.dll", + "d3dx9_29.dll", + "d3dx9_28.dll", + "d3dx9_27.dll", + "d3dx9_26.dll", + "d3dx9_25.dll", + "d3dx9_24.dll", + NULL + }; + dllhandle_t d3dx9_dll = NULL; + HRESULT (WINAPI *qD3DXCompileShaderFromFileA)(LPCSTR pSrcFile, CONST D3DXMACRO* pDefines, LPD3DXINCLUDE pInclude, LPCSTR pFunctionName, LPCSTR pProfile, DWORD Flags, LPD3DXBUFFER* ppShader, LPD3DXBUFFER* ppErrorMsgs, LPD3DXCONSTANTTABLE* ppConstantTable); + HRESULT (WINAPI *qD3DXPreprocessShader)(LPCSTR pSrcData, UINT SrcDataSize, CONST D3DXMACRO* pDefines, LPD3DXINCLUDE pInclude, LPD3DXBUFFER* ppShaderText, LPD3DXBUFFER* ppErrorMsgs); + HRESULT (WINAPI *qD3DXCompileShader)(LPCSTR pSrcData, UINT SrcDataLen, CONST D3DXMACRO* pDefines, LPD3DXINCLUDE pInclude, LPCSTR pFunctionName, LPCSTR pProfile, DWORD Flags, LPD3DXBUFFER* ppShader, LPD3DXBUFFER* ppErrorMsgs, LPD3DXCONSTANTTABLE* ppConstantTable); + dllfunction_t d3dx9_dllfuncs[] = + { + {"D3DXCompileShaderFromFileA", (void **) &qD3DXCompileShaderFromFileA}, + {"D3DXPreprocessShader", (void **) &qD3DXPreprocessShader}, + {"D3DXCompileShader", (void **) &qD3DXCompileShader}, + {NULL, NULL} + }; + if (Sys_LoadLibrary(dllnames_d3dx9, &d3dx9_dll, d3dx9_dllfuncs)) + { + DWORD shaderflags = 0; + if (debugshader) + shaderflags = D3DXSHADER_DEBUG | D3DXSHADER_SKIPOPTIMIZATION; + vsbin = (DWORD *)Mem_Realloc(tempmempool, vsbin, 0); + psbin = (DWORD *)Mem_Realloc(tempmempool, psbin, 0); + if (vertstring && vertstring[0]) + { + if (debugshader) + { +// vsresult = qD3DXPreprocessShader(vertstring, strlen(vertstring), NULL, NULL, &vsbuffer, &vslog); +// FS_WriteFile(va("%s_vs.fx", cachename), vsbuffer->GetBufferPointer(), vsbuffer->GetBufferSize()); + FS_WriteFile(va("%s_vs.fx", cachename), vertstring, strlen(vertstring)); + vsresult = qD3DXCompileShaderFromFileA(va("%s/%s_vs.fx", fs_gamedir, cachename), NULL, NULL, "main", vsversion, shaderflags, &vsbuffer, &vslog, &vsconstanttable); + } + else + vsresult = qD3DXCompileShader(vertstring, strlen(vertstring), NULL, NULL, "main", vsversion, shaderflags, &vsbuffer, &vslog, &vsconstanttable); + if (vsbuffer) + { + vsbinsize = vsbuffer->GetBufferSize(); + vsbin = (DWORD *)Mem_Alloc(tempmempool, vsbinsize); + memcpy(vsbin, vsbuffer->GetBufferPointer(), vsbinsize); + vsbuffer->Release(); + } + if (vslog) + { + strlcpy(temp, (const char *)vslog->GetBufferPointer(), min(sizeof(temp), vslog->GetBufferSize())); + Con_Printf("HLSL vertex shader compile output for %s follows:\n%s\n", cachename, temp); + vslog->Release(); + } + } + if (fragstring && fragstring[0]) + { + if (debugshader) + { +// psresult = qD3DXPreprocessShader(fragstring, strlen(fragstring), NULL, NULL, &psbuffer, &pslog); +// FS_WriteFile(va("%s_ps.fx", cachename), psbuffer->GetBufferPointer(), psbuffer->GetBufferSize()); + FS_WriteFile(va("%s_ps.fx", cachename), fragstring, strlen(fragstring)); + psresult = qD3DXCompileShaderFromFileA(va("%s/%s_ps.fx", fs_gamedir, cachename), NULL, NULL, "main", psversion, shaderflags, &psbuffer, &pslog, &psconstanttable); + } + else + psresult = qD3DXCompileShader(fragstring, strlen(fragstring), NULL, NULL, "main", psversion, shaderflags, &psbuffer, &pslog, &psconstanttable); + if (psbuffer) + { + psbinsize = psbuffer->GetBufferSize(); + psbin = (DWORD *)Mem_Alloc(tempmempool, psbinsize); + memcpy(psbin, psbuffer->GetBufferPointer(), psbinsize); + psbuffer->Release(); + } + if (pslog) + { + strlcpy(temp, (const char *)pslog->GetBufferPointer(), min(sizeof(temp), pslog->GetBufferSize())); + Con_Printf("HLSL pixel shader compile output for %s follows:\n%s\n", cachename, temp); + pslog->Release(); + } + } + Sys_UnloadLibrary(&d3dx9_dll); + } + else + Con_Printf("Unable to compile shader - D3DXCompileShader function not found\n"); + } + if (vsbin && psbin) + { + vsresult = IDirect3DDevice9_CreateVertexShader(vid_d3d9dev, vsbin, &p->vertexshader); + if (FAILED(vsresult)) + Con_Printf("HLSL CreateVertexShader failed for %s (hresult = %8x)\n", cachename, vsresult); + psresult = IDirect3DDevice9_CreatePixelShader(vid_d3d9dev, psbin, &p->pixelshader); + if (FAILED(psresult)) + Con_Printf("HLSL CreatePixelShader failed for %s (hresult = %8x)\n", cachename, psresult); + } + // free the shader data + vsbin = (DWORD *)Mem_Realloc(tempmempool, vsbin, 0); + psbin = (DWORD *)Mem_Realloc(tempmempool, psbin, 0); +} + +static void R_HLSL_CompilePermutation(r_hlsl_permutation_t *p, unsigned int mode, unsigned int permutation) +{ + int i; + shadermodeinfo_t *modeinfo = hlslshadermodeinfo + mode; + int vertstring_length = 0; + int geomstring_length = 0; + int fragstring_length = 0; + char *t; + char *vertexstring, *geometrystring, *fragmentstring; + char *vertstring, *geomstring, *fragstring; + char permutationname[256]; + char cachename[256]; + int vertstrings_count = 0; + int geomstrings_count = 0; + int fragstrings_count = 0; + const char *vertstrings_list[32+3+SHADERSTATICPARMS_COUNT+1]; + const char *geomstrings_list[32+3+SHADERSTATICPARMS_COUNT+1]; + const char *fragstrings_list[32+3+SHADERSTATICPARMS_COUNT+1]; + + if (p->compiled) + return; + p->compiled = true; + p->vertexshader = NULL; + p->pixelshader = NULL; + + permutationname[0] = 0; + cachename[0] = 0; + vertexstring = R_HLSL_GetText(modeinfo->vertexfilename, true); + geometrystring = R_HLSL_GetText(modeinfo->geometryfilename, false); + fragmentstring = R_HLSL_GetText(modeinfo->fragmentfilename, false); + + strlcat(permutationname, modeinfo->vertexfilename, sizeof(permutationname)); + strlcat(cachename, "hlsl/", sizeof(cachename)); + + // define HLSL so that the shader can tell apart the HLSL compiler and the Cg compiler + vertstrings_count = 0; + geomstrings_count = 0; + fragstrings_count = 0; + vertstrings_list[vertstrings_count++] = "#define HLSL\n"; + geomstrings_list[geomstrings_count++] = "#define HLSL\n"; + fragstrings_list[fragstrings_count++] = "#define HLSL\n"; + + // the first pretext is which type of shader to compile as + // (later these will all be bound together as a program object) + vertstrings_list[vertstrings_count++] = "#define VERTEX_SHADER\n"; + geomstrings_list[geomstrings_count++] = "#define GEOMETRY_SHADER\n"; + fragstrings_list[fragstrings_count++] = "#define FRAGMENT_SHADER\n"; + + // the second pretext is the mode (for example a light source) + vertstrings_list[vertstrings_count++] = modeinfo->pretext; + geomstrings_list[geomstrings_count++] = modeinfo->pretext; + fragstrings_list[fragstrings_count++] = modeinfo->pretext; + strlcat(permutationname, modeinfo->name, sizeof(permutationname)); + strlcat(cachename, modeinfo->name, sizeof(cachename)); + + // now add all the permutation pretexts + for (i = 0;i < SHADERPERMUTATION_COUNT;i++) + { + if (permutation & (1<vertexshader || !vertstring[0]) && (p->pixelshader || !fragstring[0])) + Con_DPrintf("^5HLSL shader %s compiled.\n", permutationname); + else + Con_Printf("^1HLSL shader %s failed! some features may not work properly.\n", permutationname); + + // free the strings + if (vertstring) + Mem_Free(vertstring); + if (geomstring) + Mem_Free(geomstring); + if (fragstring) + Mem_Free(fragstring); + if (vertexstring) + Mem_Free(vertexstring); + if (geometrystring) + Mem_Free(geometrystring); + if (fragmentstring) + Mem_Free(fragmentstring); +} + +static inline void hlslVSSetParameter16f(D3DVSREGISTER_t r, const float *a) {IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, a, 4);} +static inline void hlslVSSetParameter4fv(D3DVSREGISTER_t r, const float *a) {IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, a, 1);} +static inline void hlslVSSetParameter4f(D3DVSREGISTER_t r, float x, float y, float z, float w) {float temp[4];Vector4Set(temp, x, y, z, w);IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, temp, 1);} +static inline void hlslVSSetParameter3f(D3DVSREGISTER_t r, float x, float y, float z) {float temp[4];Vector4Set(temp, x, y, z, 0);IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, temp, 1);} +static inline void hlslVSSetParameter2f(D3DVSREGISTER_t r, float x, float y) {float temp[4];Vector4Set(temp, x, y, 0, 0);IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, temp, 1);} +static inline void hlslVSSetParameter1f(D3DVSREGISTER_t r, float x) {float temp[4];Vector4Set(temp, x, 0, 0, 0);IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, temp, 1);} + +static inline void hlslPSSetParameter16f(D3DPSREGISTER_t r, const float *a) {IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, a, 4);} +static inline void hlslPSSetParameter4fv(D3DPSREGISTER_t r, const float *a) {IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, a, 1);} +static inline void hlslPSSetParameter4f(D3DPSREGISTER_t r, float x, float y, float z, float w) {float temp[4];Vector4Set(temp, x, y, z, w);IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, temp, 1);} +static inline void hlslPSSetParameter3f(D3DPSREGISTER_t r, float x, float y, float z) {float temp[4];Vector4Set(temp, x, y, z, 0);IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, temp, 1);} +static inline void hlslPSSetParameter2f(D3DPSREGISTER_t r, float x, float y) {float temp[4];Vector4Set(temp, x, y, 0, 0);IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, temp, 1);} +static inline void hlslPSSetParameter1f(D3DPSREGISTER_t r, float x) {float temp[4];Vector4Set(temp, x, 0, 0, 0);IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, temp, 1);} + +void R_SetupShader_SetPermutationHLSL(unsigned int mode, unsigned int permutation) +{ + r_hlsl_permutation_t *perm = R_HLSL_FindPermutation(mode, permutation); + if (r_hlsl_permutation != perm) + { + r_hlsl_permutation = perm; + if (!r_hlsl_permutation->vertexshader && !r_hlsl_permutation->pixelshader) + { + if (!r_hlsl_permutation->compiled) + R_HLSL_CompilePermutation(perm, mode, permutation); + if (!r_hlsl_permutation->vertexshader && !r_hlsl_permutation->pixelshader) + { + // remove features until we find a valid permutation + int i; + for (i = 0;i < SHADERPERMUTATION_COUNT;i++) + { + // reduce i more quickly whenever it would not remove any bits + int j = 1<<(SHADERPERMUTATION_COUNT-1-i); + if (!(permutation & j)) + continue; + permutation -= j; + r_hlsl_permutation = R_HLSL_FindPermutation(mode, permutation); + if (!r_hlsl_permutation->compiled) + R_HLSL_CompilePermutation(perm, mode, permutation); + if (r_hlsl_permutation->vertexshader || r_hlsl_permutation->pixelshader) + break; + } + if (i >= SHADERPERMUTATION_COUNT) + { + //Con_Printf("Could not find a working Cg shader for permutation %s %s\n", shadermodeinfo[mode].vertexfilename, shadermodeinfo[mode].pretext); + r_hlsl_permutation = R_HLSL_FindPermutation(mode, permutation); + return; // no bit left to clear, entire mode is broken + } + } + } + IDirect3DDevice9_SetVertexShader(vid_d3d9dev, r_hlsl_permutation->vertexshader); + IDirect3DDevice9_SetPixelShader(vid_d3d9dev, r_hlsl_permutation->pixelshader); + } + hlslVSSetParameter16f(D3DVSREGISTER_ModelViewProjectionMatrix, gl_modelviewprojection16f); + hlslVSSetParameter16f(D3DVSREGISTER_ModelViewMatrix, gl_modelview16f); + hlslPSSetParameter1f(D3DPSREGISTER_ClientTime, cl.time); } #endif @@ -4387,8 +4997,42 @@ void R_GLSL_Restart_f(void) if (cgshaderstring && cgshaderstring != builtincgshaderstring) Mem_Free(cgshaderstring); cgshaderstring = NULL; + if (hlslshaderstring && hlslshaderstring != builtincgshaderstring) + Mem_Free(hlslshaderstring); + hlslshaderstring = NULL; switch(vid.renderpath) { + case RENDERPATH_D3D9: +#ifdef SUPPORTD3D + { + r_hlsl_permutation_t *p; + r_hlsl_permutation = NULL; +// cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR +// cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR +// cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR +// cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR + limit = Mem_ExpandableArray_IndexRange(&r_hlsl_permutationarray); + for (i = 0;i < limit;i++) + { + if ((p = (r_hlsl_permutation_t*)Mem_ExpandableArray_RecordAtIndex(&r_hlsl_permutationarray, i))) + { + if (p->vertexshader) + IDirect3DVertexShader9_Release(p->vertexshader); + if (p->pixelshader) + IDirect3DPixelShader9_Release(p->pixelshader); + Mem_ExpandableArray_FreeRecord(&r_hlsl_permutationarray, (void*)p); + } + } + memset(r_hlsl_permutationhash, 0, sizeof(r_hlsl_permutationhash)); + } +#endif + break; + case RENDERPATH_D3D10: + Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); + break; + case RENDERPATH_D3D11: + Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); + break; case RENDERPATH_GL20: { r_glsl_permutation_t *p; @@ -4428,8 +5072,8 @@ void R_GLSL_Restart_f(void) } memset(r_cg_permutationhash, 0, sizeof(r_cg_permutationhash)); } - break; #endif + break; case RENDERPATH_GL13: case RENDERPATH_GL11: break; @@ -4476,6 +5120,25 @@ void R_GLSL_DumpShader_f(void) else Con_Printf("failed to write to cg/default.cg\n"); #endif + +#ifdef SUPPORTD3D + file = FS_OpenRealFile("hlsl/default.hlsl", "w", false); + if (file) + { + FS_Print(file, "/* The engine may define the following macros:\n"); + FS_Print(file, "#define VERTEX_SHADER\n#define GEOMETRY_SHADER\n#define FRAGMENT_SHADER\n"); + for (i = 0;i < SHADERMODE_COUNT;i++) + FS_Print(file, hlslshadermodeinfo[i].pretext); + for (i = 0;i < SHADERPERMUTATION_COUNT;i++) + FS_Print(file, shaderpermutationinfo[i].pretext); + FS_Print(file, "*/\n"); + FS_Print(file, builtincgshaderstring); + FS_Close(file); + Con_Printf("hlsl/default.hlsl written\n"); + } + else + Con_Printf("failed to write to hlsl/default.hlsl\n"); +#endif } void R_SetupShader_Generic(rtexture_t *first, rtexture_t *second, int texturemode, int rgbscale) @@ -4484,15 +5147,28 @@ void R_SetupShader_Generic(rtexture_t *first, rtexture_t *second, int texturemod texturemode = GL_MODULATE; switch (vid.renderpath) { + case RENDERPATH_D3D9: +#ifdef SUPPORTD3D + R_SetupShader_SetPermutationHLSL(SHADERMODE_GENERIC, SHADERPERMUTATION_VIEWTINT | (first ? SHADERPERMUTATION_DIFFUSE : 0) | (second ? SHADERPERMUTATION_SPECULAR : 0) | (texturemode == GL_MODULATE ? SHADERPERMUTATION_COLORMAPPING : (texturemode == GL_ADD ? SHADERPERMUTATION_GLOW : (texturemode == GL_DECAL ? SHADERPERMUTATION_VERTEXTEXTUREBLEND : 0)))); + R_Mesh_TexBind(GL20TU_FIRST , first ); + R_Mesh_TexBind(GL20TU_SECOND, second); +#endif + break; + case RENDERPATH_D3D10: + Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); + break; + case RENDERPATH_D3D11: + Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); + break; case RENDERPATH_GL20: - R_SetupShader_SetPermutationGLSL(SHADERMODE_GENERIC, (first ? SHADERPERMUTATION_DIFFUSE : 0) | (second ? SHADERPERMUTATION_SPECULAR : 0) | (r_shadow_glossexact.integer ? SHADERPERMUTATION_EXACTSPECULARMATH : 0) | (texturemode == GL_MODULATE ? SHADERPERMUTATION_COLORMAPPING : (texturemode == GL_ADD ? SHADERPERMUTATION_GLOW : (texturemode == GL_DECAL ? SHADERPERMUTATION_VERTEXTEXTUREBLEND : 0)))); - if (r_glsl_permutation->loc_Texture_First ) R_Mesh_TexBind(GL20TU_FIRST , first ); - if (r_glsl_permutation->loc_Texture_Second) R_Mesh_TexBind(GL20TU_SECOND, second); + R_SetupShader_SetPermutationGLSL(SHADERMODE_GENERIC, SHADERPERMUTATION_VIEWTINT | (first ? SHADERPERMUTATION_DIFFUSE : 0) | (second ? SHADERPERMUTATION_SPECULAR : 0) | (texturemode == GL_MODULATE ? SHADERPERMUTATION_COLORMAPPING : (texturemode == GL_ADD ? SHADERPERMUTATION_GLOW : (texturemode == GL_DECAL ? SHADERPERMUTATION_VERTEXTEXTUREBLEND : 0)))); + R_Mesh_TexBind(GL20TU_FIRST , first ); + R_Mesh_TexBind(GL20TU_SECOND, second); break; case RENDERPATH_CGGL: #ifdef SUPPORTCG CHECKCGERROR - R_SetupShader_SetPermutationCG(SHADERMODE_GENERIC, (first ? SHADERPERMUTATION_DIFFUSE : 0) | (second ? SHADERPERMUTATION_SPECULAR : 0) | (r_shadow_glossexact.integer ? SHADERPERMUTATION_EXACTSPECULARMATH : 0) | (texturemode == GL_MODULATE ? SHADERPERMUTATION_COLORMAPPING : (texturemode == GL_ADD ? SHADERPERMUTATION_GLOW : (texturemode == GL_DECAL ? SHADERPERMUTATION_VERTEXTEXTUREBLEND : 0)))); + R_SetupShader_SetPermutationCG(SHADERMODE_GENERIC, SHADERPERMUTATION_VIEWTINT | (first ? SHADERPERMUTATION_DIFFUSE : 0) | (second ? SHADERPERMUTATION_SPECULAR : 0) | (texturemode == GL_MODULATE ? SHADERPERMUTATION_COLORMAPPING : (texturemode == GL_ADD ? SHADERPERMUTATION_GLOW : (texturemode == GL_DECAL ? SHADERPERMUTATION_VERTEXTEXTUREBLEND : 0)))); if (r_cg_permutation->fp_Texture_First ) CG_BindTexture(r_cg_permutation->fp_Texture_First , first );CHECKCGERROR if (r_cg_permutation->fp_Texture_Second) CG_BindTexture(r_cg_permutation->fp_Texture_Second, second);CHECKCGERROR #endif @@ -4514,6 +5190,17 @@ void R_SetupShader_DepthOrShadow(void) { switch (vid.renderpath) { + case RENDERPATH_D3D9: +#ifdef SUPPORTD3D + R_SetupShader_SetPermutationHLSL(SHADERMODE_DEPTH_OR_SHADOW, 0); +#endif + break; + case RENDERPATH_D3D10: + Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); + break; + case RENDERPATH_D3D11: + Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); + break; case RENDERPATH_GL20: R_SetupShader_SetPermutationGLSL(SHADERMODE_DEPTH_OR_SHADOW, 0); break; @@ -4536,6 +5223,17 @@ void R_SetupShader_ShowDepth(void) { switch (vid.renderpath) { + case RENDERPATH_D3D9: +#ifdef SUPPORTHLSL + R_SetupShader_SetPermutationHLSL(SHADERMODE_SHOWDEPTH, 0); +#endif + break; + case RENDERPATH_D3D10: + Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); + break; + case RENDERPATH_D3D11: + Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); + break; case RENDERPATH_GL20: R_SetupShader_SetPermutationGLSL(SHADERMODE_SHOWDEPTH, 0); break; @@ -4556,8 +5254,6 @@ extern cvar_t r_shadow_deferred_8bitrange; extern rtexture_t *r_shadow_attenuationgradienttexture; extern rtexture_t *r_shadow_attenuation2dtexture; extern rtexture_t *r_shadow_attenuation3dtexture; -extern qboolean r_shadow_usingshadowmaprect; -extern qboolean r_shadow_usingshadowmapcube; extern qboolean r_shadow_usingshadowmap2d; extern qboolean r_shadow_usingshadowmaportho; extern float r_shadow_shadowmap_texturescale[2]; @@ -4565,9 +5261,8 @@ extern float r_shadow_shadowmap_parameters[4]; extern qboolean r_shadow_shadowmapvsdct; extern qboolean r_shadow_shadowmapsampler; extern int r_shadow_shadowmappcf; -extern rtexture_t *r_shadow_shadowmaprectangletexture; extern rtexture_t *r_shadow_shadowmap2dtexture; -extern rtexture_t *r_shadow_shadowmapcubetexture[R_SHADOW_SHADOWMAP_NUMCUBEMAPS]; +extern rtexture_t *r_shadow_shadowmap2dcolortexture; extern rtexture_t *r_shadow_shadowmapvsdcttexture; extern matrix4x4_t r_shadow_shadowmapmatrix; extern int r_shadow_shadowmaplod; // changes for each light based on distance @@ -4575,10 +5270,106 @@ extern int r_shadow_prepass_width; extern int r_shadow_prepass_height; extern rtexture_t *r_shadow_prepassgeometrydepthtexture; extern rtexture_t *r_shadow_prepassgeometrynormalmaptexture; +extern rtexture_t *r_shadow_prepassgeometrydepthcolortexture; extern rtexture_t *r_shadow_prepasslightingdiffusetexture; extern rtexture_t *r_shadow_prepasslightingspeculartexture; extern cvar_t gl_mesh_separatearrays; -void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, float ambientscale, float diffusescale, float specularscale, rsurfacepass_t rsurfacepass, int texturenumsurfaces, const msurface_t **texturesurfacelist) +static qboolean R_BlendFuncAllowsColormod(int src, int dst) +{ + // a blendfunc allows colormod if: + // a) it can never keep the destination pixel invariant, or + // b) it can keep the destination pixel invariant, and still can do so if colormodded + // this is to prevent unintended side effects from colormod + + // in formulas: + // IF there is a (s, sa) for which for all (d, da), + // s * src(s, d, sa, da) + d * dst(s, d, sa, da) == d + // THEN, for this (s, sa) and all (colormod, d, da): + // s*colormod * src(s*colormod, d, sa, da) + d * dst(s*colormod, d, sa, da) == d + // OBVIOUSLY, this means that + // s*colormod * src(s*colormod, d, sa, da) = 0 + // dst(s*colormod, d, sa, da) = 1 + + // note: not caring about GL_SRC_ALPHA_SATURATE and following here, these are unused in DP code + + // main condition to leave dst color invariant: + // s * src(s, d, sa, da) + d * dst(s, d, sa, da) == d + // src == GL_ZERO: + // s * 0 + d * dst(s, d, sa, da) == d + // => dst == GL_ONE/GL_SRC_COLOR/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA + // => colormod is a problem for GL_SRC_COLOR only + // src == GL_ONE: + // s + d * dst(s, d, sa, da) == d + // => s == 0 + // => dst == GL_ONE/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA + // => colormod is never problematic for these + // src == GL_SRC_COLOR: + // s*s + d * dst(s, d, sa, da) == d + // => s == 0 + // => dst == GL_ONE/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA + // => colormod is never problematic for these + // src == GL_ONE_MINUS_SRC_COLOR: + // s*(1-s) + d * dst(s, d, sa, da) == d + // => s == 0 or s == 1 + // => dst == GL_ONE/GL_SRC_COLOR/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA + // => colormod is a problem for GL_SRC_COLOR only + // src == GL_DST_COLOR + // s*d + d * dst(s, d, sa, da) == d + // => s == 1 + // => dst == GL_ZERO/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA + // => colormod is always a problem + // or + // => s == 0 + // => dst == GL_ONE/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA + // => colormod is never problematic for these + // => BUT, we do not know s! We must assume it is problematic + // then... except in GL_ONE case, where we know all invariant + // cases are fine + // src == GL_ONE_MINUS_DST_COLOR + // s*(1-d) + d * dst(s, d, sa, da) == d + // => s == 0 (1-d is impossible to handle for our desired result) + // => dst == GL_ONE/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA + // => colormod is never problematic for these + // src == GL_SRC_ALPHA + // s*sa + d * dst(s, d, sa, da) == d + // => s == 0, or sa == 0 + // => dst == GL_ONE/GL_SRC_COLOR/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA + // => colormod breaks in the case GL_SRC_COLOR only + // src == GL_ONE_MINUS_SRC_ALPHA + // s*(1-sa) + d * dst(s, d, sa, da) == d + // => s == 0, or sa == 1 + // => dst == GL_ONE/GL_SRC_COLOR/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA + // => colormod breaks in the case GL_SRC_COLOR only + // src == GL_DST_ALPHA + // s*da + d * dst(s, d, sa, da) == d + // => s == 0 + // => dst == GL_ONE/GL_ONE_MINUS_SRC_COLOR/GL_SRC_ALPHA/GL_ONE_MINUS_SRC_ALPHA + // => colormod is never problematic for these + + switch(src) + { + case GL_ZERO: + case GL_ONE_MINUS_SRC_COLOR: + case GL_SRC_ALPHA: + case GL_ONE_MINUS_SRC_ALPHA: + if(dst == GL_SRC_COLOR) + return false; + return true; + case GL_ONE: + case GL_SRC_COLOR: + case GL_ONE_MINUS_DST_COLOR: + case GL_DST_ALPHA: + case GL_ONE_MINUS_DST_ALPHA: + return true; + case GL_DST_COLOR: + if(dst == GL_ONE) + return true; + return false; + default: + return false; + } +} +void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, float ambientscale, float diffusescale, float specularscale, rsurfacepass_t rsurfacepass, int texturenumsurfaces, const msurface_t **texturesurfacelist, void *surfacewaterplane) { // select a permutation of the lighting shader appropriate to this // combination of texture, entity, light source, and fogging, only use the @@ -4586,21 +5377,36 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, // fragment shader on features that are not being used unsigned int permutation = 0; unsigned int mode = 0; + qboolean allow_colormod; + static float dummy_colormod[3] = {1, 1, 1}; + float *colormod = rsurface.colormod; float m16f[16]; + r_waterstate_waterplane_t *waterplane = (r_waterstate_waterplane_t *)surfacewaterplane; if (rsurfacepass == RSURFPASS_BACKGROUND) { // distorted background if (rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERSHADER) + { mode = SHADERMODE_WATER; + if (rsurface.texture->r_water_waterscroll[0] && rsurface.texture->r_water_waterscroll[1]) + permutation |= SHADERPERMUTATION_NORMALMAPSCROLLBLEND; + GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + allow_colormod = R_BlendFuncAllowsColormod(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + } else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFRACTION) + { mode = SHADERMODE_REFRACTION; + GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + allow_colormod = R_BlendFuncAllowsColormod(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + } else { mode = SHADERMODE_GENERIC; permutation |= SHADERPERMUTATION_DIFFUSE; + GL_BlendFunc(GL_ONE, GL_ZERO); + allow_colormod = R_BlendFuncAllowsColormod(GL_ONE, GL_ZERO); } GL_AlphaTest(false); - GL_BlendFunc(GL_ONE, GL_ZERO); } else if (rsurfacepass == RSURFPASS_DEFERREDGEOMETRY) { @@ -4627,6 +5433,7 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND; GL_AlphaTest(false); GL_BlendFunc(GL_ONE, GL_ZERO); + allow_colormod = R_BlendFuncAllowsColormod(GL_ONE, GL_ZERO); } else if (rsurfacepass == RSURFPASS_RTLIGHT) { @@ -4654,24 +5461,15 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, if (diffusescale > 0) permutation |= SHADERPERMUTATION_DIFFUSE; if (specularscale > 0) - { permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE; - if (r_shadow_glossexact.integer) - permutation |= SHADERPERMUTATION_EXACTSPECULARMATH; - } if (r_refdef.fogenabled) permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE); if (rsurface.texture->colormapping) permutation |= SHADERPERMUTATION_COLORMAPPING; - if (r_shadow_usingshadowmaprect || r_shadow_usingshadowmap2d || r_shadow_usingshadowmapcube) - { - if (r_shadow_usingshadowmaprect) - permutation |= SHADERPERMUTATION_SHADOWMAPRECT; - if (r_shadow_usingshadowmap2d) - permutation |= SHADERPERMUTATION_SHADOWMAP2D; - if (r_shadow_usingshadowmapcube) - permutation |= SHADERPERMUTATION_SHADOWMAPCUBE; - else if(r_shadow_shadowmapvsdct) + if (r_shadow_usingshadowmap2d) + { + permutation |= SHADERPERMUTATION_SHADOWMAP2D; + if(r_shadow_shadowmapvsdct) permutation |= SHADERPERMUTATION_SHADOWMAPVSDCT; if (r_shadow_shadowmapsampler) @@ -4685,6 +5483,7 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, permutation |= SHADERPERMUTATION_REFLECTCUBE; GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0); GL_BlendFunc(GL_SRC_ALPHA, GL_ONE); + allow_colormod = R_BlendFuncAllowsColormod(GL_SRC_ALPHA, GL_ONE); } else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT) { @@ -4715,10 +5514,7 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, if (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW)) { permutation |= SHADERPERMUTATION_SHADOWMAPORTHO; - if (r_shadow_usingshadowmaprect) - permutation |= SHADERPERMUTATION_SHADOWMAPRECT; - if (r_shadow_usingshadowmap2d) - permutation |= SHADERPERMUTATION_SHADOWMAP2D; + permutation |= SHADERPERMUTATION_SHADOWMAP2D; if (r_shadow_shadowmapsampler) permutation |= SHADERPERMUTATION_SHADOWSAMPLER; @@ -4733,6 +5529,7 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, permutation |= SHADERPERMUTATION_REFLECTCUBE; GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0); GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2); + allow_colormod = R_BlendFuncAllowsColormod(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2); } else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT_DIRECTIONAL) { @@ -4757,11 +5554,7 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, permutation |= SHADERPERMUTATION_GLOW; permutation |= SHADERPERMUTATION_DIFFUSE; if (specularscale > 0) - { permutation |= SHADERPERMUTATION_SPECULAR; - if (r_shadow_glossexact.integer) - permutation |= SHADERPERMUTATION_EXACTSPECULARMATH; - } if (r_refdef.fogenabled) permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE); if (rsurface.texture->colormapping) @@ -4769,10 +5562,7 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, if (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW)) { permutation |= SHADERPERMUTATION_SHADOWMAPORTHO; - if (r_shadow_usingshadowmaprect) - permutation |= SHADERPERMUTATION_SHADOWMAPRECT; - if (r_shadow_usingshadowmap2d) - permutation |= SHADERPERMUTATION_SHADOWMAP2D; + permutation |= SHADERPERMUTATION_SHADOWMAP2D; if (r_shadow_shadowmapsampler) permutation |= SHADERPERMUTATION_SHADOWSAMPLER; @@ -4789,6 +5579,7 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, permutation |= SHADERPERMUTATION_REFLECTCUBE; GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0); GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2); + allow_colormod = R_BlendFuncAllowsColormod(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2); } else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) { @@ -4818,10 +5609,7 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, if (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW)) { permutation |= SHADERPERMUTATION_SHADOWMAPORTHO; - if (r_shadow_usingshadowmaprect) - permutation |= SHADERPERMUTATION_SHADOWMAPRECT; - if (r_shadow_usingshadowmap2d) - permutation |= SHADERPERMUTATION_SHADOWMAP2D; + permutation |= SHADERPERMUTATION_SHADOWMAP2D; if (r_shadow_shadowmapsampler) permutation |= SHADERPERMUTATION_SHADOWSAMPLER; @@ -4838,6 +5626,7 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, permutation |= SHADERPERMUTATION_REFLECTCUBE; GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0); GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2); + allow_colormod = R_BlendFuncAllowsColormod(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2); } else { @@ -4866,10 +5655,7 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, if (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW)) { permutation |= SHADERPERMUTATION_SHADOWMAPORTHO; - if (r_shadow_usingshadowmaprect) - permutation |= SHADERPERMUTATION_SHADOWMAPRECT; - if (r_shadow_usingshadowmap2d) - permutation |= SHADERPERMUTATION_SHADOWMAP2D; + permutation |= SHADERPERMUTATION_SHADOWMAP2D; if (r_shadow_shadowmapsampler) permutation |= SHADERPERMUTATION_SHADOWSAMPLER; @@ -4884,7 +5670,15 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP; if (rsurface.texture->reflectmasktexture) permutation |= SHADERPERMUTATION_REFLECTCUBE; - if (r_glsl_deluxemapping.integer >= 1 && rsurface.uselightmaptexture && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brushq3.deluxemapping) + if (FAKELIGHT_ENABLED) + { + // fake lightmapping (q1bsp, q3bsp, fullbright map) + mode = SHADERMODE_FAKELIGHT; + permutation |= SHADERPERMUTATION_DIFFUSE; + if (specularscale > 0) + permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE; + } + else if (r_glsl_deluxemapping.integer >= 1 && rsurface.uselightmaptexture && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brushq3.deluxemapping) { // deluxemapping (light direction texture) if (rsurface.uselightmaptexture && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brushq3.deluxemapping && r_refdef.scene.worldmodel->brushq3.deluxemapping_modelspace) @@ -4893,23 +5687,15 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE; permutation |= SHADERPERMUTATION_DIFFUSE; if (specularscale > 0) - { permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE; - if (r_shadow_glossexact.integer) - permutation |= SHADERPERMUTATION_EXACTSPECULARMATH; - } } - else if (r_glsl_deluxemapping.integer >= 2) + else if (r_glsl_deluxemapping.integer >= 2 && rsurface.uselightmaptexture) { // fake deluxemapping (uniform light direction in tangentspace) mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE; permutation |= SHADERPERMUTATION_DIFFUSE; if (specularscale > 0) - { permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE; - if (r_shadow_glossexact.integer) - permutation |= SHADERPERMUTATION_EXACTSPECULARMATH; - } } else if (rsurface.uselightmaptexture) { @@ -4923,9 +5709,157 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, } GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0); GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2); + allow_colormod = R_BlendFuncAllowsColormod(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2); } + if(!allow_colormod) + colormod = dummy_colormod; switch(vid.renderpath) { + case RENDERPATH_D3D9: +#ifdef SUPPORTD3D + RSurf_PrepareVerticesForBatch(BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | (rsurface.modellightmapcolor4f ? BATCHNEED_VERTEXMESH_VERTEXCOLOR : 0) | BATCHNEED_VERTEXMESH_TEXCOORD | (rsurface.uselightmaptexture ? BATCHNEED_VERTEXMESH_LIGHTMAP : 0), texturenumsurfaces, texturesurfacelist); + R_Mesh_PrepareVertices_Mesh(rsurface.batchnumvertices, rsurface.batchvertexmesh, rsurface.batchvertexmeshbuffer); + R_SetupShader_SetPermutationHLSL(mode, permutation); + Matrix4x4_ToArrayFloatGL(&rsurface.matrix, m16f);hlslPSSetParameter16f(D3DPSREGISTER_ModelToReflectCube, m16f); + if (mode == SHADERMODE_LIGHTSOURCE) + { + Matrix4x4_ToArrayFloatGL(&rsurface.entitytolight, m16f);hlslVSSetParameter16f(D3DVSREGISTER_ModelToLight, m16f); + hlslVSSetParameter3f(D3DVSREGISTER_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]); + } + else + { + if (mode == SHADERMODE_LIGHTDIRECTION) + { + hlslVSSetParameter3f(D3DVSREGISTER_LightDir, rsurface.modellight_lightdir[0], rsurface.modellight_lightdir[1], rsurface.modellight_lightdir[2]); + } + } + Matrix4x4_ToArrayFloatGL(&rsurface.texture->currenttexmatrix, m16f);hlslVSSetParameter16f(D3DVSREGISTER_TexMatrix, m16f); + Matrix4x4_ToArrayFloatGL(&rsurface.texture->currentbackgroundtexmatrix, m16f);hlslVSSetParameter16f(D3DVSREGISTER_BackgroundTexMatrix, m16f); + Matrix4x4_ToArrayFloatGL(&r_shadow_shadowmapmatrix, m16f);hlslVSSetParameter16f(D3DVSREGISTER_ShadowMapMatrix, m16f); + hlslVSSetParameter3f(D3DVSREGISTER_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]); + hlslVSSetParameter4f(D3DVSREGISTER_FogPlane, rsurface.fogplane[0], rsurface.fogplane[1], rsurface.fogplane[2], rsurface.fogplane[3]); + + if (mode == SHADERMODE_LIGHTSOURCE) + { + hlslPSSetParameter3f(D3DPSREGISTER_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]); + hlslPSSetParameter3f(D3DPSREGISTER_LightColor, lightcolorbase[0], lightcolorbase[1], lightcolorbase[2]); + hlslPSSetParameter3f(D3DPSREGISTER_Color_Ambient, colormod[0] * ambientscale, colormod[1] * ambientscale, colormod[2] * ambientscale); + hlslPSSetParameter3f(D3DPSREGISTER_Color_Diffuse, colormod[0] * diffusescale, colormod[1] * diffusescale, colormod[2] * diffusescale); + hlslPSSetParameter3f(D3DPSREGISTER_Color_Specular, r_refdef.view.colorscale * specularscale, r_refdef.view.colorscale * specularscale, r_refdef.view.colorscale * specularscale); + + // additive passes are only darkened by fog, not tinted + hlslPSSetParameter3f(D3DPSREGISTER_FogColor, 0, 0, 0); + hlslPSSetParameter1f(D3DPSREGISTER_SpecularPower, rsurface.texture->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f)); + } + else + { + if (mode == SHADERMODE_FLATCOLOR) + { + hlslPSSetParameter3f(D3DPSREGISTER_Color_Ambient, colormod[0], colormod[1], colormod[2]); + } + else if (mode == SHADERMODE_LIGHTDIRECTION) + { + hlslPSSetParameter3f(D3DPSREGISTER_Color_Ambient, (r_refdef.scene.ambient + rsurface.modellight_ambient[0] * r_refdef.lightmapintensity) * colormod[0], (r_refdef.scene.ambient + rsurface.modellight_ambient[1] * r_refdef.lightmapintensity) * colormod[1], (r_refdef.scene.ambient + rsurface.modellight_ambient[2] * r_refdef.lightmapintensity) * colormod[2]); + hlslPSSetParameter3f(D3DPSREGISTER_Color_Diffuse, r_refdef.lightmapintensity * colormod[0], r_refdef.lightmapintensity * colormod[1], r_refdef.lightmapintensity * colormod[2]); + hlslPSSetParameter3f(D3DPSREGISTER_Color_Specular, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale); + hlslPSSetParameter3f(D3DPSREGISTER_DeferredMod_Diffuse, colormod[0] * r_shadow_deferred_8bitrange.value, colormod[1] * r_shadow_deferred_8bitrange.value, colormod[2] * r_shadow_deferred_8bitrange.value); + hlslPSSetParameter3f(D3DPSREGISTER_DeferredMod_Specular, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value); + hlslPSSetParameter3f(D3DPSREGISTER_LightColor, rsurface.modellight_diffuse[0], rsurface.modellight_diffuse[1], rsurface.modellight_diffuse[2]); + hlslPSSetParameter3f(D3DPSREGISTER_LightDir, rsurface.modellight_lightdir[0], rsurface.modellight_lightdir[1], rsurface.modellight_lightdir[2]); + } + else + { + hlslPSSetParameter3f(D3DPSREGISTER_Color_Ambient, r_refdef.scene.ambient * colormod[0], r_refdef.scene.ambient * colormod[1], r_refdef.scene.ambient * colormod[2]); + hlslPSSetParameter3f(D3DPSREGISTER_Color_Diffuse, rsurface.texture->lightmapcolor[0], rsurface.texture->lightmapcolor[1], rsurface.texture->lightmapcolor[2]); + hlslPSSetParameter3f(D3DPSREGISTER_Color_Specular, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale); + hlslPSSetParameter3f(D3DPSREGISTER_DeferredMod_Diffuse, colormod[0] * diffusescale * r_shadow_deferred_8bitrange.value, colormod[1] * diffusescale * r_shadow_deferred_8bitrange.value, colormod[2] * diffusescale * r_shadow_deferred_8bitrange.value); + hlslPSSetParameter3f(D3DPSREGISTER_DeferredMod_Specular, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value); + } + // additive passes are only darkened by fog, not tinted + if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD) + hlslPSSetParameter3f(D3DPSREGISTER_FogColor, 0, 0, 0); + else + hlslPSSetParameter3f(D3DPSREGISTER_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]); + hlslPSSetParameter4f(D3DPSREGISTER_DistortScaleRefractReflect, r_water_refractdistort.value * rsurface.texture->refractfactor, r_water_refractdistort.value * rsurface.texture->refractfactor, r_water_reflectdistort.value * rsurface.texture->reflectfactor, r_water_reflectdistort.value * rsurface.texture->reflectfactor); + hlslPSSetParameter4f(D3DPSREGISTER_ScreenScaleRefractReflect, r_waterstate.screenscale[0], r_waterstate.screenscale[1], r_waterstate.screenscale[0], r_waterstate.screenscale[1]); + hlslPSSetParameter4f(D3DPSREGISTER_ScreenCenterRefractReflect, r_waterstate.screencenter[0], r_waterstate.screencenter[1], r_waterstate.screencenter[0], r_waterstate.screencenter[1]); + hlslPSSetParameter4f(D3DPSREGISTER_RefractColor, rsurface.texture->refractcolor4f[0], rsurface.texture->refractcolor4f[1], rsurface.texture->refractcolor4f[2], rsurface.texture->refractcolor4f[3] * rsurface.texture->lightmapcolor[3]); + hlslPSSetParameter4f(D3DPSREGISTER_ReflectColor, rsurface.texture->reflectcolor4f[0], rsurface.texture->reflectcolor4f[1], rsurface.texture->reflectcolor4f[2], rsurface.texture->reflectcolor4f[3] * rsurface.texture->lightmapcolor[3]); + hlslPSSetParameter1f(D3DPSREGISTER_ReflectFactor, rsurface.texture->reflectmax - rsurface.texture->reflectmin); + hlslPSSetParameter1f(D3DPSREGISTER_ReflectOffset, rsurface.texture->reflectmin); + hlslPSSetParameter1f(D3DPSREGISTER_SpecularPower, rsurface.texture->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f)); + if (mode == SHADERMODE_WATER) + hlslPSSetParameter2f(D3DPSREGISTER_NormalmapScrollBlend, rsurface.texture->r_water_waterscroll[0], rsurface.texture->r_water_waterscroll[1]); + } + hlslPSSetParameter2f(D3DPSREGISTER_ShadowMap_TextureScale, r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]); + hlslPSSetParameter4f(D3DPSREGISTER_ShadowMap_Parameters, r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]); + hlslPSSetParameter3f(D3DPSREGISTER_Color_Glow, rsurface.glowmod[0], rsurface.glowmod[1], rsurface.glowmod[2]); + hlslPSSetParameter1f(D3DPSREGISTER_Alpha, rsurface.texture->lightmapcolor[3] * ((rsurface.texture->basematerialflags & MATERIALFLAG_WATERSHADER && r_waterstate.enabled && !r_refdef.view.isoverlay) ? rsurface.texture->r_water_wateralpha : 1)); + hlslPSSetParameter3f(D3DPSREGISTER_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]); + if (rsurface.texture->pantstexture) + hlslPSSetParameter3f(D3DPSREGISTER_Color_Pants, rsurface.colormap_pantscolor[0], rsurface.colormap_pantscolor[1], rsurface.colormap_pantscolor[2]); + else + hlslPSSetParameter3f(D3DPSREGISTER_Color_Pants, 0, 0, 0); + if (rsurface.texture->shirttexture) + hlslPSSetParameter3f(D3DPSREGISTER_Color_Shirt, rsurface.colormap_shirtcolor[0], rsurface.colormap_shirtcolor[1], rsurface.colormap_shirtcolor[2]); + else + hlslPSSetParameter3f(D3DPSREGISTER_Color_Shirt, 0, 0, 0); + hlslPSSetParameter4f(D3DPSREGISTER_FogPlane, rsurface.fogplane[0], rsurface.fogplane[1], rsurface.fogplane[2], rsurface.fogplane[3]); + hlslPSSetParameter1f(D3DPSREGISTER_FogPlaneViewDist, rsurface.fogplaneviewdist); + hlslPSSetParameter1f(D3DPSREGISTER_FogRangeRecip, rsurface.fograngerecip); + hlslPSSetParameter1f(D3DPSREGISTER_FogHeightFade, rsurface.fogheightfade); + hlslPSSetParameter1f(D3DPSREGISTER_OffsetMapping_Scale, r_glsl_offsetmapping_scale.value); + hlslPSSetParameter2f(D3DPSREGISTER_ScreenToDepth, r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]); + hlslPSSetParameter2f(D3DPSREGISTER_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height); + + R_Mesh_TexBind(GL20TU_NORMAL , rsurface.texture->nmaptexture ); + R_Mesh_TexBind(GL20TU_COLOR , rsurface.texture->basetexture ); + R_Mesh_TexBind(GL20TU_GLOSS , rsurface.texture->glosstexture ); + R_Mesh_TexBind(GL20TU_GLOW , rsurface.texture->glowtexture ); + if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND) R_Mesh_TexBind(GL20TU_SECONDARY_NORMAL , rsurface.texture->backgroundnmaptexture ); + if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND) R_Mesh_TexBind(GL20TU_SECONDARY_COLOR , rsurface.texture->backgroundbasetexture ); + if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND) R_Mesh_TexBind(GL20TU_SECONDARY_GLOSS , rsurface.texture->backgroundglosstexture ); + if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND) R_Mesh_TexBind(GL20TU_SECONDARY_GLOW , rsurface.texture->backgroundglowtexture ); + if (permutation & SHADERPERMUTATION_COLORMAPPING) R_Mesh_TexBind(GL20TU_PANTS , rsurface.texture->pantstexture ); + if (permutation & SHADERPERMUTATION_COLORMAPPING) R_Mesh_TexBind(GL20TU_SHIRT , rsurface.texture->shirttexture ); + if (permutation & SHADERPERMUTATION_REFLECTCUBE) R_Mesh_TexBind(GL20TU_REFLECTMASK , rsurface.texture->reflectmasktexture ); + if (permutation & SHADERPERMUTATION_REFLECTCUBE) R_Mesh_TexBind(GL20TU_REFLECTCUBE , rsurface.texture->reflectcubetexture ? rsurface.texture->reflectcubetexture : r_texture_whitecube); + if (permutation & SHADERPERMUTATION_FOGHEIGHTTEXTURE) R_Mesh_TexBind(GL20TU_FOGHEIGHTTEXTURE , r_texture_fogheighttexture ); + if (permutation & (SHADERPERMUTATION_FOGINSIDE | SHADERPERMUTATION_FOGOUTSIDE)) R_Mesh_TexBind(GL20TU_FOGMASK , r_texture_fogattenuation ); + R_Mesh_TexBind(GL20TU_LIGHTMAP , rsurface.lightmaptexture ? rsurface.lightmaptexture : r_texture_white); + R_Mesh_TexBind(GL20TU_DELUXEMAP , rsurface.deluxemaptexture ? rsurface.deluxemaptexture : r_texture_blanknormalmap); + if (rsurface.rtlight ) R_Mesh_TexBind(GL20TU_ATTENUATION , r_shadow_attenuationgradienttexture ); + if (rsurfacepass == RSURFPASS_BACKGROUND) + { + R_Mesh_TexBind(GL20TU_REFRACTION , waterplane->texture_refraction ? waterplane->texture_refraction : r_texture_black); + if(mode == SHADERMODE_GENERIC) R_Mesh_TexBind(GL20TU_FIRST , waterplane->texture_camera ? waterplane->texture_camera : r_texture_black); + R_Mesh_TexBind(GL20TU_REFLECTION , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black); + } + else + { + if (permutation & SHADERPERMUTATION_REFLECTION ) R_Mesh_TexBind(GL20TU_REFLECTION , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black); + } +// if (rsurfacepass == RSURFPASS_DEFERREDLIGHT ) R_Mesh_TexBind(GL20TU_SCREENDEPTH , r_shadow_prepassgeometrydepthtexture ); +// if (rsurfacepass == RSURFPASS_DEFERREDLIGHT ) R_Mesh_TexBind(GL20TU_SCREENNORMALMAP , r_shadow_prepassgeometrynormalmaptexture ); + if (permutation & SHADERPERMUTATION_DEFERREDLIGHTMAP ) R_Mesh_TexBind(GL20TU_SCREENDIFFUSE , r_shadow_prepasslightingdiffusetexture ); + if (permutation & SHADERPERMUTATION_DEFERREDLIGHTMAP ) R_Mesh_TexBind(GL20TU_SCREENSPECULAR , r_shadow_prepasslightingspeculartexture ); + if (rsurface.rtlight || (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW))) + { + R_Mesh_TexBind(GL20TU_SHADOWMAP2D, r_shadow_shadowmap2dcolortexture); + if (rsurface.rtlight) + { + if (permutation & SHADERPERMUTATION_CUBEFILTER ) R_Mesh_TexBind(GL20TU_CUBE , rsurface.rtlight->currentcubemap ); + if (permutation & SHADERPERMUTATION_SHADOWMAPVSDCT ) R_Mesh_TexBind(GL20TU_CUBEPROJECTION , r_shadow_shadowmapvsdcttexture ); + } + } +#endif + break; + case RENDERPATH_D3D10: + Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); + break; + case RENDERPATH_D3D11: + Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); + break; case RENDERPATH_GL20: if (gl_mesh_separatearrays.integer) { @@ -4935,7 +5869,7 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset); R_Mesh_TexCoordPointer(1, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchsvector3f, rsurface.batchsvector3f_vertexbuffer, rsurface.batchsvector3f_bufferoffset); R_Mesh_TexCoordPointer(2, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchtvector3f, rsurface.batchtvector3f_vertexbuffer, rsurface.batchtvector3f_bufferoffset); - R_Mesh_TexCoordPointer(3, 4, GL_FLOAT, sizeof(float[3]), rsurface.batchnormal3f, rsurface.batchnormal3f_vertexbuffer, rsurface.batchnormal3f_bufferoffset); + R_Mesh_TexCoordPointer(3, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchnormal3f, rsurface.batchnormal3f_vertexbuffer, rsurface.batchnormal3f_bufferoffset); R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordlightmap2f, rsurface.batchtexcoordlightmap2f_vertexbuffer, rsurface.batchtexcoordlightmap2f_bufferoffset); } else @@ -4950,37 +5884,37 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, if (r_glsl_permutation->loc_ModelToLight >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.entitytolight, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelToLight, 1, false, m16f);} if (r_glsl_permutation->loc_LightPosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]); if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightColor, lightcolorbase[0], lightcolorbase[1], lightcolorbase[2]); - if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Ambient, rsurface.colormod[0] * ambientscale, rsurface.colormod[1] * ambientscale, rsurface.colormod[2] * ambientscale); - if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Diffuse, rsurface.colormod[0] * diffusescale, rsurface.colormod[1] * diffusescale, rsurface.colormod[2] * diffusescale); + if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Ambient, colormod[0] * ambientscale, colormod[1] * ambientscale, colormod[2] * ambientscale); + if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Diffuse, colormod[0] * diffusescale, colormod[1] * diffusescale, colormod[2] * diffusescale); if (r_glsl_permutation->loc_Color_Specular >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Specular, r_refdef.view.colorscale * specularscale, r_refdef.view.colorscale * specularscale, r_refdef.view.colorscale * specularscale); // additive passes are only darkened by fog, not tinted if (r_glsl_permutation->loc_FogColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_FogColor, 0, 0, 0); - if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface.texture->specularpower * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f)); + if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface.texture->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f)); } else { if (mode == SHADERMODE_FLATCOLOR) { - if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Ambient, rsurface.colormod[0], rsurface.colormod[1], rsurface.colormod[2]); + if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Ambient, colormod[0], colormod[1], colormod[2]); } else if (mode == SHADERMODE_LIGHTDIRECTION) { - if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Ambient, (r_refdef.scene.ambient + rsurface.modellight_ambient[0] * r_refdef.lightmapintensity) * rsurface.colormod[0], (r_refdef.scene.ambient + rsurface.modellight_ambient[1] * r_refdef.lightmapintensity) * rsurface.colormod[1], (r_refdef.scene.ambient + rsurface.modellight_ambient[2] * r_refdef.lightmapintensity) * rsurface.colormod[2]); - if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Diffuse, r_refdef.lightmapintensity * rsurface.colormod[0], r_refdef.lightmapintensity * rsurface.colormod[1], r_refdef.lightmapintensity * rsurface.colormod[2]); + if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Ambient, (r_refdef.scene.ambient + rsurface.modellight_ambient[0] * r_refdef.lightmapintensity * r_refdef.scene.rtlightstylevalue[0]) * colormod[0], (r_refdef.scene.ambient + rsurface.modellight_ambient[1] * r_refdef.lightmapintensity * r_refdef.scene.rtlightstylevalue[0]) * colormod[1], (r_refdef.scene.ambient + rsurface.modellight_ambient[2] * r_refdef.lightmapintensity * r_refdef.scene.rtlightstylevalue[0]) * colormod[2]); + if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Diffuse, r_refdef.lightmapintensity * colormod[0], r_refdef.lightmapintensity * colormod[1], r_refdef.lightmapintensity * colormod[2]); if (r_glsl_permutation->loc_Color_Specular >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Specular, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale); - if (r_glsl_permutation->loc_DeferredMod_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_DeferredMod_Diffuse, rsurface.colormod[0] * r_shadow_deferred_8bitrange.value, rsurface.colormod[1] * r_shadow_deferred_8bitrange.value, rsurface.colormod[2] * r_shadow_deferred_8bitrange.value); + if (r_glsl_permutation->loc_DeferredMod_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_DeferredMod_Diffuse, colormod[0] * r_shadow_deferred_8bitrange.value, colormod[1] * r_shadow_deferred_8bitrange.value, colormod[2] * r_shadow_deferred_8bitrange.value); if (r_glsl_permutation->loc_DeferredMod_Specular >= 0) qglUniform3fARB(r_glsl_permutation->loc_DeferredMod_Specular, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value); - if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightColor, rsurface.modellight_diffuse[0], rsurface.modellight_diffuse[1], rsurface.modellight_diffuse[2]); + if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightColor, rsurface.modellight_diffuse[0] * r_refdef.scene.rtlightstylevalue[0], rsurface.modellight_diffuse[1] * r_refdef.scene.rtlightstylevalue[0], rsurface.modellight_diffuse[2] * r_refdef.scene.rtlightstylevalue[0]); if (r_glsl_permutation->loc_LightDir >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightDir, rsurface.modellight_lightdir[0], rsurface.modellight_lightdir[1], rsurface.modellight_lightdir[2]); } else { - if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Ambient, r_refdef.scene.ambient * rsurface.colormod[0], r_refdef.scene.ambient * rsurface.colormod[1], r_refdef.scene.ambient * rsurface.colormod[2]); + if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Ambient, r_refdef.scene.ambient * colormod[0], r_refdef.scene.ambient * colormod[1], r_refdef.scene.ambient * colormod[2]); if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Diffuse, rsurface.texture->lightmapcolor[0], rsurface.texture->lightmapcolor[1], rsurface.texture->lightmapcolor[2]); if (r_glsl_permutation->loc_Color_Specular >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Specular, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale); - if (r_glsl_permutation->loc_DeferredMod_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_DeferredMod_Diffuse, rsurface.colormod[0] * diffusescale * r_shadow_deferred_8bitrange.value, rsurface.colormod[1] * diffusescale * r_shadow_deferred_8bitrange.value, rsurface.colormod[2] * diffusescale * r_shadow_deferred_8bitrange.value); + if (r_glsl_permutation->loc_DeferredMod_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_DeferredMod_Diffuse, colormod[0] * diffusescale * r_shadow_deferred_8bitrange.value, colormod[1] * diffusescale * r_shadow_deferred_8bitrange.value, colormod[2] * diffusescale * r_shadow_deferred_8bitrange.value); if (r_glsl_permutation->loc_DeferredMod_Specular >= 0) qglUniform3fARB(r_glsl_permutation->loc_DeferredMod_Specular, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value); } // additive passes are only darkened by fog, not tinted @@ -4994,11 +5928,12 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, if (r_glsl_permutation->loc_DistortScaleRefractReflect >= 0) qglUniform4fARB(r_glsl_permutation->loc_DistortScaleRefractReflect, r_water_refractdistort.value * rsurface.texture->refractfactor, r_water_refractdistort.value * rsurface.texture->refractfactor, r_water_reflectdistort.value * rsurface.texture->reflectfactor, r_water_reflectdistort.value * rsurface.texture->reflectfactor); if (r_glsl_permutation->loc_ScreenScaleRefractReflect >= 0) qglUniform4fARB(r_glsl_permutation->loc_ScreenScaleRefractReflect, r_waterstate.screenscale[0], r_waterstate.screenscale[1], r_waterstate.screenscale[0], r_waterstate.screenscale[1]); if (r_glsl_permutation->loc_ScreenCenterRefractReflect >= 0) qglUniform4fARB(r_glsl_permutation->loc_ScreenCenterRefractReflect, r_waterstate.screencenter[0], r_waterstate.screencenter[1], r_waterstate.screencenter[0], r_waterstate.screencenter[1]); - if (r_glsl_permutation->loc_RefractColor >= 0) qglUniform4fvARB(r_glsl_permutation->loc_RefractColor, 1, rsurface.texture->refractcolor4f); - if (r_glsl_permutation->loc_ReflectColor >= 0) qglUniform4fvARB(r_glsl_permutation->loc_ReflectColor, 1, rsurface.texture->reflectcolor4f); + if (r_glsl_permutation->loc_RefractColor >= 0) qglUniform4fARB(r_glsl_permutation->loc_RefractColor, rsurface.texture->refractcolor4f[0], rsurface.texture->refractcolor4f[1], rsurface.texture->refractcolor4f[2], rsurface.texture->refractcolor4f[3] * rsurface.texture->lightmapcolor[3]); + if (r_glsl_permutation->loc_ReflectColor >= 0) qglUniform4fARB(r_glsl_permutation->loc_ReflectColor, rsurface.texture->reflectcolor4f[0], rsurface.texture->reflectcolor4f[1], rsurface.texture->reflectcolor4f[2], rsurface.texture->reflectcolor4f[3] * rsurface.texture->lightmapcolor[3]); if (r_glsl_permutation->loc_ReflectFactor >= 0) qglUniform1fARB(r_glsl_permutation->loc_ReflectFactor, rsurface.texture->reflectmax - rsurface.texture->reflectmin); if (r_glsl_permutation->loc_ReflectOffset >= 0) qglUniform1fARB(r_glsl_permutation->loc_ReflectOffset, rsurface.texture->reflectmin); - if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface.texture->specularpower * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f)); + if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface.texture->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f)); + if (r_glsl_permutation->loc_NormalmapScrollBlend >= 0) qglUniform2fARB(r_glsl_permutation->loc_NormalmapScrollBlend, rsurface.texture->r_water_waterscroll[0], rsurface.texture->r_water_waterscroll[1]); } if (r_glsl_permutation->loc_TexMatrix >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currenttexmatrix, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_TexMatrix, 1, false, m16f);} if (r_glsl_permutation->loc_BackgroundTexMatrix >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currentbackgroundtexmatrix, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_BackgroundTexMatrix, 1, false, m16f);} @@ -5007,7 +5942,7 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, if (r_glsl_permutation->loc_ShadowMap_Parameters >= 0) qglUniform4fARB(r_glsl_permutation->loc_ShadowMap_Parameters, r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]); if (r_glsl_permutation->loc_Color_Glow >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Glow, rsurface.glowmod[0], rsurface.glowmod[1], rsurface.glowmod[2]); - if (r_glsl_permutation->loc_Alpha >= 0) qglUniform1fARB(r_glsl_permutation->loc_Alpha, rsurface.texture->lightmapcolor[3]); + if (r_glsl_permutation->loc_Alpha >= 0) qglUniform1fARB(r_glsl_permutation->loc_Alpha, rsurface.texture->lightmapcolor[3] * ((rsurface.texture->basematerialflags & MATERIALFLAG_WATERSHADER && r_waterstate.enabled && !r_refdef.view.isoverlay) ? rsurface.texture->r_water_wateralpha : 1)); if (r_glsl_permutation->loc_EyePosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]); if (r_glsl_permutation->loc_Color_Pants >= 0) { @@ -5048,24 +5983,29 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, if (r_glsl_permutation->loc_Texture_ReflectCube >= 0) R_Mesh_TexBind(GL20TU_REFLECTCUBE , rsurface.texture->reflectcubetexture ? rsurface.texture->reflectcubetexture : r_texture_whitecube); if (r_glsl_permutation->loc_Texture_FogHeightTexture>= 0) R_Mesh_TexBind(GL20TU_FOGHEIGHTTEXTURE , r_texture_fogheighttexture ); if (r_glsl_permutation->loc_Texture_FogMask >= 0) R_Mesh_TexBind(GL20TU_FOGMASK , r_texture_fogattenuation ); - if (r_glsl_permutation->loc_Texture_Lightmap >= 0) R_Mesh_TexBind(GL20TU_LIGHTMAP , r_texture_white ); - if (r_glsl_permutation->loc_Texture_Deluxemap >= 0) R_Mesh_TexBind(GL20TU_DELUXEMAP , r_texture_blanknormalmap ); + if (r_glsl_permutation->loc_Texture_Lightmap >= 0) R_Mesh_TexBind(GL20TU_LIGHTMAP , rsurface.lightmaptexture ? rsurface.lightmaptexture : r_texture_white); + if (r_glsl_permutation->loc_Texture_Deluxemap >= 0) R_Mesh_TexBind(GL20TU_DELUXEMAP , rsurface.deluxemaptexture ? rsurface.deluxemaptexture : r_texture_blanknormalmap); if (r_glsl_permutation->loc_Texture_Attenuation >= 0) R_Mesh_TexBind(GL20TU_ATTENUATION , r_shadow_attenuationgradienttexture ); - if (r_glsl_permutation->loc_Texture_Refraction >= 0) R_Mesh_TexBind(GL20TU_REFRACTION , r_texture_white ); - if (r_glsl_permutation->loc_Texture_Reflection >= 0) R_Mesh_TexBind(GL20TU_REFLECTION , r_texture_white ); - if (r_glsl_permutation->loc_Texture_ScreenDepth >= 0) R_Mesh_TexBind(GL20TU_SCREENDEPTH , r_shadow_prepassgeometrydepthtexture ); - if (r_glsl_permutation->loc_Texture_ScreenNormalMap >= 0) R_Mesh_TexBind(GL20TU_SCREENNORMALMAP , r_shadow_prepassgeometrynormalmaptexture ); + if (rsurfacepass == RSURFPASS_BACKGROUND) + { + if(r_glsl_permutation->loc_Texture_Refraction >= 0) R_Mesh_TexBind(GL20TU_REFRACTION , waterplane->texture_refraction ? waterplane->texture_refraction : r_texture_black); + else if(r_glsl_permutation->loc_Texture_First >= 0) R_Mesh_TexBind(GL20TU_FIRST , waterplane->texture_camera ? waterplane->texture_camera : r_texture_black); + if(r_glsl_permutation->loc_Texture_Reflection >= 0) R_Mesh_TexBind(GL20TU_REFLECTION , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black); + } + else + { + if (permutation & SHADERPERMUTATION_REFLECTION ) R_Mesh_TexBind(GL20TU_REFLECTION , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black); + } +// if (r_glsl_permutation->loc_Texture_ScreenDepth >= 0) R_Mesh_TexBind(GL20TU_SCREENDEPTH , r_shadow_prepassgeometrydepthtexture ); +// if (r_glsl_permutation->loc_Texture_ScreenNormalMap >= 0) R_Mesh_TexBind(GL20TU_SCREENNORMALMAP , r_shadow_prepassgeometrynormalmaptexture ); if (r_glsl_permutation->loc_Texture_ScreenDiffuse >= 0) R_Mesh_TexBind(GL20TU_SCREENDIFFUSE , r_shadow_prepasslightingdiffusetexture ); if (r_glsl_permutation->loc_Texture_ScreenSpecular >= 0) R_Mesh_TexBind(GL20TU_SCREENSPECULAR , r_shadow_prepasslightingspeculartexture ); if (rsurface.rtlight || (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW))) { - if (r_glsl_permutation->loc_Texture_ShadowMap2D >= 0) R_Mesh_TexBind(r_shadow_usingshadowmaportho ? GL20TU_SHADOWMAPORTHO2D : GL20TU_SHADOWMAP2D, r_shadow_shadowmap2dtexture ); - if (r_glsl_permutation->loc_Texture_ShadowMapRect >= 0) R_Mesh_TexBind(r_shadow_usingshadowmaportho ? GL20TU_SHADOWMAPORTHORECT : GL20TU_SHADOWMAPRECT, r_shadow_shadowmaprectangletexture ); + if (r_glsl_permutation->loc_Texture_ShadowMap2D >= 0) R_Mesh_TexBind(GL20TU_SHADOWMAP2D, r_shadow_shadowmap2dtexture ); if (rsurface.rtlight) { if (r_glsl_permutation->loc_Texture_Cube >= 0) R_Mesh_TexBind(GL20TU_CUBE , rsurface.rtlight->currentcubemap ); - if (r_shadow_usingshadowmapcube) - if (r_glsl_permutation->loc_Texture_ShadowMapCube >= 0) R_Mesh_TexBind(GL20TU_SHADOWMAPCUBE , r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]); if (r_glsl_permutation->loc_Texture_CubeProjection >= 0) R_Mesh_TexBind(GL20TU_CUBEPROJECTION , r_shadow_shadowmapvsdcttexture ); } } @@ -5081,7 +6021,7 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset); R_Mesh_TexCoordPointer(1, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchsvector3f, rsurface.batchsvector3f_vertexbuffer, rsurface.batchsvector3f_bufferoffset); R_Mesh_TexCoordPointer(2, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchtvector3f, rsurface.batchtvector3f_vertexbuffer, rsurface.batchtvector3f_bufferoffset); - R_Mesh_TexCoordPointer(3, 4, GL_FLOAT, sizeof(float[3]), rsurface.batchnormal3f, rsurface.batchnormal3f_vertexbuffer, rsurface.batchnormal3f_bufferoffset); + R_Mesh_TexCoordPointer(3, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchnormal3f, rsurface.batchnormal3f_vertexbuffer, rsurface.batchnormal3f_bufferoffset); R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordlightmap2f, rsurface.batchtexcoordlightmap2f_vertexbuffer, rsurface.batchtexcoordlightmap2f_bufferoffset); } else @@ -5114,36 +6054,36 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, { if (r_cg_permutation->fp_LightPosition) cgGLSetParameter3f(r_cg_permutation->fp_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);CHECKCGERROR if (r_cg_permutation->fp_LightColor) cgGLSetParameter3f(r_cg_permutation->fp_LightColor, lightcolorbase[0], lightcolorbase[1], lightcolorbase[2]);CHECKCGERROR - if (r_cg_permutation->fp_Color_Ambient) cgGLSetParameter3f(r_cg_permutation->fp_Color_Ambient, rsurface.colormod[0] * ambientscale, rsurface.colormod[1] * ambientscale, rsurface.colormod[2] * ambientscale);CHECKCGERROR - if (r_cg_permutation->fp_Color_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_Color_Diffuse, rsurface.colormod[0] * diffusescale, rsurface.colormod[1] * diffusescale, rsurface.colormod[2] * diffusescale);CHECKCGERROR + if (r_cg_permutation->fp_Color_Ambient) cgGLSetParameter3f(r_cg_permutation->fp_Color_Ambient, colormod[0] * ambientscale, colormod[1] * ambientscale, colormod[2] * ambientscale);CHECKCGERROR + if (r_cg_permutation->fp_Color_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_Color_Diffuse, colormod[0] * diffusescale, colormod[1] * diffusescale, colormod[2] * diffusescale);CHECKCGERROR if (r_cg_permutation->fp_Color_Specular) cgGLSetParameter3f(r_cg_permutation->fp_Color_Specular, r_refdef.view.colorscale * specularscale, r_refdef.view.colorscale * specularscale, r_refdef.view.colorscale * specularscale);CHECKCGERROR // additive passes are only darkened by fog, not tinted if (r_cg_permutation->fp_FogColor) cgGLSetParameter3f(r_cg_permutation->fp_FogColor, 0, 0, 0);CHECKCGERROR - if (r_cg_permutation->fp_SpecularPower) cgGLSetParameter1f(r_cg_permutation->fp_SpecularPower, rsurface.texture->specularpower * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f));CHECKCGERROR + if (r_cg_permutation->fp_SpecularPower) cgGLSetParameter1f(r_cg_permutation->fp_SpecularPower, rsurface.texture->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f));CHECKCGERROR } else { if (mode == SHADERMODE_FLATCOLOR) { - if (r_cg_permutation->fp_Color_Ambient) cgGLSetParameter3f(r_cg_permutation->fp_Color_Ambient, rsurface.colormod[0], rsurface.colormod[1], rsurface.colormod[2]);CHECKCGERROR + if (r_cg_permutation->fp_Color_Ambient) cgGLSetParameter3f(r_cg_permutation->fp_Color_Ambient, colormod[0], colormod[1], colormod[2]);CHECKCGERROR } else if (mode == SHADERMODE_LIGHTDIRECTION) { - if (r_cg_permutation->fp_Color_Ambient) cgGLSetParameter3f(r_cg_permutation->fp_Color_Ambient, (r_refdef.scene.ambient + rsurface.modellight_ambient[0] * r_refdef.lightmapintensity) * rsurface.colormod[0], (r_refdef.scene.ambient + rsurface.modellight_ambient[1] * r_refdef.lightmapintensity) * rsurface.colormod[1], (r_refdef.scene.ambient + rsurface.modellight_ambient[2] * r_refdef.lightmapintensity) * rsurface.colormod[2]);CHECKCGERROR - if (r_cg_permutation->fp_Color_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_Color_Diffuse, r_refdef.lightmapintensity * rsurface.colormod[0], r_refdef.lightmapintensity * rsurface.colormod[1], r_refdef.lightmapintensity * rsurface.colormod[2]);CHECKCGERROR + if (r_cg_permutation->fp_Color_Ambient) cgGLSetParameter3f(r_cg_permutation->fp_Color_Ambient, (r_refdef.scene.ambient + rsurface.modellight_ambient[0] * r_refdef.lightmapintensity) * colormod[0], (r_refdef.scene.ambient + rsurface.modellight_ambient[1] * r_refdef.lightmapintensity) * colormod[1], (r_refdef.scene.ambient + rsurface.modellight_ambient[2] * r_refdef.lightmapintensity) * colormod[2]);CHECKCGERROR + if (r_cg_permutation->fp_Color_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_Color_Diffuse, r_refdef.lightmapintensity * colormod[0], r_refdef.lightmapintensity * colormod[1], r_refdef.lightmapintensity * colormod[2]);CHECKCGERROR if (r_cg_permutation->fp_Color_Specular) cgGLSetParameter3f(r_cg_permutation->fp_Color_Specular, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale);CHECKCGERROR - if (r_cg_permutation->fp_DeferredMod_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_DeferredMod_Diffuse, rsurface.colormod[0] * r_shadow_deferred_8bitrange.value, rsurface.colormod[1] * r_shadow_deferred_8bitrange.value, rsurface.colormod[2] * r_shadow_deferred_8bitrange.value);CHECKCGERROR + if (r_cg_permutation->fp_DeferredMod_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_DeferredMod_Diffuse, colormod[0] * r_shadow_deferred_8bitrange.value, colormod[1] * r_shadow_deferred_8bitrange.value, colormod[2] * r_shadow_deferred_8bitrange.value);CHECKCGERROR if (r_cg_permutation->fp_DeferredMod_Specular) cgGLSetParameter3f(r_cg_permutation->fp_DeferredMod_Specular, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value);CHECKCGERROR if (r_cg_permutation->fp_LightColor) cgGLSetParameter3f(r_cg_permutation->fp_LightColor, rsurface.modellight_diffuse[0], rsurface.modellight_diffuse[1], rsurface.modellight_diffuse[2]);CHECKCGERROR if (r_cg_permutation->fp_LightDir) cgGLSetParameter3f(r_cg_permutation->fp_LightDir, rsurface.modellight_lightdir[0], rsurface.modellight_lightdir[1], rsurface.modellight_lightdir[2]);CHECKCGERROR } else { - if (r_cg_permutation->fp_Color_Ambient) cgGLSetParameter3f(r_cg_permutation->fp_Color_Ambient, r_refdef.scene.ambient * rsurface.colormod[0], r_refdef.scene.ambient * rsurface.colormod[1], r_refdef.scene.ambient * rsurface.colormod[2]);CHECKCGERROR + if (r_cg_permutation->fp_Color_Ambient) cgGLSetParameter3f(r_cg_permutation->fp_Color_Ambient, r_refdef.scene.ambient * colormod[0], r_refdef.scene.ambient * colormod[1], r_refdef.scene.ambient * colormod[2]);CHECKCGERROR if (r_cg_permutation->fp_Color_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_Color_Diffuse, rsurface.texture->lightmapcolor[0], rsurface.texture->lightmapcolor[1], rsurface.texture->lightmapcolor[2]);CHECKCGERROR if (r_cg_permutation->fp_Color_Specular) cgGLSetParameter3f(r_cg_permutation->fp_Color_Specular, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale);CHECKCGERROR - if (r_cg_permutation->fp_DeferredMod_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_DeferredMod_Diffuse, rsurface.colormod[0] * diffusescale * r_shadow_deferred_8bitrange.value, rsurface.colormod[1] * diffusescale * r_shadow_deferred_8bitrange.value, rsurface.colormod[2] * diffusescale * r_shadow_deferred_8bitrange.value);CHECKCGERROR + if (r_cg_permutation->fp_DeferredMod_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_DeferredMod_Diffuse, colormod[0] * diffusescale * r_shadow_deferred_8bitrange.value, colormod[1] * diffusescale * r_shadow_deferred_8bitrange.value, colormod[2] * diffusescale * r_shadow_deferred_8bitrange.value);CHECKCGERROR if (r_cg_permutation->fp_DeferredMod_Specular) cgGLSetParameter3f(r_cg_permutation->fp_DeferredMod_Specular, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value);CHECKCGERROR } // additive passes are only darkened by fog, not tinted @@ -5158,16 +6098,17 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, if (r_cg_permutation->fp_DistortScaleRefractReflect) cgGLSetParameter4f(r_cg_permutation->fp_DistortScaleRefractReflect, r_water_refractdistort.value * rsurface.texture->refractfactor, r_water_refractdistort.value * rsurface.texture->refractfactor, r_water_reflectdistort.value * rsurface.texture->reflectfactor, r_water_reflectdistort.value * rsurface.texture->reflectfactor);CHECKCGERROR if (r_cg_permutation->fp_ScreenScaleRefractReflect) cgGLSetParameter4f(r_cg_permutation->fp_ScreenScaleRefractReflect, r_waterstate.screenscale[0], r_waterstate.screenscale[1], r_waterstate.screenscale[0], r_waterstate.screenscale[1]);CHECKCGERROR if (r_cg_permutation->fp_ScreenCenterRefractReflect) cgGLSetParameter4f(r_cg_permutation->fp_ScreenCenterRefractReflect, r_waterstate.screencenter[0], r_waterstate.screencenter[1], r_waterstate.screencenter[0], r_waterstate.screencenter[1]);CHECKCGERROR - if (r_cg_permutation->fp_RefractColor) cgGLSetParameter4fv(r_cg_permutation->fp_RefractColor, rsurface.texture->refractcolor4f);CHECKCGERROR - if (r_cg_permutation->fp_ReflectColor) cgGLSetParameter4fv(r_cg_permutation->fp_ReflectColor, rsurface.texture->reflectcolor4f);CHECKCGERROR + if (r_cg_permutation->fp_RefractColor) cgGLSetParameter4fv(r_cg_permutation->fp_RefractColor, rsurface.texture->refractcolor4f[0], rsurface.texture->refractcolor4f[1], rsurface.texture->refractcolor4f[2], rsurface.texture->refractcolor4f[3] * rsurface.texture->lightmapcolor[3]);CHECKCGERROR + if (r_cg_permutation->fp_ReflectColor) cgGLSetParameter4fv(r_cg_permutation->fp_ReflectColor, rsurface.texture->reflectcolor4f[0], rsurface.texture->reflectcolor4f[1], rsurface.texture->reflectcolor4f[2], rsurface.texture->reflectcolor4f[3] * rsurface.texture->lightmapcolor[3]);CHECKCGERROR if (r_cg_permutation->fp_ReflectFactor) cgGLSetParameter1f(r_cg_permutation->fp_ReflectFactor, rsurface.texture->reflectmax - rsurface.texture->reflectmin);CHECKCGERROR if (r_cg_permutation->fp_ReflectOffset) cgGLSetParameter1f(r_cg_permutation->fp_ReflectOffset, rsurface.texture->reflectmin);CHECKCGERROR - if (r_cg_permutation->fp_SpecularPower) cgGLSetParameter1f(r_cg_permutation->fp_SpecularPower, rsurface.texture->specularpower * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f));CHECKCGERROR + if (r_cg_permutation->fp_SpecularPower) cgGLSetParameter1f(r_cg_permutation->fp_SpecularPower, rsurface.texture->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f));CHECKCGERROR + if (r_cg_permutation->fp_NormalmapScrollBlend) cgGLSetParameter2f(r_cg_permutation->fp_NormalmapScrollBlend, rsurface.texture->r_water_waterscroll[0], rsurface.texture->r_water_waterscroll[1]); } if (r_cg_permutation->fp_ShadowMap_TextureScale) cgGLSetParameter2f(r_cg_permutation->fp_ShadowMap_TextureScale, r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]);CHECKCGERROR if (r_cg_permutation->fp_ShadowMap_Parameters) cgGLSetParameter4f(r_cg_permutation->fp_ShadowMap_Parameters, r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]);CHECKCGERROR if (r_cg_permutation->fp_Color_Glow) cgGLSetParameter3f(r_cg_permutation->fp_Color_Glow, rsurface.glowmod[0], rsurface.glowmod[1], rsurface.glowmod[2]);CHECKCGERROR - if (r_cg_permutation->fp_Alpha) cgGLSetParameter1f(r_cg_permutation->fp_Alpha, rsurface.texture->lightmapcolor[3]);CHECKCGERROR + if (r_cg_permutation->fp_Alpha) cgGLSetParameter1f(r_cg_permutation->fp_Alpha, rsurface.texture->lightmapcolor[3] * ((rsurface.texture->basematerialflags & MATERIALFLAG_WATERSHADER && r_waterstate.enabled && !r_refdef.view.isoverlay) ? rsurface.texture->r_water_wateralpha : 1));CHECKCGERROR if (r_cg_permutation->fp_EyePosition) cgGLSetParameter3f(r_cg_permutation->fp_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);CHECKCGERROR if (r_cg_permutation->fp_Color_Pants) { @@ -5210,11 +6151,19 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, if (r_cg_permutation->fp_Texture_ReflectCube ) CG_BindTexture(r_cg_permutation->fp_Texture_ReflectCube , rsurface.texture->reflectcubetexture ? rsurface.texture->reflectcubetexture : r_texture_whitecube);CHECKCGERROR if (r_cg_permutation->fp_Texture_FogHeightTexture) CG_BindTexture(r_cg_permutation->fp_Texture_FogHeightTexture, r_texture_fogheighttexture );CHECKCGERROR if (r_cg_permutation->fp_Texture_FogMask ) CG_BindTexture(r_cg_permutation->fp_Texture_FogMask , r_texture_fogattenuation );CHECKCGERROR - if (r_cg_permutation->fp_Texture_Lightmap ) CG_BindTexture(r_cg_permutation->fp_Texture_Lightmap , r_texture_white );CHECKCGERROR - if (r_cg_permutation->fp_Texture_Deluxemap ) CG_BindTexture(r_cg_permutation->fp_Texture_Deluxemap , r_texture_blanknormalmap );CHECKCGERROR + if (r_cg_permutation->fp_Texture_Lightmap ) CG_BindTexture(r_cg_permutation->fp_Texture_Lightmap , rsurface.lightmaptexture ? rsurface.lightmaptexture : r_texture_white);CHECKCGERROR + if (r_cg_permutation->fp_Texture_Deluxemap ) CG_BindTexture(r_cg_permutation->fp_Texture_Deluxemap , rsurface.deluxemaptexture ? rsurface.deluxemaptexture : r_texture_blanknormalmap);CHECKCGERROR if (r_cg_permutation->fp_Texture_Attenuation ) CG_BindTexture(r_cg_permutation->fp_Texture_Attenuation , r_shadow_attenuationgradienttexture );CHECKCGERROR - if (r_cg_permutation->fp_Texture_Refraction ) CG_BindTexture(r_cg_permutation->fp_Texture_Refraction , r_texture_white );CHECKCGERROR - if (r_cg_permutation->fp_Texture_Reflection ) CG_BindTexture(r_cg_permutation->fp_Texture_Reflection , r_texture_white );CHECKCGERROR + if (rsurfacepass == RSURFPASS_BACKGROUND) + { + if (r_cg_permutation->fp_Texture_Refraction ) CG_BindTexture(r_cg_permutation->fp_Texture_Refraction , waterplane->texture_refraction ? waterplane->texture_refraction : r_texture_black);CHECKCGERROR + else if (r_cg_permutation->fp_Texture_First ) CG_BindTexture(r_cg_permutation->fp_Texture_First , waterplane->texture_camera ? waterplane->texture_camera : r_texture_black);CHECKCGERROR + if (r_cg_permutation->fp_Texture_Reflection ) CG_BindTexture(r_cg_permutation->fp_Texture_Reflection , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black);CHECKCGERROR + } + else + { + if (r_cg_permutation->fp_Texture_Reflection ) CG_BindTexture(r_cg_permutation->fp_Texture_Reflection , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black);CHECKCGERROR + } if (r_cg_permutation->fp_Texture_ScreenDepth ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenDepth , r_shadow_prepassgeometrydepthtexture );CHECKCGERROR if (r_cg_permutation->fp_Texture_ScreenNormalMap) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenNormalMap, r_shadow_prepassgeometrynormalmaptexture );CHECKCGERROR if (r_cg_permutation->fp_Texture_ScreenDiffuse ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenDiffuse , r_shadow_prepasslightingdiffusetexture );CHECKCGERROR @@ -5222,12 +6171,9 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, if (rsurface.rtlight || (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW))) { if (r_cg_permutation->fp_Texture_ShadowMap2D ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMap2D , r_shadow_shadowmap2dtexture );CHECKCGERROR - if (r_cg_permutation->fp_Texture_ShadowMapRect ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMapRect , r_shadow_shadowmaprectangletexture );CHECKCGERROR if (rsurface.rtlight) { if (r_cg_permutation->fp_Texture_Cube ) CG_BindTexture(r_cg_permutation->fp_Texture_Cube , rsurface.rtlight->currentcubemap );CHECKCGERROR - if (r_shadow_usingshadowmapcube) - if (r_cg_permutation->fp_Texture_ShadowMapCube ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMapCube , r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]);CHECKCGERROR if (r_cg_permutation->fp_Texture_CubeProjection ) CG_BindTexture(r_cg_permutation->fp_Texture_CubeProjection , r_shadow_shadowmapvsdcttexture );CHECKCGERROR } } @@ -5267,20 +6213,11 @@ void R_SetupShader_DeferredLight(const rtlight_t *rtlight) if (diffusescale > 0) permutation |= SHADERPERMUTATION_DIFFUSE; if (specularscale > 0) - { permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE; - if (r_shadow_glossexact.integer) - permutation |= SHADERPERMUTATION_EXACTSPECULARMATH; - } - if (r_shadow_usingshadowmaprect || r_shadow_usingshadowmap2d || r_shadow_usingshadowmapcube) + if (r_shadow_usingshadowmap2d) { - if (r_shadow_usingshadowmaprect) - permutation |= SHADERPERMUTATION_SHADOWMAPRECT; - if (r_shadow_usingshadowmap2d) - permutation |= SHADERPERMUTATION_SHADOWMAP2D; - if (r_shadow_usingshadowmapcube) - permutation |= SHADERPERMUTATION_SHADOWMAPCUBE; - else if(r_shadow_shadowmapvsdct) + permutation |= SHADERPERMUTATION_SHADOWMAP2D; + if (r_shadow_shadowmapvsdct) permutation |= SHADERPERMUTATION_SHADOWMAPVSDCT; if (r_shadow_shadowmapsampler) @@ -5296,6 +6233,34 @@ void R_SetupShader_DeferredLight(const rtlight_t *rtlight) Matrix4x4_ToArrayFloatGL(&viewtolight, viewtolight16f); switch(vid.renderpath) { + case RENDERPATH_D3D9: +#ifdef SUPPORTD3D + R_SetupShader_SetPermutationHLSL(mode, permutation); + hlslPSSetParameter3f(D3DPSREGISTER_LightPosition, viewlightorigin[0], viewlightorigin[1], viewlightorigin[2]); + hlslPSSetParameter16f(D3DPSREGISTER_ViewToLight, viewtolight16f); + hlslPSSetParameter3f(D3DPSREGISTER_DeferredColor_Ambient , lightcolorbase[0] * ambientscale * range, lightcolorbase[1] * ambientscale * range, lightcolorbase[2] * ambientscale * range); + hlslPSSetParameter3f(D3DPSREGISTER_DeferredColor_Diffuse , lightcolorbase[0] * diffusescale * range, lightcolorbase[1] * diffusescale * range, lightcolorbase[2] * diffusescale * range); + hlslPSSetParameter3f(D3DPSREGISTER_DeferredColor_Specular, lightcolorbase[0] * specularscale * range, lightcolorbase[1] * specularscale * range, lightcolorbase[2] * specularscale * range); + hlslPSSetParameter2f(D3DPSREGISTER_ShadowMap_TextureScale, r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]); + hlslPSSetParameter4f(D3DPSREGISTER_ShadowMap_Parameters, r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]); + hlslPSSetParameter1f(D3DPSREGISTER_SpecularPower, (r_shadow_gloss.integer == 2 ? r_shadow_gloss2exponent.value : r_shadow_glossexponent.value) * (r_shadow_glossexact.integer ? 0.25f : 1.0f)); + hlslPSSetParameter2f(D3DPSREGISTER_ScreenToDepth, r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]); + hlslPSSetParameter2f(D3DPSREGISTER_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height); + + R_Mesh_TexBind(GL20TU_ATTENUATION , r_shadow_attenuationgradienttexture ); + R_Mesh_TexBind(GL20TU_SCREENDEPTH , r_shadow_prepassgeometrydepthcolortexture ); + R_Mesh_TexBind(GL20TU_SCREENNORMALMAP , r_shadow_prepassgeometrynormalmaptexture ); + R_Mesh_TexBind(GL20TU_CUBE , rsurface.rtlight->currentcubemap ); + R_Mesh_TexBind(GL20TU_SHADOWMAP2D , r_shadow_shadowmap2dcolortexture ); + R_Mesh_TexBind(GL20TU_CUBEPROJECTION , r_shadow_shadowmapvsdcttexture ); +#endif + break; + case RENDERPATH_D3D10: + Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); + break; + case RENDERPATH_D3D11: + Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); + break; case RENDERPATH_GL20: R_SetupShader_SetPermutationGLSL(mode, permutation); if (r_glsl_permutation->loc_LightPosition >= 0) qglUniform3fARB( r_glsl_permutation->loc_LightPosition , viewlightorigin[0], viewlightorigin[1], viewlightorigin[2]); @@ -5305,7 +6270,7 @@ void R_SetupShader_DeferredLight(const rtlight_t *rtlight) if (r_glsl_permutation->loc_DeferredColor_Specular >= 0) qglUniform3fARB( r_glsl_permutation->loc_DeferredColor_Specular , lightcolorbase[0] * specularscale * range, lightcolorbase[1] * specularscale * range, lightcolorbase[2] * specularscale * range); if (r_glsl_permutation->loc_ShadowMap_TextureScale >= 0) qglUniform2fARB( r_glsl_permutation->loc_ShadowMap_TextureScale , r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]); if (r_glsl_permutation->loc_ShadowMap_Parameters >= 0) qglUniform4fARB( r_glsl_permutation->loc_ShadowMap_Parameters , r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]); - if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB( r_glsl_permutation->loc_SpecularPower , (r_shadow_gloss.integer == 2 ? r_shadow_gloss2exponent.value : r_shadow_glossexponent.value) * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f)); + if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB( r_glsl_permutation->loc_SpecularPower , (r_shadow_gloss.integer == 2 ? r_shadow_gloss2exponent.value : r_shadow_glossexponent.value) * (r_shadow_glossexact.integer ? 0.25f : 1.0f)); if (r_glsl_permutation->loc_ScreenToDepth >= 0) qglUniform2fARB( r_glsl_permutation->loc_ScreenToDepth , r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]); if (r_glsl_permutation->loc_PixelToScreenTexCoord >= 0) qglUniform2fARB(r_glsl_permutation->loc_PixelToScreenTexCoord, 1.0f/vid.width, 1.0f/vid.height); @@ -5313,9 +6278,6 @@ void R_SetupShader_DeferredLight(const rtlight_t *rtlight) if (r_glsl_permutation->loc_Texture_ScreenDepth >= 0) R_Mesh_TexBind(GL20TU_SCREENDEPTH , r_shadow_prepassgeometrydepthtexture ); if (r_glsl_permutation->loc_Texture_ScreenNormalMap >= 0) R_Mesh_TexBind(GL20TU_SCREENNORMALMAP , r_shadow_prepassgeometrynormalmaptexture ); if (r_glsl_permutation->loc_Texture_Cube >= 0) R_Mesh_TexBind(GL20TU_CUBE , rsurface.rtlight->currentcubemap ); - if (r_glsl_permutation->loc_Texture_ShadowMapRect >= 0) R_Mesh_TexBind(GL20TU_SHADOWMAPRECT , r_shadow_shadowmaprectangletexture ); - if (r_shadow_usingshadowmapcube) - if (r_glsl_permutation->loc_Texture_ShadowMapCube >= 0) R_Mesh_TexBind(GL20TU_SHADOWMAPCUBE , r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]); if (r_glsl_permutation->loc_Texture_ShadowMap2D >= 0) R_Mesh_TexBind(GL20TU_SHADOWMAP2D , r_shadow_shadowmap2dtexture ); if (r_glsl_permutation->loc_Texture_CubeProjection >= 0) R_Mesh_TexBind(GL20TU_CUBEPROJECTION , r_shadow_shadowmapvsdcttexture ); break; @@ -5329,7 +6291,7 @@ void R_SetupShader_DeferredLight(const rtlight_t *rtlight) if (r_cg_permutation->fp_DeferredColor_Specular ) cgGLSetParameter3f(r_cg_permutation->fp_DeferredColor_Specular, lightcolorbase[0] * specularscale * range, lightcolorbase[1] * specularscale * range, lightcolorbase[2] * specularscale * range);CHECKCGERROR if (r_cg_permutation->fp_ShadowMap_TextureScale ) cgGLSetParameter2f(r_cg_permutation->fp_ShadowMap_TextureScale, r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]);CHECKCGERROR if (r_cg_permutation->fp_ShadowMap_Parameters ) cgGLSetParameter4f(r_cg_permutation->fp_ShadowMap_Parameters, r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]);CHECKCGERROR - if (r_cg_permutation->fp_SpecularPower ) cgGLSetParameter1f(r_cg_permutation->fp_SpecularPower, (r_shadow_gloss.integer == 2 ? r_shadow_gloss2exponent.value : r_shadow_glossexponent.value) * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f));CHECKCGERROR + if (r_cg_permutation->fp_SpecularPower ) cgGLSetParameter1f(r_cg_permutation->fp_SpecularPower, (r_shadow_gloss.integer == 2 ? r_shadow_gloss2exponent.value : r_shadow_glossexponent.value) * (r_shadow_glossexact.integer ? 0.25f : 1.0f));CHECKCGERROR if (r_cg_permutation->fp_ScreenToDepth ) cgGLSetParameter2f(r_cg_permutation->fp_ScreenToDepth, r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]);CHECKCGERROR if (r_cg_permutation->fp_PixelToScreenTexCoord ) cgGLSetParameter2f(r_cg_permutation->fp_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);CHECKCGERROR @@ -5337,9 +6299,6 @@ void R_SetupShader_DeferredLight(const rtlight_t *rtlight) if (r_cg_permutation->fp_Texture_ScreenDepth ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenDepth , r_shadow_prepassgeometrydepthtexture );CHECKCGERROR if (r_cg_permutation->fp_Texture_ScreenNormalMap ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenNormalMap, r_shadow_prepassgeometrynormalmaptexture );CHECKCGERROR if (r_cg_permutation->fp_Texture_Cube ) CG_BindTexture(r_cg_permutation->fp_Texture_Cube , rsurface.rtlight->currentcubemap );CHECKCGERROR - if (r_cg_permutation->fp_Texture_ShadowMapRect ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMapRect , r_shadow_shadowmaprectangletexture );CHECKCGERROR - if (r_shadow_usingshadowmapcube) - if (r_cg_permutation->fp_Texture_ShadowMapCube ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMapCube , r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]);CHECKCGERROR if (r_cg_permutation->fp_Texture_ShadowMap2D ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMap2D , r_shadow_shadowmap2dtexture );CHECKCGERROR if (r_cg_permutation->fp_Texture_CubeProjection ) CG_BindTexture(r_cg_permutation->fp_Texture_CubeProjection , r_shadow_shadowmapvsdcttexture );CHECKCGERROR #endif @@ -5540,7 +6499,7 @@ skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboole // check for DDS texture file first if (!r_loaddds || !(ddsbase = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s.dds", basename), textureflags, &ddshasalpha, ddsavgcolor, miplevel))) { - basepixels = loadimagepixelsbgra(name, complain, true, r_texture_convertsRGB_skin.integer, &miplevel); + basepixels = loadimagepixelsbgra(name, complain, true, r_texture_convertsRGB_skin.integer != 0, &miplevel); if (basepixels == NULL) return NULL; } @@ -5578,7 +6537,7 @@ skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboole { basepixels_width = image_width; basepixels_height = image_height; - skinframe->base = R_LoadTexture2D (r_main_texturepool, skinframe->basename, basepixels_width, basepixels_height, basepixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), miplevel, NULL); + skinframe->base = R_LoadTexture2D (r_main_texturepool, skinframe->basename, basepixels_width, basepixels_height, basepixels, TEXTYPE_BGRA, textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), miplevel, NULL); if (textureflags & TEXF_ALPHA) { for (j = 3;j < basepixels_width * basepixels_height * 4;j += 4) @@ -5600,23 +6559,23 @@ skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboole pixels[j+2] = 255; pixels[j+3] = basepixels[j+3]; } - skinframe->fog = R_LoadTexture2D (r_main_texturepool, va("%s_mask", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), miplevel, NULL); + skinframe->fog = R_LoadTexture2D (r_main_texturepool, va("%s_mask", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), miplevel, NULL); Mem_Free(pixels); } } R_SKINFRAME_LOAD_AVERAGE_COLORS(basepixels_width * basepixels_height, basepixels[4 * pix + comp]); //Con_Printf("Texture %s has average colors %f %f %f alpha %f\n", name, skinframe->avgcolor[0], skinframe->avgcolor[1], skinframe->avgcolor[2], skinframe->avgcolor[3]); if (r_savedds && qglGetCompressedTexImageARB && skinframe->base) - R_SaveTextureDDSFile(skinframe->base, va("dds/%s.dds", skinframe->basename), true); + R_SaveTextureDDSFile(skinframe->base, va("dds/%s.dds", skinframe->basename), true, skinframe->hasalpha); if (r_savedds && qglGetCompressedTexImageARB && skinframe->fog) - R_SaveTextureDDSFile(skinframe->fog, va("dds/%s_mask.dds", skinframe->basename), true); + R_SaveTextureDDSFile(skinframe->fog, va("dds/%s_mask.dds", skinframe->basename), true, true); } if (r_loaddds) { mymiplevel = savemiplevel; if (r_loadnormalmap) - skinframe->nmap = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_norm.dds", skinframe->basename), textureflags | TEXF_ALPHA, NULL, NULL, mymiplevel); + skinframe->nmap = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_norm.dds", skinframe->basename), (TEXF_ALPHA | textureflags) & (r_mipnormalmaps.integer ? ~0 : ~TEXF_MIPMAP), NULL, NULL, mymiplevel); skinframe->glow = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_glow.dds", skinframe->basename), textureflags, NULL, NULL, mymiplevel); if (r_loadgloss) skinframe->gloss = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_gloss.dds", skinframe->basename), textureflags, NULL, NULL, mymiplevel); @@ -5631,7 +6590,7 @@ skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboole mymiplevel = savemiplevel; if ((pixels = loadimagepixelsbgra(va("%s_norm", skinframe->basename), false, false, false, &mymiplevel)) != NULL) { - skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, (TEXF_ALPHA | skinframe->textureflags) & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL); + skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, (TEXF_ALPHA | textureflags) & (r_mipnormalmaps.integer ? ~0 : ~TEXF_MIPMAP) & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL); Mem_Free(pixels); pixels = NULL; } @@ -5639,7 +6598,7 @@ skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboole { pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4); Image_HeightmapToNormalmap_BGRA(bumppixels, pixels, image_width, image_height, false, r_shadow_bumpscale_bumpmap.value); - skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, (TEXF_ALPHA | skinframe->textureflags) & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL); + skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, (TEXF_ALPHA | textureflags) & (r_mipnormalmaps.integer ? ~0 : ~TEXF_MIPMAP) & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL); Mem_Free(pixels); Mem_Free(bumppixels); } @@ -5647,60 +6606,60 @@ skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboole { pixels = (unsigned char *)Mem_Alloc(tempmempool, basepixels_width * basepixels_height * 4); Image_HeightmapToNormalmap_BGRA(basepixels, pixels, basepixels_width, basepixels_height, false, r_shadow_bumpscale_basetexture.value); - skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), basepixels_width, basepixels_height, pixels, TEXTYPE_BGRA, (TEXF_ALPHA | skinframe->textureflags) & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL); + skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), basepixels_width, basepixels_height, pixels, TEXTYPE_BGRA, (TEXF_ALPHA | textureflags) & (r_mipnormalmaps.integer ? ~0 : ~TEXF_MIPMAP) & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL); Mem_Free(pixels); } if (r_savedds && qglGetCompressedTexImageARB && skinframe->nmap) - R_SaveTextureDDSFile(skinframe->nmap, va("dds/%s_norm.dds", skinframe->basename), true); + R_SaveTextureDDSFile(skinframe->nmap, va("dds/%s_norm.dds", skinframe->basename), true, true); } // _luma is supported only for tenebrae compatibility // _glow is the preferred name mymiplevel = savemiplevel; - if (skinframe->glow == NULL && ((pixels = loadimagepixelsbgra(va("%s_glow", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer, &mymiplevel)) || (pixels = loadimagepixelsbgra(va("%s_luma", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer, &mymiplevel)))) + if (skinframe->glow == NULL && ((pixels = loadimagepixelsbgra(va("%s_glow", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer != 0, &mymiplevel)) || (pixels = loadimagepixelsbgra(va("%s_luma", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer != 0, &mymiplevel)))) { - skinframe->glow = R_LoadTexture2D (r_main_texturepool, va("%s_glow", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_glow.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL); + skinframe->glow = R_LoadTexture2D (r_main_texturepool, va("%s_glow", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, textureflags & (gl_texturecompression_glow.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL); if (r_savedds && qglGetCompressedTexImageARB && skinframe->glow) - R_SaveTextureDDSFile(skinframe->glow, va("dds/%s_glow.dds", skinframe->basename), true); + R_SaveTextureDDSFile(skinframe->glow, va("dds/%s_glow.dds", skinframe->basename), true, true); Mem_Free(pixels);pixels = NULL; } mymiplevel = savemiplevel; - if (skinframe->gloss == NULL && r_loadgloss && (pixels = loadimagepixelsbgra(va("%s_gloss", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer, &mymiplevel))) + if (skinframe->gloss == NULL && r_loadgloss && (pixels = loadimagepixelsbgra(va("%s_gloss", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer != 0, &mymiplevel))) { - skinframe->gloss = R_LoadTexture2D (r_main_texturepool, va("%s_gloss", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_gloss.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL); + skinframe->gloss = R_LoadTexture2D (r_main_texturepool, va("%s_gloss", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, textureflags & (gl_texturecompression_gloss.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL); if (r_savedds && qglGetCompressedTexImageARB && skinframe->gloss) - R_SaveTextureDDSFile(skinframe->gloss, va("dds/%s_gloss.dds", skinframe->basename), true); + R_SaveTextureDDSFile(skinframe->gloss, va("dds/%s_gloss.dds", skinframe->basename), true, true); Mem_Free(pixels); pixels = NULL; } mymiplevel = savemiplevel; - if (skinframe->pants == NULL && (pixels = loadimagepixelsbgra(va("%s_pants", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer, &mymiplevel))) + if (skinframe->pants == NULL && (pixels = loadimagepixelsbgra(va("%s_pants", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer != 0, &mymiplevel))) { - skinframe->pants = R_LoadTexture2D (r_main_texturepool, va("%s_pants", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL); + skinframe->pants = R_LoadTexture2D (r_main_texturepool, va("%s_pants", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL); if (r_savedds && qglGetCompressedTexImageARB && skinframe->pants) - R_SaveTextureDDSFile(skinframe->pants, va("dds/%s_pants.dds", skinframe->basename), true); + R_SaveTextureDDSFile(skinframe->pants, va("dds/%s_pants.dds", skinframe->basename), true, false); Mem_Free(pixels); pixels = NULL; } mymiplevel = savemiplevel; - if (skinframe->shirt == NULL && (pixels = loadimagepixelsbgra(va("%s_shirt", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer, &mymiplevel))) + if (skinframe->shirt == NULL && (pixels = loadimagepixelsbgra(va("%s_shirt", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer != 0, &mymiplevel))) { - skinframe->shirt = R_LoadTexture2D (r_main_texturepool, va("%s_shirt", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL); + skinframe->shirt = R_LoadTexture2D (r_main_texturepool, va("%s_shirt", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL); if (r_savedds && qglGetCompressedTexImageARB && skinframe->shirt) - R_SaveTextureDDSFile(skinframe->shirt, va("dds/%s_shirt.dds", skinframe->basename), true); + R_SaveTextureDDSFile(skinframe->shirt, va("dds/%s_shirt.dds", skinframe->basename), true, false); Mem_Free(pixels); pixels = NULL; } mymiplevel = savemiplevel; - if (skinframe->reflect == NULL && (pixels = loadimagepixelsbgra(va("%s_reflect", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer, &mymiplevel))) + if (skinframe->reflect == NULL && (pixels = loadimagepixelsbgra(va("%s_reflect", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer != 0, &mymiplevel))) { - skinframe->reflect = R_LoadTexture2D (r_main_texturepool, va("%s_reflect", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_reflectmask.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL); + skinframe->reflect = R_LoadTexture2D (r_main_texturepool, va("%s_reflect", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, textureflags & (gl_texturecompression_reflectmask.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL); if (r_savedds && qglGetCompressedTexImageARB && skinframe->reflect) - R_SaveTextureDDSFile(skinframe->reflect, va("dds/%s_reflect.dds", skinframe->basename), true); + R_SaveTextureDDSFile(skinframe->reflect, va("dds/%s_reflect.dds", skinframe->basename), true, true); Mem_Free(pixels); pixels = NULL; } @@ -5750,10 +6709,10 @@ skinframe_t *R_SkinFrame_LoadInternalBGRA(const char *name, int textureflags, co temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8); temp2 = temp1 + width * height * 4; Image_HeightmapToNormalmap_BGRA(skindata, temp2, width, height, false, r_shadow_bumpscale_basetexture.value); - skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va("%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_BGRA, skinframe->textureflags | TEXF_ALPHA, -1, NULL); + skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va("%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_BGRA, (textureflags | TEXF_ALPHA) & (r_mipnormalmaps.integer ? ~0 : ~TEXF_MIPMAP), -1, NULL); Mem_Free(temp1); } - skinframe->base = skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_BGRA, skinframe->textureflags, -1, NULL); + skinframe->base = skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_BGRA, textureflags, -1, NULL); if (textureflags & TEXF_ALPHA) { for (i = 3;i < width * height * 4;i += 4) @@ -5770,7 +6729,7 @@ skinframe_t *R_SkinFrame_LoadInternalBGRA(const char *name, int textureflags, co memcpy(fogpixels, skindata, width * height * 4); for (i = 0;i < width * height * 4;i += 4) fogpixels[i] = fogpixels[i+1] = fogpixels[i+2] = 255; - skinframe->fog = R_LoadTexture2D(r_main_texturepool, va("%s_fog", skinframe->basename), width, height, fogpixels, TEXTYPE_BGRA, skinframe->textureflags, -1, NULL); + skinframe->fog = R_LoadTexture2D(r_main_texturepool, va("%s_fog", skinframe->basename), width, height, fogpixels, TEXTYPE_BGRA, textureflags, -1, NULL); Mem_Free(fogpixels); } } @@ -5815,7 +6774,7 @@ skinframe_t *R_SkinFrame_LoadInternalQuake(const char *name, int textureflags, i Con_Printf("loading quake skin \"%s\"\n", name); // we actually don't upload anything until the first use, because mdl skins frequently go unused, and are almost never used in both modes (colormapped and non-colormapped) - skinframe->qpixels = Mem_Alloc(r_main_mempool, width*height); + skinframe->qpixels = (unsigned char *)Mem_Alloc(r_main_mempool, width*height); memcpy(skinframe->qpixels, skindata, width*height); skinframe->qwidth = width; skinframe->qheight = height; @@ -5873,7 +6832,7 @@ static void R_SkinFrame_GenerateTexturesFromQPixels(skinframe_t *skinframe, qboo // use either a custom palette or the quake palette Image_Copy8bitBGRA(skindata, temp1, width * height, palette_bgra_complete); Image_HeightmapToNormalmap_BGRA(temp1, temp2, width, height, false, r_shadow_bumpscale_basetexture.value); - skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va("%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_BGRA, skinframe->textureflags | TEXF_ALPHA, -1, NULL); + skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va("%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_BGRA, (skinframe->textureflags | TEXF_ALPHA) & (r_mipnormalmaps.integer ? ~0 : ~TEXF_MIPMAP), -1, NULL); Mem_Free(temp1); } @@ -5935,7 +6894,7 @@ skinframe_t *R_SkinFrame_LoadInternal8bit(const char *name, int textureflags, co if (developer_loading.integer) Con_Printf("loading embedded 8bit image \"%s\"\n", name); - skinframe->base = skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, -1, palette); + skinframe->base = skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_PALETTE, textureflags, -1, palette); if (textureflags & TEXF_ALPHA) { for (i = 0;i < width * height;i++) @@ -5947,7 +6906,7 @@ skinframe_t *R_SkinFrame_LoadInternal8bit(const char *name, int textureflags, co } } if (r_loadfog && skinframe->hasalpha) - skinframe->fog = R_LoadTexture2D(r_main_texturepool, va("%s_fog", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, -1, alphapalette); + skinframe->fog = R_LoadTexture2D(r_main_texturepool, va("%s_fog", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, textureflags, -1, alphapalette); } R_SKINFRAME_LOAD_AVERAGE_COLORS(width * height, ((unsigned char *)palette)[skindata[pix]*4 + comp]); @@ -5987,7 +6946,7 @@ skinframe_t *R_SkinFrame_LoadMissing(void) //static char *suffix[6] = {"ft", "bk", "rt", "lf", "up", "dn"}; typedef struct suffixinfo_s { - char *suffix; + const char *suffix; qboolean flipx, flipy, flipdiagonal; } suffixinfo_t; @@ -6040,7 +6999,7 @@ rtexture_t *R_LoadCubemap(const char *basename) // generate an image name based on the base and and suffix dpsnprintf(name, sizeof(name), "%s%s", basename, suffix[j][i].suffix); // load it - if ((image_buffer = loadimagepixelsbgra(name, false, false, r_texture_convertsRGB_cubemap.integer, NULL))) + if ((image_buffer = loadimagepixelsbgra(name, false, false, r_texture_convertsRGB_cubemap.integer != 0, NULL))) { // an image loaded, make sure width and height are equal if (image_width == image_height && (!cubemappixels || image_width == cubemapsize)) @@ -6139,7 +7098,7 @@ void R_Main_ResizeViewCache(void) r_refdef.viewcache.maxentities = numentities; if (r_refdef.viewcache.entityvisible) Mem_Free(r_refdef.viewcache.entityvisible); - r_refdef.viewcache.entityvisible = Mem_Alloc(r_main_mempool, r_refdef.viewcache.maxentities); + r_refdef.viewcache.entityvisible = (unsigned char *)Mem_Alloc(r_main_mempool, r_refdef.viewcache.maxentities); } if (r_refdef.viewcache.world_numclusters != numclusters) { @@ -6147,21 +7106,21 @@ void R_Main_ResizeViewCache(void) r_refdef.viewcache.world_numclusterbytes = numclusterbytes; if (r_refdef.viewcache.world_pvsbits) Mem_Free(r_refdef.viewcache.world_pvsbits); - r_refdef.viewcache.world_pvsbits = Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numclusterbytes); + r_refdef.viewcache.world_pvsbits = (unsigned char *)Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numclusterbytes); } if (r_refdef.viewcache.world_numleafs != numleafs) { r_refdef.viewcache.world_numleafs = numleafs; if (r_refdef.viewcache.world_leafvisible) Mem_Free(r_refdef.viewcache.world_leafvisible); - r_refdef.viewcache.world_leafvisible = Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numleafs); + r_refdef.viewcache.world_leafvisible = (unsigned char *)Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numleafs); } if (r_refdef.viewcache.world_numsurfaces != numsurfaces) { r_refdef.viewcache.world_numsurfaces = numsurfaces; if (r_refdef.viewcache.world_surfacevisible) Mem_Free(r_refdef.viewcache.world_surfacevisible); - r_refdef.viewcache.world_surfacevisible = Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numsurfaces); + r_refdef.viewcache.world_surfacevisible = (unsigned char *)Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numsurfaces); } } @@ -6187,6 +7146,9 @@ void gl_main_start(void) { case RENDERPATH_GL20: case RENDERPATH_CGGL: + case RENDERPATH_D3D9: + case RENDERPATH_D3D10: + case RENDERPATH_D3D11: Cvar_SetValueQuick(&r_textureunits, vid.texunits); Cvar_SetValueQuick(&gl_combine, 1); Cvar_SetValueQuick(&r_glsl, 1); @@ -6250,6 +7212,12 @@ void gl_main_start(void) memset(r_cg_permutationhash, 0, sizeof(r_cg_permutationhash)); Mem_ExpandableArray_NewArray(&r_cg_permutationarray, r_main_mempool, sizeof(r_cg_permutation_t), 256); cgshaderstring = NULL; +#endif +#ifdef SUPPORTD3D + r_hlsl_permutation = NULL; + memset(r_hlsl_permutationhash, 0, sizeof(r_hlsl_permutationhash)); + Mem_ExpandableArray_NewArray(&r_hlsl_permutationarray, r_main_mempool, sizeof(r_hlsl_permutation_t), 256); + hlslshaderstring = NULL; #endif memset(&r_svbsp, 0, sizeof (r_svbsp)); @@ -6263,8 +7231,25 @@ void gl_main_shutdown(void) R_Main_FreeViewCache(); - if (r_maxqueries) - qglDeleteQueriesARB(r_maxqueries, r_queries); + switch(vid.renderpath) + { + case RENDERPATH_GL11: + case RENDERPATH_GL13: + case RENDERPATH_GL20: + case RENDERPATH_CGGL: + if (r_maxqueries) + qglDeleteQueriesARB(r_maxqueries, r_queries); + break; + case RENDERPATH_D3D9: + //Con_DPrintf("FIXME D3D9 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); + break; + case RENDERPATH_D3D10: + Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); + break; + case RENDERPATH_D3D11: + Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); + break; + } r_numqueries = 0; r_maxqueries = 0; @@ -6295,14 +7280,6 @@ void gl_main_shutdown(void) //r_texture_fogintensity = NULL; memset(&r_bloomstate, 0, sizeof(r_bloomstate)); memset(&r_waterstate, 0, sizeof(r_waterstate)); - r_glsl_permutation = NULL; - memset(r_glsl_permutationhash, 0, sizeof(r_glsl_permutationhash)); - glslshaderstring = NULL; -#ifdef SUPPORTCG - r_cg_permutation = NULL; - memset(r_cg_permutationhash, 0, sizeof(r_cg_permutationhash)); - cgshaderstring = NULL; -#endif R_GLSL_Restart_f(); } @@ -6379,6 +7356,7 @@ void GL_Main_Init(void) Cvar_RegisterVariable(&r_showdisabledepthtest); Cvar_RegisterVariable(&r_drawportals); Cvar_RegisterVariable(&r_drawentities); + Cvar_RegisterVariable(&r_draw2d); Cvar_RegisterVariable(&r_drawworld); Cvar_RegisterVariable(&r_cullentities_trace); Cvar_RegisterVariable(&r_cullentities_trace_samples); @@ -6391,6 +7369,8 @@ void GL_Main_Init(void) Cvar_RegisterVariable(&r_fullbrights); Cvar_RegisterVariable(&r_wateralpha); Cvar_RegisterVariable(&r_dynamic); + Cvar_RegisterVariable(&r_fakelight); + Cvar_RegisterVariable(&r_fakelight_intensity); Cvar_RegisterVariable(&r_fullbright); Cvar_RegisterVariable(&r_shadows); Cvar_RegisterVariable(&r_shadows_darken); @@ -6427,11 +7407,17 @@ void GL_Main_Init(void) Cvar_RegisterVariable(&r_glsl_postprocess_uservec2); Cvar_RegisterVariable(&r_glsl_postprocess_uservec3); Cvar_RegisterVariable(&r_glsl_postprocess_uservec4); + Cvar_RegisterVariable(&r_glsl_postprocess_uservec1_enable); + Cvar_RegisterVariable(&r_glsl_postprocess_uservec2_enable); + Cvar_RegisterVariable(&r_glsl_postprocess_uservec3_enable); + Cvar_RegisterVariable(&r_glsl_postprocess_uservec4_enable); + Cvar_RegisterVariable(&r_water); Cvar_RegisterVariable(&r_water_resolutionmultiplier); Cvar_RegisterVariable(&r_water_clippingplanebias); Cvar_RegisterVariable(&r_water_refractdistort); Cvar_RegisterVariable(&r_water_reflectdistort); + Cvar_RegisterVariable(&r_water_scissormode); Cvar_RegisterVariable(&r_lerpsprites); Cvar_RegisterVariable(&r_lerpmodels); Cvar_RegisterVariable(&r_lerplightstyles); @@ -6452,10 +7438,11 @@ void GL_Main_Init(void) Cvar_RegisterVariable(&gl_lightmaps); Cvar_RegisterVariable(&r_test); Cvar_RegisterVariable(&r_glsl_saturation); + Cvar_RegisterVariable(&r_glsl_saturation_redcompensate); Cvar_RegisterVariable(&r_framedatasize); if (gamemode == GAME_NEHAHRA || gamemode == GAME_TENEBRAE) Cvar_SetValue("r_fullbrights", 0); - R_RegisterModule("GL_Main", gl_main_start, gl_main_shutdown, gl_main_newmap); + R_RegisterModule("GL_Main", gl_main_start, gl_main_shutdown, gl_main_newmap, NULL, NULL); Cvar_RegisterVariable(&r_track_sprites); Cvar_RegisterVariable(&r_track_sprites_flags); @@ -6526,9 +7513,7 @@ void GL_Init (void) Con_DPrintf("\nQuakeC extensions for server and client: %s\nQuakeC extensions for menu: %s\n", vm_sv_extensions, vm_m_extensions ); // clear to black (loading plaque will be seen over this) - CHECKGLERROR - qglClearColor(0,0,0,1);CHECKGLERROR - qglClear(GL_COLOR_BUFFER_BIT);CHECKGLERROR + GL_Clear(GL_COLOR_BUFFER_BIT, NULL, 1.0f, 128); } int R_CullBox(const vec3_t mins, const vec3_t maxs) @@ -6728,30 +7713,68 @@ void R_AnimCache_ClearCache(void) void R_AnimCache_UpdateEntityMeshBuffers(entity_render_t *ent, int numvertices) { int i; + + // identical memory layout, so no need to allocate... + // this also provides the vertexposition structure to everything, e.g. + // depth masked rendering currently uses it even if having separate + // arrays + // NOTE: get rid of this optimization if changing it to e.g. 4f + ent->animcache_vertexposition = (r_vertexposition_t *)ent->animcache_vertex3f; + + // TODO: + // get rid of following uses of VERTEXPOSITION, change to the array: + // R_DrawTextureSurfaceList_Sky if skyrendermasked + // R_DrawSurface_TransparentCallback if r_transparentdepthmasking.integer + // R_DrawTextureSurfaceList_DepthOnly + // R_Q1BSP_DrawShadowMap + + switch(vid.renderpath) + { + case RENDERPATH_GL20: + case RENDERPATH_CGGL: + // need the meshbuffers if !gl_mesh_separatearrays.integer + if (gl_mesh_separatearrays.integer) + return; + break; + case RENDERPATH_D3D9: + case RENDERPATH_D3D10: + case RENDERPATH_D3D11: + // always need the meshbuffers + break; + case RENDERPATH_GL13: + case RENDERPATH_GL11: + // never need the meshbuffers + return; + } + if (!ent->animcache_vertexmesh && ent->animcache_normal3f) - ent->animcache_vertexmesh = R_FrameData_Alloc(sizeof(r_vertexmesh_t)*numvertices); + ent->animcache_vertexmesh = (r_vertexmesh_t *)R_FrameData_Alloc(sizeof(r_vertexmesh_t)*numvertices); + /* if (!ent->animcache_vertexposition) - ent->animcache_vertexposition = R_FrameData_Alloc(sizeof(r_vertexposition_t)*numvertices); + ent->animcache_vertexposition = (r_vertexposition_t *)R_FrameData_Alloc(sizeof(r_vertexposition_t)*numvertices); + */ if (ent->animcache_vertexposition) { + /* for (i = 0;i < numvertices;i++) - VectorCopy(ent->animcache_vertex3f + 3*i, ent->animcache_vertexposition[i].vertex3f); + memcpy(ent->animcache_vertexposition[i].vertex3f, ent->animcache_vertex3f + 3*i, sizeof(float[3])); + */ // TODO: upload vertex buffer? } if (ent->animcache_vertexmesh) { memcpy(ent->animcache_vertexmesh, ent->model->surfmesh.vertexmesh, sizeof(r_vertexmesh_t)*numvertices); for (i = 0;i < numvertices;i++) - VectorCopy(ent->animcache_vertex3f + 3*i, ent->animcache_vertexmesh[i].vertex3f); + memcpy(ent->animcache_vertexmesh[i].vertex3f, ent->animcache_vertex3f + 3*i, sizeof(float[3])); if (ent->animcache_svector3f) for (i = 0;i < numvertices;i++) - VectorCopy(ent->animcache_svector3f + 3*i, ent->animcache_vertexmesh[i].svector3f); + memcpy(ent->animcache_vertexmesh[i].svector3f, ent->animcache_svector3f + 3*i, sizeof(float[3])); if (ent->animcache_tvector3f) for (i = 0;i < numvertices;i++) - VectorCopy(ent->animcache_tvector3f + 3*i, ent->animcache_vertexmesh[i].tvector3f); + memcpy(ent->animcache_vertexmesh[i].tvector3f, ent->animcache_tvector3f + 3*i, sizeof(float[3])); if (ent->animcache_normal3f) for (i = 0;i < numvertices;i++) - VectorCopy(ent->animcache_normal3f + 3*i, ent->animcache_vertexmesh[i].normal3f); + memcpy(ent->animcache_vertexmesh[i].normal3f, ent->animcache_normal3f + 3*i, sizeof(float[3])); // TODO: upload vertex buffer? } } @@ -6774,11 +7797,11 @@ qboolean R_AnimCache_GetEntity(entity_render_t *ent, qboolean wantnormals, qbool { numvertices = model->surfmesh.num_vertices; if (wantnormals) - ent->animcache_normal3f = R_FrameData_Alloc(sizeof(float[3])*numvertices); + ent->animcache_normal3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices); if (wanttangents) { - ent->animcache_svector3f = R_FrameData_Alloc(sizeof(float[3])*numvertices); - ent->animcache_tvector3f = R_FrameData_Alloc(sizeof(float[3])*numvertices); + ent->animcache_svector3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices); + ent->animcache_tvector3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices); } if (!r_framedata_failed) { @@ -6795,13 +7818,13 @@ qboolean R_AnimCache_GetEntity(entity_render_t *ent, qboolean wantnormals, qbool return false; // get some memory for this entity and generate mesh data numvertices = model->surfmesh.num_vertices; - ent->animcache_vertex3f = R_FrameData_Alloc(sizeof(float[3])*numvertices); + ent->animcache_vertex3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices); if (wantnormals) - ent->animcache_normal3f = R_FrameData_Alloc(sizeof(float[3])*numvertices); + ent->animcache_normal3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices); if (wanttangents) { - ent->animcache_svector3f = R_FrameData_Alloc(sizeof(float[3])*numvertices); - ent->animcache_tvector3f = R_FrameData_Alloc(sizeof(float[3])*numvertices); + ent->animcache_svector3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices); + ent->animcache_tvector3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices); } if (!r_framedata_failed) { @@ -6822,6 +7845,9 @@ void R_AnimCache_CacheVisibleEntities(void) { case RENDERPATH_GL20: case RENDERPATH_CGGL: + case RENDERPATH_D3D9: + case RENDERPATH_D3D10: + case RENDERPATH_D3D11: break; case RENDERPATH_GL13: case RENDERPATH_GL11: @@ -6876,7 +7902,18 @@ static void R_View_UpdateEntityLighting (void) { vec3_t org; Matrix4x4_OriginFromMatrix(&ent->matrix, org); - r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, org, ent->modellight_ambient, ent->modellight_diffuse, tempdiffusenormal); + + // complete lightning for lit sprites + // todo: make a EF_ field so small ents could be lit purely by modellight and skipping real rtlight pass (like EF_NORTLIGHT)? + if (ent->model->type == mod_sprite && !(ent->model->data_textures[0].basematerialflags & MATERIALFLAG_FULLBRIGHT)) + { + if (ent->model->sprite.sprnum_type == SPR_OVERHEAD) // apply offset for overhead sprites + org[2] = org[2] + r_overheadsprites_pushback.value; + R_CompleteLightPoint(ent->modellight_ambient, ent->modellight_diffuse, ent->modellight_lightdir, org, LP_LIGHTMAP | LP_RTWORLD | LP_DYNLIGHT); + } + else + r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, org, ent->modellight_ambient, ent->modellight_diffuse, tempdiffusenormal); + if(ent->flags & RENDER_EQUALIZE) { // first fix up ambient lighting... @@ -6996,7 +8033,7 @@ static void R_View_UpdateEntityVisible (void) { ent = r_refdef.scene.entities[i]; if (!(ent->flags & renderimask)) - if (!R_CullBox(ent->mins, ent->maxs) || (ent->model->type == mod_sprite && (ent->model->sprite.sprnum_type == SPR_LABEL || ent->model->sprite.sprnum_type == SPR_LABEL_SCALE))) + if (!R_CullBox(ent->mins, ent->maxs) || (ent->model && ent->model->type == mod_sprite && (ent->model->sprite.sprnum_type == SPR_LABEL || ent->model->sprite.sprnum_type == SPR_LABEL_SCALE))) if ((ent->flags & (RENDER_NODEPTHTEST | RENDER_VIEWMODEL)) || r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs(r_refdef.scene.worldmodel, r_refdef.viewcache.world_leafvisible, ent->mins, ent->maxs)) r_refdef.viewcache.entityvisible[i] = true; } @@ -7114,11 +8151,38 @@ static void R_DrawModelsAddWaterPlanes(void) } } -static void R_View_SetFrustum(void) +static void R_View_SetFrustum(const int *scissor) { int i; - double slopex, slopey; - vec3_t forward, left, up, origin; + double fpx = +1, fnx = -1, fpy = +1, fny = -1; + vec3_t forward, left, up, origin, v; + + if(scissor) + { + // flipped x coordinates (because x points left here) + fpx = 1.0 - 2.0 * (scissor[0] - r_refdef.view.viewport.x) / (double) (r_refdef.view.viewport.width); + fnx = 1.0 - 2.0 * (scissor[0] + scissor[2] - r_refdef.view.viewport.x) / (double) (r_refdef.view.viewport.width); + + // 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: + // non-flipped y coordinates + fny = -1.0 + 2.0 * (vid.height - scissor[1] - scissor[3] - r_refdef.view.viewport.y) / (double) (r_refdef.view.viewport.height); + fpy = -1.0 + 2.0 * (vid.height - scissor[1] - r_refdef.view.viewport.y) / (double) (r_refdef.view.viewport.height); + break; + case RENDERPATH_GL11: + case RENDERPATH_GL13: + case RENDERPATH_GL20: + case RENDERPATH_CGGL: + // non-flipped y coordinates + fny = -1.0 + 2.0 * (scissor[1] - r_refdef.view.viewport.y) / (double) (r_refdef.view.viewport.height); + fpy = -1.0 + 2.0 * (scissor[1] + scissor[3] - r_refdef.view.viewport.y) / (double) (r_refdef.view.viewport.height); + break; + } + } // we can't trust r_refdef.view.forward and friends in reflected scenes Matrix4x4_ToVectors(&r_refdef.view.matrix, forward, left, up, origin); @@ -7187,13 +8251,29 @@ static void R_View_SetFrustum(void) if (r_refdef.view.useperspective) { - slopex = 1.0 / r_refdef.view.frustum_x; - slopey = 1.0 / r_refdef.view.frustum_y; - VectorMA(forward, -slopex, left, r_refdef.view.frustum[0].normal); - VectorMA(forward, slopex, left, r_refdef.view.frustum[1].normal); - VectorMA(forward, -slopey, up , r_refdef.view.frustum[2].normal); - VectorMA(forward, slopey, up , r_refdef.view.frustum[3].normal); - VectorCopy(forward, r_refdef.view.frustum[4].normal); + // calculate frustum corners, which are used to calculate deformed frustum planes for shadow caster culling + VectorMAMAM(1024, forward, fnx * 1024.0 * r_refdef.view.frustum_x, left, fny * 1024.0 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[0]); + VectorMAMAM(1024, forward, fpx * 1024.0 * r_refdef.view.frustum_x, left, fny * 1024.0 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[1]); + VectorMAMAM(1024, forward, fnx * 1024.0 * r_refdef.view.frustum_x, left, fpy * 1024.0 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[2]); + VectorMAMAM(1024, forward, fpx * 1024.0 * r_refdef.view.frustum_x, left, fpy * 1024.0 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[3]); + + // then the normals from the corners relative to origin + CrossProduct(r_refdef.view.frustumcorner[2], r_refdef.view.frustumcorner[0], r_refdef.view.frustum[0].normal); + CrossProduct(r_refdef.view.frustumcorner[1], r_refdef.view.frustumcorner[3], r_refdef.view.frustum[1].normal); + CrossProduct(r_refdef.view.frustumcorner[0], r_refdef.view.frustumcorner[1], r_refdef.view.frustum[2].normal); + CrossProduct(r_refdef.view.frustumcorner[3], r_refdef.view.frustumcorner[2], r_refdef.view.frustum[3].normal); + + // in a NORMAL view, forward cross left == up + // in a REFLECTED view, forward cross left == down + // so our cross products above need to be adjusted for a left handed coordinate system + CrossProduct(forward, left, v); + if(DotProduct(v, up) < 0) + { + VectorNegate(r_refdef.view.frustum[0].normal, r_refdef.view.frustum[0].normal); + VectorNegate(r_refdef.view.frustum[1].normal, r_refdef.view.frustum[1].normal); + VectorNegate(r_refdef.view.frustum[2].normal, r_refdef.view.frustum[2].normal); + VectorNegate(r_refdef.view.frustum[3].normal, r_refdef.view.frustum[3].normal); + } // Leaving those out was a mistake, those were in the old code, and they // fix a reproducable bug in this one: frustum culling got fucked up when viewmatrix was an identity matrix @@ -7203,11 +8283,14 @@ static void R_View_SetFrustum(void) VectorNormalize(r_refdef.view.frustum[2].normal); VectorNormalize(r_refdef.view.frustum[3].normal); - // calculate frustum corners, which are used to calculate deformed frustum planes for shadow caster culling - VectorMAMAMAM(1, r_refdef.view.origin, 1024, forward, -1024 * r_refdef.view.frustum_x, left, -1024 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[0]); - VectorMAMAMAM(1, r_refdef.view.origin, 1024, forward, 1024 * r_refdef.view.frustum_x, left, -1024 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[1]); - VectorMAMAMAM(1, r_refdef.view.origin, 1024, forward, -1024 * r_refdef.view.frustum_x, left, 1024 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[2]); - VectorMAMAMAM(1, r_refdef.view.origin, 1024, forward, 1024 * r_refdef.view.frustum_x, left, 1024 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[3]); + // make the corners absolute + VectorAdd(r_refdef.view.frustumcorner[0], r_refdef.view.origin, r_refdef.view.frustumcorner[0]); + VectorAdd(r_refdef.view.frustumcorner[1], r_refdef.view.origin, r_refdef.view.frustumcorner[1]); + VectorAdd(r_refdef.view.frustumcorner[2], r_refdef.view.origin, r_refdef.view.frustumcorner[2]); + VectorAdd(r_refdef.view.frustumcorner[3], r_refdef.view.origin, r_refdef.view.frustumcorner[3]); + + // one more normal + VectorCopy(forward, r_refdef.view.frustum[4].normal); r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[0].normal); r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[1].normal); @@ -7269,10 +8352,19 @@ static void R_View_SetFrustum(void) //PlaneClassify(&frustum[4]); } +void R_View_UpdateWithScissor(const int *myscissor) +{ + R_Main_ResizeViewCache(); + R_View_SetFrustum(myscissor); + R_View_WorldVisibility(r_refdef.view.useclipplane); + R_View_UpdateEntityVisible(); + R_View_UpdateEntityLighting(); +} + void R_View_Update(void) { R_Main_ResizeViewCache(); - R_View_SetFrustum(); + R_View_SetFrustum(NULL); R_View_WorldVisibility(r_refdef.view.useclipplane); R_View_UpdateEntityVisible(); R_View_UpdateEntityLighting(); @@ -7318,6 +8410,18 @@ void R_EntityMatrix(const matrix4x4_t *matrix) CHECKGLERROR switch(vid.renderpath) { + case RENDERPATH_D3D9: +#ifdef SUPPORTD3D + hlslVSSetParameter16f(D3DVSREGISTER_ModelViewProjectionMatrix, gl_modelviewprojection16f); + hlslVSSetParameter16f(D3DVSREGISTER_ModelViewMatrix, gl_modelview16f); +#endif + break; + case RENDERPATH_D3D10: + Con_DPrintf("FIXME D3D10 shader %s:%i\n", __FILE__, __LINE__); + break; + case RENDERPATH_D3D11: + Con_DPrintf("FIXME D3D11 shader %s:%i\n", __FILE__, __LINE__); + break; case RENDERPATH_GL20: if (r_glsl_permutation && r_glsl_permutation->loc_ModelViewProjectionMatrix >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewProjectionMatrix, 1, false, gl_modelviewprojection16f); if (r_glsl_permutation && r_glsl_permutation->loc_ModelViewMatrix >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewMatrix, 1, false, gl_modelview16f); @@ -7356,16 +8460,25 @@ void R_ResetViewRendering2D(void) GL_DepthMask(false); GL_DepthRange(0, 1); GL_DepthTest(false); + GL_DepthFunc(GL_LEQUAL); R_EntityMatrix(&identitymatrix); R_Mesh_ResetTextureState(); GL_PolygonOffset(0, 0); - qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR - qglDepthFunc(GL_LEQUAL);CHECKGLERROR - qglDisable(GL_STENCIL_TEST);CHECKGLERROR - qglStencilMask(~0);CHECKGLERROR - qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR - qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR - GL_CullFace(GL_FRONT); // quake is backwards, this culls back faces + R_SetStencil(false, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_ALWAYS, 128, 255); + switch(vid.renderpath) + { + case RENDERPATH_GL11: + case RENDERPATH_GL13: + case RENDERPATH_GL20: + case RENDERPATH_CGGL: + qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR + break; + case RENDERPATH_D3D9: + case RENDERPATH_D3D10: + case RENDERPATH_D3D11: + break; + } + GL_CullFace(GL_NONE); } void R_ResetViewRendering3D(void) @@ -7382,15 +8495,24 @@ void R_ResetViewRendering3D(void) GL_DepthMask(true); GL_DepthRange(0, 1); GL_DepthTest(true); + GL_DepthFunc(GL_LEQUAL); R_EntityMatrix(&identitymatrix); R_Mesh_ResetTextureState(); GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset); - qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR - qglDepthFunc(GL_LEQUAL);CHECKGLERROR - qglDisable(GL_STENCIL_TEST);CHECKGLERROR - qglStencilMask(~0);CHECKGLERROR - qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR - qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR + R_SetStencil(false, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_ALWAYS, 128, 255); + switch(vid.renderpath) + { + case RENDERPATH_GL11: + case RENDERPATH_GL13: + case RENDERPATH_GL20: + case RENDERPATH_CGGL: + qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR + break; + case RENDERPATH_D3D9: + case RENDERPATH_D3D10: + case RENDERPATH_D3D11: + break; + } GL_CullFace(r_refdef.view.cullface_back); } @@ -7426,6 +8548,9 @@ static void R_Water_StartFrame(void) { case RENDERPATH_GL20: case RENDERPATH_CGGL: + case RENDERPATH_D3D9: + case RENDERPATH_D3D10: + case RENDERPATH_D3D11: break; case RENDERPATH_GL13: case RENDERPATH_GL11: @@ -7498,7 +8623,7 @@ static void R_Water_StartFrame(void) r_waterstate.numwaterplanes = 0; } -void R_Water_AddWaterPlane(msurface_t *surface) +void R_Water_AddWaterPlane(msurface_t *surface, int entno) { int triangleindex, planeindex; const int *e; @@ -7506,12 +8631,8 @@ void R_Water_AddWaterPlane(msurface_t *surface) vec3_t normal; vec3_t center; mplane_t plane; - int cam_ent; r_waterstate_waterplane_t *p; texture_t *t = R_GetCurrentTexture(surface->texture); - cam_ent = t->camera_entity; - if(!(t->currentmaterialflags & MATERIALFLAG_CAMERA)) - cam_ent = 0; // just use the first triangle with a valid normal for any decisions VectorClear(normal); @@ -7558,6 +8679,18 @@ void R_Water_AddWaterPlane(msurface_t *surface) p->materialflags = 0; p->pvsvalid = false; p->camera_entity = t->camera_entity; + VectorCopy(surface->mins, p->mins); + VectorCopy(surface->maxs, p->maxs); + } + else + { + // merge mins/maxs + p->mins[0] = min(p->mins[0], surface->mins[0]); + p->mins[1] = min(p->mins[1], surface->mins[1]); + p->mins[2] = min(p->mins[2], surface->mins[2]); + p->maxs[0] = max(p->maxs[0], surface->maxs[0]); + p->maxs[1] = max(p->maxs[1], surface->maxs[1]); + p->maxs[2] = max(p->maxs[2], surface->maxs[2]); } // merge this surface's materialflags into the waterplane p->materialflags |= t->currentmaterialflags; @@ -7576,6 +8709,7 @@ void R_Water_AddWaterPlane(msurface_t *surface) static void R_Water_ProcessPlanes(void) { + int myscissor[4]; r_refdef_view_t originalview; r_refdef_view_t myview; int planeindex; @@ -7590,14 +8724,14 @@ static void R_Water_ProcessPlanes(void) if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION)) { if (!p->texture_refraction) - p->texture_refraction = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_refraction", planeindex), r_waterstate.texturewidth, r_waterstate.textureheight, NULL, TEXTYPE_COLORBUFFER, TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL); + p->texture_refraction = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_refraction", planeindex), r_waterstate.texturewidth, r_waterstate.textureheight, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL); if (!p->texture_refraction) goto error; } else if (p->materialflags & MATERIALFLAG_CAMERA) { if (!p->texture_camera) - p->texture_camera = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_camera", planeindex), r_waterstate.camerawidth, r_waterstate.cameraheight, NULL, TEXTYPE_COLORBUFFER, TEXF_FORCELINEAR, -1, NULL); + p->texture_camera = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_camera", planeindex), r_waterstate.camerawidth, r_waterstate.cameraheight, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_FORCELINEAR, -1, NULL); if (!p->texture_camera) goto error; } @@ -7605,7 +8739,7 @@ static void R_Water_ProcessPlanes(void) if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION)) { if (!p->texture_reflection) - p->texture_reflection = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_reflection", planeindex), r_waterstate.texturewidth, r_waterstate.textureheight, NULL, TEXTYPE_COLORBUFFER, TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL); + p->texture_reflection = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_reflection", planeindex), r_waterstate.texturewidth, r_waterstate.textureheight, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL); if (!p->texture_reflection) goto error; } @@ -7624,11 +8758,19 @@ static void R_Water_ProcessPlanes(void) if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION)) { r_refdef.view = myview; + if(r_water_scissormode.integer) + { + R_SetupView(true); + if(R_ScissorForBBox(p->mins, p->maxs, myscissor)) + continue; // FIXME the plane then still may get rendered but with broken texture, but it sure won't be visible + } + // render reflected scene and copy into texture Matrix4x4_Reflect(&r_refdef.view.matrix, p->plane.normal[0], p->plane.normal[1], p->plane.normal[2], p->plane.dist, -2); // update the r_refdef.view.origin because otherwise the sky renders at the wrong location (amongst other problems) Matrix4x4_OriginFromMatrix(&r_refdef.view.matrix, r_refdef.view.origin); r_refdef.view.clipplane = p->plane; + // reverse the cullface settings for this render r_refdef.view.cullface_front = GL_FRONT; r_refdef.view.cullface_back = GL_BACK; @@ -7643,7 +8785,12 @@ static void R_Water_ProcessPlanes(void) R_ResetViewRendering3D(); R_ClearScreen(r_refdef.fogenabled); - R_View_Update(); + if(r_water_scissormode.integer & 2) + R_View_UpdateWithScissor(myscissor); + else + R_View_Update(); + if(r_water_scissormode.integer & 1) + GL_Scissor(myscissor[0], myscissor[1], myscissor[2], myscissor[3]); R_RenderScene(); R_Mesh_CopyToTexture(p->texture_reflection, 0, 0, r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height); @@ -7653,8 +8800,15 @@ static void R_Water_ProcessPlanes(void) // (except that a clipping plane should be used to hide everything on one side of the water, and the viewer's weapon model should be omitted) if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION)) { + r_refdef.view = myview; + if(r_water_scissormode.integer) + { + R_SetupView(true); + if(R_ScissorForBBox(p->mins, p->maxs, myscissor)) + continue; // FIXME the plane then still may get rendered but with broken texture, but it sure won't be visible + } + r_waterstate.renderingrefraction = true; - r_refdef.view = myview; r_refdef.view.clipplane = p->plane; VectorNegate(r_refdef.view.clipplane.normal, r_refdef.view.clipplane.normal); @@ -7666,14 +8820,23 @@ static void R_Water_ProcessPlanes(void) r_waterstate.renderingrefraction = false; // we don't want to hide the player model from these ones CL_VM_TransformView(p->camera_entity - MAX_EDICTS, &r_refdef.view.matrix, &r_refdef.view.clipplane, visorigin); R_RenderView_UpdateViewVectors(); - r_refdef.scene.worldmodel->brush.FatPVS(r_refdef.scene.worldmodel, visorigin, 2, r_refdef.viewcache.world_pvsbits, (r_refdef.viewcache.world_numclusters+7)>>3, false); + if(r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.FatPVS) + { + r_refdef.view.usecustompvs = true; + r_refdef.scene.worldmodel->brush.FatPVS(r_refdef.scene.worldmodel, visorigin, 2, r_refdef.viewcache.world_pvsbits, (r_refdef.viewcache.world_numclusters+7)>>3, false); + } } PlaneClassify(&r_refdef.view.clipplane); R_ResetViewRendering3D(); R_ClearScreen(r_refdef.fogenabled); - R_View_Update(); + if(r_water_scissormode.integer & 2) + R_View_UpdateWithScissor(myscissor); + else + R_View_Update(); + if(r_water_scissormode.integer & 1) + GL_Scissor(myscissor[0], myscissor[1], myscissor[2], myscissor[3]); R_RenderScene(); R_Mesh_CopyToTexture(p->texture_refraction, 0, 0, r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height); @@ -7698,14 +8861,20 @@ static void R_Water_ProcessPlanes(void) CL_VM_TransformView(p->camera_entity - MAX_EDICTS, &r_refdef.view.matrix, &r_refdef.view.clipplane, visorigin); } + // note: all of the view is used for displaying... so + // there is no use in scissoring + // reverse the cullface settings for this render r_refdef.view.cullface_front = GL_FRONT; r_refdef.view.cullface_back = GL_BACK; // also reverse the view matrix Matrix4x4_ConcatScale3(&r_refdef.view.matrix, 1, 1, -1); // this serves to invert texcoords in the result, as the copied texture is mapped the wrong way round R_RenderView_UpdateViewVectors(); - if(p->camera_entity) + if(p->camera_entity && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.FatPVS) + { + r_refdef.view.usecustompvs = true; r_refdef.scene.worldmodel->brush.FatPVS(r_refdef.scene.worldmodel, visorigin, 2, r_refdef.viewcache.world_pvsbits, (r_refdef.viewcache.world_numclusters+7)>>3, false); + } // camera needs no clipplane r_refdef.view.useclipplane = false; @@ -7744,6 +8913,9 @@ void R_Bloom_StartFrame(void) { case RENDERPATH_GL20: case RENDERPATH_CGGL: + case RENDERPATH_D3D9: + case RENDERPATH_D3D10: + case RENDERPATH_D3D11: break; case RENDERPATH_GL13: case RENDERPATH_GL11: @@ -7796,7 +8968,7 @@ void R_Bloom_StartFrame(void) r_bloomstate.screentexturewidth = screentexturewidth; r_bloomstate.screentextureheight = screentextureheight; if (r_bloomstate.screentexturewidth && r_bloomstate.screentextureheight) - r_bloomstate.texture_screen = R_LoadTexture2D(r_main_texturepool, "screen", r_bloomstate.screentexturewidth, r_bloomstate.screentextureheight, NULL, TEXTYPE_COLORBUFFER, TEXF_FORCENEAREST | TEXF_CLAMP, -1, NULL); + r_bloomstate.texture_screen = R_LoadTexture2D(r_main_texturepool, "screen", r_bloomstate.screentexturewidth, r_bloomstate.screentextureheight, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_FORCENEAREST | TEXF_CLAMP, -1, NULL); } if (r_bloomstate.bloomtexturewidth != bloomtexturewidth || r_bloomstate.bloomtextureheight != bloomtextureheight) { @@ -7806,7 +8978,7 @@ void R_Bloom_StartFrame(void) r_bloomstate.bloomtexturewidth = bloomtexturewidth; r_bloomstate.bloomtextureheight = bloomtextureheight; if (r_bloomstate.bloomtexturewidth && r_bloomstate.bloomtextureheight) - r_bloomstate.texture_bloom = R_LoadTexture2D(r_main_texturepool, "bloom", r_bloomstate.bloomtexturewidth, r_bloomstate.bloomtextureheight, NULL, TEXTYPE_COLORBUFFER, TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL); + r_bloomstate.texture_bloom = R_LoadTexture2D(r_main_texturepool, "bloom", r_bloomstate.bloomtexturewidth, r_bloomstate.bloomtextureheight, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL); } // when doing a reduced render (HDR) we want to use a smaller area @@ -7838,6 +9010,29 @@ void R_Bloom_StartFrame(void) r_bloomstate.bloomtexcoord2f[6] = 0; r_bloomstate.bloomtexcoord2f[7] = 0; + switch(vid.renderpath) + { + case RENDERPATH_GL11: + case RENDERPATH_GL13: + case RENDERPATH_GL20: + case RENDERPATH_CGGL: + break; + case RENDERPATH_D3D9: + case RENDERPATH_D3D10: + case RENDERPATH_D3D11: + { + int i; + for (i = 0;i < 4;i++) + { + r_bloomstate.screentexcoord2f[i*2+0] += 0.5f / (float)r_bloomstate.screentexturewidth; + r_bloomstate.screentexcoord2f[i*2+1] += 0.5f / (float)r_bloomstate.screentextureheight; + r_bloomstate.bloomtexcoord2f[i*2+0] += 0.5f / (float)r_bloomstate.bloomtexturewidth; + r_bloomstate.bloomtexcoord2f[i*2+1] += 0.5f / (float)r_bloomstate.bloomtextureheight; + } + } + break; + } + if (r_hdr.integer || r_bloom.integer) { r_bloomstate.enabled = true; @@ -7856,7 +9051,21 @@ void R_Bloom_CopyBloomTexture(float colorscale) R_SetViewport(&r_bloomstate.viewport); GL_BlendFunc(GL_ONE, GL_ZERO); GL_Color(colorscale, colorscale, colorscale, 1); - R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, r_bloomstate.screentexcoord2f); + // D3D has upside down Y coords, the easiest way to flip this is to flip the screen vertices rather than the texcoords, so we just use a different array for that... + switch(vid.renderpath) + { + case RENDERPATH_GL11: + case RENDERPATH_GL13: + case RENDERPATH_GL20: + case RENDERPATH_CGGL: + R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, r_bloomstate.screentexcoord2f); + break; + case RENDERPATH_D3D9: + case RENDERPATH_D3D10: + case RENDERPATH_D3D11: + R_Mesh_PrepareVertices_Generic_Arrays(4, r_d3dscreenvertex3f, NULL, r_bloomstate.screentexcoord2f); + break; + } // TODO: do boxfilter scale-down in shader? R_SetupShader_Generic(r_bloomstate.texture_screen, NULL, GL_MODULATE, 1); R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0); @@ -7952,31 +9161,6 @@ void R_Bloom_MakeTexture(void) R_Mesh_CopyToTexture(r_bloomstate.texture_bloom, 0, 0, r_bloomstate.viewport.x, r_bloomstate.viewport.y, r_bloomstate.viewport.width, r_bloomstate.viewport.height); r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height; } - - // apply subtract last - // (just like it would be in a GLSL shader) - if (r_bloom_colorsubtract.value > 0 && vid.support.ext_blend_subtract) - { - GL_BlendFunc(GL_ONE, GL_ZERO); - GL_Color(1,1,1,1); - R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, r_bloomstate.bloomtexcoord2f); - R_SetupShader_Generic(r_bloomstate.texture_bloom, NULL, GL_MODULATE, 1); - R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0); - r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight; - - GL_BlendFunc(GL_ONE, GL_ONE); - qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT); - R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1); - GL_Color(r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 1); - R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, r_bloomstate.bloomtexcoord2f); - R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0); - r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight; - qglBlendEquationEXT(GL_FUNC_ADD_EXT); - - // copy the darkened bloom view to a texture - R_Mesh_CopyToTexture(r_bloomstate.texture_bloom, 0, 0, r_bloomstate.viewport.x, r_bloomstate.viewport.y, r_bloomstate.viewport.width, r_bloomstate.viewport.height); - r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height; - } } void R_HDR_RenderBloomTexture(void) @@ -8042,6 +9226,9 @@ static void R_BlendView(void) { case RENDERPATH_GL20: case RENDERPATH_CGGL: + case RENDERPATH_D3D9: + case RENDERPATH_D3D10: + case RENDERPATH_D3D11: permutation = (r_bloomstate.texture_bloom ? SHADERPERMUTATION_BLOOM : 0) | (r_refdef.viewblend[3] > 0 ? SHADERPERMUTATION_VIEWTINT : 0) @@ -8089,7 +9276,20 @@ static void R_BlendView(void) { GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); GL_Color(1, 1, 1, cl.motionbluralpha); - R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, r_bloomstate.screentexcoord2f); + switch(vid.renderpath) + { + case RENDERPATH_GL11: + case RENDERPATH_GL13: + case RENDERPATH_GL20: + case RENDERPATH_CGGL: + R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, r_bloomstate.screentexcoord2f); + break; + case RENDERPATH_D3D9: + case RENDERPATH_D3D10: + case RENDERPATH_D3D11: + R_Mesh_PrepareVertices_Generic_Arrays(4, r_d3dscreenvertex3f, NULL, r_bloomstate.screentexcoord2f); + break; + } R_SetupShader_Generic(r_bloomstate.texture_screen, NULL, GL_MODULATE, 1); R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0); r_refdef.stats.bloom_drawpixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height; @@ -8129,19 +9329,23 @@ static void R_BlendView(void) #define sscanf sscanf_s #endif memset(uservecs, 0, sizeof(uservecs)); - sscanf(r_glsl_postprocess_uservec1.string, "%f %f %f %f", &uservecs[0][0], &uservecs[0][1], &uservecs[0][2], &uservecs[0][3]); - sscanf(r_glsl_postprocess_uservec2.string, "%f %f %f %f", &uservecs[1][0], &uservecs[1][1], &uservecs[1][2], &uservecs[1][3]); - sscanf(r_glsl_postprocess_uservec3.string, "%f %f %f %f", &uservecs[2][0], &uservecs[2][1], &uservecs[2][2], &uservecs[2][3]); - sscanf(r_glsl_postprocess_uservec4.string, "%f %f %f %f", &uservecs[3][0], &uservecs[3][1], &uservecs[3][2], &uservecs[3][3]); + if (r_glsl_postprocess_uservec1_enable.integer) + sscanf(r_glsl_postprocess_uservec1.string, "%f %f %f %f", &uservecs[0][0], &uservecs[0][1], &uservecs[0][2], &uservecs[0][3]); + if (r_glsl_postprocess_uservec2_enable.integer) + sscanf(r_glsl_postprocess_uservec2.string, "%f %f %f %f", &uservecs[1][0], &uservecs[1][1], &uservecs[1][2], &uservecs[1][3]); + if (r_glsl_postprocess_uservec3_enable.integer) + sscanf(r_glsl_postprocess_uservec3.string, "%f %f %f %f", &uservecs[2][0], &uservecs[2][1], &uservecs[2][2], &uservecs[2][3]); + if (r_glsl_postprocess_uservec4_enable.integer) + sscanf(r_glsl_postprocess_uservec4.string, "%f %f %f %f", &uservecs[3][0], &uservecs[3][1], &uservecs[3][2], &uservecs[3][3]); R_ResetViewRendering2D(); GL_Color(1, 1, 1, 1); - R_Mesh_PrepareVertices_Mesh_Arrays(4, r_screenvertex3f, NULL, NULL, NULL, NULL, r_bloomstate.screentexcoord2f, r_bloomstate.bloomtexcoord2f); GL_BlendFunc(GL_ONE, GL_ZERO); switch(vid.renderpath) { case RENDERPATH_GL20: + R_Mesh_PrepareVertices_Mesh_Arrays(4, r_screenvertex3f, NULL, NULL, NULL, NULL, r_bloomstate.screentexcoord2f, r_bloomstate.bloomtexcoord2f); R_SetupShader_SetPermutationGLSL(SHADERMODE_POSTPROCESS, permutation); if (r_glsl_permutation->loc_Texture_First >= 0) R_Mesh_TexBind(GL20TU_FIRST , r_bloomstate.texture_screen); if (r_glsl_permutation->loc_Texture_Second >= 0) R_Mesh_TexBind(GL20TU_SECOND , r_bloomstate.texture_bloom ); @@ -8154,9 +9358,11 @@ static void R_BlendView(void) if (r_glsl_permutation->loc_UserVec4 >= 0) qglUniform4fARB(r_glsl_permutation->loc_UserVec4 , uservecs[3][0], uservecs[3][1], uservecs[3][2], uservecs[3][3]); if (r_glsl_permutation->loc_Saturation >= 0) qglUniform1fARB(r_glsl_permutation->loc_Saturation , r_glsl_saturation.value); if (r_glsl_permutation->loc_PixelToScreenTexCoord >= 0) qglUniform2fARB(r_glsl_permutation->loc_PixelToScreenTexCoord, 1.0f/vid.width, 1.0f/vid.height); + if (r_glsl_permutation->loc_BloomColorSubtract >= 0) qglUniform4fARB(r_glsl_permutation->loc_BloomColorSubtract , r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 0.0f); break; case RENDERPATH_CGGL: #ifdef SUPPORTCG + R_Mesh_PrepareVertices_Mesh_Arrays(4, r_screenvertex3f, NULL, NULL, NULL, NULL, r_bloomstate.screentexcoord2f, r_bloomstate.bloomtexcoord2f); R_SetupShader_SetPermutationCG(SHADERMODE_POSTPROCESS, permutation); if (r_cg_permutation->fp_Texture_First ) CG_BindTexture(r_cg_permutation->fp_Texture_First , r_bloomstate.texture_screen);CHECKCGERROR if (r_cg_permutation->fp_Texture_Second ) CG_BindTexture(r_cg_permutation->fp_Texture_Second , r_bloomstate.texture_bloom );CHECKCGERROR @@ -8169,8 +9375,34 @@ static void R_BlendView(void) if (r_cg_permutation->fp_UserVec4 ) cgGLSetParameter4f( r_cg_permutation->fp_UserVec4 , uservecs[3][0], uservecs[3][1], uservecs[3][2], uservecs[3][3]);CHECKCGERROR if (r_cg_permutation->fp_Saturation ) cgGLSetParameter1f( r_cg_permutation->fp_Saturation , r_glsl_saturation.value);CHECKCGERROR if (r_cg_permutation->fp_PixelToScreenTexCoord) cgGLSetParameter2f(r_cg_permutation->fp_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);CHECKCGERROR + if (r_cg_permutation->fp_BloomColorSubtract ) cgGLSetParameter4f(r_cg_permutation->fp_BloomColorSubtract , r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 0.0f); #endif break; + case RENDERPATH_D3D9: +#ifdef SUPPORTD3D + // D3D has upside down Y coords, the easiest way to flip this is to flip the screen vertices rather than the texcoords, so we just use a different array for that... + R_Mesh_PrepareVertices_Mesh_Arrays(4, r_d3dscreenvertex3f, NULL, NULL, NULL, NULL, r_bloomstate.screentexcoord2f, r_bloomstate.bloomtexcoord2f); + R_SetupShader_SetPermutationHLSL(SHADERMODE_POSTPROCESS, permutation); + R_Mesh_TexBind(GL20TU_FIRST , r_bloomstate.texture_screen); + R_Mesh_TexBind(GL20TU_SECOND , r_bloomstate.texture_bloom ); + R_Mesh_TexBind(GL20TU_GAMMARAMPS, r_texture_gammaramps ); + hlslPSSetParameter4f(D3DPSREGISTER_ViewTintColor , r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]); + hlslPSSetParameter2f(D3DPSREGISTER_PixelSize , 1.0/r_bloomstate.screentexturewidth, 1.0/r_bloomstate.screentextureheight); + hlslPSSetParameter4f(D3DPSREGISTER_UserVec1 , uservecs[0][0], uservecs[0][1], uservecs[0][2], uservecs[0][3]); + hlslPSSetParameter4f(D3DPSREGISTER_UserVec2 , uservecs[1][0], uservecs[1][1], uservecs[1][2], uservecs[1][3]); + hlslPSSetParameter4f(D3DPSREGISTER_UserVec3 , uservecs[2][0], uservecs[2][1], uservecs[2][2], uservecs[2][3]); + hlslPSSetParameter4f(D3DPSREGISTER_UserVec4 , uservecs[3][0], uservecs[3][1], uservecs[3][2], uservecs[3][3]); + hlslPSSetParameter1f(D3DPSREGISTER_Saturation , r_glsl_saturation.value); + hlslPSSetParameter2f(D3DPSREGISTER_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height); + hlslPSSetParameter4f(D3DPSREGISTER_BloomColorSubtract , r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 0.0f); +#endif + break; + case RENDERPATH_D3D10: + Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); + break; + case RENDERPATH_D3D11: + Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); + break; default: break; } @@ -8243,6 +9475,10 @@ void R_UpdateVariables(void) r_refdef.scene.rtdlight = (r_shadow_realtime_world.integer || r_shadow_realtime_dlight.integer) && !gl_flashblend.integer && r_dynamic.integer; r_refdef.scene.rtdlightshadows = r_refdef.scene.rtdlight && r_shadow_realtime_dlight_shadows.integer && vid.stencil; r_refdef.lightmapintensity = r_refdef.scene.rtworld ? r_shadow_realtime_world_lightmaps.value : 1; + if (FAKELIGHT_ENABLED) + { + r_refdef.lightmapintensity *= r_fakelight_intensity.value; + } if (r_showsurfaces.integer) { r_refdef.scene.rtworld = false; @@ -8317,6 +9553,9 @@ void R_UpdateVariables(void) { case RENDERPATH_GL20: case RENDERPATH_CGGL: + case RENDERPATH_D3D9: + case RENDERPATH_D3D10: + case RENDERPATH_D3D11: if(v_glslgamma.integer && !vid_gammatables_trivial) { if(!r_texture_gammaramps || vid_gammatables_serial != r_texture_gammaramps_serial) @@ -8343,7 +9582,7 @@ void R_UpdateVariables(void) } else { - r_texture_gammaramps = R_LoadTexture2D(r_main_texturepool, "gammaramps", RAMPWIDTH, 1, &rampbgr[0][0], TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_PERSISTENT | TEXF_ALLOWUPDATES, -1, NULL); + r_texture_gammaramps = R_LoadTexture2D(r_main_texturepool, "gammaramps", RAMPWIDTH, 1, &rampbgr[0][0], TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_PERSISTENT, -1, NULL); } } } @@ -8402,6 +9641,9 @@ void R_RenderView(void) r_textureframe++; // used only by R_GetCurrentTexture rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity + if(R_CompileShader_CheckStaticParms()) + R_GLSL_Restart_f(); + if (!r_drawentities.integer) r_refdef.scene.numentities = 0; @@ -8411,7 +9653,7 @@ void R_RenderView(void) if (r_refdef.view.isoverlay) { // TODO: FIXME: move this into its own backend function maybe? [2/5/2008 Andreas] - GL_Clear( GL_DEPTH_BUFFER_BIT ); + GL_Clear(GL_DEPTH_BUFFER_BIT, NULL, 1.0f, 0); R_TimeReport("depthclear"); r_refdef.view.showdebug = false; @@ -8478,6 +9720,7 @@ void R_RenderView(void) GL_Scissor(0, 0, vid.width, vid.height); GL_ScissorTest(false); + CHECKGLERROR } @@ -8729,6 +9972,27 @@ void R_RenderScene(void) R_TimeReport("coronas"); } +#if 0 + { + GL_DepthTest(false); + qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE); + GL_Color(1, 1, 1, 1); + qglBegin(GL_POLYGON); + qglVertex3f(r_refdef.view.frustumcorner[0][0], r_refdef.view.frustumcorner[0][1], r_refdef.view.frustumcorner[0][2]); + qglVertex3f(r_refdef.view.frustumcorner[1][0], r_refdef.view.frustumcorner[1][1], r_refdef.view.frustumcorner[1][2]); + qglVertex3f(r_refdef.view.frustumcorner[3][0], r_refdef.view.frustumcorner[3][1], r_refdef.view.frustumcorner[3][2]); + qglVertex3f(r_refdef.view.frustumcorner[2][0], r_refdef.view.frustumcorner[2][1], r_refdef.view.frustumcorner[2][2]); + qglEnd(); + qglBegin(GL_POLYGON); + qglVertex3f(r_refdef.view.frustumcorner[0][0] + 1000 * r_refdef.view.forward[0], r_refdef.view.frustumcorner[0][1] + 1000 * r_refdef.view.forward[1], r_refdef.view.frustumcorner[0][2] + 1000 * r_refdef.view.forward[2]); + qglVertex3f(r_refdef.view.frustumcorner[1][0] + 1000 * r_refdef.view.forward[0], r_refdef.view.frustumcorner[1][1] + 1000 * r_refdef.view.forward[1], r_refdef.view.frustumcorner[1][2] + 1000 * r_refdef.view.forward[2]); + qglVertex3f(r_refdef.view.frustumcorner[3][0] + 1000 * r_refdef.view.forward[0], r_refdef.view.frustumcorner[3][1] + 1000 * r_refdef.view.forward[1], r_refdef.view.frustumcorner[3][2] + 1000 * r_refdef.view.forward[2]); + qglVertex3f(r_refdef.view.frustumcorner[2][0] + 1000 * r_refdef.view.forward[0], r_refdef.view.frustumcorner[2][1] + 1000 * r_refdef.view.forward[1], r_refdef.view.frustumcorner[2][2] + 1000 * r_refdef.view.forward[2]); + qglEnd(); + qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL); + } +#endif + // don't let sound skip if going slow if (r_refdef.scene.extraupdate) S_ExtraUpdate (); @@ -8757,7 +10021,7 @@ void R_DrawBBoxMesh(vec3_t mins, vec3_t maxs, float cr, float cg, float cb, floa GL_DepthMask(false); GL_DepthRange(0, 1); GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset); - R_Mesh_ResetTextureState(); +// R_Mesh_ResetTextureState(); vertex3f[ 0] = mins[0];vertex3f[ 1] = mins[1];vertex3f[ 2] = mins[2]; // vertex3f[ 3] = maxs[0];vertex3f[ 4] = mins[1];vertex3f[ 5] = mins[2]; @@ -8927,7 +10191,6 @@ void R_DrawNoModel_TransparentCallback(const entity_render_t *ent, const rtlight GL_PolygonOffset(rsurface.basepolygonfactor, rsurface.basepolygonoffset); GL_DepthTest(!(rsurface.ent_flags & RENDER_NODEPTHTEST)); GL_CullFace((rsurface.ent_flags & RENDER_DOUBLESIDED) ? GL_NONE : r_refdef.view.cullface_back); - R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1); memcpy(color4f, nomodelcolor4f, sizeof(float[6*4])); for (i = 0, c = color4f;i < 6;i++, c += 4) { @@ -8947,7 +10210,8 @@ void R_DrawNoModel_TransparentCallback(const entity_render_t *ent, const rtlight c[2] = (c[2] * f1 + r_refdef.fogcolor[2] * f2); } } - R_Mesh_ResetTextureState(); +// R_Mesh_ResetTextureState(); + R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1); R_Mesh_PrepareVertices_Generic_Arrays(6, nomodelvertex3f, color4f, NULL); R_Mesh_Draw(0, 6, 0, 8, nomodelelement3i, NULL, 0, nomodelelement3s, NULL, 0); } @@ -9307,29 +10571,33 @@ texture_t *R_GetCurrentTexture(texture_t *t) r_qwskincache_size = cl.maxclients; if (r_qwskincache) Mem_Free(r_qwskincache); - r_qwskincache = Mem_Alloc(r_main_mempool, sizeof(*r_qwskincache) * r_qwskincache_size); + r_qwskincache = (r_qwskincache_t *)Mem_Alloc(r_main_mempool, sizeof(*r_qwskincache) * r_qwskincache_size); } if (strcmp(r_qwskincache[i].name, cl.scores[i].qw_skin)) R_LoadQWSkin(&r_qwskincache[i], cl.scores[i].qw_skin); t->currentskinframe = r_qwskincache[i].skinframe; if (t->currentskinframe == NULL) - t->currentskinframe = t->skinframes[(int)(t->skinframerate * (cl.time - rsurface.ent_shadertime)) % t->numskinframes]; + t->currentskinframe = t->skinframes[(unsigned int)(t->skinframerate * (cl.time - rsurface.ent_shadertime)) % t->numskinframes]; } else if (t->numskinframes >= 2) - t->currentskinframe = t->skinframes[(int)(t->skinframerate * (cl.time - rsurface.ent_shadertime)) % t->numskinframes]; + t->currentskinframe = t->skinframes[(unsigned int)(t->skinframerate * (cl.time - rsurface.ent_shadertime)) % t->numskinframes]; if (t->backgroundnumskinframes >= 2) - t->backgroundcurrentskinframe = t->backgroundskinframes[(int)(t->backgroundskinframerate * (cl.time - rsurface.ent_shadertime)) % t->backgroundnumskinframes]; + t->backgroundcurrentskinframe = t->backgroundskinframes[(unsigned int)(t->backgroundskinframerate * (cl.time - rsurface.ent_shadertime)) % t->backgroundnumskinframes]; t->currentmaterialflags = t->basematerialflags; t->currentalpha = rsurface.colormod[3]; if (t->basematerialflags & MATERIALFLAG_WATERALPHA && (model->brush.supportwateralpha || r_novis.integer)) t->currentalpha *= r_wateralpha.value; if(t->basematerialflags & MATERIALFLAG_WATERSHADER && r_waterstate.enabled && !r_refdef.view.isoverlay) - t->currentalpha *= t->r_water_wateralpha; + t->currentmaterialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW; // we apply wateralpha later if(!r_waterstate.enabled || r_refdef.view.isoverlay) t->currentmaterialflags &= ~(MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION | MATERIALFLAG_CAMERA); if (!(rsurface.ent_flags & RENDER_LIGHT)) t->currentmaterialflags |= MATERIALFLAG_FULLBRIGHT; + else if (FAKELIGHT_ENABLED) + { + // no modellight if using fakelight for the map + } else if (rsurface.modeltexcoordlightmap2f == NULL && !(t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)) { // pick a model lighting mode @@ -9479,6 +10747,9 @@ texture_t *R_GetCurrentTexture(texture_t *t) blendfunc1 = GL_ONE; blendfunc2 = GL_ZERO; } + // don't colormod evilblend textures + if(!R_BlendFuncAllowsColormod(blendfunc1, blendfunc2)) + VectorSet(t->lightmapcolor, 1, 1, 1); depthmask = !(t->currentmaterialflags & MATERIALFLAG_BLENDED); if (t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT) { @@ -9597,6 +10868,7 @@ void R_Mesh_ResizeArrays(int newvertices) void RSurf_ActiveWorldEntity(void) { + int newvertices; dp_model_t *model = r_refdef.scene.worldmodel; //if (rsurface.entity == r_refdef.scene.worldentity) // return; @@ -9607,8 +10879,9 @@ void RSurf_ActiveWorldEntity(void) rsurface.ent_qwskin = -1; rsurface.ent_shadertime = 0; rsurface.ent_flags = r_refdef.scene.worldentity->flags; - if (rsurface.array_size < model->surfmesh.num_vertices) - R_Mesh_ResizeArrays(model->surfmesh.num_vertices); + newvertices = max(model->surfmesh.num_vertices, model->surfmesh.num_triangles); + if (rsurface.array_size < newvertices) + R_Mesh_ResizeArrays(newvertices); rsurface.matrix = identitymatrix; rsurface.inversematrix = identitymatrix; rsurface.matrixscale = 1; @@ -9712,6 +10985,7 @@ void RSurf_ActiveWorldEntity(void) void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, qboolean wanttangents, qboolean prepass) { + int newvertices; dp_model_t *model = ent->model; //if (rsurface.entity == ent && (!model->surfmesh.isanimated || (!wantnormals && !wanttangents))) // return; @@ -9722,8 +10996,9 @@ void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, q rsurface.ent_qwskin = (ent->entitynumber <= cl.maxclients && ent->entitynumber >= 1 && cls.protocol == PROTOCOL_QUAKEWORLD && cl.scores[ent->entitynumber - 1].qw_skin[0] && !strcmp(ent->model->name, "progs/player.mdl")) ? (ent->entitynumber - 1) : -1; rsurface.ent_shadertime = ent->shadertime; rsurface.ent_flags = ent->flags; - if (rsurface.array_size < model->surfmesh.num_vertices) - R_Mesh_ResizeArrays(model->surfmesh.num_vertices); + newvertices = max(model->surfmesh.num_vertices, model->surfmesh.num_triangles); + if (rsurface.array_size < newvertices) + R_Mesh_ResizeArrays(newvertices); rsurface.matrix = ent->matrix; rsurface.inversematrix = ent->inversematrix; rsurface.matrixscale = Matrix4x4_ScaleFromMatrix(&rsurface.matrix); @@ -9893,7 +11168,7 @@ void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, q void RSurf_ActiveCustomEntity(const matrix4x4_t *matrix, const matrix4x4_t *inversematrix, int entflags, double shadertime, float r, float g, float b, float a, int numvertices, const float *vertex3f, const float *texcoord2f, const float *normal3f, const float *svector3f, const float *tvector3f, const float *color4f, int numtriangles, const int *element3i, const unsigned short *element3s, qboolean wantnormals, qboolean wanttangents) { - int i; + int newvertices; rsurface.entity = r_refdef.scene.worldentity; rsurface.skeleton = NULL; @@ -9903,8 +11178,9 @@ void RSurf_ActiveCustomEntity(const matrix4x4_t *matrix, const matrix4x4_t *inve rsurface.ent_flags = entflags; rsurface.modelnumvertices = numvertices; rsurface.modelnumtriangles = numtriangles; - if (rsurface.array_size < rsurface.modelnumvertices) - R_Mesh_ResizeArrays(rsurface.modelnumvertices); + newvertices = max(rsurface.modelnumvertices, rsurface.modelnumtriangles); + if (rsurface.array_size < newvertices) + R_Mesh_ResizeArrays(newvertices); rsurface.matrix = *matrix; rsurface.inversematrix = *inversematrix; rsurface.matrixscale = Matrix4x4_ScaleFromMatrix(&rsurface.matrix); @@ -10033,25 +11309,6 @@ void RSurf_ActiveCustomEntity(const matrix4x4_t *matrix, const matrix4x4_t *inve rsurface.modeltvector3f = rsurface.array_modeltvector3f; } } - - // now convert arrays into vertexmesh structs - for (i = 0;i < numvertices;i++) - { - VectorCopy(rsurface.modelvertex3f + 3*i, rsurface.array_modelvertexposition[i].vertex3f); - VectorCopy(rsurface.modelvertex3f + 3*i, rsurface.array_modelvertexmesh[i].vertex3f); - if (rsurface.modelsvector3f) - VectorCopy(rsurface.modelsvector3f + 3*i, rsurface.array_modelvertexmesh[i].svector3f); - if (rsurface.modeltvector3f) - VectorCopy(rsurface.modeltvector3f + 3*i, rsurface.array_modelvertexmesh[i].tvector3f); - if (rsurface.modelnormal3f) - VectorCopy(rsurface.modelnormal3f + 3*i, rsurface.array_modelvertexmesh[i].normal3f); - if (rsurface.modellightmapcolor4f) - Vector4Scale(rsurface.modellightmapcolor4f + 4*i, 255.0f, rsurface.array_modelvertexmesh[i].color4ub); - if (rsurface.modeltexcoordtexture2f) - Vector2Copy(rsurface.modeltexcoordtexture2f + 2*i, rsurface.array_modelvertexmesh[i].texcoordtexture2f); - if (rsurface.modeltexcoordlightmap2f) - Vector2Copy(rsurface.modeltexcoordlightmap2f + 2*i, rsurface.array_modelvertexmesh[i].texcoordlightmap2f); - } } float RSurf_FogPoint(const float *v) @@ -10108,7 +11365,6 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const int surfacefirstvertex; int surfaceendvertex; int surfacenumvertices; - int surfaceadjustvertex; int needsupdate; int i, j; qboolean gaps; @@ -10144,8 +11400,6 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const endvertex = surfaceendvertex; numtriangles += surfacenumtriangles; } - if (!numtriangles) - return; // we now know the vertex range used, and if there are any gaps in it rsurface.batchfirstvertex = firstvertex; @@ -10269,7 +11523,7 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const // when the model data has no vertex buffer (dynamic mesh), we need to // eliminate gaps - if (!rsurface.modelvertexmeshbuffer || (!gl_vbo.integer && !vid.forcevbo)) + if (!rsurface.modelvertexmeshbuffer) batchneed |= BATCHNEED_NOGAPS; // if needsupdate, we have to do a dynamic vertex batch for sure @@ -10438,7 +11692,6 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const surfacefirstvertex = texturesurfacelist[i]->num_firstvertex; surfacenumvertices = texturesurfacelist[i]->num_vertices; surfacefirsttriangle = texturesurfacelist[i]->num_firsttriangle; - surfaceadjustvertex = numvertices - surfacefirstvertex; surfacenumtriangles = texturesurfacelist[i]->num_triangles; // copy only the data requested if ((batchneed & BATCHNEED_VERTEXPOSITION) && rsurface.modelvertexposition) @@ -10589,6 +11842,7 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const VectorMAMAMAM(1, center, DotProduct(forward, v), newforward, DotProduct(right, v), newright, DotProduct(up, v), newup, rsurface.array_batchvertex3f + 3*(j+i)); } } + // if we get here, BATCHNEED_ARRAY_NORMAL and BATCHNEED_ARRAY_VECTOR are in batchneed, so no need to check Mod_BuildNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchnormal3f, true); Mod_BuildTextureVectorsFromNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchtexcoordtexture2f, rsurface.array_batchnormal3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchsvector3f, rsurface.array_batchtvector3f, true); rsurface.batchvertex3f = rsurface.array_batchvertex3f; @@ -10689,20 +11943,26 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const } } } - Mod_BuildNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchnormal3f, true); - Mod_BuildTextureVectorsFromNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchtexcoordtexture2f, rsurface.array_batchnormal3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchsvector3f, rsurface.array_batchtvector3f, true); rsurface.batchvertex3f = rsurface.array_batchvertex3f; rsurface.batchvertex3f_vertexbuffer = NULL; rsurface.batchvertex3f_bufferoffset = 0; - rsurface.batchsvector3f = rsurface.array_batchsvector3f; - rsurface.batchsvector3f_vertexbuffer = NULL; - rsurface.batchsvector3f_bufferoffset = 0; - rsurface.batchtvector3f = rsurface.array_batchtvector3f; - rsurface.batchtvector3f_vertexbuffer = NULL; - rsurface.batchtvector3f_bufferoffset = 0; - rsurface.batchnormal3f = rsurface.array_batchnormal3f; - rsurface.batchnormal3f_vertexbuffer = NULL; - rsurface.batchnormal3f_bufferoffset = 0; + if(batchneed & (BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR)) // otherwise these can stay NULL + { + Mod_BuildNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchnormal3f, true); + rsurface.batchnormal3f = rsurface.array_batchnormal3f; + rsurface.batchnormal3f_vertexbuffer = NULL; + rsurface.batchnormal3f_bufferoffset = 0; + } + if(batchneed & BATCHNEED_ARRAY_VECTOR) // otherwise these can stay NULL + { + Mod_BuildTextureVectorsFromNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchtexcoordtexture2f, rsurface.array_batchnormal3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchsvector3f, rsurface.array_batchtvector3f, true); + rsurface.batchsvector3f = rsurface.array_batchsvector3f; + rsurface.batchsvector3f_vertexbuffer = NULL; + rsurface.batchsvector3f_bufferoffset = 0; + rsurface.batchtvector3f = rsurface.array_batchtvector3f; + rsurface.batchtvector3f_vertexbuffer = NULL; + rsurface.batchtvector3f_bufferoffset = 0; + } break; case Q3DEFORM_NORMAL: // deform the normals to make reflections wavey @@ -10716,16 +11976,19 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const normal[2] = rsurface.batchnormal3f[j*3+2] + deform->parms[0] * noise4f(196 + vertex[0], vertex[1], vertex[2], r_refdef.scene.time * deform->parms[1]); VectorNormalize(normal); } - Mod_BuildTextureVectorsFromNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchtexcoordtexture2f, rsurface.array_batchnormal3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchsvector3f, rsurface.array_batchtvector3f, true); - rsurface.batchsvector3f = rsurface.array_batchsvector3f; - rsurface.batchsvector3f_vertexbuffer = NULL; - rsurface.batchsvector3f_bufferoffset = 0; - rsurface.batchtvector3f = rsurface.array_batchtvector3f; - rsurface.batchtvector3f_vertexbuffer = NULL; - rsurface.batchtvector3f_bufferoffset = 0; rsurface.batchnormal3f = rsurface.array_batchnormal3f; rsurface.batchnormal3f_vertexbuffer = NULL; rsurface.batchnormal3f_bufferoffset = 0; + if(batchneed & BATCHNEED_ARRAY_VECTOR) // otherwise these can stay NULL + { + Mod_BuildTextureVectorsFromNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchtexcoordtexture2f, rsurface.array_batchnormal3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchsvector3f, rsurface.array_batchtvector3f, true); + rsurface.batchsvector3f = rsurface.array_batchsvector3f; + rsurface.batchsvector3f_vertexbuffer = NULL; + rsurface.batchsvector3f_bufferoffset = 0; + rsurface.batchtvector3f = rsurface.array_batchtvector3f; + rsurface.batchtvector3f_vertexbuffer = NULL; + rsurface.batchtvector3f_bufferoffset = 0; + } break; case Q3DEFORM_WAVE: // deform vertex array to make wavey water and flags and such @@ -10748,20 +12011,24 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const } VectorMA(rsurface.batchvertex3f + 3*j, scale, rsurface.batchnormal3f + 3*j, rsurface.array_batchvertex3f + 3*j); } + // if we get here, BATCHNEED_ARRAY_NORMAL is in batchneed, so no need to check Mod_BuildNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchnormal3f, true); - Mod_BuildTextureVectorsFromNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchtexcoordtexture2f, rsurface.array_batchnormal3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchsvector3f, rsurface.array_batchtvector3f, true); rsurface.batchvertex3f = rsurface.array_batchvertex3f; rsurface.batchvertex3f_vertexbuffer = NULL; rsurface.batchvertex3f_bufferoffset = 0; - rsurface.batchsvector3f = rsurface.array_batchsvector3f; - rsurface.batchsvector3f_vertexbuffer = NULL; - rsurface.batchsvector3f_bufferoffset = 0; - rsurface.batchtvector3f = rsurface.array_batchtvector3f; - rsurface.batchtvector3f_vertexbuffer = NULL; - rsurface.batchtvector3f_bufferoffset = 0; rsurface.batchnormal3f = rsurface.array_batchnormal3f; rsurface.batchnormal3f_vertexbuffer = NULL; rsurface.batchnormal3f_bufferoffset = 0; + if(batchneed & BATCHNEED_ARRAY_VECTOR) // otherwise these can stay NULL + { + Mod_BuildTextureVectorsFromNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchtexcoordtexture2f, rsurface.array_batchnormal3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchsvector3f, rsurface.array_batchtvector3f, true); + rsurface.batchsvector3f = rsurface.array_batchsvector3f; + rsurface.batchsvector3f_vertexbuffer = NULL; + rsurface.batchsvector3f_bufferoffset = 0; + rsurface.batchtvector3f = rsurface.array_batchtvector3f; + rsurface.batchtvector3f_vertexbuffer = NULL; + rsurface.batchtvector3f_bufferoffset = 0; + } break; case Q3DEFORM_BULGE: // deform vertex array to make the surface have moving bulges @@ -10770,20 +12037,24 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const scale = sin(rsurface.batchtexcoordtexture2f[j*2+0] * deform->parms[0] + r_refdef.scene.time * deform->parms[2]) * deform->parms[1]; VectorMA(rsurface.batchvertex3f + 3*j, scale, rsurface.batchnormal3f + 3*j, rsurface.array_batchvertex3f + 3*j); } + // if we get here, BATCHNEED_ARRAY_NORMAL is in batchneed, so no need to check Mod_BuildNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchnormal3f, true); - Mod_BuildTextureVectorsFromNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchtexcoordtexture2f, rsurface.array_batchnormal3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchsvector3f, rsurface.array_batchtvector3f, true); rsurface.batchvertex3f = rsurface.array_batchvertex3f; rsurface.batchvertex3f_vertexbuffer = NULL; rsurface.batchvertex3f_bufferoffset = 0; - rsurface.batchsvector3f = rsurface.array_batchsvector3f; - rsurface.batchsvector3f_vertexbuffer = NULL; - rsurface.batchsvector3f_bufferoffset = 0; - rsurface.batchtvector3f = rsurface.array_batchtvector3f; - rsurface.batchtvector3f_vertexbuffer = NULL; - rsurface.batchtvector3f_bufferoffset = 0; rsurface.batchnormal3f = rsurface.array_batchnormal3f; rsurface.batchnormal3f_vertexbuffer = NULL; rsurface.batchnormal3f_bufferoffset = 0; + if(batchneed & BATCHNEED_ARRAY_VECTOR) // otherwise these can stay NULL + { + Mod_BuildTextureVectorsFromNormals(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.array_batchvertex3f, rsurface.batchtexcoordtexture2f, rsurface.array_batchnormal3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.array_batchsvector3f, rsurface.array_batchtvector3f, true); + rsurface.batchsvector3f = rsurface.array_batchsvector3f; + rsurface.batchsvector3f_vertexbuffer = NULL; + rsurface.batchsvector3f_bufferoffset = 0; + rsurface.batchtvector3f = rsurface.array_batchtvector3f; + rsurface.batchtvector3f_vertexbuffer = NULL; + rsurface.batchtvector3f_bufferoffset = 0; + } break; case Q3DEFORM_MOVE: // deform vertex array @@ -10919,28 +12190,37 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const void RSurf_DrawBatch(void) { - R_Mesh_Draw(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchfirsttriangle, rsurface.batchnumtriangles, rsurface.batchelement3i, rsurface.batchelement3i_indexbuffer, rsurface.batchelement3i_bufferoffset, rsurface.batchelement3s, rsurface.batchelement3s_indexbuffer, rsurface.batchelement3s_bufferoffset); -} - -static void RSurf_BindLightmapForBatch(void) -{ - switch(vid.renderpath) + // sometimes a zero triangle surface (usually a degenerate patch) makes it + // through the pipeline, killing it earlier in the pipeline would have + // per-surface overhead rather than per-batch overhead, so it's best to + // reject it here, before it hits glDraw. + if (rsurface.batchnumtriangles == 0) + return; +#if 0 + // batch debugging code + if (r_test.integer && rsurface.entity == r_refdef.scene.worldentity && rsurface.batchvertex3f == r_refdef.scene.worldentity->model->surfmesh.data_vertex3f) { - case RENDERPATH_CGGL: -#ifdef SUPPORTCG - if (r_cg_permutation->fp_Texture_Lightmap ) CG_BindTexture(r_cg_permutation->fp_Texture_Lightmap , rsurface.lightmaptexture );CHECKCGERROR - if (r_cg_permutation->fp_Texture_Deluxemap) CG_BindTexture(r_cg_permutation->fp_Texture_Deluxemap, rsurface.deluxemaptexture);CHECKCGERROR -#endif - break; - case RENDERPATH_GL20: - if (r_glsl_permutation->loc_Texture_Lightmap >= 0) R_Mesh_TexBind(GL20TU_LIGHTMAP , rsurface.lightmaptexture ); - if (r_glsl_permutation->loc_Texture_Deluxemap >= 0) R_Mesh_TexBind(GL20TU_DELUXEMAP, rsurface.deluxemaptexture); - break; - case RENDERPATH_GL13: - case RENDERPATH_GL11: - R_Mesh_TexBind(0, rsurface.lightmaptexture); - break; + int i; + int j; + int c; + const int *e; + e = rsurface.batchelement3i + rsurface.batchfirsttriangle*3; + for (i = 0;i < rsurface.batchnumtriangles*3;i++) + { + c = e[i]; + for (j = 0;j < rsurface.entity->model->num_surfaces;j++) + { + if (c >= rsurface.modelsurfaces[j].num_firstvertex && c < (rsurface.modelsurfaces[j].num_firstvertex + rsurface.modelsurfaces[j].num_vertices)) + { + if (rsurface.modelsurfaces[j].texture != rsurface.texture) + Sys_Error("RSurf_DrawBatch: index %i uses different texture (%s) than surface %i which it belongs to (which uses %s)\n", c, rsurface.texture->name, j, rsurface.modelsurfaces[j].texture->name); + break; + } + } + } } +#endif + R_Mesh_Draw(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchfirsttriangle, rsurface.batchnumtriangles, rsurface.batchelement3i, rsurface.batchelement3i_indexbuffer, rsurface.batchelement3i_bufferoffset, rsurface.batchelement3s, rsurface.batchelement3s_indexbuffer, rsurface.batchelement3s_bufferoffset); } static int RSurf_FindWaterPlaneForSurface(const msurface_t *surface) @@ -10972,30 +12252,6 @@ static int RSurf_FindWaterPlaneForSurface(const msurface_t *surface) return bestplaneindex; } -static void RSurf_BindReflectionForBatch(int planeindex) -{ - // pick the closest matching water plane and bind textures - r_waterstate_waterplane_t *bestp = planeindex >= 0 ? r_waterstate.waterplanes + planeindex : NULL; - switch(vid.renderpath) - { - case RENDERPATH_CGGL: -#ifdef SUPPORTCG - if (r_cg_permutation->fp_Texture_Refraction) {CG_BindTexture(r_cg_permutation->fp_Texture_Refraction, bestp ? bestp->texture_refraction : r_texture_black);CHECKCGERROR} - else if (r_cg_permutation->fp_Texture_First) {CG_BindTexture(r_cg_permutation->fp_Texture_First, bestp ? bestp->texture_camera : r_texture_black);CHECKCGERROR} - if (r_cg_permutation->fp_Texture_Reflection) {CG_BindTexture(r_cg_permutation->fp_Texture_Reflection, bestp ? bestp->texture_reflection : r_texture_black);CHECKCGERROR} -#endif - break; - case RENDERPATH_GL20: - if (r_glsl_permutation->loc_Texture_Refraction >= 0) R_Mesh_TexBind(GL20TU_REFRACTION, bestp ? bestp->texture_refraction : r_texture_black); - else if (r_glsl_permutation->loc_Texture_First >= 0) R_Mesh_TexBind(GL20TU_FIRST, bestp ? bestp->texture_camera : r_texture_black); - if (r_glsl_permutation->loc_Texture_Reflection >= 0) R_Mesh_TexBind(GL20TU_REFLECTION, bestp ? bestp->texture_reflection : r_texture_black); - break; - case RENDERPATH_GL13: - case RENDERPATH_GL11: - break; - } -} - static void RSurf_DrawBatch_GL11_MakeFullbrightLightmapColorArray(void) { int i; @@ -11111,7 +12367,7 @@ static void RSurf_DrawBatch_GL11_Lightmap(float r, float g, float b, float a, qb if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(r, g, b, a); R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, rsurface.passcolor4f_vertexbuffer, rsurface.passcolor4f_bufferoffset); GL_Color(r, g, b, a); - RSurf_BindLightmapForBatch(); + R_Mesh_TexBind(0, rsurface.lightmaptexture); RSurf_DrawBatch(); } @@ -11158,6 +12414,40 @@ static void RSurf_DrawBatch_GL11_ClampColor(void) } } +static void RSurf_DrawBatch_GL11_ApplyFakeLight(void) +{ + int i; + float f; + const float *v; + const float *n; + float *c; + //vec3_t eyedir; + + // fake shading + for (i = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3, n = rsurface.batchnormal3f + rsurface.batchfirstvertex * 3, c = rsurface.array_passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, v += 3, n += 3, c += 4) + { + f = -DotProduct(r_refdef.view.forward, n); + f = max(0, f); + f = f * 0.85 + 0.15; // work around so stuff won't get black + f *= r_refdef.lightmapintensity; + Vector4Set(c, f, f, f, 1); + } + + rsurface.passcolor4f = rsurface.array_passcolor4f; + rsurface.passcolor4f_vertexbuffer = 0; + rsurface.passcolor4f_bufferoffset = 0; +} + +static void RSurf_DrawBatch_GL11_FakeLight(float r, float g, float b, float a, qboolean applycolor, qboolean applyfog) +{ + RSurf_DrawBatch_GL11_ApplyFakeLight(); + if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(); + if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(r, g, b, a); + R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, rsurface.passcolor4f_vertexbuffer, rsurface.passcolor4f_bufferoffset); + GL_Color(r, g, b, a); + RSurf_DrawBatch(); +} + static void RSurf_DrawBatch_GL11_ApplyVertexShade(float *r, float *g, float *b, float *a, qboolean *applycolor) { int i; @@ -11274,7 +12564,7 @@ static void R_DrawTextureSurfaceList_Sky(int texturenumsurfaces, const msurface_ // just to make sure that braindead drivers don't draw // anything despite that colormask... GL_BlendFunc(GL_ZERO, GL_ONE); - RSurf_PrepareVerticesForBatch(BATCHNEED_VERTEXPOSITION, texturenumsurfaces, texturesurfacelist); + RSurf_PrepareVerticesForBatch(BATCHNEED_VERTEXPOSITION | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist); R_Mesh_PrepareVertices_Position(rsurface.batchnumvertices, rsurface.batchvertexposition, rsurface.batchvertexpositionbuffer); } else @@ -11282,7 +12572,7 @@ static void R_DrawTextureSurfaceList_Sky(int texturenumsurfaces, const msurface_ R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1); // fog sky GL_BlendFunc(GL_ONE, GL_ZERO); - RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX, texturenumsurfaces, texturesurfacelist); + RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist); GL_Color(r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2], 1); R_Mesh_PrepareVertices_Generic_Arrays(rsurface.batchnumvertices, rsurface.batchvertex3f, NULL, NULL); } @@ -11304,7 +12594,7 @@ static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, const msurface { // render screenspace normalmap to texture GL_DepthMask(true); - R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_DEFERREDGEOMETRY, texturenumsurfaces, texturesurfacelist); + R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_DEFERREDGEOMETRY, texturenumsurfaces, texturesurfacelist, NULL); RSurf_DrawBatch(); return; } @@ -11325,24 +12615,18 @@ static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, const msurface { // render water or distortion background GL_DepthMask(true); - R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BACKGROUND, end-start, texturesurfacelist + start); - RSurf_BindReflectionForBatch(startplaneindex); - if (rsurface.uselightmaptexture && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)) - RSurf_BindLightmapForBatch(); + R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BACKGROUND, end-start, texturesurfacelist + start, (void *)(r_waterstate.waterplanes + startplaneindex)); RSurf_DrawBatch(); // blend surface on top GL_DepthMask(false); - R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BASE, end-start, texturesurfacelist + start); + R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BASE, end-start, texturesurfacelist + start, NULL); RSurf_DrawBatch(); } else if ((rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION) && !r_waterstate.renderingscene) { // render surface with reflection texture as input GL_DepthMask(writedepth && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED)); - R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BASE, end-start, texturesurfacelist + start); - RSurf_BindReflectionForBatch(startplaneindex); - if (rsurface.uselightmaptexture && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)) - RSurf_BindLightmapForBatch(); + R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BASE, end-start, texturesurfacelist + start, (void *)(r_waterstate.waterplanes + startplaneindex)); RSurf_DrawBatch(); } } @@ -11351,9 +12635,7 @@ static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, const msurface // render surface batch normally GL_DepthMask(writedepth && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED)); - R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BASE, texturenumsurfaces, texturesurfacelist); - if (rsurface.uselightmaptexture && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)) - RSurf_BindLightmapForBatch(); + R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BASE, texturenumsurfaces, texturesurfacelist, NULL); RSurf_DrawBatch(); } @@ -11378,7 +12660,7 @@ static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, const msurface else { GL_AlphaTest(false); - qglDepthFunc(GL_EQUAL);CHECKGLERROR + GL_DepthFunc(GL_EQUAL); } } GL_DepthMask(layer->depthmask && writedepth); @@ -11416,6 +12698,8 @@ static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, const msurface R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset); if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) RSurf_DrawBatch_GL11_VertexShade(layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog); + else if (FAKELIGHT_ENABLED) + RSurf_DrawBatch_GL11_FakeLight(layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog); else if (rsurface.uselightmaptexture) RSurf_DrawBatch_GL11_Lightmap(layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog); else @@ -11456,10 +12740,9 @@ static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, const msurface Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type); } } - CHECKGLERROR if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) { - qglDepthFunc(GL_LEQUAL);CHECKGLERROR + GL_DepthFunc(GL_LEQUAL); GL_AlphaTest(false); } } @@ -11482,7 +12765,7 @@ static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, const msurface else { GL_AlphaTest(false); - qglDepthFunc(GL_EQUAL);CHECKGLERROR + GL_DepthFunc(GL_EQUAL); } } GL_DepthMask(layer->depthmask && writedepth); @@ -11502,6 +12785,8 @@ static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, const msurface R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordlightmap2f, rsurface.batchtexcoordlightmap2f_vertexbuffer, rsurface.batchtexcoordlightmap2f_bufferoffset); if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) RSurf_DrawBatch_GL11_VertexShade(1, 1, 1, 1, false, false); + else if (FAKELIGHT_ENABLED) + RSurf_DrawBatch_GL11_FakeLight(1, 1, 1, 1, false, false); else if (rsurface.uselightmaptexture) RSurf_DrawBatch_GL11_Lightmap(1, 1, 1, 1, false, false); else @@ -11558,10 +12843,9 @@ static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, const msurface Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type); } } - CHECKGLERROR if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) { - qglDepthFunc(GL_LEQUAL);CHECKGLERROR + GL_DepthFunc(GL_LEQUAL); GL_AlphaTest(false); } } @@ -11574,7 +12858,7 @@ static void R_DrawTextureSurfaceList_ShowSurfaces(int texturenumsurfaces, const float c[4]; GL_AlphaTest(false); - R_Mesh_ResetTextureState(); +// R_Mesh_ResetTextureState(); R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1); if(rsurface.texture && rsurface.texture->currentskinframe) @@ -11654,6 +12938,14 @@ static void R_DrawTextureSurfaceList_ShowSurfaces(int texturenumsurfaces, const RSurf_DrawBatch_GL11_ApplyVertexShade(&one, &one, &one, &one, &applycolor); r_refdef.lightmapintensity = 0; // we're in showsurfaces, after all } + else if (FAKELIGHT_ENABLED) + { + RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist); + + r_refdef.lightmapintensity = r_fakelight_intensity.value; + RSurf_DrawBatch_GL11_ApplyFakeLight(); + r_refdef.lightmapintensity = 0; // we're in showsurfaces, after all + } else { RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_VERTEXCOLOR | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist); @@ -11758,6 +13050,9 @@ static void R_DrawWorldTextureSurfaceList(int texturenumsurfaces, const msurface { case RENDERPATH_GL20: case RENDERPATH_CGGL: + case RENDERPATH_D3D9: + case RENDERPATH_D3D10: + case RENDERPATH_D3D11: R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist, writedepth, prepass); break; case RENDERPATH_GL13: @@ -11783,6 +13078,9 @@ static void R_DrawModelTextureSurfaceList(int texturenumsurfaces, const msurface { case RENDERPATH_GL20: case RENDERPATH_CGGL: + case RENDERPATH_D3D9: + case RENDERPATH_D3D10: + case RENDERPATH_D3D11: R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist, writedepth, prepass); break; case RENDERPATH_GL13: @@ -11817,6 +13115,9 @@ static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const { case RENDERPATH_GL20: case RENDERPATH_CGGL: + case RENDERPATH_D3D9: + case RENDERPATH_D3D10: + case RENDERPATH_D3D11: RSurf_ActiveModelEntity(ent, true, true, false); break; case RENDERPATH_GL13: @@ -11861,7 +13162,7 @@ static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const GL_BlendFunc(GL_ONE, GL_ZERO); GL_DepthMask(true); GL_AlphaTest(false); - R_Mesh_ResetTextureState(); +// R_Mesh_ResetTextureState(); R_SetupShader_DepthOrShadow(); } RSurf_SetupDepthAndCulling(); @@ -11879,19 +13180,35 @@ static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const surface = rsurface.modelsurfaces + surfacelist[i]; texture = surface->texture; rsurface.texture = R_GetCurrentTexture(texture); - rsurface.lightmaptexture = surface->lightmaptexture; - rsurface.deluxemaptexture = surface->deluxemaptexture; - rsurface.uselightmaptexture = surface->lightmaptexture != NULL; // scan ahead until we find a different texture endsurface = min(i + MAXBATCH_TRANSPARENTSURFACES, numsurfaces); texturenumsurfaces = 0; texturesurfacelist[texturenumsurfaces++] = surface; - for (;j < endsurface;j++) + if(FAKELIGHT_ENABLED) { - surface = rsurface.modelsurfaces + surfacelist[j]; - if (texture != surface->texture || rsurface.lightmaptexture != surface->lightmaptexture) - break; - texturesurfacelist[texturenumsurfaces++] = surface; + rsurface.lightmaptexture = NULL; + rsurface.deluxemaptexture = NULL; + rsurface.uselightmaptexture = false; + for (;j < endsurface;j++) + { + surface = rsurface.modelsurfaces + surfacelist[j]; + if (texture != surface->texture) + break; + texturesurfacelist[texturenumsurfaces++] = surface; + } + } + else + { + rsurface.lightmaptexture = surface->lightmaptexture; + rsurface.deluxemaptexture = surface->deluxemaptexture; + rsurface.uselightmaptexture = surface->lightmaptexture != NULL; + for (;j < endsurface;j++) + { + surface = rsurface.modelsurfaces + surfacelist[j]; + if (texture != surface->texture || rsurface.lightmaptexture != surface->lightmaptexture) + break; + texturesurfacelist[texturenumsurfaces++] = surface; + } } // render the range of surfaces if (ent == r_refdef.scene.worldentity) @@ -11985,9 +13302,6 @@ void R_QueueWorldSurfaceList(int numsurfaces, const msurface_t **surfacelist, in // use skin 1 instead) texture = surfacelist[i]->texture; rsurface.texture = R_GetCurrentTexture(texture); - rsurface.lightmaptexture = surfacelist[i]->lightmaptexture; - rsurface.deluxemaptexture = surfacelist[i]->deluxemaptexture; - rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL && !depthonly && !prepass; if (!(rsurface.texture->currentmaterialflags & flagsmask) || (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW)) { // if this texture is not the kind we want, skip ahead to the next one @@ -11995,9 +13309,24 @@ void R_QueueWorldSurfaceList(int numsurfaces, const msurface_t **surfacelist, in ; continue; } - // simply scan ahead until we find a different texture or lightmap state - for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.lightmaptexture == surfacelist[j]->lightmaptexture;j++) - ; + if(FAKELIGHT_ENABLED || depthonly || prepass) + { + rsurface.lightmaptexture = NULL; + rsurface.deluxemaptexture = NULL; + rsurface.uselightmaptexture = false; + // simply scan ahead until we find a different texture or lightmap state + for (;j < numsurfaces && texture == surfacelist[j]->texture;j++) + ; + } + else + { + rsurface.lightmaptexture = surfacelist[i]->lightmaptexture; + rsurface.deluxemaptexture = surfacelist[i]->deluxemaptexture; + rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL; + // simply scan ahead until we find a different texture or lightmap state + for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.lightmaptexture == surfacelist[j]->lightmaptexture;j++) + ; + } // render the range of surfaces R_ProcessWorldTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly, prepass); } @@ -12049,9 +13378,6 @@ void R_QueueModelSurfaceList(entity_render_t *ent, int numsurfaces, const msurfa // use skin 1 instead) texture = surfacelist[i]->texture; rsurface.texture = R_GetCurrentTexture(texture); - rsurface.lightmaptexture = surfacelist[i]->lightmaptexture; - rsurface.deluxemaptexture = surfacelist[i]->deluxemaptexture; - rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL && !depthonly && !prepass; if (!(rsurface.texture->currentmaterialflags & flagsmask) || (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW)) { // if this texture is not the kind we want, skip ahead to the next one @@ -12059,9 +13385,24 @@ void R_QueueModelSurfaceList(entity_render_t *ent, int numsurfaces, const msurfa ; continue; } - // simply scan ahead until we find a different texture or lightmap state - for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.lightmaptexture == surfacelist[j]->lightmaptexture;j++) - ; + if(FAKELIGHT_ENABLED || depthonly || prepass) + { + rsurface.lightmaptexture = NULL; + rsurface.deluxemaptexture = NULL; + rsurface.uselightmaptexture = false; + // simply scan ahead until we find a different texture or lightmap state + for (;j < numsurfaces && texture == surfacelist[j]->texture;j++) + ; + } + else + { + rsurface.lightmaptexture = surfacelist[i]->lightmaptexture; + rsurface.deluxemaptexture = surfacelist[i]->deluxemaptexture; + rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL; + // simply scan ahead until we find a different texture or lightmap state + for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.lightmaptexture == surfacelist[j]->lightmaptexture;j++) + ; + } // render the range of surfaces R_ProcessModelTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly, ent, prepass); } @@ -12102,7 +13443,7 @@ void R_DrawLoc_Callback(const entity_render_t *ent, const rtlight_t *rtlight, in GL_CullFace(GL_NONE); R_EntityMatrix(&identitymatrix); - R_Mesh_ResetTextureState(); +// R_Mesh_ResetTextureState(); i = surfacelist[0]; GL_Color(((i & 0x0007) >> 0) * (1.0f / 7.0f) * r_refdef.view.colorscale, @@ -12163,7 +13504,7 @@ static void R_DecalSystem_SpawnTriangle(decalsystem_t *decalsystem, const float qboolean useshortelements; decalsystem->maxdecals = max(16, decalsystem->maxdecals * 2); useshortelements = decalsystem->maxdecals * 3 <= 65536; - decalsystem->decals = Mem_Alloc(cls.levelmempool, decalsystem->maxdecals * (sizeof(tridecal_t) + sizeof(float[3][3]) + sizeof(float[3][2]) + sizeof(float[3][4]) + sizeof(int[3]) + (useshortelements ? sizeof(unsigned short[3]) : 0))); + decalsystem->decals = (tridecal_t *)Mem_Alloc(cls.levelmempool, decalsystem->maxdecals * (sizeof(tridecal_t) + sizeof(float[3][3]) + sizeof(float[3][2]) + sizeof(float[3][4]) + sizeof(int[3]) + (useshortelements ? sizeof(unsigned short[3]) : 0))); decalsystem->color4f = (float *)(decalsystem->decals + decalsystem->maxdecals); decalsystem->texcoord2f = (float *)(decalsystem->color4f + decalsystem->maxdecals*12); decalsystem->vertex3f = (float *)(decalsystem->texcoord2f + decalsystem->maxdecals*6); @@ -12342,7 +13683,7 @@ static void R_DecalSystem_SplatEntity(entity_render_t *ent, const vec3_t worldor return; } - if (!model->brush.data_nodes && !cl_decals_models.integer) + if (!model->brush.data_leafs && !cl_decals_models.integer) { if (decalsystem->model) R_DecalSystem_Reset(decalsystem); @@ -12693,9 +14034,9 @@ static void R_DrawModelDecals_Entity(entity_render_t *ent) if (decal->triangleindex >= 0 && decal->triangleindex < rsurface.modelnumtriangles) { e = rsurface.modelelement3i + 3*decal->triangleindex; - VectorCopy(rsurface.modelvertexposition[e[0]].vertex3f, v3f); - VectorCopy(rsurface.modelvertexposition[e[1]].vertex3f, v3f + 3); - VectorCopy(rsurface.modelvertexposition[e[2]].vertex3f, v3f + 6); + VectorCopy(rsurface.modelvertex3f + 3*e[0], v3f); + VectorCopy(rsurface.modelvertex3f + 3*e[1], v3f + 3); + VectorCopy(rsurface.modelvertex3f + 3*e[2], v3f + 6); } else { @@ -12727,7 +14068,7 @@ static void R_DrawModelDecals_Entity(entity_render_t *ent) // now render the decals all at once // (this assumes they all use one particle font texture!) RSurf_ActiveCustomEntity(&rsurface.matrix, &rsurface.inversematrix, rsurface.ent_flags, rsurface.ent_shadertime, 1, 1, 1, 1, numdecals*3, decalsystem->vertex3f, decalsystem->texcoord2f, NULL, NULL, NULL, decalsystem->color4f, numtris, decalsystem->element3i, decalsystem->element3s, false, false); - R_Mesh_ResetTextureState(); +// R_Mesh_ResetTextureState(); R_Mesh_PrepareVertices_Generic_Arrays(numtris * 3, decalsystem->vertex3f, decalsystem->color4f, decalsystem->texcoord2f); GL_DepthMask(false); GL_DepthRange(0, 1); @@ -12785,9 +14126,27 @@ void R_DrawDebugModel(void) dp_model_t *model = ent->model; vec3_t v; + switch(vid.renderpath) + { + case RENDERPATH_GL11: + case RENDERPATH_GL13: + case RENDERPATH_GL20: + case RENDERPATH_CGGL: + break; + case RENDERPATH_D3D9: + //Con_DPrintf("FIXME D3D9 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); + return; + case RENDERPATH_D3D10: + Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); + return; + case RENDERPATH_D3D11: + Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__); + return; + } + flagsmask = MATERIALFLAG_SKY | MATERIALFLAG_WALL; - R_Mesh_ResetTextureState(); +// R_Mesh_ResetTextureState(); R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1); GL_DepthRange(0, 1); GL_DepthTest(!r_showdisabledepthtest.integer); @@ -13070,6 +14429,9 @@ void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean wr { case RENDERPATH_GL20: case RENDERPATH_CGGL: + case RENDERPATH_D3D9: + case RENDERPATH_D3D10: + case RENDERPATH_D3D11: RSurf_ActiveModelEntity(ent, model->wantnormals, model->wanttangents, false); break; case RENDERPATH_GL13: @@ -13084,6 +14446,9 @@ void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean wr { case RENDERPATH_GL20: case RENDERPATH_CGGL: + case RENDERPATH_D3D9: + case RENDERPATH_D3D10: + case RENDERPATH_D3D11: RSurf_ActiveModelEntity(ent, true, true, false); break; case RENDERPATH_GL13: @@ -13204,7 +14569,6 @@ void R_DrawCustomSurface_Texture(texture_t *texture, const matrix4x4_t *texmatri const msurface_t *surfacelist = &surface; // fake enough texture and surface state to render this geometry - surface.texture = texture; surface.num_triangles = numtriangles; surface.num_firsttriangle = firsttriangle;