Post Reply 
 
Thread Rating:
  • 0 Votes - 0 Average
  • 1
  • 2
  • 3
  • 4
  • 5
Shiny roads
02-02-2010, 07:18 AM
Post: #16
 
Ugh yeah, it seems my album is only available to people who are logged in (or only to me). Not sure why, I'll try to fix that if the gallery system allows me. The album is prolly private... anyone how I can make it public please?

There are road reflections on all tracks, but I made them very discrete. They are best seen during turns. I tried leaving them stronger at first, but imo it looked bad and unrealistic past a point (that would look ok on a track where it's raining, otherwise the road looks too wet which doesn't make sense).

I set maximum reflections for water, but if anyone wants I can turn that down a bit. The current reflection doesn't seem over-bright to me... probably depends on brightness settings or other factors. This is how the water looks here: In order to view links, you must have to reply to this thread. , In order to view links, you must have to reply to this thread.
Find all posts by this user
Quote this message in a reply
02-02-2010, 11:26 AM
Post: #17
 
The water looks totally white for me too. It looks great in your screenshots, though. I'll take a closer look at this.
Find all posts by this user
Quote this message in a reply
02-02-2010, 04:59 PM
Post: #18
 
I tested with different rendering settings enabled but never got any white water. Maybe it's something else, possibly video card specific?

Just to be sure it's not the engine, I'm using the following build: In order to view links, you must have to reply to this thread. Try running it from that executable using the latest official vdrift release and seeing if that still results white water. If it does there has to be another issue somewhere.

White can also mean the reflection is too strong, but why would it show differently to everyone on the same map?
Find all posts by this user
Quote this message in a reply
02-02-2010, 06:40 PM
Post: #19
 
maybe it's a linux bug? ubuntu 9.10 here.
just in case it's a graphics card/driver issue:
nvidia 9600m gs on 195.30

and a picture for reference:

[Image: b_vlight.jpg]
Find all posts by this user
Quote this message in a reply
02-02-2010, 07:39 PM
Post: #20
 
portets Wrote:maybe it's a linux bug? ubuntu 9.10 here.
just in case it's a graphics card/driver issue:
nvidia 9600m gs on 195.30

and a picture for reference:

[Image: b_vlight.jpg]

Yeah, that doesn't happen here. It looks like the reflected texture is being mapped differently... the white is likely due to the brightest part of the skybox falling in the middle (for the correct reflection of the track the skybox is in a good angle so that doesn't happen). It's probably a Linux issue, if no one can confirm this happening on Windows too.
Find all posts by this user
Quote this message in a reply
02-02-2010, 09:36 PM
Post: #21
 
