cvar_t r_glsl_offsetmapping = {CVAR_SAVE, "r_glsl_offsetmapping", "0", "offset mapping effect (also known as parallax mapping or virtual displacement mapping)"};
cvar_t r_glsl_offsetmapping_reliefmapping = {CVAR_SAVE, "r_glsl_offsetmapping_reliefmapping", "0", "relief mapping effect (higher quality)"};
cvar_t r_glsl_offsetmapping_scale = {CVAR_SAVE, "r_glsl_offsetmapping_scale", "0.04", "how deep the offset mapping effect is"};
-cvar_t r_glsl_water = {CVAR_SAVE, "r_glsl_water", "0", "whether to use reflections and refraction on water surfaces (note: r_wateralpha must be set below 1)"};
-cvar_t r_glsl_water_clippingplanebias = {CVAR_SAVE, "r_glsl_water_clippingplanebias", "1", "a rather technical setting which avoids black pixels around water edges"};
-cvar_t r_glsl_water_resolutionmultiplier = {CVAR_SAVE, "r_glsl_water_resolutionmultiplier", "0.5", "multiplier for screen resolution when rendering refracted/reflected scenes, 1 is full quality, lower values are faster"};
-cvar_t r_glsl_water_refractcolor_r = {CVAR_SAVE, "r_glsl_water_refractcolor_r", "1", "water color tint for refraction"};
-cvar_t r_glsl_water_refractcolor_g = {CVAR_SAVE, "r_glsl_water_refractcolor_g", "1", "water color tint for refraction"};
-cvar_t r_glsl_water_refractcolor_b = {CVAR_SAVE, "r_glsl_water_refractcolor_b", "1", "water color tint for refraction"};
-cvar_t r_glsl_water_reflectcolor_r = {CVAR_SAVE, "r_glsl_water_reflectcolor_r", "1", "water color tint for reflection"};
-cvar_t r_glsl_water_reflectcolor_g = {CVAR_SAVE, "r_glsl_water_reflectcolor_g", "1", "water color tint for reflection"};
-cvar_t r_glsl_water_reflectcolor_b = {CVAR_SAVE, "r_glsl_water_reflectcolor_b", "1", "water color tint for reflection"};
-cvar_t r_glsl_water_refractdistort = {CVAR_SAVE, "r_glsl_water_refractdistort", "0.01", "how much water refractions shimmer"};
-cvar_t r_glsl_water_reflectdistort = {CVAR_SAVE, "r_glsl_water_reflectdistort", "0.01", "how much water reflections shimmer"};
cvar_t r_glsl_deluxemapping = {CVAR_SAVE, "r_glsl_deluxemapping", "1", "use per pixel lighting on deluxemap-compiled q3bsp maps (or a value of 2 forces deluxemap shading even without deluxemaps)"};
cvar_t r_glsl_contrastboost = {CVAR_SAVE, "r_glsl_contrastboost", "1", "by how much to multiply the contrast in dark areas (1 is no change)"};
+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_lerpsprites = {CVAR_SAVE, "r_lerpsprites", "1", "enables animation smoothing on sprites (requires r_lerpmodels 1)"};
cvar_t r_lerpmodels = {CVAR_SAVE, "r_lerpmodels", "1", "enables animation smoothing on models"};
cvar_t r_waterscroll = {CVAR_SAVE, "r_waterscroll", "1", "makes water scroll around, value controls how much"};
cvar_t r_test = {0, "r_test", "0", "internal development use only, leave it alone (usually does nothing anyway)"};
cvar_t r_batchmode = {0, "r_batchmode", "1", "selects method of rendering multiple surfaces with one driver call (values are 0, 1, 2, etc...)"};
+cvar_t r_track_sprites = {CVAR_SAVE, "r_track_sprites", "1", "track SPR_LABEL* sprites by putting them as indicator at the screen border to rotate to"};
+cvar_t r_track_sprites_flags = {CVAR_SAVE, "r_track_sprites_flags", "1", "1: Rotate sprites accodringly, 2: Make it a continuous rotation"};
+cvar_t r_track_sprites_scalew = {CVAR_SAVE, "r_track_sprites_scalew", "1", "width scaling of tracked sprites"};
+cvar_t r_track_sprites_scaleh = {CVAR_SAVE, "r_track_sprites_scaleh", "1", "height scaling of tracked sprites"};
extern qboolean v_flipped_state;
rtexture_t *r_texture_fogattenuation;
//rtexture_t *r_texture_fogintensity;
-// information about each possible shader permutation
-r_glsl_permutation_t r_glsl_permutations[SHADERPERMUTATION_MAX];
-// currently selected permutation
-r_glsl_permutation_t *r_glsl_permutation;
-
char r_qwskincache[MAX_SCOREBOARD][MAX_QPATH];
skinframe_t *r_qwskincache_skinframe[MAX_SCOREBOARD];
"varying vec3 VectorT; // direction of T texcoord (sometimes crudely called binormal)\n"
"varying vec3 VectorR; // direction of R texcoord (surface normal)\n"
"\n"
-"//#ifdef USEWATER\n"
+"//#ifdef MODE_WATER\n"
"varying vec4 ModelViewProjectionPosition;\n"
"//#else\n"
-"//# ifdef USEREFLECTION\n"
+"//# ifdef MODE_REFRACTION\n"
+"//varying vec4 ModelViewProjectionPosition;\n"
+"//# else\n"
+"//# ifdef USEREFLECTION\n"
"//varying vec4 ModelViewProjectionPosition;\n"
+"//# endif\n"
"//# endif\n"
"//#endif\n"
"\n"
" VectorR = gl_MultiTexCoord3.xyz;\n"
"#endif\n"
"\n"
-"//#if defined(USEWATER) || defined(USEREFLECTION)\n"
+"//#if defined(MODE_WATER) || defined(MODE_REFRACTION) || defined(USEREFLECTION)\n"
"// ModelViewProjectionPosition = gl_Vertex * gl_ModelViewProjectionMatrix;\n"
"// //ModelViewProjectionPosition_svector = (gl_Vertex + vec4(gl_MultiTexCoord1.xyz, 0)) * gl_ModelViewProjectionMatrix - ModelViewProjectionPosition;\n"
"// //ModelViewProjectionPosition_tvector = (gl_Vertex + vec4(gl_MultiTexCoord2.xyz, 0)) * gl_ModelViewProjectionMatrix - ModelViewProjectionPosition;\n"
" // rendering\n"
" gl_Position = ftransform();\n"
"\n"
-"#ifdef USEWATER\n"
+"#ifdef MODE_WATER\n"
" ModelViewProjectionPosition = gl_Position;\n"
-"#else\n"
-"# ifdef USEREFLECTION\n"
+"#endif\n"
+"#ifdef MODE_REFRACTION\n"
+" ModelViewProjectionPosition = gl_Position;\n"
+"#endif\n"
+"#ifdef USEREFLECTION\n"
" ModelViewProjectionPosition = gl_Position;\n"
-"# endif\n"
"#endif\n"
"}\n"
"\n"
"uniform myhvec3 Color_Shirt;\n"
"uniform myhvec3 FogColor;\n"
"\n"
-"//#ifdef USEWATER\n"
+"//#ifdef MODE_WATER\n"
"uniform vec4 DistortScaleRefractReflect;\n"
"uniform vec4 ScreenScaleRefractReflect;\n"
"uniform vec4 ScreenCenterRefractReflect;\n"
-"uniform myhvec3 RefractColor;\n"
-"uniform myhvec3 ReflectColor;\n"
+"uniform myhvec4 RefractColor;\n"
+"uniform myhvec4 ReflectColor;\n"
+"uniform myhalf ReflectFactor;\n"
+"uniform myhalf ReflectOffset;\n"
"//#else\n"
-"//# ifdef USEREFLECTION\n"
+"//# ifdef MODE_REFRACTION\n"
"//uniform vec4 DistortScaleRefractReflect;\n"
"//uniform vec4 ScreenScaleRefractReflect;\n"
"//uniform vec4 ScreenCenterRefractReflect;\n"
-"//uniform myhvec3 ReflectColor;\n"
+"//uniform myhvec4 RefractColor;\n"
+"//# ifdef USEREFLECTION\n"
+"//uniform myhvec4 ReflectColor;\n"
+"//# endif\n"
+"//# else\n"
+"//# ifdef USEREFLECTION\n"
+"//uniform vec4 DistortScaleRefractReflect;\n"
+"//uniform vec4 ScreenScaleRefractReflect;\n"
+"//uniform vec4 ScreenCenterRefractReflect;\n"
+"//uniform myhvec4 ReflectColor;\n"
+"//# endif\n"
"//# endif\n"
"//#endif\n"
"\n"
" return TexCoord;\n"
"#endif\n"
"}\n"
+"#endif // USEOFFSETMAPPING\n"
+"\n"
+"#ifdef MODE_WATER\n"
+"\n"
+"// water pass\n"
+"void main(void)\n"
+"{\n"
+"#ifdef USEOFFSETMAPPING\n"
+" // apply offsetmapping\n"
+" vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
+"#define TexCoord TexCoordOffset\n"
"#endif\n"
"\n"
+" vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
+" //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
+" vec4 ScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect + vec2(normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5))).xyxy * DistortScaleRefractReflect;\n"
+" float Fresnel = pow(min(1.0, 1.0 - float(normalize(EyeVector).z)), 5.0) * ReflectFactor + ReflectOffset;\n"
+" gl_FragColor = mix(texture2D(Texture_Refraction, ScreenTexCoord.xy) * RefractColor, texture2D(Texture_Reflection, ScreenTexCoord.zw) * ReflectColor, Fresnel);\n"
+"}\n"
+"\n"
+"#else // MODE_WATER\n"
+"#ifdef MODE_REFRACTION\n"
+"\n"
+"// refraction pass\n"
+"void main(void)\n"
+"{\n"
+"#ifdef USEOFFSETMAPPING\n"
+" // apply offsetmapping\n"
+" vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
+"#define TexCoord TexCoordOffset\n"
+"#endif\n"
+"\n"
+" vec2 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect.xy * (1.0 / ModelViewProjectionPosition.w);\n"
+" //vec2 ScreenTexCoord = (ModelViewProjectionPosition.xy + normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5)).xy * DistortScaleRefractReflect.xy * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n"
+" vec2 ScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy + vec2(normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5))).xy * DistortScaleRefractReflect.xy;\n"
+" gl_FragColor = texture2D(Texture_Refraction, ScreenTexCoord) * RefractColor;\n"
+"}\n"
+"\n"
+"#else // MODE_REFRACTION\n"
"void main(void)\n"
"{\n"
"#ifdef USEOFFSETMAPPING\n"
"\n"
"#ifdef MODE_LIGHTDIRECTION\n"
" // directional model lighting\n"
-"\n"
+"# ifdef USESPECULAR\n"
" // get the surface normal and light normal\n"
" myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
" myhvec3 diffusenormal = myhvec3(LightVector);\n"
"\n"
" // calculate directional shading\n"
" color.rgb *= AmbientColor + DiffuseColor * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0));\n"
-"# ifdef USESPECULAR\n"
" myhvec3 specularnormal = normalize(diffusenormal + myhvec3(normalize(EyeVector)));\n"
" color.rgb += myhvec3(texture2D(Texture_Gloss, TexCoord)) * SpecularColor * pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
+"# else\n"
+"# ifdef USEDIFFUSE\n"
+" // get the surface normal and light normal\n"
+" myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
+" myhvec3 diffusenormal = myhvec3(LightVector);\n"
+"\n"
+" // calculate directional shading\n"
+" color.rgb *= AmbientColor + DiffuseColor * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0));\n"
+"# else\n"
+" color.rgb *= AmbientColor;\n"
+"# endif\n"
"# endif\n"
+"\n"
" color *= myhvec4(gl_Color);\n"
"#endif // MODE_LIGHTDIRECTION\n"
"\n"
"\n"
"\n"
"\n"
-"#ifdef MODE_LIGHTSOURCE\n"
-"# ifdef USEWATER\n"
-" color.rgb *= color.a;\n"
-"# endif\n"
-"#else\n"
-"# ifdef USEWATER\n"
-" vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
-" //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
-" vec4 ScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect + vec3(normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5))).xyxy * DistortScaleRefractReflect;\n"
-" myhalf Fresnel = myhalf(pow(min(1.0, 1.0 - float(normalize(EyeVector).z)), 2.0));\n"
-" color.rgb = mix(mix(myhvec3(texture2D(Texture_Refraction, ScreenTexCoord.xy)) * RefractColor, myhvec3(texture2D(Texture_Reflection, ScreenTexCoord.zw)) * ReflectColor, Fresnel), color.rgb, color.a);\n"
-"# else\n"
-"# ifdef USEREFLECTION\n"
+"#ifdef USEGLOW\n"
+" color.rgb += myhvec3(texture2D(Texture_Glow, TexCoord)) * GlowScale;\n"
+"#endif\n"
+"\n"
+"#ifndef MODE_LIGHTSOURCE\n"
+"# ifdef USEREFLECTION\n"
" vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
" //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
" vec4 ScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect + vec3(normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5))).xyxy * DistortScaleRefractReflect;\n"
-" color.rgb += myhvec3(texture2D(Texture_Gloss, TexCoord)) * myhvec3(texture2D(Texture_Reflection, ScreenTexCoord.zw));\n"
-"# endif\n"
+" color.rgb = mix(color.rgb, myhvec3(texture2D(Texture_Reflection, ScreenTexCoord.zw)) * ReflectColor.rgb, ReflectColor.a);\n"
"# endif\n"
"#endif\n"
"\n"
-"#ifdef USEGLOW\n"
-" color.rgb += myhvec3(texture2D(Texture_Glow, TexCoord)) * GlowScale;\n"
-"#endif\n"
-"\n"
"#ifdef USEFOG\n"
" // apply fog\n"
" color.rgb = mix(FogColor, color.rgb, myhalf(texture2D(Texture_FogMask, myhvec2(length(EyeVectorModelSpace)*FogRangeRecip, 0.0))));\n"
"#endif\n"
"\n"
"#ifdef USECONTRASTBOOST\n"
-" color.rgb = color.rgb * SceneBrightness / (ContrastBoostCoeff * color.rgb + myhvec3(1, 1, 1));\n"
-"#else\n"
-" color.rgb *= SceneBrightness;\n"
+" color.rgb = color.rgb / (ContrastBoostCoeff * color.rgb + myhvec3(1, 1, 1));\n"
"#endif\n"
"\n"
+" color.rgb *= SceneBrightness;\n"
+"\n"
" gl_FragColor = vec4(color);\n"
"}\n"
+"#endif // MODE_REFRACTION\n"
+"#endif // MODE_WATER\n"
"\n"
"#endif // FRAGMENT_SHADER\n"
;
+#define SHADERPERMUTATION_COLORMAPPING (1<<0) // indicates this is a colormapped skin
+#define SHADERPERMUTATION_CONTRASTBOOST (1<<1) // r_glsl_contrastboost boosts the contrast at low color levels (similar to gamma)
+#define SHADERPERMUTATION_FOG (1<<2) // tint the color by fog color or black if using additive blend mode
+#define SHADERPERMUTATION_CUBEFILTER (1<<3) // (lightsource) use cubemap light filter
+#define SHADERPERMUTATION_GLOW (1<<4) // (lightmap) blend in an additive glow texture
+#define SHADERPERMUTATION_DIFFUSE (1<<5) // (lightsource) whether to use directional shading
+#define SHADERPERMUTATION_SPECULAR (1<<6) // (lightsource or deluxemapping) render specular effects
+#define SHADERPERMUTATION_REFLECTION (1<<7) // normalmap-perturbed reflection of the scene infront of the surface, preformed as an overlay on the surface
+#define SHADERPERMUTATION_OFFSETMAPPING (1<<8) // adjust texcoords to roughly simulate a displacement mapped surface
+#define SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING (1<<9) // adjust texcoords to accurately simulate a displacement mapped surface (requires OFFSETMAPPING to also be set!)
+#define SHADERPERMUTATION_MODEBASE (1<<10) // multiplier for the SHADERMODE_ values to get a valid index
+
// NOTE: MUST MATCH ORDER OF SHADERPERMUTATION_* DEFINES!
-const char *permutationinfo[][2] =
+const char *shaderpermutationinfo[][2] =
{
- {"#define MODE_LIGHTMAP\n", " lightmap"},
- {"#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"},
- {"#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"},
- {"#define MODE_LIGHTDIRECTION\n", " lightdirection"},
- {"#define MODE_LIGHTSOURCE\n", " lightsource"},
- {"#define USEWATER\n", " water"},
- {"#define USEREFLECTION\n", " reflection"},
- {"#define USEGLOW\n", " glow"},
- {"#define USEFOG\n", " fog"},
{"#define USECOLORMAPPING\n", " colormapping"},
- {"#define USEDIFFUSE\n", " diffuse"},
{"#define USECONTRASTBOOST\n", " contrastboost"},
- {"#define USESPECULAR\n", " specular"},
+ {"#define USEFOG\n", " fog"},
{"#define USECUBEFILTER\n", " cubefilter"},
+ {"#define USEGLOW\n", " glow"},
+ {"#define USEDIFFUSE\n", " diffuse"},
+ {"#define USESPECULAR\n", " specular"},
+ {"#define USEREFLECTION\n", " reflection"},
{"#define USEOFFSETMAPPING\n", " offsetmapping"},
{"#define USEOFFSETMAPPING_RELIEFMAPPING\n", " reliefmapping"},
{NULL, NULL}
};
-void R_GLSL_CompilePermutation(const char *filename, int permutation)
+// this enum is multiplied by SHADERPERMUTATION_MODEBASE
+typedef enum shadermode_e
+{
+ SHADERMODE_LIGHTMAP, // (lightmap) use directional pixel shading from fixed light direction (q3bsp)
+ SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE, // (lightmap) use directional pixel shading from texture containing modelspace light directions (deluxemap)
+ SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE, // (lightmap) use directional pixel shading from texture containing tangentspace light directions (deluxemap)
+ SHADERMODE_LIGHTDIRECTION, // (lightmap) use directional pixel shading from fixed light direction (q3bsp)
+ SHADERMODE_LIGHTSOURCE, // (lightsource) use directional pixel shading from light source (rtlight)
+ SHADERMODE_REFRACTION, // refract background (the material is rendered normally after this pass)
+ SHADERMODE_WATER, // refract background and reflection (the material is rendered normally after this pass)
+ SHADERMODE_COUNT
+}
+shadermode_t;
+
+// NOTE: MUST MATCH ORDER OF SHADERMODE_* ENUMS!
+const char *shadermodeinfo[][2] =
+{
+ {"#define MODE_LIGHTMAP\n", " lightmap"},
+ {"#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"},
+ {"#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"},
+ {"#define MODE_LIGHTDIRECTION\n", " lightdirection"},
+ {"#define MODE_LIGHTSOURCE\n", " lightsource"},
+ {"#define MODE_REFRACTION\n", " refraction"},
+ {"#define MODE_WATER\n", " water"},
+ {NULL, NULL}
+};
+
+#define SHADERPERMUTATION_INDICES (SHADERPERMUTATION_MODEBASE * SHADERMODE_COUNT)
+
+typedef struct r_glsl_permutation_s
+{
+ // indicates if we have tried compiling this permutation already
+ qboolean compiled;
+ // 0 if compilation failed
+ int program;
+ // locations of detected uniforms in program object, or -1 if not found
+ int loc_Texture_Normal;
+ int loc_Texture_Color;
+ int loc_Texture_Gloss;
+ int loc_Texture_Cube;
+ int loc_Texture_Attenuation;
+ int loc_Texture_FogMask;
+ int loc_Texture_Pants;
+ int loc_Texture_Shirt;
+ int loc_Texture_Lightmap;
+ int loc_Texture_Deluxemap;
+ int loc_Texture_Glow;
+ int loc_Texture_Refraction;
+ int loc_Texture_Reflection;
+ int loc_FogColor;
+ int loc_LightPosition;
+ int loc_EyePosition;
+ int loc_LightColor;
+ int loc_Color_Pants;
+ int loc_Color_Shirt;
+ int loc_FogRangeRecip;
+ int loc_AmbientScale;
+ int loc_DiffuseScale;
+ int loc_SpecularScale;
+ int loc_SpecularPower;
+ int loc_GlowScale;
+ int loc_SceneBrightness; // or: Scenebrightness * ContrastBoost
+ int loc_OffsetMapping_Scale;
+ int loc_AmbientColor;
+ int loc_DiffuseColor;
+ int loc_SpecularColor;
+ int loc_LightDir;
+ int loc_ContrastBoostCoeff; // 1 - 1/ContrastBoost
+ int loc_DistortScaleRefractReflect;
+ int loc_ScreenScaleRefractReflect;
+ int loc_ScreenCenterRefractReflect;
+ int loc_RefractColor;
+ int loc_ReflectColor;
+ int loc_ReflectFactor;
+ int loc_ReflectOffset;
+}
+r_glsl_permutation_t;
+
+// information about each possible shader permutation
+r_glsl_permutation_t r_glsl_permutations[SHADERPERMUTATION_INDICES];
+// currently selected permutation
+r_glsl_permutation_t *r_glsl_permutation;
+
+// these are additional flags used only by R_GLSL_CompilePermutation
+#define SHADERTYPE_USES_VERTEXSHADER (1<<0)
+#define SHADERTYPE_USES_GEOMETRYSHADER (1<<1)
+#define SHADERTYPE_USES_FRAGMENTSHADER (1<<2)
+
+static void R_GLSL_CompilePermutation(const char *filename, int permutation, int shadertype)
{
int i;
qboolean shaderfound;
- r_glsl_permutation_t *p = r_glsl_permutations + (permutation & SHADERPERMUTATION_MASK);
+ r_glsl_permutation_t *p = r_glsl_permutations + permutation;
int vertstrings_count;
int geomstrings_count;
int fragstrings_count;
geomstrings_count = 1;
fragstrings_count = 1;
permutationname[0] = 0;
- for (i = 0;permutationinfo[i][0];i++)
+ i = permutation / SHADERPERMUTATION_MODEBASE;
+ vertstrings_list[vertstrings_count++] = shadermodeinfo[i][0];
+ geomstrings_list[geomstrings_count++] = shadermodeinfo[i][0];
+ fragstrings_list[fragstrings_count++] = shadermodeinfo[i][0];
+ strlcat(permutationname, shadermodeinfo[i][1], sizeof(permutationname));
+ for (i = 0;shaderpermutationinfo[i][0];i++)
{
if (permutation & (1<<i))
{
- vertstrings_list[vertstrings_count++] = permutationinfo[i][0];
- geomstrings_list[geomstrings_count++] = permutationinfo[i][0];
- fragstrings_list[fragstrings_count++] = permutationinfo[i][0];
- strlcat(permutationname, permutationinfo[i][1], sizeof(permutationname));
+ vertstrings_list[vertstrings_count++] = shaderpermutationinfo[i][0];
+ geomstrings_list[geomstrings_count++] = shaderpermutationinfo[i][0];
+ fragstrings_list[fragstrings_count++] = shaderpermutationinfo[i][0];
+ strlcat(permutationname, shaderpermutationinfo[i][1], sizeof(permutationname));
}
else
{
shaderfound = false;
if (shaderstring)
{
- Con_DPrintf("GLSL shader text for \"%s\" loaded from disk\n", filename);
+ Con_DPrint("from disk... ");
vertstrings_list[vertstrings_count++] = shaderstring;
geomstrings_list[geomstrings_count++] = shaderstring;
fragstrings_list[fragstrings_count++] = shaderstring;
}
else if (!strcmp(filename, "glsl/default.glsl"))
{
- Con_DPrintf("GLSL shader text for \"%s\" loaded from engine\n", filename);
vertstrings_list[vertstrings_count++] = builtinshaderstring;
geomstrings_list[geomstrings_count++] = builtinshaderstring;
fragstrings_list[fragstrings_count++] = builtinshaderstring;
shaderfound = true;
}
// clear any lists that are not needed by this shader
- if (!(permutation & SHADERPERMUTATION_USES_VERTEXSHADER))
+ if (!(shadertype & SHADERTYPE_USES_VERTEXSHADER))
vertstrings_count = 0;
- if (!(permutation & SHADERPERMUTATION_USES_GEOMETRYSHADER))
+ if (!(shadertype & SHADERTYPE_USES_GEOMETRYSHADER))
geomstrings_count = 0;
- if (!(permutation & SHADERPERMUTATION_USES_FRAGMENTSHADER))
+ if (!(shadertype & SHADERTYPE_USES_FRAGMENTSHADER))
fragstrings_count = 0;
// compile the shader program
if (shaderfound && vertstrings_count + geomstrings_count + fragstrings_count)
p->loc_ScreenCenterRefractReflect = qglGetUniformLocationARB(p->program, "ScreenCenterRefractReflect");
p->loc_RefractColor = qglGetUniformLocationARB(p->program, "RefractColor");
p->loc_ReflectColor = qglGetUniformLocationARB(p->program, "ReflectColor");
+ p->loc_ReflectFactor = qglGetUniformLocationARB(p->program, "ReflectFactor");
+ p->loc_ReflectOffset = qglGetUniformLocationARB(p->program, "ReflectOffset");
// initialize the samplers to refer to the texture units we use
if (p->loc_Texture_Normal >= 0) qglUniform1iARB(p->loc_Texture_Normal, 0);
if (p->loc_Texture_Color >= 0) qglUniform1iARB(p->loc_Texture_Color, 1);
if (p->loc_Texture_Reflection >= 0) qglUniform1iARB(p->loc_Texture_Reflection, 12);
CHECKGLERROR
qglUseProgramObjectARB(0);CHECKGLERROR
+ if (developer.integer)
+ Con_Printf("GLSL shader %s :%s compiled.\n", filename, permutationname);
}
else
- Con_Printf("permutation%s failed for shader %s, some features may not work properly!\n", permutationname, filename);
+ {
+ if (developer.integer)
+ Con_Printf("GLSL shader %s :%s failed! source code line offset for above errors is %i.\n", permutationname, filename, -(vertstrings_count - 1));
+ else
+ Con_Printf("GLSL shader %s :%s failed! some features may not work properly.\n", permutationname, filename);
+ }
if (shaderstring)
Mem_Free(shaderstring);
}
void R_GLSL_Restart_f(void)
{
int i;
- for (i = 0;i < SHADERPERMUTATION_MAX;i++)
+ for (i = 0;i < SHADERPERMUTATION_INDICES;i++)
if (r_glsl_permutations[i].program)
GL_Backend_FreeProgram(r_glsl_permutations[i].program);
memset(r_glsl_permutations, 0, sizeof(r_glsl_permutations));
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;permutationinfo[i][0];i++)
- FS_Printf(file, "// %s", permutationinfo[i][0]);
+ for (i = 0;shadermodeinfo[i][0];i++)
+ FS_Printf(file, "// %s", shadermodeinfo[i][0]);
+ for (i = 0;shaderpermutationinfo[i][0];i++)
+ FS_Printf(file, "// %s", shaderpermutationinfo[i][0]);
FS_Print(file, "\n");
FS_Print(file, builtinshaderstring);
FS_Close(file);
extern rtexture_t *r_shadow_attenuationgradienttexture;
extern rtexture_t *r_shadow_attenuation2dtexture;
extern rtexture_t *r_shadow_attenuation3dtexture;
-int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, float ambientscale, float diffusescale, float specularscale)
+int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, float ambientscale, float diffusescale, float specularscale, rsurfacepass_t rsurfacepass)
{
// select a permutation of the lighting shader appropriate to this
// combination of texture, entity, light source, and fogging, only use the
// fragment shader on features that are not being used
const char *shaderfilename = NULL;
unsigned int permutation = 0;
- rtexture_t *nmap;
+ unsigned int shadertype = 0;
+ shadermode_t mode = 0;
r_glsl_permutation = NULL;
+ shaderfilename = "glsl/default.glsl";
+ shadertype = SHADERTYPE_USES_VERTEXSHADER | SHADERTYPE_USES_FRAGMENTSHADER;
// TODO: implement geometry-shader based shadow volumes someday
- if (rsurface.rtlight)
+ if (r_glsl_offsetmapping.integer)
+ {
+ permutation |= SHADERPERMUTATION_OFFSETMAPPING;
+ if (r_glsl_offsetmapping_reliefmapping.integer)
+ permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
+ }
+ if (rsurfacepass == RSURFPASS_BACKGROUND)
+ {
+ // distorted background
+ if (rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERSHADER)
+ mode = SHADERMODE_WATER;
+ else
+ mode = SHADERMODE_REFRACTION;
+ }
+ else if (rsurfacepass == RSURFPASS_RTLIGHT)
{
// light source
- shaderfilename = "glsl/default.glsl";
- permutation = SHADERPERMUTATION_MODE_LIGHTSOURCE | SHADERPERMUTATION_USES_VERTEXSHADER | SHADERPERMUTATION_USES_FRAGMENTSHADER;
+ mode = SHADERMODE_LIGHTSOURCE;
if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
permutation |= SHADERPERMUTATION_CUBEFILTER;
if (diffusescale > 0)
permutation |= SHADERPERMUTATION_FOG;
if (rsurface.texture->colormapping)
permutation |= SHADERPERMUTATION_COLORMAPPING;
- if (r_glsl_offsetmapping.integer)
- {
- permutation |= SHADERPERMUTATION_OFFSETMAPPING;
- if (r_glsl_offsetmapping_reliefmapping.integer)
- permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
- }
if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
permutation |= SHADERPERMUTATION_CONTRASTBOOST;
- if (rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERSHADER)
- permutation |= SHADERPERMUTATION_WATER;
if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
permutation |= SHADERPERMUTATION_REFLECTION;
}
else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
{
- // bright unshaded geometry
- shaderfilename = "glsl/default.glsl";
- permutation = SHADERPERMUTATION_USES_VERTEXSHADER | SHADERPERMUTATION_USES_FRAGMENTSHADER;
- permutation |= SHADERPERMUTATION_MODE_LIGHTMAP;
+ // unshaded geometry (fullbright or ambient model lighting)
+ mode = SHADERMODE_LIGHTMAP;
if (rsurface.texture->currentskinframe->glow)
permutation |= SHADERPERMUTATION_GLOW;
if (r_refdef.fogenabled)
}
if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
permutation |= SHADERPERMUTATION_CONTRASTBOOST;
- if (rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERSHADER)
- permutation |= SHADERPERMUTATION_WATER;
if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
permutation |= SHADERPERMUTATION_REFLECTION;
}
- else if (modellighting)
+ else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT_DIRECTIONAL)
{
// directional model lighting
- shaderfilename = "glsl/default.glsl";
- permutation = SHADERPERMUTATION_USES_VERTEXSHADER | SHADERPERMUTATION_USES_FRAGMENTSHADER;
- permutation |= SHADERPERMUTATION_MODE_LIGHTDIRECTION;
+ mode = SHADERMODE_LIGHTDIRECTION;
if (rsurface.texture->currentskinframe->glow)
permutation |= SHADERPERMUTATION_GLOW;
+ permutation |= SHADERPERMUTATION_DIFFUSE;
if (specularscale > 0)
permutation |= SHADERPERMUTATION_SPECULAR;
if (r_refdef.fogenabled)
permutation |= SHADERPERMUTATION_FOG;
if (rsurface.texture->colormapping)
permutation |= SHADERPERMUTATION_COLORMAPPING;
- if (r_glsl_offsetmapping.integer)
- {
- permutation |= SHADERPERMUTATION_OFFSETMAPPING;
- if (r_glsl_offsetmapping_reliefmapping.integer)
- permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
- }
if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
permutation |= SHADERPERMUTATION_CONTRASTBOOST;
- if (rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERSHADER)
- permutation |= SHADERPERMUTATION_WATER;
+ if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
+ permutation |= SHADERPERMUTATION_REFLECTION;
+ }
+ else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
+ {
+ // ambient model lighting
+ mode = SHADERMODE_LIGHTDIRECTION;
+ if (rsurface.texture->currentskinframe->glow)
+ permutation |= SHADERPERMUTATION_GLOW;
+ if (r_refdef.fogenabled)
+ permutation |= SHADERPERMUTATION_FOG;
+ if (rsurface.texture->colormapping)
+ permutation |= SHADERPERMUTATION_COLORMAPPING;
+ if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
+ permutation |= SHADERPERMUTATION_CONTRASTBOOST;
if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
permutation |= SHADERPERMUTATION_REFLECTION;
}
else
{
// lightmapped wall
- shaderfilename = "glsl/default.glsl";
- permutation = SHADERPERMUTATION_USES_VERTEXSHADER | SHADERPERMUTATION_USES_FRAGMENTSHADER;
if (r_glsl_deluxemapping.integer >= 1 && rsurface.uselightmaptexture && r_refdef.worldmodel && r_refdef.worldmodel->brushq3.deluxemapping)
{
// deluxemapping (light direction texture)
if (rsurface.uselightmaptexture && r_refdef.worldmodel && r_refdef.worldmodel->brushq3.deluxemapping && r_refdef.worldmodel->brushq3.deluxemapping_modelspace)
- permutation |= SHADERPERMUTATION_MODE_LIGHTDIRECTIONMAP_MODELSPACE;
+ mode = SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE;
else
- permutation |= SHADERPERMUTATION_MODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
+ mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
if (specularscale > 0)
- permutation |= SHADERPERMUTATION_SPECULAR;
+ permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
}
else if (r_glsl_deluxemapping.integer >= 2)
{
// fake deluxemapping (uniform light direction in tangentspace)
- permutation |= SHADERPERMUTATION_MODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
+ mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
if (specularscale > 0)
- permutation |= SHADERPERMUTATION_SPECULAR;
+ permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
}
else
{
// ordinary lightmapping
- permutation |= SHADERPERMUTATION_MODE_LIGHTMAP;
+ mode = SHADERMODE_LIGHTMAP;
}
if (rsurface.texture->currentskinframe->glow)
permutation |= SHADERPERMUTATION_GLOW;
permutation |= SHADERPERMUTATION_FOG;
if (rsurface.texture->colormapping)
permutation |= SHADERPERMUTATION_COLORMAPPING;
- if (r_glsl_offsetmapping.integer)
- {
- permutation |= SHADERPERMUTATION_OFFSETMAPPING;
- if (r_glsl_offsetmapping_reliefmapping.integer)
- permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
- }
if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
permutation |= SHADERPERMUTATION_CONTRASTBOOST;
- if (rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERSHADER)
- permutation |= SHADERPERMUTATION_WATER;
if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
permutation |= SHADERPERMUTATION_REFLECTION;
}
- if (!r_glsl_permutations[permutation & SHADERPERMUTATION_MASK].program)
+ permutation |= mode * SHADERPERMUTATION_MODEBASE;
+ if (!r_glsl_permutations[permutation].program)
{
- if (!r_glsl_permutations[permutation & SHADERPERMUTATION_MASK].compiled)
- R_GLSL_CompilePermutation(shaderfilename, permutation);
- if (!r_glsl_permutations[permutation & SHADERPERMUTATION_MASK].program)
+ if (!r_glsl_permutations[permutation].compiled)
+ R_GLSL_CompilePermutation(shaderfilename, permutation, shadertype);
+ if (!r_glsl_permutations[permutation].program)
{
// remove features until we find a valid permutation
unsigned int i;
- for (i = (SHADERPERMUTATION_MAX >> 1);;i>>=1)
+ for (i = (SHADERPERMUTATION_MODEBASE >> 1);;i>>=1)
{
if (!i)
{
if (!(permutation & i))
continue;
permutation &= ~i;
- if (!r_glsl_permutations[permutation & SHADERPERMUTATION_MASK].compiled)
- R_GLSL_CompilePermutation(shaderfilename, permutation);
- if (r_glsl_permutations[permutation & SHADERPERMUTATION_MASK].program)
+ if (!r_glsl_permutations[permutation].compiled)
+ R_GLSL_CompilePermutation(shaderfilename, permutation, shadertype);
+ if (r_glsl_permutations[permutation].program)
break;
}
}
}
- r_glsl_permutation = r_glsl_permutations + (permutation & SHADERPERMUTATION_MASK);
+ r_glsl_permutation = r_glsl_permutations + permutation;
CHECKGLERROR
qglUseProgramObjectARB(r_glsl_permutation->program);CHECKGLERROR
- R_Mesh_TexMatrix(0, &rsurface.texture->currenttexmatrix);
- if (permutation & SHADERPERMUTATION_MODE_LIGHTSOURCE)
+ if (mode == SHADERMODE_LIGHTSOURCE)
{
- if (r_glsl_permutation->loc_Texture_Cube >= 0 && rsurface.rtlight) R_Mesh_TexBindCubeMap(3, R_GetTexture(rsurface.rtlight->currentcubemap));
if (r_glsl_permutation->loc_LightPosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);
if (permutation & SHADERPERMUTATION_DIFFUSE)
{
if (r_glsl_permutation->loc_SpecularScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularScale, 0);
}
}
- else if (permutation & SHADERPERMUTATION_MODE_LIGHTDIRECTION)
+ else if (mode == SHADERMODE_LIGHTDIRECTION)
{
if (r_glsl_permutation->loc_AmbientColor >= 0)
qglUniform3fARB(r_glsl_permutation->loc_AmbientColor, rsurface.modellight_ambient[0] * ambientscale, rsurface.modellight_ambient[1] * ambientscale, rsurface.modellight_ambient[2] * ambientscale);
if (r_glsl_permutation->loc_DiffuseScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_DiffuseScale, r_refdef.lightmapintensity * 2.0f);
if (r_glsl_permutation->loc_SpecularScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularScale, r_refdef.lightmapintensity * specularscale * 2.0f);
}
- nmap = rsurface.texture->currentskinframe->nmap;
- if (gl_lightmaps.integer)
- nmap = r_texture_blanknormalmap;
- if (r_glsl_permutation->loc_Texture_Normal >= 0) R_Mesh_TexBind(0, R_GetTexture(nmap));
- if (r_glsl_permutation->loc_Texture_Color >= 0) R_Mesh_TexBind(1, R_GetTexture(rsurface.texture->basetexture));
- if (r_glsl_permutation->loc_Texture_Gloss >= 0) R_Mesh_TexBind(2, R_GetTexture(rsurface.texture->glosstexture));
- //if (r_glsl_permutation->loc_Texture_Cube >= 0 && permutation & SHADERPERMUTATION_MODE_LIGHTSOURCE) R_Mesh_TexBindCubeMap(3, R_GetTexture(rsurface.rtlight->currentcubemap));
- if (r_glsl_permutation->loc_Texture_Attenuation >= 0) R_Mesh_TexBind(10, R_GetTexture(r_shadow_attenuationgradienttexture));
- if (r_glsl_permutation->loc_Texture_FogMask >= 0) R_Mesh_TexBind(4, R_GetTexture(r_texture_fogattenuation));
- if (r_glsl_permutation->loc_Texture_Pants >= 0) R_Mesh_TexBind(5, R_GetTexture(rsurface.texture->currentskinframe->pants));
- if (r_glsl_permutation->loc_Texture_Shirt >= 0) R_Mesh_TexBind(6, R_GetTexture(rsurface.texture->currentskinframe->shirt));
- //if (r_glsl_permutation->loc_Texture_Lightmap >= 0) R_Mesh_TexBind(7, R_GetTexture(r_texture_white));
- //if (r_glsl_permutation->loc_Texture_Deluxemap >= 0) R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
- if (r_glsl_permutation->loc_Texture_Glow >= 0) R_Mesh_TexBind(9, R_GetTexture(rsurface.texture->currentskinframe->glow));
- if (r_glsl_permutation->loc_Texture_Refraction >= 0) R_Mesh_TexBind(11, R_GetTexture(r_texture_white)); // changed per surface
- if (r_glsl_permutation->loc_Texture_Reflection >= 0) R_Mesh_TexBind(12, R_GetTexture(r_texture_white)); // changed per surface
if (r_glsl_permutation->loc_GlowScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_GlowScale, r_hdr_glowintensity.value);
if (r_glsl_permutation->loc_ContrastBoostCoeff >= 0)
{
// color.rgb *= [[SceneBrightness * ContrastBoost]];
// color.rgb /= [[(ContrastBoost - 1) / ContrastBoost]] * color.rgb + 1;
// and Black:
- // color.rgb = [[SceneBrightness * ContrastBoost]] / ([[(ContrastBoost - 1) * SceneBrightness]] + 1 / color.rgb);
+ // color.rgb = [[SceneBrightness * ContrastBoost]] * color.rgb / ([[(ContrastBoost - 1) * SceneBrightness]] * color.rgb + 1);
// and do [[calculations]] here in the engine
qglUniform1fARB(r_glsl_permutation->loc_ContrastBoostCoeff, (r_glsl_contrastboost.value - 1) * r_view.colorscale);
if (r_glsl_permutation->loc_SceneBrightness >= 0) qglUniform1fARB(r_glsl_permutation->loc_SceneBrightness, r_view.colorscale * r_glsl_contrastboost.value);
if (rsurface.rtlight || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD))
qglUniform3fARB(r_glsl_permutation->loc_FogColor, 0, 0, 0);
else
+ /*
+ {
+ vec3_t fogvec;
+ // color.rgb *= SceneBrightness;
+ VectorScale(r_refdef.fogcolor, r_view.colorscale, fogvec);
+ if(r_glsl_permutation->loc_ContrastBoostCoeff >= 0) // need to support contrast boost
+ {
+ // color.rgb *= ContrastBoost / ((ContrastBoost - 1) * color.rgb + 1);
+ fogvec[0] *= r_glsl_contrastboost.value / ((r_glsl_contrastboost.value - 1) * fogvec[0] + 1);
+ fogvec[1] *= r_glsl_contrastboost.value / ((r_glsl_contrastboost.value - 1) * fogvec[1] + 1);
+ fogvec[2] *= r_glsl_contrastboost.value / ((r_glsl_contrastboost.value - 1) * fogvec[2] + 1);
+ }
+ qglUniform3fARB(r_glsl_permutation->loc_FogColor, fogvec[0], fogvec[1], fogvec[2]);
+ }
+ */
qglUniform3fARB(r_glsl_permutation->loc_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
}
if (r_glsl_permutation->loc_EyePosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_EyePosition, rsurface.modelorg[0], rsurface.modelorg[1], rsurface.modelorg[2]);
if (r_glsl_permutation->loc_FogRangeRecip >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogRangeRecip, r_refdef.fograngerecip);
if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface.texture->specularpower);
if (r_glsl_permutation->loc_OffsetMapping_Scale >= 0) qglUniform1fARB(r_glsl_permutation->loc_OffsetMapping_Scale, r_glsl_offsetmapping_scale.value);
- if (r_glsl_permutation->loc_DistortScaleRefractReflect >= 0) qglUniform4fARB(r_glsl_permutation->loc_DistortScaleRefractReflect, r_glsl_water_refractdistort.value, r_glsl_water_refractdistort.value, r_glsl_water_reflectdistort.value, r_glsl_water_reflectdistort.value);
+ 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) qglUniform3fARB(r_glsl_permutation->loc_RefractColor, r_glsl_water_refractcolor_r.value, r_glsl_water_refractcolor_g.value, r_glsl_water_refractcolor_b.value);
- if (r_glsl_permutation->loc_ReflectColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_ReflectColor, r_glsl_water_reflectcolor_r.value, r_glsl_water_reflectcolor_g.value, r_glsl_water_reflectcolor_b.value);
+ 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_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);
CHECKGLERROR
return permutation;
}
-void R_SwitchSurfaceShader(int permutation)
-{
- if (r_glsl_permutation != r_glsl_permutations + (permutation & SHADERPERMUTATION_MASK))
- {
- r_glsl_permutation = r_glsl_permutations + (permutation & SHADERPERMUTATION_MASK);
- CHECKGLERROR
- qglUseProgramObjectARB(r_glsl_permutation->program);
- CHECKGLERROR
- }
-}
-
#define SKINFRAME_HASH 1024
struct
if (skinframe && skinframe->base)
return skinframe;
- basepixels = loadimagepixels(name, complain, 0, 0);
+ basepixels = loadimagepixels(name, complain, 0, 0, true);
if (basepixels == NULL)
return NULL;
// _norm is the name used by tenebrae and has been adopted as standard
if (loadnormalmap)
{
- if ((pixels = loadimagepixels(va("%s_norm", skinframe->basename), false, 0, 0)) != NULL)
+ if ((pixels = loadimagepixels(va("%s_norm", skinframe->basename), false, 0, 0, false)) != NULL)
{
skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), NULL);
Mem_Free(pixels);
pixels = NULL;
}
- else if (r_shadow_bumpscale_bumpmap.value > 0 && (bumppixels = loadimagepixels(va("%s_bump", skinframe->basename), false, 0, 0)) != NULL)
+ else if (r_shadow_bumpscale_bumpmap.value > 0 && (bumppixels = loadimagepixels(va("%s_bump", skinframe->basename), false, 0, 0, false)) != NULL)
{
pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
Image_HeightmapToNormalmap(bumppixels, pixels, image_width, image_height, false, r_shadow_bumpscale_bumpmap.value);
// _luma is supported for tenebrae compatibility
// (I think it's a very stupid name, but oh well)
// _glow is the preferred name
- if (loadglow && ((pixels = loadimagepixels(va("%s_glow", skinframe->basename), false, 0, 0)) != NULL || (pixels = loadimagepixels(va("%s_luma", skinframe->basename), false, 0, 0)) != NULL)) {skinframe->glow = R_LoadTexture2D (r_main_texturepool, va("%s_glow", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags & (gl_texturecompression_glow.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;}
- if (loadgloss && (pixels = loadimagepixels(va("%s_gloss", skinframe->basename), false, 0, 0)) != NULL) {skinframe->gloss = R_LoadTexture2D (r_main_texturepool, va("%s_gloss", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags & (gl_texturecompression_gloss.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;}
- if (loadpantsandshirt && (pixels = loadimagepixels(va("%s_pants", skinframe->basename), false, 0, 0)) != NULL) {skinframe->pants = R_LoadTexture2D (r_main_texturepool, va("%s_pants", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;}
- if (loadpantsandshirt && (pixels = loadimagepixels(va("%s_shirt", skinframe->basename), false, 0, 0)) != NULL) {skinframe->shirt = R_LoadTexture2D (r_main_texturepool, va("%s_shirt", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;}
+ if (loadglow && ((pixels = loadimagepixels(va("%s_glow", skinframe->basename), false, 0, 0, false)) != NULL || (pixels = loadimagepixels(va("%s_luma", skinframe->basename), false, 0, 0, false)) != NULL)) {skinframe->glow = R_LoadTexture2D (r_main_texturepool, va("%s_glow", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags & (gl_texturecompression_glow.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;}
+ if (loadgloss && (pixels = loadimagepixels(va("%s_gloss", skinframe->basename), false, 0, 0, false)) != NULL) {skinframe->gloss = R_LoadTexture2D (r_main_texturepool, va("%s_gloss", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags & (gl_texturecompression_gloss.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;}
+ if (loadpantsandshirt && (pixels = loadimagepixels(va("%s_pants", skinframe->basename), false, 0, 0, false)) != NULL) {skinframe->pants = R_LoadTexture2D (r_main_texturepool, va("%s_pants", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;}
+ if (loadpantsandshirt && (pixels = loadimagepixels(va("%s_shirt", skinframe->basename), false, 0, 0, false)) != NULL) {skinframe->shirt = R_LoadTexture2D (r_main_texturepool, va("%s_shirt", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;}
if (basepixels)
Mem_Free(basepixels);
Cvar_RegisterVariable(&r_glsl_offsetmapping);
Cvar_RegisterVariable(&r_glsl_offsetmapping_reliefmapping);
Cvar_RegisterVariable(&r_glsl_offsetmapping_scale);
- Cvar_RegisterVariable(&r_glsl_water);
- Cvar_RegisterVariable(&r_glsl_water_resolutionmultiplier);
- Cvar_RegisterVariable(&r_glsl_water_clippingplanebias);
- Cvar_RegisterVariable(&r_glsl_water_refractcolor_r);
- Cvar_RegisterVariable(&r_glsl_water_refractcolor_g);
- Cvar_RegisterVariable(&r_glsl_water_refractcolor_b);
- Cvar_RegisterVariable(&r_glsl_water_reflectcolor_r);
- Cvar_RegisterVariable(&r_glsl_water_reflectcolor_g);
- Cvar_RegisterVariable(&r_glsl_water_reflectcolor_b);
- Cvar_RegisterVariable(&r_glsl_water_refractdistort);
- Cvar_RegisterVariable(&r_glsl_water_reflectdistort);
Cvar_RegisterVariable(&r_glsl_deluxemapping);
+ 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_lerpsprites);
Cvar_RegisterVariable(&r_lerpmodels);
Cvar_RegisterVariable(&r_waterscroll);
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);
+
+ Cvar_RegisterVariable(&r_track_sprites);
+ Cvar_RegisterVariable(&r_track_sprites_flags);
+ Cvar_RegisterVariable(&r_track_sprites_scalew);
+ Cvar_RegisterVariable(&r_track_sprites_scaleh);
}
extern void R_Textures_Init(void);
for (i = 0;i < r_refdef.numentities;i++)
{
ent = r_refdef.entities[i];
- r_viewcache.entityvisible[i] = !(ent->flags & renderimask) && !R_CullBox(ent->mins, ent->maxs) && ((ent->effects & EF_NODEPTHTEST) || (ent->flags & RENDER_VIEWMODEL) || r_refdef.worldmodel->brush.BoxTouchingVisibleLeafs(r_refdef.worldmodel, r_viewcache.world_leafvisible, ent->mins, ent->maxs));
+ r_viewcache.entityvisible[i] = !(ent->flags & renderimask) && ((ent->model->type == mod_sprite && (ent->model->sprite.sprnum_type == SPR_LABEL || ent->model->sprite.sprnum_type == SPR_LABEL_SCALE)) || !R_CullBox(ent->mins, ent->maxs)) && ((ent->effects & EF_NODEPTHTEST) || (ent->flags & RENDER_VIEWMODEL) || r_refdef.worldmodel->brush.BoxTouchingVisibleLeafs(r_refdef.worldmodel, r_viewcache.world_leafvisible, ent->mins, ent->maxs));
+
}
if(r_cullentities_trace.integer)
{
for (i = 0;i < r_refdef.numentities;i++)
{
ent = r_refdef.entities[i];
- r_viewcache.entityvisible[i] = !(ent->flags & renderimask) && !R_CullBox(ent->mins, ent->maxs);
+ r_viewcache.entityvisible[i] = !(ent->flags & renderimask) && ((ent->model->type == mod_sprite && (ent->model->sprite.sprnum_type == SPR_LABEL || ent->model->sprite.sprnum_type == SPR_LABEL_SCALE)) || !R_CullBox(ent->mins, ent->maxs));
}
}
}
}
+static void R_DrawModelsDebug(void)
+{
+ int i;
+ entity_render_t *ent;
+
+ if (!r_drawentities.integer)
+ return;
+
+ for (i = 0;i < r_refdef.numentities;i++)
+ {
+ if (!r_viewcache.entityvisible[i])
+ continue;
+ ent = r_refdef.entities[i];
+ r_refdef.stats.entities++;
+ if (ent->model && ent->model->DrawDebug != NULL)
+ ent->model->DrawDebug(ent);
+ }
+}
+
static void R_DrawModelsAddWaterPlanes(void)
{
int i;
r_view.frustum[5].dist = m[15] + m[14];
#endif
-
-
if (r_view.useperspective)
{
slopex = 1.0 / r_view.frustum_x;
VectorMA(r_view.forward, -slopey, r_view.up , r_view.frustum[2].normal);
VectorMA(r_view.forward, slopey, r_view.up , r_view.frustum[3].normal);
VectorCopy(r_view.forward, r_view.frustum[4].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
+ // I couldn't reproduce it after adding those normalizations. --blub
+ VectorNormalize(r_view.frustum[0].normal);
+ VectorNormalize(r_view.frustum[1].normal);
+ VectorNormalize(r_view.frustum[2].normal);
+ VectorNormalize(r_view.frustum[3].normal);
// calculate frustum corners, which are used to calculate deformed frustum planes for shadow caster culling
VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward, -1024 * slopex, r_view.left, -1024 * slopey, r_view.up, r_view.frustumcorner[0]);
if (r_view.useclipplane)
{
// LordHavoc: couldn't figure out how to make this approach the
- vec_t dist = r_view.clipplane.dist - r_glsl_water_clippingplanebias.value;
+ vec_t dist = r_view.clipplane.dist - r_water_clippingplanebias.value;
vec_t viewdist = DotProduct(r_view.origin, r_view.clipplane.normal);
- if (viewdist < r_view.clipplane.dist + r_glsl_water_clippingplanebias.value)
+ if (viewdist < r_view.clipplane.dist + r_water_clippingplanebias.value)
dist = r_view.clipplane.dist;
GL_SetupView_ApplyCustomNearClipPlane(r_view.clipplane.normal[0], r_view.clipplane.normal[1], r_view.clipplane.normal[2], dist);
}
static void R_Water_StartFrame(void)
{
int i;
- int texturewidth, textureheight;
+ int waterwidth, waterheight, texturewidth, textureheight;
r_waterstate_waterplane_t *p;
- r_waterstate.maxwaterplanes = 0;
-
// set waterwidth and waterheight to the water resolution that will be
// used (often less than the screen resolution for faster rendering)
- r_waterstate.waterwidth = (int)bound(1, r_view.width * r_glsl_water_resolutionmultiplier.value, r_view.width);
- r_waterstate.waterheight = (int)bound(1, r_view.height * r_glsl_water_resolutionmultiplier.value, r_view.height);
+ waterwidth = (int)bound(1, r_view.width * r_water_resolutionmultiplier.value, r_view.width);
+ waterheight = (int)bound(1, r_view.height * r_water_resolutionmultiplier.value, r_view.height);
// calculate desired texture sizes
- if (gl_support_arb_texture_non_power_of_two)
+ // can't use water if the card does not support the texture size
+ if (!r_water.integer || !r_glsl.integer || !gl_support_fragment_shader || waterwidth > gl_max_texture_size || waterheight > gl_max_texture_size)
+ texturewidth = textureheight = waterwidth = waterheight = 0;
+ else if (gl_support_arb_texture_non_power_of_two)
{
- texturewidth = r_waterstate.waterwidth;
- textureheight = r_waterstate.waterheight;
+ texturewidth = waterwidth;
+ textureheight = waterheight;
}
else
{
- for (texturewidth = 1;texturewidth < r_waterstate.waterwidth ;texturewidth *= 2);
- for (textureheight = 1;textureheight < r_waterstate.waterheight;textureheight *= 2);
+ for (texturewidth = 1;texturewidth < waterwidth ;texturewidth *= 2);
+ for (textureheight = 1;textureheight < waterheight;textureheight *= 2);
}
- if (!r_glsl_water.integer)
- texturewidth = textureheight = 0;
-
// allocate textures as needed
- if (r_waterstate.texturewidth != texturewidth || r_waterstate.textureheight != textureheight)
+ if (r_waterstate.waterwidth != waterwidth || r_waterstate.waterheight != waterheight || r_waterstate.texturewidth != texturewidth || r_waterstate.textureheight != textureheight)
{
+ r_waterstate.maxwaterplanes = MAX_WATERPLANES;
for (i = 0, p = r_waterstate.waterplanes;i < r_waterstate.maxwaterplanes;i++, p++)
{
if (p->texture_refraction)
R_FreeTexture(p->texture_reflection);
p->texture_reflection = NULL;
}
+ memset(&r_waterstate, 0, sizeof(r_waterstate));
+ r_waterstate.waterwidth = waterwidth;
+ r_waterstate.waterheight = waterheight;
r_waterstate.texturewidth = texturewidth;
r_waterstate.textureheight = textureheight;
}
- if ((!texturewidth && !textureheight) || texturewidth > gl_max_texture_size || textureheight > gl_max_texture_size)
+ if (r_waterstate.waterwidth)
{
- // can't use water if the parameters are too weird
- // can't use water if the card does not support the texture size
- memset(&r_waterstate, 0, sizeof(r_waterstate));
- return;
- }
+ r_waterstate.enabled = true;
- r_waterstate.enabled = true;
+ // set up variables that will be used in shader setup
+ r_waterstate.screenscale[0] = 0.5f * (float)waterwidth / (float)texturewidth;
+ r_waterstate.screenscale[1] = 0.5f * (float)waterheight / (float)textureheight;
+ r_waterstate.screencenter[0] = 0.5f * (float)waterwidth / (float)texturewidth;
+ r_waterstate.screencenter[1] = 0.5f * (float)waterheight / (float)textureheight;
+ }
r_waterstate.maxwaterplanes = MAX_WATERPLANES;
-
- // set up variables that will be used in shader setup
- r_waterstate.screenscale[0] = 0.5f * (float)r_waterstate.waterwidth / (float)r_waterstate.texturewidth;
- r_waterstate.screenscale[1] = 0.5f * (float)r_waterstate.waterheight / (float)r_waterstate.textureheight;
- r_waterstate.screencenter[0] = 0.5f * (float)r_waterstate.waterwidth / (float)r_waterstate.texturewidth;
- r_waterstate.screencenter[1] = 0.5f * (float)r_waterstate.waterheight / (float)r_waterstate.textureheight;
+ r_waterstate.numwaterplanes = 0;
}
static void R_Water_AddWaterPlane(msurface_t *surface)
r_waterstate_waterplane_t *p;
// just use the first triangle with a valid normal for any decisions
VectorClear(normal);
+ VectorClear(center);
for (triangleindex = 0, e = rsurface.modelelement3i + surface->num_firsttriangle * 3;triangleindex < surface->num_triangles;triangleindex++, e += 3)
{
Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[0]*3, vert[0]);
// merge this surface's materialflags into the waterplane
p->materialflags |= surface->texture->currentframe->currentmaterialflags;
// merge this surface's PVS into the waterplane
- if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION) && r_refdef.worldmodel && r_refdef.worldmodel->brush.FatPVS)
+ if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION) && r_refdef.worldmodel && r_refdef.worldmodel->brush.FatPVS)
{
r_refdef.worldmodel->brush.FatPVS(r_refdef.worldmodel, r_view.origin, 2, p->pvsbits, sizeof(p->pvsbits), p->pvsvalid);
p->pvsvalid = true;
int planeindex;
r_waterstate_waterplane_t *p;
+ originalview = r_view;
+
// make sure enough textures are allocated
for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
{
- if (p->materialflags & MATERIALFLAG_WATERSHADER)
+ 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_RGBA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_ALWAYSPRECACHE, NULL);
// render views
for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
{
- originalview = r_view;
r_view.showdebug = false;
r_view.width = r_waterstate.waterwidth;
r_view.height = r_waterstate.waterheight;
// render the normal view scene and copy into texture
// (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)
+ if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
{
r_view.clipplane = p->plane;
VectorNegate(r_view.clipplane.normal, r_view.clipplane.normal);
R_ResetViewRendering3D();
R_ClearScreen();
+ if (r_timereport_active)
+ R_TimeReport("viewclear");
R_RenderScene(false);
R_ResetViewRendering3D();
R_ClearScreen();
+ if (r_timereport_active)
+ R_TimeReport("viewclear");
}
r_view = originalview;
+ r_view.clear = true;
r_waterstate.renderingscene = false;
}
return;
error:
r_view = originalview;
r_waterstate.renderingscene = false;
- Cvar_SetValueQuick(&r_glsl_water, 0);
- Con_Printf("R_Water_ProcessPlanes: Error: texture creation failed! Turned off r_glsl_water.\n");
+ Cvar_SetValueQuick(&r_water, 0);
+ Con_Printf("R_Water_ProcessPlanes: Error: texture creation failed! Turned off r_water.\n");
return;
}
R_ClearScreen();
if (r_timereport_active)
- R_TimeReport("clear");
-
+ R_TimeReport("viewclear");
// restore the view settings
r_view.width = oldwidth;
CHECKGLERROR
if (r_timereport_active)
- R_TimeReport("setup");
+ R_TimeReport("viewsetup");
R_ResetViewRendering3D();
- R_ClearScreen();
- if (r_timereport_active)
- R_TimeReport("clear");
+ if (r_view.clear)
+ {
+ R_ClearScreen();
+ if (r_timereport_active)
+ R_TimeReport("viewclear");
+ }
+ r_view.clear = true;
r_view.showdebug = true;
R_View_Update();
if (r_timereport_active)
- R_TimeReport("watervisibility");
+ R_TimeReport("watervis");
if (cl.csqc_vidvars.drawworld && r_refdef.worldmodel && r_refdef.worldmodel->DrawAddWaterPlanes)
{
qglUseProgramObjectARB(0);CHECKGLERROR
}
+ if (r_view.showdebug && r_refdef.worldmodel && r_refdef.worldmodel->DrawDebug && (r_showtris.value > 0 || r_shownormals.value > 0 || r_showcollisionbrushes.value > 0))
+ {
+ r_refdef.worldmodel->DrawDebug(r_refdef.worldentity);
+ if (r_timereport_active)
+ R_TimeReport("worlddebug");
+ R_DrawModelsDebug();
+ if (r_timereport_active)
+ R_TimeReport("modeldebug");
+ }
+
+ if (gl_support_fragment_shader)
+ {
+ qglUseProgramObjectARB(0);CHECKGLERROR
+ }
+
if (cl.csqc_vidvars.drawworld)
{
R_DrawCoronas();
}
}
-static void R_DrawCollisionBrush(const colbrushf_t *brush)
-{
- int i;
- R_Mesh_VertexPointer(brush->points->v, 0, 0);
- i = (int)(((size_t)brush) / sizeof(colbrushf_t));
- GL_Color((i & 31) * (1.0f / 32.0f) * r_view.colorscale, ((i >> 5) & 31) * (1.0f / 32.0f) * r_view.colorscale, ((i >> 10) & 31) * (1.0f / 32.0f) * r_view.colorscale, 0.2f);
- GL_LockArrays(0, brush->numpoints);
- R_Mesh_Draw(0, brush->numpoints, brush->numtriangles, brush->elements, 0, 0);
- GL_LockArrays(0, 0);
-}
-
-static void R_DrawCollisionSurface(const entity_render_t *ent, const msurface_t *surface)
-{
- int i;
- if (!surface->num_collisiontriangles)
- return;
- R_Mesh_VertexPointer(surface->data_collisionvertex3f, 0, 0);
- i = (int)(((size_t)surface) / sizeof(msurface_t));
- GL_Color((i & 31) * (1.0f / 32.0f) * r_view.colorscale, ((i >> 5) & 31) * (1.0f / 32.0f) * r_view.colorscale, ((i >> 10) & 31) * (1.0f / 32.0f) * r_view.colorscale, 0.2f);
- GL_LockArrays(0, surface->num_collisionvertices);
- R_Mesh_Draw(0, surface->num_collisionvertices, surface->num_collisiontriangles, surface->data_collisionelement3i, 0, 0);
- GL_LockArrays(0, 0);
-}
-
static void R_Texture_AddLayer(texture_t *t, qboolean depthmask, int blendfunc1, int blendfunc2, texturelayertype_t type, rtexture_t *texture, const matrix4x4_t *matrix, float r, float g, float b, float a)
{
texturelayer_t *layer;
if (t->basematerialflags & MATERIALFLAG_WATERALPHA && (model->brush.supportwateralpha || r_novis.integer))
{
t->currentalpha *= r_wateralpha.value;
+ /*
+ * FIXME what is this supposed to do?
// if rendering refraction/reflection, disable transparency
if (r_waterstate.enabled && (t->currentalpha < 1 || (t->currentmaterialflags & MATERIALFLAG_ALPHA)))
t->currentmaterialflags |= MATERIALFLAG_WATERSHADER;
+ */
}
+ if(!r_waterstate.enabled)
+ t->currentmaterialflags &= ~(MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION);
if (!(ent->flags & RENDER_LIGHT))
t->currentmaterialflags |= MATERIALFLAG_FULLBRIGHT;
+ else if (rsurface.modeltexcoordlightmap2f == NULL)
+ {
+ // pick a model lighting mode
+ if (VectorLength2(ent->modellight_diffuse) >= (1.0f / 256.0f))
+ t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT | MATERIALFLAG_MODELLIGHT_DIRECTIONAL;
+ else
+ t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT;
+ }
if (ent->effects & EF_ADDITIVE)
t->currentmaterialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
else if (t->currentalpha < 1)
t->currentmaterialflags |= MATERIALFLAG_SHORTDEPTHRANGE;
if (t->backgroundnumskinframes && !(t->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED))
t->currentmaterialflags |= MATERIALFLAG_VERTEXTEXTUREBLEND;
- if (t->currentmaterialflags & MATERIALFLAG_WATERSHADER)
- t->currentmaterialflags &= ~(MATERIALFLAG_ADD | MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_CUSTOMBLEND);
for (i = 0, tcmod = t->tcmods;i < Q3MAXTCMODS && (tcmod->tcmod || i < 1);i++, tcmod++)
{
static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, msurface_t **texturesurfacelist)
{
+ if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION)))
+ return;
+
if (rsurface.mode != RSURFMODE_GLSL)
{
rsurface.mode = RSURFMODE_GLSL;
R_Mesh_ResetTextureState();
}
- R_SetupSurfaceShader(vec3_origin, rsurface.lightmode == 2, 1, 1, rsurface.texture->specularscale);
- if (!r_glsl_permutation)
- return;
-
- if (rsurface.lightmode == 2)
- RSurf_PrepareVerticesForBatch(true, r_glsl_permutation->loc_Texture_Normal >= 0, texturenumsurfaces, texturesurfacelist);
- else
- RSurf_PrepareVerticesForBatch(r_glsl_permutation->loc_Texture_Normal >= 0, r_glsl_permutation->loc_Texture_Normal >= 0, texturenumsurfaces, texturesurfacelist);
- R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
- R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
- R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
- R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
- R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
-
- GL_Color(rsurface.texture->currentlayers[0].color[0], rsurface.texture->currentlayers[0].color[1], rsurface.texture->currentlayers[0].color[2], rsurface.texture->currentlayers[0].color[3]);
+ R_Mesh_TexMatrix(0, &rsurface.texture->currenttexmatrix);
+ R_Mesh_TexBind(0, R_GetTexture(rsurface.texture->currentskinframe->nmap));
+ R_Mesh_TexBind(1, R_GetTexture(rsurface.texture->basetexture));
+ R_Mesh_TexBind(2, R_GetTexture(rsurface.texture->glosstexture));
+ R_Mesh_TexBind(4, R_GetTexture(r_texture_fogattenuation));
+ R_Mesh_TexBind(5, R_GetTexture(rsurface.texture->currentskinframe->pants));
+ R_Mesh_TexBind(6, R_GetTexture(rsurface.texture->currentskinframe->shirt));
if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
{
R_Mesh_TexBind(7, R_GetTexture(r_texture_grey128));
- if (r_glsl_permutation->loc_Texture_Deluxemap >= 0)
- R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
+ R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
R_Mesh_ColorPointer(NULL, 0, 0);
}
else if (rsurface.uselightmaptexture)
{
R_Mesh_TexBind(7, R_GetTexture(texturesurfacelist[0]->lightmaptexture));
- if (r_glsl_permutation->loc_Texture_Deluxemap >= 0)
- R_Mesh_TexBind(8, R_GetTexture(texturesurfacelist[0]->deluxemaptexture));
+ R_Mesh_TexBind(8, R_GetTexture(texturesurfacelist[0]->deluxemaptexture));
R_Mesh_ColorPointer(NULL, 0, 0);
}
else
{
R_Mesh_TexBind(7, R_GetTexture(r_texture_white));
- if (r_glsl_permutation->loc_Texture_Deluxemap >= 0)
- R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
+ R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
}
+ R_Mesh_TexBind(9, R_GetTexture(rsurface.texture->currentskinframe->glow));
+ R_Mesh_TexBind(11, R_GetTexture(r_texture_white)); // changed per surface
+ R_Mesh_TexBind(12, R_GetTexture(r_texture_white)); // changed per surface
+
+ if (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
+ {
+ // render background
+ GL_BlendFunc(GL_ONE, GL_ZERO);
+ GL_DepthMask(true);
+ GL_AlphaTest(false);
+
+ GL_Color(1, 1, 1, 1);
+ R_Mesh_ColorPointer(NULL, 0, 0);
+
+ R_SetupSurfaceShader(vec3_origin, rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT, 1, 1, rsurface.texture->specularscale, RSURFPASS_BACKGROUND);
+ if (r_glsl_permutation)
+ {
+ RSurf_PrepareVerticesForBatch(true, true, texturenumsurfaces, texturesurfacelist);
+ R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
+ R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
+ R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
+ R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
+ R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
+ RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist, -1, -1, r_glsl_permutation->loc_Texture_Refraction ? 11 : -1, r_glsl_permutation->loc_Texture_Reflection ? 12 : -1);
+ }
+
+ GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
+ GL_DepthMask(false);
+ GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
+ if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
+ {
+ R_Mesh_TexBind(7, R_GetTexture(r_texture_grey128));
+ R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
+ R_Mesh_ColorPointer(NULL, 0, 0);
+ }
+ else if (rsurface.uselightmaptexture)
+ {
+ R_Mesh_TexBind(7, R_GetTexture(texturesurfacelist[0]->lightmaptexture));
+ R_Mesh_TexBind(8, R_GetTexture(texturesurfacelist[0]->deluxemaptexture));
+ R_Mesh_ColorPointer(NULL, 0, 0);
+ }
+ else
+ {
+ R_Mesh_TexBind(7, R_GetTexture(r_texture_white));
+ R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
+ R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
+ }
+ R_Mesh_TexBind(11, R_GetTexture(r_texture_white)); // changed per surface
+ R_Mesh_TexBind(12, R_GetTexture(r_texture_white)); // changed per surface
+ }
+
+ R_SetupSurfaceShader(vec3_origin, rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT, 1, 1, rsurface.texture->specularscale, RSURFPASS_BASE);
+ if (!r_glsl_permutation)
+ return;
+
+ RSurf_PrepareVerticesForBatch(r_glsl_permutation->loc_Texture_Normal >= 0 || r_glsl_permutation->loc_LightDir >= 0, r_glsl_permutation->loc_Texture_Normal >= 0, texturenumsurfaces, texturesurfacelist);
+ R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
+ R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
+ R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
+ R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
+ R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
+ GL_Color(rsurface.texture->currentlayers[0].color[0], rsurface.texture->currentlayers[0].color[1], rsurface.texture->currentlayers[0].color[2], rsurface.texture->currentlayers[0].color[3]);
+
+ if (r_glsl_permutation->loc_Texture_Refraction >= 0)
+ {
+ GL_BlendFunc(GL_ONE, GL_ZERO);
+ GL_DepthMask(true);
+ GL_AlphaTest(false);
+ }
if (rsurface.uselightmaptexture && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
{
- if (rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERSHADER)
- RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist, 7, r_glsl_permutation->loc_Texture_Deluxemap >= 0 ? 8 : -1, 11, 12);
- else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
- RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist, 7, r_glsl_permutation->loc_Texture_Deluxemap >= 0 ? 8 : -1, -1, 12);
+ if (r_glsl_permutation->loc_Texture_Refraction >= 0 || r_glsl_permutation->loc_Texture_Reflection >= 0)
+ RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist, 7, r_glsl_permutation->loc_Texture_Deluxemap >= 0 ? 8 : -1, r_glsl_permutation->loc_Texture_Refraction >= 0 ? 11 : -1, r_glsl_permutation->loc_Texture_Reflection >= 0 ? 12 : -1);
else
RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist, 7, r_glsl_permutation->loc_Texture_Deluxemap >= 0 ? 8 : -1);
}
else
{
- if (rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERSHADER)
- RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist, -1, -1, 11, 12);
- else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
- RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist, -1, -1, -1, 12);
+ if (r_glsl_permutation->loc_Texture_Refraction >= 0 || r_glsl_permutation->loc_Texture_Reflection >= 0)
+ RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist, -1, -1, r_glsl_permutation->loc_Texture_Refraction >= 0 ? 11 : -1, r_glsl_permutation->loc_Texture_Reflection >= 0 ? 12 : -1);
else
RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
}
if (rsurface.mode != RSURFMODE_MULTIPASS)
rsurface.mode = RSURFMODE_MULTIPASS;
RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
+
for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
{
vec4_t layercolor;
m.pointer_texcoord_bufferobject[1] = rsurface.texcoordtexture2f_bufferobject;
m.pointer_texcoord_bufferoffset[1] = rsurface.texcoordtexture2f_bufferoffset;
R_Mesh_TextureState(&m);
- if (rsurface.lightmode == 2)
+ if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
else if (rsurface.uselightmaptexture)
RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
if (rsurface.mode != RSURFMODE_MULTIPASS)
rsurface.mode = RSURFMODE_MULTIPASS;
RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
+
for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
{
if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
m.pointer_texcoord_bufferobject[0] = rsurface.modeltexcoordlightmap2f_bufferobject;
m.pointer_texcoord_bufferoffset[0] = rsurface.modeltexcoordlightmap2f_bufferoffset;
R_Mesh_TextureState(&m);
- if (rsurface.lightmode == 2)
+ if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
else if (rsurface.uselightmaptexture)
RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
R_Mesh_TextureState(&m);
- if (rsurface.lightmode == 2)
+ if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, layer->color[0], layer->color[1], layer->color[2], layer->color[3], layer->color[0] != 1 || layer->color[1] != 1 || layer->color[2] != 1 || layer->color[3] != 1, applyfog);
else
RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, layer->color[0], layer->color[1], layer->color[2], layer->color[3], layer->color[0] != 1 || layer->color[1] != 1 || layer->color[2] != 1 || layer->color[3] != 1, applyfog);
GL_DepthMask(writedepth);
GL_Color(1,1,1,1);
GL_AlphaTest(false);
- // use lightmode 0 (fullbright or lightmap) or 2 (model lighting)
- rsurface.lightmode = ((rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT) || rsurface.modeltexcoordlightmap2f != NULL) ? 0 : 2;
R_Mesh_ColorPointer(NULL, 0, 0);
memset(&m, 0, sizeof(m));
m.tex[0] = R_GetTexture(r_texture_white);
m.pointer_texcoord_bufferobject[0] = rsurface.modeltexcoordlightmap2f_bufferobject;
m.pointer_texcoord_bufferoffset[0] = rsurface.modeltexcoordlightmap2f_bufferoffset;
R_Mesh_TextureState(&m);
- RSurf_PrepareVerticesForBatch(rsurface.lightmode == 2, false, texturenumsurfaces, texturesurfacelist);
- if (rsurface.lightmode == 2)
+ RSurf_PrepareVerticesForBatch(rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT, false, texturenumsurfaces, texturesurfacelist);
+ if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
else if (rsurface.uselightmaptexture)
RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
GL_DepthMask(writedepth && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED));
GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
- // use lightmode 0 (fullbright or lightmap) or 2 (model lighting)
- rsurface.lightmode = ((rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT) || rsurface.modeltexcoordlightmap2f != NULL) ? 0 : 2;
if (r_glsl.integer && gl_support_fragment_shader)
R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist);
else if (gl_combine.integer && r_textureunits.integer >= 2)
if (addwaterplanes)
{
for (i = 0;i < numsurfaces;i++)
- if (surfacelist[i]->texture->currentframe->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
+ if (surfacelist[i]->texture->currentframe->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION))
R_Water_AddWaterPlane(surfacelist[i]);
return;
}
}
}
-void R_DrawCollisionBrushes(entity_render_t *ent)
+void R_DrawDebugModel(entity_render_t *ent)
{
- int i;
+ int i, j, k, l, flagsmask;
+ const int *elements;
q3mbrush_t *brush;
msurface_t *surface;
model_t *model = ent->model;
- if (!model->brush.num_brushes)
- return;
- CHECKGLERROR
+ vec3_t v;
+
+ flagsmask = MATERIALFLAG_SKY | MATERIALFLAG_WATER | MATERIALFLAG_WALL;
+
R_Mesh_ColorPointer(NULL, 0, 0);
R_Mesh_ResetTextureState();
- GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
- GL_DepthMask(false);
GL_DepthRange(0, 1);
GL_DepthTest(!r_showdisabledepthtest.integer);
- GL_PolygonOffset(r_refdef.polygonfactor + r_showcollisionbrushes_polygonfactor.value, r_refdef.polygonoffset + r_showcollisionbrushes_polygonoffset.value);
- for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
- if (brush->colbrushf && brush->colbrushf->numtriangles)
- R_DrawCollisionBrush(brush->colbrushf);
- for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++)
- if (surface->num_collisiontriangles)
- R_DrawCollisionSurface(ent, surface);
- GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
-}
+ GL_DepthMask(false);
+ GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-void R_DrawTrianglesAndNormals(entity_render_t *ent, qboolean drawtris, qboolean drawnormals, int flagsmask)
-{
- int i, j, k, l;
- const int *elements;
- msurface_t *surface;
- model_t *model = ent->model;
- vec3_t v;
- CHECKGLERROR
- GL_DepthRange(0, 1);
- GL_DepthTest(!r_showdisabledepthtest.integer);
- GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
- GL_DepthMask(true);
- GL_BlendFunc(GL_ONE, GL_ZERO);
- R_Mesh_ColorPointer(NULL, 0, 0);
- R_Mesh_ResetTextureState();
- for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
+ if (r_showcollisionbrushes.value > 0 && model->brush.num_brushes)
{
- if (ent == r_refdef.worldentity && !r_viewcache.world_surfacevisible[j])
- continue;
- rsurface.texture = surface->texture->currentframe;
- if ((rsurface.texture->currentmaterialflags & flagsmask) && surface->num_triangles)
+ GL_PolygonOffset(r_refdef.polygonfactor + r_showcollisionbrushes_polygonfactor.value, r_refdef.polygonoffset + r_showcollisionbrushes_polygonoffset.value);
+ for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
{
- RSurf_PrepareVerticesForBatch(true, true, 1, &surface);
- if (drawtris)
+ if (brush->colbrushf && brush->colbrushf->numtriangles)
{
- if (!rsurface.texture->currentlayers->depthmask)
- GL_Color(r_showtris.value * r_view.colorscale, 0, 0, 1);
- else if (ent == r_refdef.worldentity)
- GL_Color(r_showtris.value * r_view.colorscale, r_showtris.value * r_view.colorscale, r_showtris.value * r_view.colorscale, 1);
- else
- GL_Color(0, r_showtris.value * r_view.colorscale, 0, 1);
- elements = (ent->model->surfmesh.data_element3i + 3 * surface->num_firsttriangle);
- CHECKGLERROR
- qglBegin(GL_LINES);
- for (k = 0;k < surface->num_triangles;k++, elements += 3)
- {
-#define GLVERTEXELEMENT(n) qglVertex3f(rsurface.vertex3f[elements[n]*3+0], rsurface.vertex3f[elements[n]*3+1], rsurface.vertex3f[elements[n]*3+2])
- GLVERTEXELEMENT(0);GLVERTEXELEMENT(1);
- GLVERTEXELEMENT(1);GLVERTEXELEMENT(2);
- GLVERTEXELEMENT(2);GLVERTEXELEMENT(0);
- }
- qglEnd();
- CHECKGLERROR
+ R_Mesh_VertexPointer(brush->colbrushf->points->v, 0, 0);
+ GL_Color((i & 31) * (1.0f / 32.0f) * r_view.colorscale, ((i >> 5) & 31) * (1.0f / 32.0f) * r_view.colorscale, ((i >> 10) & 31) * (1.0f / 32.0f) * r_view.colorscale, r_showcollisionbrushes.value);
+ R_Mesh_Draw(0, brush->colbrushf->numpoints, brush->colbrushf->numtriangles, brush->colbrushf->elements, 0, 0);
}
- if (drawnormals)
+ }
+ for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++)
+ {
+ if (surface->num_collisiontriangles)
{
- GL_Color(r_shownormals.value * r_view.colorscale, 0, 0, 1);
- qglBegin(GL_LINES);
- for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
- {
- VectorCopy(rsurface.vertex3f + l * 3, v);
- qglVertex3f(v[0], v[1], v[2]);
- VectorMA(v, 8, rsurface.svector3f + l * 3, v);
- qglVertex3f(v[0], v[1], v[2]);
- }
- qglEnd();
- CHECKGLERROR
- GL_Color(0, 0, r_shownormals.value * r_view.colorscale, 1);
- qglBegin(GL_LINES);
- for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
+ R_Mesh_VertexPointer(surface->data_collisionvertex3f, 0, 0);
+ GL_Color((i & 31) * (1.0f / 32.0f) * r_view.colorscale, ((i >> 5) & 31) * (1.0f / 32.0f) * r_view.colorscale, ((i >> 10) & 31) * (1.0f / 32.0f) * r_view.colorscale, r_showcollisionbrushes.value);
+ R_Mesh_Draw(0, surface->num_collisionvertices, surface->num_collisiontriangles, surface->data_collisionelement3i, 0, 0);
+ }
+ }
+ }
+
+ GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
+
+ if (r_showtris.integer || r_shownormals.integer)
+ {
+ if (r_showdisabledepthtest.integer)
+ {
+ GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ GL_DepthMask(false);
+ }
+ else
+ {
+ GL_BlendFunc(GL_ONE, GL_ZERO);
+ GL_DepthMask(true);
+ }
+ for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
+ {
+ if (ent == r_refdef.worldentity && !r_viewcache.world_surfacevisible[j])
+ continue;
+ rsurface.texture = surface->texture->currentframe;
+ if ((rsurface.texture->currentmaterialflags & flagsmask) && surface->num_triangles)
+ {
+ RSurf_PrepareVerticesForBatch(true, true, 1, &surface);
+ if (r_showtris.value > 0)
{
- VectorCopy(rsurface.vertex3f + l * 3, v);
- qglVertex3f(v[0], v[1], v[2]);
- VectorMA(v, 8, rsurface.tvector3f + l * 3, v);
- qglVertex3f(v[0], v[1], v[2]);
+ if (!rsurface.texture->currentlayers->depthmask)
+ GL_Color(r_view.colorscale, 0, 0, r_showtris.value);
+ else if (ent == r_refdef.worldentity)
+ GL_Color(r_view.colorscale, r_view.colorscale, r_view.colorscale, r_showtris.value);
+ else
+ GL_Color(0, r_view.colorscale, 0, r_showtris.value);
+ elements = (ent->model->surfmesh.data_element3i + 3 * surface->num_firsttriangle);
+ CHECKGLERROR
+ qglBegin(GL_LINES);
+ for (k = 0;k < surface->num_triangles;k++, elements += 3)
+ {
+#define GLVERTEXELEMENT(n) qglVertex3f(rsurface.vertex3f[elements[n]*3+0], rsurface.vertex3f[elements[n]*3+1], rsurface.vertex3f[elements[n]*3+2])
+ GLVERTEXELEMENT(0);GLVERTEXELEMENT(1);
+ GLVERTEXELEMENT(1);GLVERTEXELEMENT(2);
+ GLVERTEXELEMENT(2);GLVERTEXELEMENT(0);
+ }
+ qglEnd();
+ CHECKGLERROR
}
- qglEnd();
- CHECKGLERROR
- GL_Color(0, r_shownormals.value * r_view.colorscale, 0, 1);
- qglBegin(GL_LINES);
- for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
+ if (r_shownormals.value > 0)
{
- VectorCopy(rsurface.vertex3f + l * 3, v);
- qglVertex3f(v[0], v[1], v[2]);
- VectorMA(v, 8, rsurface.normal3f + l * 3, v);
- qglVertex3f(v[0], v[1], v[2]);
+ GL_Color(r_view.colorscale, 0, 0, r_shownormals.value);
+ qglBegin(GL_LINES);
+ for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
+ {
+ VectorCopy(rsurface.vertex3f + l * 3, v);
+ qglVertex3f(v[0], v[1], v[2]);
+ VectorMA(v, 8, rsurface.svector3f + l * 3, v);
+ qglVertex3f(v[0], v[1], v[2]);
+ }
+ qglEnd();
+ CHECKGLERROR
+ GL_Color(0, 0, r_view.colorscale, r_shownormals.value);
+ qglBegin(GL_LINES);
+ for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
+ {
+ VectorCopy(rsurface.vertex3f + l * 3, v);
+ qglVertex3f(v[0], v[1], v[2]);
+ VectorMA(v, 8, rsurface.tvector3f + l * 3, v);
+ qglVertex3f(v[0], v[1], v[2]);
+ }
+ qglEnd();
+ CHECKGLERROR
+ GL_Color(0, r_view.colorscale, 0, r_shownormals.value);
+ qglBegin(GL_LINES);
+ for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
+ {
+ VectorCopy(rsurface.vertex3f + l * 3, v);
+ qglVertex3f(v[0], v[1], v[2]);
+ VectorMA(v, 8, rsurface.normal3f + l * 3, v);
+ qglVertex3f(v[0], v[1], v[2]);
+ }
+ qglEnd();
+ CHECKGLERROR
}
- qglEnd();
- CHECKGLERROR
}
}
+ rsurface.texture = NULL;
}
- rsurface.texture = NULL;
}
extern void R_BuildLightMap(const entity_render_t *ent, msurface_t *surface);
-void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean addwaterplanes)
+void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean addwaterplanes, qboolean debug)
{
int i, j, endj, f, flagsmask;
int counttriangles = 0;
}
R_UpdateAllTextureInfo(r_refdef.worldentity);
- flagsmask = addwaterplanes ? (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION) : (skysurfaces ? MATERIALFLAG_SKY : (MATERIALFLAG_WATER | MATERIALFLAG_WALL));
+ flagsmask = addwaterplanes ? (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION) : (skysurfaces ? MATERIALFLAG_SKY : (MATERIALFLAG_WATER | MATERIALFLAG_WALL));
+
+ if (debug)
+ {
+ R_DrawDebugModel(r_refdef.worldentity);
+ return;
+ }
+
f = 0;
t = NULL;
rsurface.uselightmaptexture = false;
R_QueueSurfaceList(r_refdef.worldentity, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly, addwaterplanes);
r_refdef.stats.entities_triangles += counttriangles;
RSurf_CleanUp();
-
- if (r_view.showdebug)
- {
- if (r_showcollisionbrushes.integer && !skysurfaces && !addwaterplanes && !depthonly)
- R_DrawCollisionBrushes(r_refdef.worldentity);
-
- if ((r_showtris.integer || r_shownormals.integer) && !addwaterplanes && !depthonly)
- R_DrawTrianglesAndNormals(r_refdef.worldentity, r_showtris.integer, r_shownormals.integer, flagsmask);
- }
}
-void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean addwaterplanes)
+void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean addwaterplanes, qboolean debug)
{
int i, f, flagsmask;
int counttriangles = 0;
}
R_UpdateAllTextureInfo(ent);
- flagsmask = addwaterplanes ? (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION) : (skysurfaces ? MATERIALFLAG_SKY : (MATERIALFLAG_WATER | MATERIALFLAG_WALL));
+ flagsmask = addwaterplanes ? (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION) : (skysurfaces ? MATERIALFLAG_SKY : (MATERIALFLAG_WATER | MATERIALFLAG_WALL));
+
+ if (debug)
+ {
+ R_DrawDebugModel(ent);
+ return;
+ }
+
f = 0;
t = NULL;
rsurface.uselightmaptexture = false;
R_QueueSurfaceList(ent, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly, addwaterplanes);
r_refdef.stats.entities_triangles += counttriangles;
RSurf_CleanUp();
-
- if (r_view.showdebug)
- {
- if (r_showcollisionbrushes.integer && !skysurfaces && !addwaterplanes && !depthonly)
- R_DrawCollisionBrushes(ent);
-
- if ((r_showtris.integer || r_shownormals.integer) && !addwaterplanes && !depthonly)
- R_DrawTrianglesAndNormals(ent, r_showtris.integer, r_shownormals.integer, flagsmask);
- }
}
projects / xonotic / darkplaces.git / blobdiff