"\n"
"// common definitions between vertex shader and fragment shader:\n"
"\n"
+"#ifdef __GLSL_CG_DATA_TYPES\n"
+"#define myhalf half\n"
+"#define myhvec2 hvec2\n"
+"#define myhvec3 hvec3\n"
+"#define myhvec4 hvec4\n"
+"#else\n"
+"#define myhalf float\n"
+"#define myhvec2 vec2\n"
+"#define myhvec3 vec3\n"
+"#define myhvec4 vec4\n"
+"#endif\n"
+"\n"
"varying vec2 TexCoord;\n"
"varying vec2 TexCoordLightmap;\n"
"\n"
"uniform sampler2D Texture_Deluxemap;\n"
"uniform sampler2D Texture_Glow;\n"
"\n"
-"uniform vec3 LightColor;\n"
-"uniform vec3 AmbientColor;\n"
-"uniform vec3 DiffuseColor;\n"
-"uniform vec3 SpecularColor;\n"
-"uniform vec3 Color_Pants;\n"
-"uniform vec3 Color_Shirt;\n"
-"uniform vec3 FogColor;\n"
+"uniform myhvec3 LightColor;\n"
+"uniform myhvec3 AmbientColor;\n"
+"uniform myhvec3 DiffuseColor;\n"
+"uniform myhvec3 SpecularColor;\n"
+"uniform myhvec3 Color_Pants;\n"
+"uniform myhvec3 Color_Shirt;\n"
+"uniform myhvec3 FogColor;\n"
"\n"
-"uniform float GlowScale;\n"
-"uniform float SceneBrightness;\n"
+"uniform myhalf GlowScale;\n"
+"uniform myhalf SceneBrightness;\n"
"\n"
"uniform float OffsetMapping_Scale;\n"
"uniform float OffsetMapping_Bias;\n"
"uniform float FogRangeRecip;\n"
"\n"
-"uniform float AmbientScale;\n"
-"uniform float DiffuseScale;\n"
-"uniform float SpecularScale;\n"
-"uniform float SpecularPower;\n"
+"uniform myhalf AmbientScale;\n"
+"uniform myhalf DiffuseScale;\n"
+"uniform myhalf SpecularScale;\n"
+"uniform myhalf SpecularPower;\n"
"\n"
"void main(void)\n"
"{\n"
"\n"
"#ifdef USEOFFSETMAPPING_RELIEFMAPPING\n"
" // 14 sample relief mapping: linear search and then binary search\n"
-" vec3 OffsetVector = vec3(EyeVector.xy * (1.0 / EyeVector.z) * depthbias * OffsetMapping_Scale * vec2(-0.1, 0.1), -0.1);\n"
+" //vec3 OffsetVector = vec3(EyeVector.xy * (1.0 / EyeVector.z) * depthbias * OffsetMapping_Scale * vec2(-0.1, 0.1), -0.1);\n"
+" //vec3 OffsetVector = vec3(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-0.1, 0.1), -0.1);\n"
+" vec3 OffsetVector = vec3(eyedir.xy * OffsetMapping_Scale * vec2(-0.1, 0.1), -0.1);\n"
" vec3 RT = vec3(TexCoord - OffsetVector.xy * 10.0, 1.0) + OffsetVector;\n"
" if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;\n"
" if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;\n"
" if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;OffsetVector *= 0.5;RT -= OffsetVector;\n"
" if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;OffsetVector *= 0.5;RT -= OffsetVector;\n"
" TexCoord = RT.xy;\n"
-"#else\n"
+"#elif 1\n"
" // 3 sample offset mapping (only 3 samples because of ATI Radeon 9500-9800/X300 limits)\n"
-" vec2 OffsetVector = vec2((EyeVector.xy * (1.0 / EyeVector.z) * depthbias) * OffsetMapping_Scale * vec2(-0.333, 0.333));\n"
+" //vec2 OffsetVector = vec2(EyeVector.xy * (1.0 / EyeVector.z) * depthbias) * OffsetMapping_Scale * vec2(-0.333, 0.333);\n"
+" //vec2 OffsetVector = vec2(normalize(EyeVector.xy)) * OffsetMapping_Scale * vec2(-0.333, 0.333);\n"
+" vec2 OffsetVector = vec2(eyedir.xy) * OffsetMapping_Scale * vec2(-0.333, 0.333);\n"
+" //TexCoord += OffsetVector * 3.0;\n"
+" TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
+" TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
+" TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
+"#elif 0\n"
+" // 10 sample offset mapping\n"
+" //vec2 OffsetVector = vec2(EyeVector.xy * (1.0 / EyeVector.z) * depthbias) * OffsetMapping_Scale * vec2(-0.333, 0.333);\n"
+" //vec2 OffsetVector = vec2(normalize(EyeVector.xy)) * OffsetMapping_Scale * vec2(-0.333, 0.333);\n"
+" vec2 OffsetVector = vec2(eyedir.xy) * OffsetMapping_Scale * vec2(-0.1, 0.1);\n"
" //TexCoord += OffsetVector * 3.0;\n"
" TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
" TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
" TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
+" TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
+" TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
+" TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
+" TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
+" TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
+" TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
+" TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
+"#elif 1\n"
+" // parallax mapping as described in the paper\n"
+" // 'Parallax Mapping with Offset Limiting: A Per-Pixel Approximation of Uneven Surfaces' by Terry Welsh\n"
+" // The paper provides code in the ARB fragment program assembly language\n"
+" // I translated it to GLSL but may have done something wrong - SavageX\n"
+" // LordHavoc: removed bias and simplified to one line\n"
+" // LordHavoc: this is just a single sample offsetmapping...\n"
+" TexCoordOffset += vec2(eyedir.x, -1.0 * eyedir.y) * OffsetMapping_Scale * texture2D(Texture_Normal, TexCoord).a;\n"
+"#else\n"
+" // parallax mapping as described in the paper\n"
+" // 'Parallax Mapping with Offset Limiting: A Per-Pixel Approximation of Uneven Surfaces' by Terry Welsh\n"
+" // The paper provides code in the ARB fragment program assembly language\n"
+" // I translated it to GLSL but may have done something wrong - SavageX\n"
+" float height = texture2D(Texture_Normal, TexCoord).a;\n"
+" height = (height - 0.5) * OffsetMapping_Scale; // bias and scale\n"
+" TexCoordOffset += height * vec2(eyedir.x, -1.0 * eyedir.y);\n"
"#endif\n"
"#endif\n"
"\n"
" // combine the diffuse textures (base, pants, shirt)\n"
-" vec4 color = vec4(texture2D(Texture_Color, TexCoord));\n"
+" myhvec4 color = myhvec4(texture2D(Texture_Color, TexCoord));\n"
"#ifdef USECOLORMAPPING\n"
-" color.rgb += vec3(texture2D(Texture_Pants, TexCoord)) * Color_Pants + vec3(texture2D(Texture_Shirt, TexCoord)) * Color_Shirt;\n"
+" color.rgb += myhvec3(texture2D(Texture_Pants, TexCoord)) * Color_Pants + myhvec3(texture2D(Texture_Shirt, TexCoord)) * Color_Shirt;\n"
"#endif\n"
"\n"
"\n"
" // light source\n"
"\n"
" // get the surface normal and light normal\n"
-" vec3 surfacenormal = normalize(vec3(texture2D(Texture_Normal, TexCoord)) - 0.5);\n"
-" vec3 diffusenormal = vec3(normalize(LightVector));\n"
+" myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
+" myhvec3 diffusenormal = myhvec3(normalize(LightVector));\n"
"\n"
" // calculate directional shading\n"
-" color.rgb *= (AmbientScale + DiffuseScale * max(dot(surfacenormal, diffusenormal), 0.0));\n"
+" color.rgb *= AmbientScale + DiffuseScale * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0));\n"
"#ifdef USESPECULAR\n"
-" vec3 specularnormal = vec3(normalize(diffusenormal + vec3(normalize(EyeVector))));\n"
-" color.rgb += vec3(texture2D(Texture_Gloss, TexCoord)) * SpecularScale * pow(max(dot(surfacenormal, specularnormal), 0.0), SpecularPower);\n"
+" myhvec3 specularnormal = normalize(diffusenormal + myhvec3(normalize(EyeVector)));\n"
+" color.rgb += myhvec3(texture2D(Texture_Gloss, TexCoord)) * SpecularScale * pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
"#endif\n"
"\n"
"#ifdef USECUBEFILTER\n"
" // apply light cubemap filter\n"
" //color.rgb *= normalize(CubeVector) * 0.5 + 0.5;//vec3(textureCube(Texture_Cube, CubeVector));\n"
-" color.rgb *= vec3(textureCube(Texture_Cube, CubeVector));\n"
+" color.rgb *= myhvec3(textureCube(Texture_Cube, CubeVector));\n"
"#endif\n"
"\n"
" // apply light color\n"
" //\n"
" // pow(1-(x*x+y*y+z*z), 4) is far more realistic but needs large lights to\n"
" // provide significant illumination, large = slow = pain.\n"
-" color.rgb *= max(1.0 - dot(CubeVector, CubeVector), 0.0);\n"
+" color.rgb *= myhalf(max(1.0 - dot(CubeVector, CubeVector), 0.0));\n"
"\n"
"\n"
"\n"
" // directional model lighting\n"
"\n"
" // get the surface normal and light normal\n"
-" vec3 surfacenormal = normalize(vec3(texture2D(Texture_Normal, TexCoord)) - 0.5);\n"
-" vec3 diffusenormal = vec3(normalize(LightVector));\n"
+" myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
+" myhvec3 diffusenormal = myhvec3(normalize(LightVector));\n"
"\n"
" // calculate directional shading\n"
-" color.rgb *= AmbientColor + DiffuseColor * max(dot(surfacenormal, diffusenormal), 0.0);\n"
+" color.rgb *= AmbientColor + DiffuseColor * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0));\n"
"#ifdef USESPECULAR\n"
-" vec3 specularnormal = vec3(normalize(diffusenormal + vec3(normalize(EyeVector))));\n"
-" color.rgb += vec3(texture2D(Texture_Gloss, TexCoord)) * SpecularColor * pow(max(dot(surfacenormal, specularnormal), 0.0), SpecularPower);\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"
"#endif\n"
"\n"
"\n"
"\n"
"\n"
-"#elif defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE)\n"
+"#elif defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n"
" // deluxemap lightmapping using light vectors in modelspace (evil q3map2)\n"
"\n"
" // get the surface normal and light normal\n"
-" vec3 surfacenormal = normalize(vec3(texture2D(Texture_Normal, TexCoord)) - 0.5);\n"
-" vec3 diffusenormal_modelspace = vec3(texture2D(Texture_Deluxemap, TexCoordLightmap)) - 0.5;\n"
-" vec3 diffusenormal = normalize(vec3(dot(diffusenormal_modelspace, VectorS), dot(diffusenormal_modelspace, VectorT), dot(diffusenormal_modelspace, VectorR)));\n"
+" myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
"\n"
-" // calculate directional shading\n"
-" vec3 tempcolor = color.rgb * (DiffuseScale * max(dot(surfacenormal, diffusenormal), 0.0));\n"
-"#ifdef USESPECULAR\n"
-" vec3 specularnormal = vec3(normalize(diffusenormal + vec3(normalize(EyeVector))));\n"
-" tempcolor += vec3(texture2D(Texture_Gloss, TexCoord)) * SpecularScale * pow(max(dot(surfacenormal, specularnormal), 0.0), SpecularPower);\n"
+"#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
+" myhvec3 diffusenormal_modelspace = myhvec3(texture2D(Texture_Deluxemap, TexCoordLightmap)) - myhvec3(0.5);\n"
+" myhvec3 diffusenormal = normalize(myhvec3(dot(diffusenormal_modelspace, myhvec3(VectorS)), dot(diffusenormal_modelspace, myhvec3(VectorT)), dot(diffusenormal_modelspace, myhvec3(VectorR))));\n"
+"#else\n"
+" myhvec3 diffusenormal = normalize(myhvec3(texture2D(Texture_Deluxemap, TexCoordLightmap)) - myhvec3(0.5));\n"
"#endif\n"
-"\n"
-" // apply lightmap color\n"
-" color.rgb = tempcolor * vec3(texture2D(Texture_Lightmap, TexCoordLightmap)) + color.rgb * vec3(AmbientScale);\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"#elif defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n"
-" // deluxemap lightmapping using light vectors in tangentspace\n"
-"\n"
-" // get the surface normal and light normal\n"
-" vec3 surfacenormal = normalize(vec3(texture2D(Texture_Normal, TexCoord)) - 0.5);\n"
-" vec3 diffusenormal = normalize(vec3(texture2D(Texture_Deluxemap, TexCoordLightmap)) - 0.5);\n"
-"\n"
" // calculate directional shading\n"
-" vec3 tempcolor = color.rgb * (DiffuseScale * max(dot(surfacenormal, diffusenormal), 0.0));\n"
+" myhvec3 tempcolor = color.rgb * (DiffuseScale * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0)));\n"
"#ifdef USESPECULAR\n"
-" vec3 specularnormal = vec3(normalize(diffusenormal + vec3(normalize(EyeVector))));\n"
-" tempcolor += vec3(texture2D(Texture_Gloss, TexCoord)) * SpecularScale * pow(max(dot(surfacenormal, specularnormal), 0.0), SpecularPower);\n"
+" myhvec3 specularnormal = myhvec3(normalize(diffusenormal + myhvec3(normalize(EyeVector))));\n"
+" tempcolor += myhvec3(texture2D(Texture_Gloss, TexCoord)) * SpecularScale * pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
"#endif\n"
"\n"
" // apply lightmap color\n"
-" color.rgb = tempcolor * vec3(texture2D(Texture_Lightmap, TexCoordLightmap)) + color.rgb * vec3(AmbientScale);\n"
-"\n"
-"\n"
+" color.rgb = tempcolor * myhvec3(texture2D(Texture_Lightmap, TexCoordLightmap)) + color.rgb * AmbientScale;\n"
"\n"
"\n"
"#else // MODE none (lightmap)\n"
" // apply lightmap color\n"
-" color.rgb *= vec3(texture2D(Texture_Lightmap, TexCoordLightmap)) * DiffuseScale + vec3(AmbientScale);\n"
+" color.rgb *= myhvec3(texture2D(Texture_Lightmap, TexCoordLightmap)) * DiffuseScale + myhvec3(AmbientScale);\n"
"#endif // MODE\n"
"\n"
-" color *= gl_Color;\n"
+" color *= myhvec4(gl_Color);\n"
"\n"
"#ifdef USEGLOW\n"
-" color.rgb += vec3(texture2D(Texture_Glow, TexCoord)) * GlowScale;\n"
+" color.rgb += myhvec3(texture2D(Texture_Glow, TexCoord)) * GlowScale;\n"
"#endif\n"
"\n"
"#ifdef USEFOG\n"
" // apply fog\n"
-" float fog = texture2D(Texture_FogMask, vec2(length(EyeVectorModelSpace)*FogRangeRecip, 0.0)).x;\n"
+" myhalf fog = myhalf(texture2D(Texture_FogMask, myhvec2(length(EyeVectorModelSpace)*FogRangeRecip, 0.0)).x);\n"
" color.rgb = color.rgb * fog + FogColor * (1.0 - fog);\n"
"#endif\n"
"\n"
" color.rgb *= SceneBrightness;\n"
"\n"
-" gl_FragColor = color;\n"
+" gl_FragColor = vec4(color);\n"
"}\n"
"\n"
"#endif // FRAGMENT_SHADER\n"
;
+// NOTE: MUST MATCH ORDER OF SHADERPERMUTATION_* DEFINES!
+const char *permutationinfo[][2] =
+{
+ {"#define MODE_LIGHTSOURCE\n", " lightsource"},
+ {"#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"},
+ {"#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"},
+ {"#define MODE_LIGHTDIRECTION\n", " lightdirection"},
+ {"#define USEGLOW\n", " glow"},
+ {"#define USEFOG\n", " fog"},
+ {"#define USECOLORMAPPING\n", " colormapping"},
+ {"#define USESPECULAR\n", " specular"},
+ {"#define USECUBEFILTER\n", " cubefilter"},
+ {"#define USEOFFSETMAPPING\n", " offsetmapping"},
+ {"#define USEOFFSETMAPPING_RELIEFMAPPING\n", " reliefmapping"},
+ {NULL, NULL}
+};
+
void R_GLSL_CompilePermutation(int permutation)
{
+ int i;
r_glsl_permutation_t *p = r_glsl_permutations + permutation;
int vertstrings_count;
int fragstrings_count;
vertstrings_count = 1;
fragstrings_count = 1;
permutationname[0] = 0;
- if (permutation & SHADERPERMUTATION_MODE_LIGHTSOURCE)
- {
- vertstrings_list[vertstrings_count++] = "#define MODE_LIGHTSOURCE\n";
- fragstrings_list[fragstrings_count++] = "#define MODE_LIGHTSOURCE\n";
- strlcat(permutationname, " lightsource", sizeof(permutationname));
- }
- if (permutation & SHADERPERMUTATION_MODE_LIGHTDIRECTIONMAP_MODELSPACE)
- {
- vertstrings_list[vertstrings_count++] = "#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n";
- fragstrings_list[fragstrings_count++] = "#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n";
- strlcat(permutationname, " lightdirectionmap_modelspace", sizeof(permutationname));
- }
- if (permutation & SHADERPERMUTATION_MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)
- {
- vertstrings_list[vertstrings_count++] = "#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n";
- fragstrings_list[fragstrings_count++] = "#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n";
- strlcat(permutationname, " lightdirectionmap_tangentspace", sizeof(permutationname));
- }
- if (permutation & SHADERPERMUTATION_MODE_LIGHTDIRECTION)
- {
- vertstrings_list[vertstrings_count++] = "#define MODE_LIGHTDIRECTION\n";
- fragstrings_list[fragstrings_count++] = "#define MODE_LIGHTDIRECTION\n";
- strlcat(permutationname, " lightdirection", sizeof(permutationname));
- }
- if (permutation & SHADERPERMUTATION_GLOW)
- {
- vertstrings_list[vertstrings_count++] = "#define USEGLOW\n";
- fragstrings_list[fragstrings_count++] = "#define USEGLOW\n";
- strlcat(permutationname, " glow", sizeof(permutationname));
- }
- if (permutation & SHADERPERMUTATION_COLORMAPPING)
- {
- vertstrings_list[vertstrings_count++] = "#define USECOLORMAPPING\n";
- fragstrings_list[fragstrings_count++] = "#define USECOLORMAPPING\n";
- strlcat(permutationname, " colormapping", sizeof(permutationname));
- }
- if (permutation & SHADERPERMUTATION_SPECULAR)
- {
- vertstrings_list[vertstrings_count++] = "#define USESPECULAR\n";
- fragstrings_list[fragstrings_count++] = "#define USESPECULAR\n";
- strlcat(permutationname, " specular", sizeof(permutationname));
- }
- if (permutation & SHADERPERMUTATION_FOG)
- {
- vertstrings_list[vertstrings_count++] = "#define USEFOG\n";
- fragstrings_list[fragstrings_count++] = "#define USEFOG\n";
- strlcat(permutationname, " fog", sizeof(permutationname));
- }
- if (permutation & SHADERPERMUTATION_CUBEFILTER)
- {
- vertstrings_list[vertstrings_count++] = "#define USECUBEFILTER\n";
- fragstrings_list[fragstrings_count++] = "#define USECUBEFILTER\n";
- strlcat(permutationname, " cubefilter", sizeof(permutationname));
- }
- if (permutation & SHADERPERMUTATION_OFFSETMAPPING)
+ for (i = 0;permutationinfo[i][0];i++)
{
- vertstrings_list[vertstrings_count++] = "#define USEOFFSETMAPPING\n";
- fragstrings_list[fragstrings_count++] = "#define USEOFFSETMAPPING\n";
- strlcat(permutationname, " offsetmapping", sizeof(permutationname));
- }
- if (permutation & SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING)
- {
- vertstrings_list[vertstrings_count++] = "#define USEOFFSETMAPPING_RELIEFMAPPING\n";
- fragstrings_list[fragstrings_count++] = "#define USEOFFSETMAPPING_RELIEFMAPPING\n";
- strlcat(permutationname, " OFFSETMAPPING_RELIEFMAPPING", sizeof(permutationname));
+ if (permutation & (1<<i))
+ {
+ vertstrings_list[vertstrings_count++] = permutationinfo[i][0];
+ fragstrings_list[fragstrings_count++] = permutationinfo[i][0];
+ strlcat(permutationname, permutationinfo[i][1], sizeof(permutationname));
+ }
+ else
+ {
+ // keep line numbers correct
+ vertstrings_list[vertstrings_count++] = "\n";
+ fragstrings_list[fragstrings_count++] = "\n";
+ }
}
shaderstring = (char *)FS_LoadFile("glsl/default.glsl", r_main_mempool, false, NULL);
if (shaderstring)
{
if (modellighting)
permutation |= SHADERPERMUTATION_MODE_LIGHTDIRECTION;
- else
+ else if (r_glsl_deluxemapping.integer >= 1 && rsurface_lightmaptexture)
{
- if (r_glsl_deluxemapping.integer >= 1 && r_refdef.worldmodel && r_refdef.worldmodel->brushq3.deluxemapping && rsurface_lightmaptexture)
+ if (r_refdef.worldmodel && r_refdef.worldmodel->brushq3.deluxemapping)
{
if (r_refdef.worldmodel->brushq3.deluxemapping_modelspace)
permutation |= SHADERPERMUTATION_MODE_LIGHTDIRECTIONMAP_MODELSPACE;
l = (int)strlen(entname) - 4;
if (l >= 0 && !strcmp(entname + l, ".bsp"))
{
- strcpy(entname + l, ".ent");
+ memcpy(entname + l, ".ent", 5);
if ((entities = (char *)FS_LoadFile(entname, tempmempool, true, NULL)))
{
CL_ParseEntityLump(entities);
================
*/
void R_RenderView(void)
-{
- if (!r_refdef.entities/* || !r_refdef.worldmodel*/)
- return; //Host_Error ("R_RenderView: NULL worldmodel");
-
- CHECKGLERROR
- if (r_timereport_active)
- R_TimeReport("setup");
-
- R_View_Update();
- if (r_timereport_active)
- R_TimeReport("visibility");
-
- // GL is weird because it's bottom to top, r_view.y is top to bottom
- R_ResetViewRendering();
-
- R_ClearScreen();
- if (r_timereport_active)
- R_TimeReport("clear");
-
- // this produces a bloom texture to be used in R_BlendView() later
- if (r_hdr.integer)
- R_HDR_RenderBloomTexture();
-
- r_view.colorscale = r_hdr_scenebrightness.value;
- R_RenderScene();
-
- R_BlendView();
- if (r_timereport_active)
- R_TimeReport("blendview");
-
- GL_Scissor(0, 0, vid.width, vid.height);
- GL_ScissorTest(false);
- CHECKGLERROR
-}
-
-//[515]: csqc
-void CSQC_R_ClearScreen (void)
{
if (!r_refdef.entities/* || !r_refdef.worldmodel*/)
return; //Host_Error ("R_RenderView: NULL worldmodel");
R_ResetViewRendering();
- R_ClearScreen();
- if (r_timereport_active)
- R_TimeReport("clear");
- CHECKGLERROR
-}
-
-//[515]: csqc
-void CSQC_R_RenderScene (void)
-{
- R_ResetViewRendering();
-
R_ClearScreen();
if (r_timereport_active)
R_TimeReport("clear");
extern void R_DrawPortals (void);
void R_RenderScene(void)
{
+ DrawQ_Finish();
+
// don't let sound skip if going slow
if (r_refdef.extraupdate)
S_ExtraUpdate ();
}
}
-int R_Mesh_AddVertex3f(rmesh_t *mesh, const float *v)
+int R_Mesh_AddVertex(rmesh_t *mesh, float x, float y, float z)
{
int i;
float *vertex3f;
+ float v[3];
+ VectorSet(v, x, y, z);
for (i = 0, vertex3f = mesh->vertex3f;i < mesh->numvertices;i++, vertex3f += 3)
if (VectorDistance2(v, vertex3f) < mesh->epsilon2)
break;
{
int i;
int *e, element[3];
- element[0] = R_Mesh_AddVertex3f(mesh, vertex3f);vertex3f += 3;
- element[1] = R_Mesh_AddVertex3f(mesh, vertex3f);vertex3f += 3;
+ element[0] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
+ element[1] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
e = mesh->element3i + mesh->numtriangles * 3;
for (i = 0;i < numvertices - 2;i++, vertex3f += 3)
{
- element[2] = R_Mesh_AddVertex3f(mesh, vertex3f);
+ element[2] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);
+ if (mesh->numtriangles < mesh->maxtriangles)
+ {
+ *e++ = element[0];
+ *e++ = element[1];
+ *e++ = element[2];
+ mesh->numtriangles++;
+ }
+ element[1] = element[2];
+ }
+}
+
+void R_Mesh_AddPolygon3d(rmesh_t *mesh, int numvertices, double *vertex3d)
+{
+ int i;
+ int *e, element[3];
+ element[0] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
+ element[1] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
+ e = mesh->element3i + mesh->numtriangles * 3;
+ for (i = 0;i < numvertices - 2;i++, vertex3d += 3)
+ {
+ element[2] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);
if (mesh->numtriangles < mesh->maxtriangles)
{
*e++ = element[0];
}
}
+#define R_MESH_PLANE_DIST_EPSILON (1.0 / 32.0)
void R_Mesh_AddBrushMeshFromPlanes(rmesh_t *mesh, int numplanes, mplane_t *planes)
{
int planenum, planenum2;
int w;
int tempnumpoints;
mplane_t *plane, *plane2;
- float temppoints[2][256*3];
+ double maxdist;
+ double temppoints[2][256*3];
+ // figure out how large a bounding box we need to properly compute this brush
+ maxdist = 0;
+ for (w = 0;w < numplanes;w++)
+ maxdist = max(maxdist, planes[w].dist);
+ // now make it large enough to enclose the entire brush, and round it off to a reasonable multiple of 1024
+ maxdist = floor(maxdist * (4.0 / 1024.0) + 1) * 1024.0;
for (planenum = 0, plane = planes;planenum < numplanes;planenum++, plane++)
{
w = 0;
tempnumpoints = 4;
- PolygonF_QuadForPlane(temppoints[w], plane->normal[0], plane->normal[1], plane->normal[2], plane->normal[3], 1024.0*1024.0*1024.0);
+ PolygonD_QuadForPlane(temppoints[w], plane->normal[0], plane->normal[1], plane->normal[2], plane->dist, maxdist);
for (planenum2 = 0, plane2 = planes;planenum2 < numplanes && tempnumpoints >= 3;planenum2++, plane2++)
{
if (planenum2 == planenum)
continue;
- PolygonF_Divide(tempnumpoints, temppoints[w], plane2->normal[0], plane2->normal[1], plane2->normal[2], plane2->dist, 1.0/32.0, 0, NULL, NULL, 256, temppoints[!w], &tempnumpoints, NULL);
+ PolygonD_Divide(tempnumpoints, temppoints[w], plane2->normal[0], plane2->normal[1], plane2->normal[2], plane2->dist, R_MESH_PLANE_DIST_EPSILON, 0, NULL, NULL, 256, temppoints[!w], &tempnumpoints, NULL);
w = !w;
}
if (tempnumpoints < 3)
continue;
// generate elements forming a triangle fan for this polygon
- R_Mesh_AddPolygon3f(mesh, tempnumpoints, temppoints[w]);
+ R_Mesh_AddPolygon3d(mesh, tempnumpoints, temppoints[w]);
}
}
for (i = 0;i < 4;i++)
Matrix4x4_Transform(&imatrix1, (rsurface_vertex3f + 3 * surface->num_firstvertex) + (j+i)*3, v[i]);
for (i = 0;i < 4;i++)
- VectorMAMAMAM(1, center, v[i][0], forward, v[i][1], right, v[i][2], up, rsurface_array_modelvertex3f + (surface->num_firstvertex+i+j) * 3);
+ VectorMAMAMAM(1, center, v[i][0], forward, v[i][1], right, v[i][2], up, rsurface_array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
}
Mod_BuildNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface_modelvertex3f, rsurface_model->surfmesh.data_element3i + surface->num_firsttriangle * 3, rsurface_array_deformednormal3f, r_smoothnormals_areaweighting.integer);
Mod_BuildTextureVectorsFromNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface_modelvertex3f, rsurface_model->surfmesh.data_texcoordtexture2f, rsurface_array_deformednormal3f, rsurface_model->surfmesh.data_element3i + surface->num_firsttriangle * 3, rsurface_array_deformedsvector3f, rsurface_array_deformedtvector3f, r_smoothnormals_areaweighting.integer);
projects / xonotic / darkplaces.git / blobdiff