so i booted up my windows(wow, haven't been on windows in weeks).

same thing happens for me in windows(latest svn). looks exactly like my previous screenshot.

maybe this is a graphics card/driver issue.

i'm running nvidia's 195 series drivers on both linux and windows. 9600m gs, like i said earlier.

i think joevenzon is running nvidia also. is that right?
what card do you have, MirceaKitsune?
Find all posts by this user
Quote this message in a reply
02-03-2010, 05:08 AM
Post: #22
 
Hmm... that is odd. And my card is an ATI Radeon HD 3870 X2 running on Windows 7 64bit with latest official drivers.
Find all posts by this user
Quote this message in a reply
02-04-2010, 12:00 AM
Post: #23
 
Okay, there are a couple of things going on here. First, the shaders in SVN right now are different than the ones in the build that mirceaKitsune has, which is why it looks different for us and for him. MirceaKitsune, try replacing your data/shaders/fragment/full/*.glsl files with these:
In order to view links, you must have to reply to this thread.

Hopefully they work out of the box and don't depend on any code changes.

Second, there is an issue with the newer shaders that is causing the white water to have a big normal-colored hole in the center.

Also, in the new shaders the red channel means glossy and the green channel means reflection. You probably want glossy for the roads but reflective for the water, so if you make the water file green, it should look correct with the new shaders.
Find all posts by this user
Quote this message in a reply
02-04-2010, 12:12 AM
Post: #24
 
Okay, the shader is fixed in R477.
Find all posts by this user
Quote this message in a reply
02-04-2010, 09:37 AM
Post: #25
 
Thanks, I'll keep that in mind and will make the water and windows green a bit later. I have a separate SVN checkout of VDrift (I didn't do the gloss maps there however) and should have the latest shaders there.

I had to replace the two files in shaders\full with earlier ones though, since the latest versions in SVN don't work (not even the ones fixed today). This is my stterr:

Code:
ERROR: Shader compilation failure: data/shaders/full/vertex.glsl and data/shaders/full/fragment.glsl
ERROR:
ERROR: Vertex shader:
ERROR: 1    : #define _ALPHATEST_
ERROR: 2    : #define _SHADOWSVHIGH_
ERROR: 3    : #define _CSM3_
ERROR: 4    : #define _CSM2_
ERROR: 5    : #define _SHADOWS_
ERROR: 6    : #define _REFLECTIONSTATIC_
ERROR: 7    : #define SCREENRESY 864
ERROR: 8    : #define SCREENRESX 1152
ERROR: 9    : #version 120
ERROR: 10   :
ERROR: 11   : #ifdef _SHADOWS_
ERROR: 12   : varying vec4 projshadow_0;
ERROR: 13   : #ifdef _CSM2_
ERROR: 14   : varying vec4 projshadow_1;
ERROR: 15   : #endif
ERROR: 16   : #ifdef _CSM3_
ERROR: 17   : varying vec4 projshadow_2;
ERROR: 18   : #endif
ERROR: 19   : #endif
ERROR: 20   :
ERROR: 21   : uniform vec3 lightposition;
ERROR: 22   :
ERROR: 23   : varying vec2 texcoord_2d;
ERROR: 24   : varying vec3 V, N;
ERROR: 25   : varying vec3 refmapdir, ambientmapdir;
ERROR: 26   :
ERROR: 27   : void main()
ERROR: 28   : {
ERROR: 29   :     //transform the vertex
ERROR: 30   :     gl_Position = ftransform();
ERROR: 31   :    
ERROR: 32   :     vec4 pos = gl_ModelViewMatrix * gl_Vertex;
ERROR: 33   :     vec3 pos3 = pos.xyz;
ERROR: 34   :  
ERROR: 35   :     #ifdef _SHADOWS_
ERROR: 36   :     projshadow_0 = gl_TextureMatrix[4] * gl_TextureMatrixInverse[3] * pos;
ERROR: 37   :     #ifdef _CSM2_
ERROR: 38   :     projshadow_1 = gl_TextureMatrix[5] * gl_TextureMatrixInverse[3] * pos;
ERROR: 39   :     #endif
ERROR: 40   :     #ifdef _CSM3_
ERROR: 41   :     projshadow_2 = gl_TextureMatrix[6] * gl_TextureMatrixInverse[3] * pos;
ERROR: 42   :     #endif
ERROR: 43   :     #endif
ERROR: 44   :     
ERROR: 45   :     //set the color
ERROR: 46   :     gl_FrontColor = gl_Color;
ERROR: 47   :     
ERROR: 48   :     //set the texture coordinates
ERROR: 49   :     texcoord_2d = vec2(gl_MultiTexCoord0);
ERROR: 50   :     
ERROR: 51   :     //compute the eyespace normal
ERROR: 52   :     N = normalize(gl_NormalMatrix * gl_Normal);
ERROR: 53   :     V = normalize(-pos3);
ERROR: 54   :     //R = normalize(reflect(pos3,N));
ERROR: 55   :    
ERROR: 56   :     #ifndef _REFLECTIONDISABLED_
ERROR: 57   :     refmapdir = vec3(gl_TextureMatrix[2] * vec4(reflect(pos3, N),0));
ERROR: 58   :     #else
ERROR: 59   :     refmapdir = vec3(0.);
ERROR: 60   :     #endif
ERROR: 61   :    
ERROR: 62   :     ambientmapdir = mat3(gl_TextureMatrix[2]) * N;
ERROR: 63   : }
ERROR: 64   :
ERROR:
ERROR: Fragment shader:
ERROR: 1    : #version 120
ERROR: 2    : #define _ALPHATEST_
ERROR: 3    : #define _SHADOWSVHIGH_
ERROR: 4    : #define _CSM3_
ERROR: 5    : #define _CSM2_
ERROR: 6    : #define _SHADOWS_
ERROR: 7    : #define _REFLECTIONSTATIC_
ERROR: 8    : #define SCREENRESY 864
ERROR: 9    : #define SCREENRESX 1152
ERROR: 10   : uniform sampler2D tu0_2D; //diffuse map
ERROR: 11   : uniform sampler2D tu1_2D; //misc map (includes gloss on R channel, metallic on G channel, ...
ERROR: 12   : uniform samplerCube tu3_cube; //ambient light cube map
ERROR: 13   :
ERROR: 14   : //width and height of the diffuse texture, in pixels
ERROR: 15   : //uniform float diffuse_texture_width;
ERROR: 16   :
ERROR: 17   : uniform float contrast;
ERROR: 18   :
ERROR: 19   : #ifdef _SHADOWS_
ERROR: 20   : #ifdef _SHADOWSULTRA_
ERROR: 21   : uniform sampler2D tu4_2D; //close shadow map
ERROR: 22   : #else
ERROR: 23   : uniform sampler2DShadow tu4_2D; //close shadow map
ERROR: 24   : #endif
ERROR: 25   : #ifdef _CSM2_
ERROR: 26   : uniform sampler2DShadow tu5_2D; //far shadow map
ERROR: 27   : #endif
ERROR: 28   : #ifdef _CSM3_
ERROR: 29   : uniform sampler2DShadow tu6_2D; //far far shadow map
ERROR: 30   : #endif
ERROR: 31   : #endif
ERROR: 32   :
ERROR: 33   : //#define _FANCIERSHADOWBLENDING_
ERROR: 34   :
ERROR: 35   : #ifndef _REFLECTIONDISABLED_
ERROR: 36   : uniform samplerCube tu2_cube; //reflection map
ERROR: 37   : #endif
ERROR: 38   :
ERROR: 39   : uniform sampler2D tu8_2D; //additive map (for brake lights)
ERROR: 40   :
ERROR: 41   : #ifdef _EDGECONTRASTENHANCEMENT_
ERROR: 42   : uniform sampler2DShadow tu7_2D; //edge contrast enhancement depth map
ERROR: 43   : #endif
ERROR: 44   :
ERROR: 45   : varying vec2 texcoord_2d;
ERROR: 46   : varying vec3 V, N;
ERROR: 47   : varying vec3 refmapdir, ambientmapdir;
ERROR: 48   : uniform vec3 lightposition;
ERROR: 49   :
ERROR: 50   : const float PI = 3.141593;
ERROR: 51   : const float ONE_OVER_PI = 1.0 / PI;
ERROR: 52   :
ERROR: 53   : #ifdef _SHADOWS_
ERROR: 54   : varying vec4 projshadow_0;
ERROR: 55   : #ifdef _CSM2_
ERROR: 56   : varying vec4 projshadow_1;
ERROR: 57   : #endif
ERROR: 58   : #ifdef _CSM3_
ERROR: 59   : varying vec4 projshadow_2;
ERROR: 60   : #endif
ERROR: 61   : #endif
ERROR: 62   :
ERROR: 63   : #if ( defined (_SHADOWS_) && ( defined (_SHADOWSULTRA_) || defined (_SHADOWSVHIGH_) ) ) || defined (_EDGECONTRASTENHANCEMENT_)
ERROR: 64   : vec2 poissonDisk[16];
ERROR: 65   : #endif
ERROR: 66   :
ERROR: 67   : #ifdef _SHADOWSULTRA_
ERROR: 68   : #define    BLOCKER_SEARCH_NUM_SAMPLES 16
ERROR: 69   : #define    PCF_NUM_SAMPLES 16
ERROR: 70   : #define    NEAR_PLANE 9.5
ERROR: 71   : #define    LIGHT_WORLD_SIZE .05
ERROR: 72   : #define    LIGHT_FRUSTUM_WIDTH 3.75
ERROR: 73   : // Assuming that LIGHT_FRUSTUM_WIDTH == LIGHT_FRUSTUM_HEIGHT
ERROR: 74   : #define LIGHT_SIZE_UV (LIGHT_WORLD_SIZE / LIGHT_FRUSTUM_WIDTH)
ERROR: 75   :
ERROR: 76   : float unpackFloatFromVec4i(const vec4 value)
ERROR: 77   : {
ERROR: 78   :     const vec4 bitSh = vec4(1.0 / (256.0 * 256.0 * 256.0), 1.0 / (256.0 * 256.0), 1.0 / 256.0, 1.0);
ERROR: 79   :     return(dot(value, bitSh));
ERROR: 80   : }
ERROR: 81   :
ERROR: 82   : float unpackFloatFromVec3i(const vec3 value)
ERROR: 83   : {
ERROR: 84   :     const vec3 bitSh = vec3(1.0 / (256.0 * 256.0), 1.0 / 256.0, 1.0);
ERROR: 85   :     return(dot(value, bitSh));
ERROR: 86   : }
ERROR: 87   :
ERROR: 88   : float unpackFloatFromVec2i(const vec2 value)
ERROR: 89   : {
ERROR: 90   :     const vec2 unpack_constants = vec2(1.0/256.0, 1.0);
ERROR: 91   :     return dot(unpack_constants,value);
ERROR: 92   : }
ERROR: 93   :
ERROR: 94   : float shadow_comparison(sampler2D tu, vec2 uv, float comparison)
ERROR: 95   : {
ERROR: 96   :     float lookupvalue = unpackFloatFromVec3i(texture2D(tu, uv).rgb);
ERROR: 97   :     return lookupvalue > comparison ? 1.0 : 0.0;
ERROR: 98   : }
ERROR: 99   :
ERROR: 100  : float PenumbraSize(float zReceiver, float zBlocker) //Parallel plane estimation
ERROR: 101  : {
ERROR: 102  :     return (zReceiver - zBlocker) / zBlocker;
ERROR: 103  : }
ERROR: 104  :
ERROR: 105  : void FindBlocker(in vec2 poissonDisk[16], in sampler2D tu,
ERROR: 106  :          out float avgBlockerDepth,
ERROR: 107  :          out float numBlockers,
ERROR: 108  :          vec2 uv, float zReceiver )
ERROR: 109  : {
ERROR: 110  :     //This uses similar triangles to compute what
ERROR: 111  :     //area of the shadow map we should search
ERROR: 112  :     //float searchWidth = LIGHT_SIZE_UV * (zReceiver - NEAR_PLANE) / zReceiver;
ERROR: 113  :     float searchWidth = 10.0/2048.0;
ERROR: 114  :     //float searchWidth = LIGHT_SIZE_UV;
ERROR: 115  :     float blockerSum = 0;
ERROR: 116  :     numBlockers = 0;
ERROR: 117  :     for( int i = 0; i < BLOCKER_SEARCH_NUM_SAMPLES; ++i )
ERROR: 118  :     {
ERROR: 119  :         //float shadowMapDepth = tDepthMap.SampleLevel(PointSampler,uv + poissonDisk[i] * searchWidth,0);
ERROR: 120  :         float shadowMapDepth = unpackFloatFromVec3i(texture2D(tu, uv + poissonDisk[i] * searchWidth).rgb);
ERROR: 121  :         if ( shadowMapDepth < zReceiver ) {
ERROR: 122  :             blockerSum += shadowMapDepth;
ERROR: 123  :             numBlockers++;
ERROR: 124  :         }
ERROR: 125  :     }
ERROR: 126  :     avgBlockerDepth = blockerSum / numBlockers;
ERROR: 127  : }
ERROR: 128  :
ERROR: 129  : float PCF_Filter( in vec2 poissonDisk[16], in sampler2D tu, in vec2 uv, in float zReceiver, in float filterRadiusUV )
ERROR: 130  : {
ERROR: 131  :     float sum = 0.0f;
ERROR: 132  :     for ( int i = 0; i < PCF_NUM_SAMPLES; ++i )
ERROR: 133  :     {
ERROR: 134  :         vec2 offset = poissonDisk[i] * filterRadiusUV;
ERROR: 135  :         sum += shadow_comparison(tu, uv + offset, zReceiver);
ERROR: 136  :     }
ERROR: 137  :     return sum / PCF_NUM_SAMPLES;
ERROR: 138  :     //vec2 offset = vec2(1.0/2048.0,1.0/2048.0);
ERROR: 139  :     //vec2 offset = vec2(0.0,0.0);
ERROR: 140  :     //return unpackFloatFromVec4i(texture2D(tu, uv + offset)) >= zReceiver ? 1.0 : 0.0;
ERROR: 141  :     //return unpackFloatFromVec3i(texture2D(tu, uv + offset).rgb) > zReceiver + 1.0/(256.0*256.0) ? 1.0 : 0.0;
ERROR: 142  :     //return unpackFloatFromVec3i(texture2D(tu, uv + offset).rgb) > zReceiver + 1.0/(256.0*4.0) ? 1.0 : 0.0;
ERROR: 143  :     //return unpackFloatFromVec2i(texture2D(tu, uv + offset).rg) >= zReceiver ? 1.0 : 0.0;
ERROR: 144  : }
ERROR: 145  :
ERROR: 146  : float PCSS ( in vec2 poissonDisk[16], in sampler2D tu, vec3 coords )
ERROR: 147  : {
ERROR: 148  :     vec2 uv = coords.xy;
ERROR: 149  :     float zReceiver = coords.z; // Assumed to be eye-space z in this code
ERROR: 150  :     // STEP 1: blocker search
ERROR: 151  :     float avgBlockerDepth = 0;
ERROR: 152  :     float numBlockers = 0;
ERROR: 153  :     FindBlocker( poissonDisk, tu, avgBlockerDepth, numBlockers, uv, zReceiver );
ERROR: 154  :     if( numBlockers < 1 )
ERROR: 155  :         //There are no occluders so early out (this saves filtering)
ERROR: 156  :         return 1.0f;
ERROR: 157  :     // STEP 2: penumbra size
ERROR: 158  :     float penumbraRatio = PenumbraSize(zReceiver, avgBlockerDepth);
ERROR: 159  :     //float filterRadiusUV = penumbraRatio * LIGHT_SIZE_UV * NEAR_PLANE / coords.z;
ERROR: 160  :     float filterRadiusUV = clamp(penumbraRatio*0.05,0,20.0/2048.0);
ERROR: 161  :     //float filterRadiusUV = penumbraRatio*(256.0/2048.0);
ERROR: 162  :     // STEP 3: filtering
ERROR: 163  :     return PCF_Filter( poissonDisk, tu, uv, zReceiver, filterRadiusUV );
ERROR: 164  : }
ERROR: 165  :
ERROR: 166  : float shadow_lookup(sampler2D tu, vec3 coords)
ERROR: 167  : #else
ERROR: 168  : float shadow_lookup(sampler2DShadow tu, vec3 coords)
ERROR: 169  : #endif
ERROR: 170  : {
ERROR: 171  :     #ifdef _SHADOWSULTRA_
ERROR: 172  :     float notshadowfinal = PCSS(poissonDisk, tu, coords);
ERROR: 173  :     #else
ERROR: 174  :     #ifdef _SHADOWSVHIGH_
ERROR: 175  :     float notshadowfinal = 0.0;
ERROR: 176  :     float radius = 3.0/2048.0;
ERROR: 177  :     for (int i = 0; i < 16; i++)
ERROR: 178  :         notshadowfinal += float(shadow2D(tu,coords + radius*vec3(poissonDisk[i],0.0)).r);
ERROR: 179  :     notshadowfinal *= 1.0/16.0;
ERROR: 180  :     #else
ERROR: 181  :     //no PCF
ERROR: 182  :     float notshadowfinal = float(shadow2D(tu, coords).r);
ERROR: 183  :     #endif
ERROR: 184  :     #endif
ERROR: 185  :     
ERROR: 186  :     return notshadowfinal;
ERROR: 187  : }
ERROR: 188  :
ERROR: 189  : #ifdef _EDGECONTRASTENHANCEMENT_
ERROR: 190  : float GetEdgeContrastEnhancementFactor(in sampler2DShadow tu, in vec3 coords)
ERROR: 191  : {
ERROR: 192  :     float factor = 0.0;
ERROR: 193  :     float radius = 3.0/1024.0;
ERROR: 194  :     for (int i = 0; i < 8; i++)
ERROR: 195  :         factor += float(shadow2D(tu,coords + radius*vec3(poissonDisk[i],0.0)).r);
ERROR: 196  :     factor *= 1.0/8.0;
ERROR: 197  :     return factor;
ERROR: 198  : }
ERROR: 199  : #endif
ERROR: 200  :
ERROR: 201  : //post-processing functions
ERROR: 202  : vec3 ContrastSaturationBrightness(vec3 color, float con, float sat, float brt)
ERROR: 203  : {
ERROR: 204  :     // Increase or decrease theese values to adjust r, g and b color channels seperately
ERROR: 205  :     const float AvgLumR = 0.5;
ERROR: 206  :     const float AvgLumG = 0.5;
ERROR: 207  :     const float AvgLumB = 0.5;
ERROR: 208  :     
ERROR: 209  :     const vec3 LumCoeff = vec3(0.2125, 0.7154, 0.0721);
ERROR: 210  :     
ERROR: 211  :     vec3 AvgLumin = vec3(AvgLumR, AvgLumG, AvgLumB);
ERROR: 212  :     vec3 brtColor = color * brt;
ERROR: 213  :     vec3 intensity = vec3(dot(brtColor, LumCoeff));
ERROR: 214  :     vec3 satColor = mix(intensity, brtColor, sat);
ERROR: 215  :     vec3 conColor = mix(AvgLumin, satColor, con);
ERROR: 216  :     return conColor;
ERROR: 217  :    
ERROR: 218  :     //vec3 AvgLumin = vec3(0.5,0.5,0.5);
ERROR: 219  :     //return mix(AvgLumin, color, con);
ERROR: 220  : }
ERROR: 221  : #define BlendScreenf(base, blend)         (1.0 - ((1.0 - base) * (1.0 - blend)))
ERROR: 222  : #define BlendSoftLightf(base, blend)     ((blend < 0.5) ? (2.0 * base * blend + base * base * (1.0 - 2.0 * blend)) : (sqrt(base) * (2.0 * blend - 1.0) + 2.0 * base * (1.0 - blend)))
ERROR: 223  : #define BlendOverlayf(base, blend)     (base < 0.5 ? (2.0 * base * blend) : (1.0 - 2.0 * (1.0 - base) * (1.0 - blend)))
ERROR: 224  : #define Blend(base, blend, funcf)         vec3(funcf(base.r, blend.r), funcf(base.g, blend.g), funcf(base.b, blend.b))
ERROR: 225  : #define BlendOverlay(base, blend)         Blend(base, blend, BlendOverlayf)
ERROR: 226  : #define BlendSoftLight(base, blend)     Blend(base, blend, BlendSoftLightf)
ERROR: 227  : #define BlendScreen(base, blend)         Blend(base, blend, BlendScreenf)
ERROR: 228  : #define GammaCorrection(color, gamma)                                pow(color, 1.0 / gamma)
ERROR: 229  : #define LevelsControlInputRange(color, minInput, maxInput)                min(max(color - vec3(minInput), vec3(0.0)) / (vec3(maxInput) - vec3(minInput)), vec3(1.0))
ERROR: 230  : #define LevelsControlInput(color, minInput, gamma, maxInput)                GammaCorrection(LevelsControlInputRange(color, minInput, maxInput), gamma)
ERROR: 231  :
ERROR: 232  : float GetShadows()
ERROR: 233  : {
ERROR: 234  :     #if ( defined (_SHADOWS_) && ( defined (_SHADOWSULTRA_) || defined (_SHADOWSVHIGH_) ) ) || defined (_EDGECONTRASTENHANCEMENT_)
ERROR: 235  :     poissonDisk[0] = vec2( -0.94201624, -0.39906216 );
ERROR: 236  :     poissonDisk[1] = vec2( 0.94558609, -0.76890725 );
ERROR: 237  :     poissonDisk[2] = vec2( -0.094184101, -0.92938870 );
ERROR: 238  :     poissonDisk[3] = vec2( 0.34495938, 0.29387760 );
ERROR: 239  :     poissonDisk[4] = vec2( -0.91588581, 0.45771432 );
ERROR: 240  :     poissonDisk[5] = vec2( -0.81544232, -0.87912464 );
ERROR: 241  :     poissonDisk[6] = vec2( -0.38277543, 0.27676845 );
ERROR: 242  :     poissonDisk[7] = vec2( 0.97484398, 0.75648379 );
ERROR: 243  :     poissonDisk[8] = vec2( 0.44323325, -0.97511554 );
ERROR: 244  :     poissonDisk[9] = vec2( 0.53742981, -0.47373420 );
ERROR: 245  :     poissonDisk[10] = vec2( -0.26496911, -0.41893023 );
ERROR: 246  :     poissonDisk[11] = vec2( 0.79197514, 0.19090188 );
ERROR: 247  :     poissonDisk[12] = vec2( -0.24188840, 0.99706507 );
ERROR: 248  :     poissonDisk[13] = vec2( -0.81409955, 0.91437590 );
ERROR: 249  :     poissonDisk[14] = vec2( 0.19984126, 0.78641367 );
ERROR: 250  :     poissonDisk[15] = vec2( 0.14383161, -0.14100790 );
ERROR: 251  :     #endif
ERROR: 252  :     
ERROR: 253  :     #ifdef _SHADOWS_
ERROR: 254  :     
ERROR: 255  :     #ifdef _CSM3_
ERROR: 256  :     const int numcsm = 3;
ERROR: 257  :     #else
ERROR: 258  :     #ifdef _CSM2_
ERROR: 259  :     const int numcsm = 2;
ERROR: 260  :     #else
ERROR: 261  :     const int numcsm = 1;
ERROR: 262  :     #endif
ERROR: 263  :     #endif
ERROR: 264  :     
ERROR: 265  :     vec3 shadowcoords[numcsm];
ERROR: 266  :     
ERROR: 267  :     shadowcoords[0] = projshadow_0.xyz;
ERROR: 268  :     #ifdef _CSM2_
ERROR: 269  :     shadowcoords[1] = projshadow_1.xyz;
ERROR: 270  :     #endif
ERROR: 271  :     #ifdef _CSM3_
ERROR: 272  :     shadowcoords[2] = projshadow_2.xyz;
ERROR: 273  :     #endif
ERROR: 274  :     
ERROR: 275  :     #ifndef _FANCIERSHADOWBLENDING_
ERROR: 276  :     const float boundmargin = 0.1;
ERROR: 277  :     const float boundmax = 1.0 - boundmargin;
ERROR: 278  :     const float boundmin = 0.0 + boundmargin;
ERROR: 279  :     
ERROR: 280  :     bool effect[numcsm];
ERROR: 281  :     
ERROR: 282  :     for (int i = 0; i < numcsm; i++)
ERROR: 283  :     {
ERROR: 284  :         effect[i] = (shadowcoords[i].x < boundmin || shadowcoords[i].x > boundmax) ||
ERROR: 285  :         (shadowcoords[i].y < boundmin || shadowcoords[i].y > boundmax) ||
ERROR: 286  :         (shadowcoords[i].z < boundmin || shadowcoords[i].z > boundmax);
ERROR: 287  :     }
ERROR: 288  :     #endif //no fancier shadow blending
ERROR: 289  :     
ERROR: 290  :     //shadow lookup that works better with ATI cards:  no early out
ERROR: 291  :     float notshadow[numcsm];
ERROR: 292  :     notshadow[0] = shadow_lookup(tu4_2D, shadowcoords[0]);
ERROR: 293  :     #ifdef _CSM2_
ERROR: 294  :     notshadow[1] = shadow_lookup(tu5_2D, shadowcoords[1]);
ERROR: 295  :     #endif
ERROR: 296  :     #ifdef _CSM3_
ERROR: 297  :     notshadow[2] = shadow_lookup(tu6_2D, shadowcoords[2]);
ERROR: 298  :     #endif
ERROR: 299  :     
ERROR: 300  :     //simple shadow mixing, no shadow fade-in
ERROR: 301  :     #ifndef _FANCIERSHADOWBLENDING_
ERROR: 302  :     //float notshadowfinal = notshadow[0];
ERROR: 303  :     float notshadowfinal = max(notshadow[0],float(effect[0]));
ERROR: 304  :     #ifdef _CSM3_
ERROR: 305  :     notshadowfinal = mix(notshadowfinal,mix(notshadow[1],notshadow[2],float(effect[1])),float(effect[0]));
ERROR: 306  :     notshadowfinal = max(notshadowfinal,float(effect[2]));
ERROR: 307  :     #else
ERROR: 308  :     #ifdef _CSM2_
ERROR: 309  :     notshadowfinal = mix(notshadowfinal,notshadow[1],float(effect[0]));
ERROR: 310  :     notshadowfinal = max(notshadowfinal,float(effect[1]));
ERROR: 311  :     #endif
ERROR: 312  :     #endif
ERROR: 313  :     #endif //no fancier shadow blending
ERROR: 314  :     
ERROR: 315  :     //fancy shadow mixing, gives shadow fade-in
ERROR: 316  :     #ifdef _FANCIERSHADOWBLENDING_
ERROR: 317  :     const float bound = 1.0;
ERROR: 318  :     const float fade = 10.0;
ERROR: 319  :     float effect[numcsm];
ERROR: 320  :     
ERROR: 321  :     for (int i = 0; i < numcsm; ++i)
ERROR: 322  :     //for (int i = 3; i < 4; ++i)
ERROR: 323  :     {
ERROR: 324  :         shadowcoords[i] = clamp(shadowcoords[i], 0.0, bound);
ERROR: 325  :         float xf1 = 1.0-min(1.0,shadowcoords[i].x*fade);
ERROR: 326  :         float xf2 = max(0.0,shadowcoords[i].x*fade-(fade-1.0));
ERROR: 327  :         float yf1 = 1.0-min(1.0,shadowcoords[i].y*fade);
ERROR: 328  :         float yf2 = max(0.0,shadowcoords[i].y*fade-(fade-1.0));
ERROR: 329  :         float zf1 = 1.0-min(1.0,shadowcoords[i].z*fade);
ERROR: 330  :         float zf2 = max(0.0,shadowcoords[i].z*fade-(fade-1.0));
ERROR: 331  :         effect[i] = max(xf1,max(xf2,max(yf1,max(yf2,max(zf1,zf2)))));
ERROR: 332  :         //notshadow[i] = max(notshadow[i],effect[i]);
ERROR: 333  :     }
ERROR: 334  :     
ERROR: 335  :     float notshadowfinal = notshadow[0];
ERROR: 336  :     #ifdef _CSM3_
ERROR: 337  :     notshadowfinal = mix(notshadowfinal,mix(notshadow[1],notshadow[2],effect[1]),effect[0]);
ERROR: 338  :     notshadowfinal = max(notshadowfinal,effect[2]);
ERROR: 339  :     #else
ERROR: 340  :     #ifdef _CSM2_
ERROR: 341  :     notshadowfinal = mix(notshadowfinal,notshadow[1],effect[0]);
ERROR: 342  :     notshadowfinal = max(notshadowfinal,effect[1]);
ERROR: 343  :     #else
ERROR: 344  :     notshadowfinal = max(notshadowfinal,effect[0]);
ERROR: 345  :     #endif
ERROR: 346  :     #endif
ERROR: 347  :     #endif //fancier shadow blending
ERROR: 348  :     
ERROR: 349  :     #else //no SHADOWS
ERROR: 350  :     float notshadowfinal = 1.0;
ERROR: 351  :     #endif
ERROR: 352  :
ERROR: 353  :     return notshadowfinal;
ERROR: 354  :     //return notshadow[2];
ERROR: 355  :     //return max(shadow_lookup(tu6_2D, shadowcoords[2]),float(effect[2]));
ERROR: 356  :     //return float(effect[0])*0.25+float(effect[1])*0.25+float(effect[2])*0.25;
ERROR: 357  :     //return float(effect[0]);
ERROR: 358  : }
ERROR: 359  :
ERROR: 360  : float EffectStrength(float val, float coeff)
ERROR: 361  : {
ERROR: 362  :     return val*coeff+1.0-coeff;
ERROR: 363  : }
ERROR: 364  :
ERROR: 365  : vec3 EffectStrength(vec3 val, float coeff)
ERROR: 366  : {
ERROR: 367  :     return val*coeff+vec3(1.0-coeff);
ERROR: 368  : }
ERROR: 369  :
ERROR: 370  : float ColorCorrectfloat(in float x)
ERROR: 371  : {
ERROR: 372  :     //return pow(x,5.0)*5.23878+pow(x,4.0)*-14.45564+pow(x,3.0)*12.6883+pow(x,2.0)*-3.78462+x*1.31897-.01041;
ERROR: 373  :     return (1.-pow(1.-clamp(x,0.,1.),1.5))*1.2-0.2;
ERROR: 374  :     //return x;
ERROR: 375  : }
ERROR: 376  :
ERROR: 377  : vec3 ColorCorrect(in vec3 val)
ERROR: 378  : {
ERROR: 379  :     return vec3(ColorCorrectfloat(val.r),ColorCorrectfloat(val.g),ColorCorrectfloat(val.b))​;
ERROR: 380  : }
ERROR: 381  :
ERROR: 382  : vec3 Expose(vec3 light, float exposure)
ERROR: 383  : {
ERROR: 384  :     return vec3(1.)-exp(-light*exposure);
ERROR: 385  : }
ERROR: 386  :
ERROR: 387  : float BRDF_Ward(vec3 N, vec3 L, vec3 H, vec3 R, vec3 T, vec3 B, vec2 P, vec2 A, vec3 scale)
ERROR: 388  : {
ERROR: 389  :     float e1 = dot(H, T) / A.x;
ERROR: 390  :     float e2 = dot(H, B) / A.y;
ERROR: 391  :     float E = -2.0 * ((e1 * e1 + e2 * e2) / (1.0 + dot(H,N)));
ERROR: 392  :     float cosThetaI = dot(N, L);
ERROR: 393  :     float cosThetaR = dot(N, R);
ERROR: 394  :     float brdf = P.x * ONE_OVER_PI +
ERROR: 395  :                  P.y * (1.0 / sqrt(cosThetaI * cosThetaR)) *
ERROR: 396  :                  (1.0 / (4.0 * PI * A.x * A.y)) * exp(E);
ERROR: 397  :     return scale.x * P.x * ONE_OVER_PI +
ERROR: 398  :                       scale.y * P.y * cosThetaI * brdf +
ERROR: 399  :                       scale.z * dot(H,N) * P.y;
ERROR: 400  : }
ERROR: 401  :
ERROR: 402  : float BRDF_OrenNayar(vec3 V, vec3 N, vec3 L, float roughness)
ERROR: 403  : {
ERROR: 404  :     float S2 = roughness * roughness;
ERROR: 405  :     float dotVN = dot(V,N);
ERROR: 406  :     float dotLN = dot(L,N);
ERROR: 407  :     float thetai = acos(dotVN);
ERROR: 408  :     float thetar = acos(dotLN);
ERROR: 409  :     float alpha = max(thetai,thetar);
ERROR: 410  :     float beta = min(thetai, thetar);
ERROR: 411  :    
ERROR: 412  :     float gamma = dot(V - N * dotVN, L - N*dotLN);
ERROR: 413  :    
ERROR: 414  :     float C1 = 1.-0.5*(S2/(S2+0.33));
ERROR: 415  :     float C2 = 0.45*(S2/(S2+0.09));
ERROR: 416  :    
ERROR: 417  :     if (gamma >= 0.)
ERROR: 418  :     {
ERROR: 419  :         C2 *= sin(alpha);
ERROR: 420  :     }
ERROR: 421  :     else
ERROR: 422  :     {
ERROR: 423  :         C2 *= (sin(alpha)-pow((2.*beta)*ONE_OVER_PI,3.));
ERROR: 424  :     }
ERROR: 425  :    
ERROR: 426  :     float C3 = 0.125 * (S2/(S2+0.09)) * pow((4.*alpha*beta)*ONE_OVER_PI*ONE_OVER_PI,2.);
ERROR: 427  :    
ERROR: 428  :     float A = gamma * C2 * tan(beta);
ERROR: 429  :     float B = (1.-abs(gamma)) * C3 * tan((alpha+beta)*0.5);
ERROR: 430  :    
ERROR: 431  :     return max(0.,dotLN)*(C1+A+B);
ERROR: 432  : }
ERROR: 433  :
ERROR: 434  : float BRDF_CookTorrance(vec3 V, vec3 N, vec3 L, vec3 H, float roughness, float fresnel)
ERROR: 435  : {
ERROR: 436  :     float R2 = roughness * 3.0;
ERROR: 437  :     R2 *= R2;
ERROR: 438  :     float NdotH = dot(N, H);
ERROR: 439  :     float VdotH = dot(V, H);
ERROR: 440  :     float NdotV = dot(N, V);
ERROR: 441  :     float NdotL = max(0.,dot(N, L));
ERROR: 442  :     float OneOverVdotH = 1. / max(VdotH,0.001);
ERROR: 443  :    
ERROR: 444  :     //geometric term
ERROR: 445  :     float G1 = (2.*NdotH*NdotV) * OneOverVdotH;
ERROR: 446  :     float G2 = (2.*NdotH*NdotL) * OneOverVdotH;
ERROR: 447  :     float G = min(1.,max(0.,min(G1,G2)));
ERROR: 448  :    
ERROR: 449  :     //fresnel term
ERROR: 450  :     float F = fresnel + (1.-fresnel)*pow(1.-NdotV,5.);
ERROR: 451  :    
ERROR: 452  :     //roughness term
ERROR: 453  :     float NdotH2  = NdotH*NdotH;
ERROR: 454  :     float A = 1./(4.*R2*NdotH2*NdotH2);
ERROR: 455  :     float B = exp(-(1.-NdotH2)/(R2*NdotH2));
ERROR: 456  :     float R0 = A * B;
ERROR: 457  :    
ERROR: 458  :     //final term
ERROR: 459  :     return max(0.,(G*F*R0)/(NdotL*NdotV));
ERROR: 460  : }
ERROR: 461  :
ERROR: 462  : float BRDF_Lambert(vec3 N, vec3 L)
ERROR: 463  : {
ERROR: 464  :     return max(0.,dot(L,N));
ERROR: 465  : }
ERROR: 466  :
ERROR: 467  : void main()
ERROR: 468  : {
ERROR: 469  :     float notshadowfinal = GetShadows();
ERROR: 470  :  
ERROR: 471  :     vec4 tu0_2D_val = texture2D(tu0_2D, texcoord_2d);
ERROR: 472  :     vec3 surfacecolor = tu0_2D_val.rgb;
ERROR: 473  :     vec3 additive = texture2D(tu8_2D, texcoord_2d).rgb;
ERROR: 474  :     vec3 ambient_light = textureCube(tu3_cube, ambientmapdir).rgb;
ERROR: 475  :     //const vec3 ambient_light = vec3(1.);
ERROR: 476  :     vec4 tu1_2D_val = texture2D(tu1_2D, texcoord_2d);
ERROR: 477  :     float gloss = tu1_2D_val.r;
ERROR: 478  :     float metallic = tu1_2D_val.g;
ERROR: 479  :     vec3 L = lightposition;
ERROR: 480  :     vec3 Nn = normalize(N);
ERROR: 481  :     vec3 Vn = normalize(V);
ERROR: 482  :     vec3 H = normalize(lightposition+V);
ERROR: 483  :    
ERROR: 484  :      vec3 diffuse = surfacecolor * (BRDF_Lambert(N,L)*notshadowfinal+ambient_light)*0.5;
ERROR: 485  :    
ERROR: 486  :     vec3 specular = vec3(0.);
ERROR: 487  :     if (gloss > 0. || metallic > 0.)
ERROR: 488  :     {
ERROR: 489  :         #ifndef _REFLECTIONDISABLED_
ERROR: 490  :         vec3 specular_environment = textureCube(tu2_cube, refmapdir).rgb;
ERROR: 491  :         #else
ERROR: 492  :         vec3 specular_environment = vec3(1.);
ERROR: 493  :         #endif
ERROR: 494  :        
ERROR: 495  :         float specval = max(dot(reflect(-Vn,Nn),L),0.0);
ERROR: 496  :         float spec_add_highlight = metallic*2.0*max((pow(specval,512.0)-0.5)*2.0,0.0);
ERROR: 497  :         float brdf_gloss = clamp(BRDF_CookTorrance(Vn, Nn, L, H, 0.1, 0.05)*gloss,0.,1.);
ERROR: 498  :         float brdf_metal = clamp(BRDF_CookTorrance(Vn, Nn, L, H, 0.3, 0.15)*metallic,0.,1.);
ERROR: 499  :         //float brdf = brdf_gloss+brdf_metal;
ERROR: 500  :         specular = (notshadowfinal*0.5+0.5)*(brdf_gloss*vec3(1.)+brdf_metal*specular_environment) + vec3(1.)*spec_add_highlight*notshadowfinal;
ERROR: 501  :         diffuse *= 1.0-(brdf_gloss+brdf_metal)*0.5;
ERROR: 502  :     }
ERROR: 503  :    
ERROR: 504  :     vec3 finalcolor = diffuse + specular + additive;
ERROR: 505  :    
ERROR: 506  :     //finalcolor = surfacecolor*vec3((BRDF_Lambert(N,L)*notshadowfinal+ambient_light)*0.5);
ERROR: 507  :     //finalcolor = 1.156*(vec3(1.)-exp(-pow(finalcolor,vec3(1.3))*2.));
ERROR: 508  :     finalcolor = 1.58*(vec3(1.)-exp(-finalcolor*1.));
ERROR: 509  :     //finalcolor = (finalcolor+0.05)*1.1;
ERROR: 510  :     //finalcolor = ColorCorrect(finalcolor);
ERROR: 511  :    
ERROR: 512  :     finalcolor = ContrastSaturationBrightness(finalcolor, contrast, 1.0/contrast, (contrast-1.0)*0.5+1.0);
ERROR: 513  :     //finalcolor = Expose(finalcolor, contrast*3.0-2.0)*1.15;//(1./(1.-exp(-(contrast*3.-2.))));
ERROR: 514  :     finalcolor = clamp(finalcolor,0.0,1.0);
ERROR: 515  :     
ERROR: 516  : #ifdef _EDGECONTRASTENHANCEMENT_
ERROR: 517  :     vec3 depthcoords = vec3(gl_FragCoord.x/SCREENRESX, gl_FragCoord.y/SCREENRESY, gl_FragCoord.z-0.001);
ERROR: 518  :     float edgefactor = GetEdgeContrastEnhancementFactor(tu7_2D, depthcoords);
ERROR: 519  :     finalcolor *= edgefactor*0.5+0.5;
ERROR: 520  : #endif
ERROR: 521  :     
ERROR: 522  : #ifdef _ALPHATEST_
ERROR: 523  :     //float width = clamp(dFdx(texcoord_2d.x) * diffuse_texture_width * 0.5,0.0,0.5);
ERROR: 524  :     float width = clamp(dFdx(texcoord_2d.x) * 512.0 * 0.5,0.0,0.5);
ERROR: 525  :     float alpha = smoothstep(0.5-width, 0.5+width, tu0_2D_val.a);
ERROR: 526  : #else
ERROR: 527  :     float alpha = tu0_2D_val.a;
ERROR: 528  : #endif
ERROR: 529  :     
ERROR: 530  :     gl_FragColor.a = alpha*gl_Color.a;
ERROR: 531  :    
ERROR: 532  :     gl_FragColor.rgb = finalcolor;
ERROR: 533  :     //gl_FragColor.rgb = finalcolor*gl_Color.a;
ERROR: 534  :     //gl_FragColor.rgb = finalcolor*alpha;
ERROR: 535  : }
ERROR: 536  :
ERROR:
ERROR: Disabling shaders due to shader loading error
ERROR: Can't find file: data/cars/360/body.ova
ERROR: Can't find file: data/drivers/driver2/body.ova
ERROR: Can't find file: data/cars/360/wheel_front.ova
ERROR: Can't find file: data/cars/360/wheel_rear.ova
Find all posts by this user
Quote this message in a reply
02-05-2010, 10:04 AM
Post: #26
 
Thanks NaN for fixing the shaders. The SVN shaders are indeed different from the previous release. I'm getting the white water too... that's the gloss map being mapped incorrectly (if the way it's done now is wrong) but reflections are still good.

I modified the textures to what seems best for the current setup, but imo some things need to be tweaked in the shaders. The road reflections are now gray so there is both gloss and a watery look. Water and Windows are yellowish green (reflection with little gloss). Updated archive here In order to view links, you must have to reply to this thread. alt link In order to view links, you must have to reply to this thread.

Imo the intensities of the new shaders may need to be tweaked too. Reflections theirselves seem to be weaker than previously, and cars look too matte now. Also, there are situations (such as the white water issue) where gloss is too strong, yet from many angles it's not visible at all (would be nice to see it more often).
Find all posts by this user
Quote this message in a reply
10-15-2011, 08:20 AM
Post: #27
 
Updated Vdrift yesterday, and remembered these textures too. They don't seem to have been added to game yet, so I was wondering if they either got forgotten or are not good enough yet. I'd love to see the shiny roads in by default Smile Normally they should still work with all of the default tracks, and no more tweaks should be needed. Any news or feedback on this please?
Find all posts by this user
Quote this message in a reply
10-16-2011, 07:49 PM
Post: #28
 
Two things happened:
1) I forgot to check these in way back when
2) the specular map format changed, so now the RGB represent specular color and the A represents shininess. I auto-converted existing miscmaps but since I forgot to check yours in they didn't get included in the batch conversion.

I will load these up and run them through the converter and check them in if they convert OK.
Find all posts by this user
Quote this message in a reply
10-16-2011, 10:00 PM
Post: #29
 
I just checked in the results. The converter made the effect much more subtle, they probably need to be adjusted manually to bring up the shininess a bit. Also, the converter choked on the rouen files because they were 8-bit, so I didn't check those in. I tweaked the water on monaco88 to look better and adjusted the shaders (and fixed some bugs in them):
In order to view links, you must have to reply to this thread.
Find all posts by this user
Quote this message in a reply
02-13-2012, 05:29 AM
Post: #30
 
Hello there! Great work, portets. The road reflections on all tracks are impressive, even if not turning them. Enjoyed.
Find all posts by this user
Quote this message in a reply
Post Reply 


Forum Jump:


User(s) browsing this thread: 1 Guest(s)