Changeset 2095 for GTP/trunk/App/Demos/Illum/Ogre/Media/materials/GTPAdvancedEnvMap

Timestamp:

02/05/07 17:43:39 (18 years ago)

Author:

szirmay

Message:

 

Location:

GTP/trunk/App/Demos/Illum/Ogre/Media/materials/GTPAdvancedEnvMap/multibounce

Files:

• Copy of GTPMultipleReflection.hlsl (added)
• Copy of GTPMultipleReflection_MinMax.hlsl (added)
• GTPMultipleReflection.hlsl (modified) (4 diffs)
• GTPMultipleReflection_MinMax.hlsl (modified) (13 diffs)
• multipleReflectionMinMax/GTPMultipleReflectionMinMax.material (modified) (1 diff)
• multipleRefractionMinMax/GTPMultipleRefractionMinMax.material (added)

GTP/trunk/App/Demos/Illum/Ogre/Media/materials/GTPAdvancedEnvMap/multibounce/GTPMultipleReflection.hlsl

@@ -11 +11 @@
 }
 
-#define MAX_LIN_ITERATIONCOUNT 30  //80
-#define MIN_LIN_ITERATIONCOUNT 20  //60
+#define MAX_LIN_ITERATIONCOUNT 50  //80
+#define MIN_LIN_ITERATIONCOUNT 15  //60
 #define SECANT_ITERATIONCOUNT 1
-#define MAX_RAY_DEPTH 2
+#define MAX_RAY_DEPTH 4
 
 void linearSearch(  float3 x, float3 R, float3 N, samplerCUBE mp,
@@ -219 +219 @@
           V = normalize(V);
          
-         float F = sFresnel + pow(1 - dot(N, -V), 5) * (1 - sFresnel);   
-        
-         float3 l;
-         float4 Irefl;
+         float F;
          int depth = 0;
-        
-         while(depth < MAX_RAY_DEPTH)
-         {
-            float3 R;  
-           R = normalize(reflect( V, N));         
-                
-           float3 Nl;
-           float4 Il;
-           l = Hit(x, R, N, NormDistMap1, NormDistMap2, CubeMap, DistanceMap, Il, Nl);
-           if(Il.a == 0)
-           {
-                   depth += 1;           
-           }
-           else
-           {
-                   I = Il;
-                   depth = MAX_RAY_DEPTH;
-           }
-           x = l;          
-           N = Nl;
-           V = R;   
-           
-        }
-        if(I.a == 0)
-           I = readCubeMap(CubeMap, l);
-        Irefl = I;
-        
-        {
-        float4 Irefr;
-        N = normalize(IN.wNormal.xyz);
-        x = IN.wPos.xyz - lastCenter;
-        V  = (IN.wPos.xyz - cameraPos);
-        depth = 0;
+        F = sFresnel + pow(1 - dot(N, -V), 5) * (1 - sFresnel);  
         
         while(depth < MAX_RAY_DEPTH)
         {
           float3 R;  
-          
-          float ri = refIndex;
-         
+                 
+          float ri = refIndex;   
           if(dot(V,N) > 0)
           {
@@ -270 +234 @@
           }
           R = refract( V, N, ri);
-          if(dot(R,R) == 0) R = reflect( V, N); 
-                                        
+          if(dot(R,R) == 0) R = reflect( V, N);
+                                                
+          float3 Nl;
+          float4 Il;
+          float3 l = Hit(x, R, N, NormDistMap1, NormDistMap2, CubeMap, DistanceMap, Il, Nl);
+          if(Il.a == 0)
+          {
+                  //I = readCubeMap(CubeMap, l);
+                   depth += 1;           
+          }
+          else
+          {
+                   I = Il;
+                   depth = MAX_RAY_DEPTH;
+          }
+          x = l;           
+          N = normalize(Nl);
+          V = R;                   
+        }  
+            
+        I *= (1.0 - F); 
+    
+        return I;
+}
+
+float4 MultipleRefractionPhotonMap_PS(Shaded_OUT IN,
+                                                                        uniform samplerCUBE DistanceMap  : register(s0),
+                                                                        uniform samplerCUBE NormDistMap1 : register(s1),
+                                                                        uniform samplerCUBE NormDistMap2 : register(s2),
+                                                                        uniform samplerCUBE CubeMap      : register(s3), //NOT USED
+                                                                        uniform float3 cameraPos,
+                                                                        uniform float3 lastCenter,
+                                                                        uniform float refIndex) : COLOR0
+{
+         float4 I = 0;          
+         float3 N = normalize(IN.wNormal.xyz);
+         float3 x = IN.wPos.xyz - lastCenter;
+         float3 V  = (IN.wPos.xyz - cameraPos);
+         V = normalize(V);
+         
+        int depth = 0;
+        float3 l;
+        
+        while(depth < MAX_RAY_DEPTH)
+        {
+          float3 R;  
+                 
+          float ri = refIndex;   
+          if(dot(V,N) > 0)
+          {
+                ri = 1.0 / ri;
+                N = -N;     
+          }
+          R = refract( V, N, ri);
+          if(dot(R,R) == 0) R = reflect( V, N);
+                                                
           float3 Nl;
           float4 Il;
@@ -277 +295 @@
           if(Il.a == 0)
           {
-                   depth += 1;           
+                  depth += 1;            
           }
           else
           {
-                   I = Il;
-                   depth = MAX_RAY_DEPTH;
+                  I = Il;
+                  depth = MAX_RAY_DEPTH;
           }
           x = l;           
           N = normalize(Nl);
           V = R;                   
-        }
-        
+        }  
         if(I.a == 0)
-           I = readCubeMap(CubeMap, l);
-        Irefr = I;
-            
-        I = Irefl * F + (1.0 - F) * Irefr;      
-    }
-        return I;
-}
-
-float4 MultipleRefractionPhotonMap_PS(Shaded_OUT IN,
-                                                                        uniform samplerCUBE DistanceMap : register(s0),
-                                                                        uniform samplerCUBE NormDistMap1 : register(s1),
-                                                                        uniform samplerCUBE NormDistMap2 : register(s2),
-                                                                        uniform float3 cameraPos,
-                                                                        uniform float3 lastCenter,
-                                                                        uniform float refIndex) : COLOR0
-{
-        float4 I = float4(0,0,0,0);
-                 
-        float3 N = normalize(IN.wNormal.xyz);
-        float3 x = IN.wPos.xyz - lastCenter;
-        float3 V  = (IN.wPos.xyz - cameraPos);
-        V = normalize(V);
-        float3 l;
-        int depth = 0;
-                
-        while(depth < MAX_RAY_DEPTH)
-        {
-          float3 R;  
-          
-          float ri = refIndex;
-         
-          if(dot(V,N) > 0)
-          {
-                ri = 1.0 / ri;
-                N = -N;     
-          }
-          R = refract( V, N, ri);
-          if(dot(R,R) == 0) R = reflect( V, N); 
-                                        
-          float3 Nl;
-          float4 Il;
-          l = Hit(x, R, N, NormDistMap1, NormDistMap2, DistanceMap, DistanceMap, Il, Nl);
-          if(Il.a == 0)
-          {
-                   depth += 1;           
-          }
-          else
-          {
-                   I = Il;
-                   depth = MAX_RAY_DEPTH;
-          }
-          x = l;           
-          N = normalize(Nl);
-          V = R;                   
-        }
-        
-        return float4(l,1);
-}
+                I = 0;
+        else
+                I = float4(l,1);
+        
+        return I;
+}

GTP/trunk/App/Demos/Illum/Ogre/Media/materials/GTPAdvancedEnvMap/multibounce/GTPMultipleReflection_MinMax.hlsl

@@ -11 +11 @@
 }
 
-#define MAX_LIN_ITERATIONCOUNT 30  //80
-#define MIN_LIN_ITERATIONCOUNT 25  //60
+#define MAX_LIN_ITERATIONCOUNT 80  //80
+#define MIN_LIN_ITERATIONCOUNT 60  //60
 #define SECANT_ITERATIONCOUNT 1
-#define MAX_RAY_DEPTH 2
+#define MAX_RAY_DEPTH 4
+
+//#define METHOD1
 
 void linearSearch(  float3 x, float3 R, float3 N, samplerCUBE mp,
@@ -24 +26 @@
                     out float ppp)
 {
+ float3 Ra = abs(R), xa = abs(x);
+ float xm =  max(max(xa.x,xa.y),xa.z);
+ float Rm = max(max(Ra.x,Ra.y),Ra.z);
+ float a = xm / Rm;
  
  int shootL = 0, shootP = 0;          
@@ -29 +35 @@
  
  float min = minMax.x;
- float max = minMax.y;
- 
- float minT = 0;
- float maxT = 0;
+ float maximum = minMax.y;
+ 
+ float minD = 0;
+ float maxD = 0;
  {
         float a = dot(R,R);
         float b = 2 * dot(R, x);
         float c = dot(x,x) - min * min; 
-        float c2 = dot(x,x) - max * max; 
+        float c2 = dot(x,x) - maximum * maximum; 
         
         float dis = b*b - 4*a*c;
@@ -51 +57 @@
         {
          numvalids++;
-         if(t1 > maxT)maxT = t1;
-         if(t1 < minT || minT == 0)minT = t1;
+         if(t1 > maxD)maxD = t1;
+         if(t1 < minD || minD == 0)minD = t1;
         }
         if(t2 > 0)
         {
          numvalids++;
-         if(t2 > maxT)maxT = t2;
-         if(t2 < minT || minT == 0)minT = t2;
+         if(t2 > maxD)maxD = t2;
+         if(t2 < minD || minD == 0)minD = t2;
         }
         if(t3 > 0)
         {
          numvalids++;
-         if(t3 > maxT)maxT = t3;
-         if(t3 < minT || minT == 0)minT = t3;
+         if(t3 > maxD)maxD = t3;
+         if(t3 < minD || minD == 0)minD = t3;
         }
         if(t4 > 0)
         {
          numvalids++;
-         if(t4 > maxT)maxT = t4;
-         if(t4 < minT || minT == 0)minT = t4;
+         if(t4 > maxD)maxD = t4;
+         if(t4 < minD || minD == 0)minD = t4;
         }
         
         if(numvalids % 2 == 1)
-         minT = 0.01;
+         minD = 0.01;
         if(numvalids == 0)
-         minT = maxT + 1.0;     
+         minD = maxD + 1.0;     
  }
  
+#ifdef METHOD1
  int iterationNeeded = MAX_LIN_ITERATIONCOUNT;// + (dot(normalize(x), R) + 1.0) / 2.0 * (MAX_LIN_ITERATIONCOUNT - MIN_LIN_ITERATIONCOUNT);
  float pa;
- float dt = (maxT - minT) / (float) iterationNeeded ;
- dp = minT;
+ float dD = (maxD - minD) / (float) iterationNeeded ;
+ dp = minD; 
+ 
  //Linear iteration
- while(dp <= maxT && !found)
+ while(dp <= maxD && !found)
  {
+         
+#else
+ float dt =  length(x / xm - R / Rm) * MAX_LIN_ITERATIONCOUNT;
+ dt = max(dt, MIN_LIN_ITERATIONCOUNT);
+ dt = 1.0 / dt;
+ 
+ float minT = max(minD / (a + minD) - dt, dt);
+ float maxT = maxD / (a + maxD) + dt;
+ 
+ float t = minT;//dt;
+ float pa;
+ 
+ while(t <= maxT && !found)
+ {
+         dp = a * t / (1 - t);
+#endif
+
    p = x + R * dp;
    pa = readDistanceCubeMap(mp, p);
@@ -107 +132 @@
    else
      shootL = 0;
-      
-   dp += dt;  
+ 
+ #ifdef METHOD1     
+   dp += dD; 
+ #else 
+   t += dt;
+ #endif
  }
 
@@ -214 +243 @@
                                                         uniform float4 min1,
                                                         uniform float4 min2,
-                                                        uniform float4 max,
+                                                        uniform float4 Max,
                                                         uniform float4 max1,
                                                         uniform float4 max2) : COLOR0
@@ -220 +249 @@
         float2 miniMaxi1;
     miniMaxi1.x = min.a;
-    miniMaxi1.y = max.a;
+    miniMaxi1.y = Max.a;
    
     float2 miniMaxi2;
@@ -258 +287 @@
            x = l;          
            N = Nl;
-           V = R;   
-           
+           V = R;          
         }
         if(I.a == 0)
-           I = readCubeMap(CubeMap, l);
+          I = readCubeMap(CubeMap, l);
         
         return I;
@@ -275 +303 @@
                                                         uniform float3 lastCenter,
                                                         uniform float refIndex,
-                                                        //uniform float sFresnel, //0.04 
+                                                        uniform float sFresnel, //0.04 
                                                         uniform float4 min,
                                                         uniform float4 min1,
                                                         uniform float4 min2,
-                                                        uniform float4 max,
+                                                        uniform float4 Max,
                                                         uniform float4 max1,
                                                         uniform float4 max2) : COLOR0
@@ -285 +313 @@
         float2 miniMaxi1;
     miniMaxi1.x = min.a;
-    miniMaxi1.y = max.a;
+    miniMaxi1.y = Max.a;
    
     float2 miniMaxi2;
@@ -295 +323 @@
     miniMaxi3.y = max2.a;
 
-         float4 I = float4(0,0,0,0);
+        float4 I = float4(0,0,0,0);
                         
          float3 N = normalize(IN.wNormal.xyz);
          float3 x = IN.wPos.xyz - lastCenter;
          float3 V  = (IN.wPos.xyz - cameraPos);
+          V = normalize(V);
          
-         float sFresnel = 0.04;
-         float F = sFresnel + pow(1 - dot(N, -V), 5) * (1 - sFresnel);
-         
-         V = normalize(V);
-         float3 l;
-         float4 Irefl;
+         float F;
          int depth = 0;
-        
-         while(depth < MAX_RAY_DEPTH)
-         {
-            float3 R;  
-           R = normalize(reflect( V, N));         
-                
-           float3 Nl;
-           float4 Il;
-           l = Hit(x, R, N, NormDistMap1, NormDistMap2, CubeMap, DistanceMap, miniMaxi1, miniMaxi2, miniMaxi3, Il, Nl);
-           if(Il.a == 0)
-           {
-                   depth += 1;           
-           }
-           else
-           {
-                   I = Il;
-                   depth = MAX_RAY_DEPTH;
-           }
-           x = l;          
-           N = Nl;
-           V = R;   
-           
-        }
-        if(I.a == 0)
-           I = readCubeMap(CubeMap, l);
-        Irefl = I;
-        
-        {
-        float4 Irefr;
-        N = normalize(IN.wNormal.xyz);
-        x = IN.wPos.xyz - lastCenter;
-        V  = (IN.wPos.xyz - cameraPos);
-        V = normalize(V);
-        depth = 0;
+        F = sFresnel + pow(1 - dot(N, -V), 5) * (1 - sFresnel);  
         
         while(depth < MAX_RAY_DEPTH)
         {
           float3 R;  
-          
-          float ri = refIndex;
-         
+                 
+          float ri = refIndex;   
           if(dot(V,N) > 0)
           {
@@ -355 +345 @@
           }
           R = refract( V, N, ri);
-          if(dot(R,R) == 0) R = reflect( V, N); 
-                                        
+          if(dot(R,R) == 0) R = reflect( V, N);
+                                                
           float3 Nl;
           float4 Il;
-          l = Hit(x, R, N, NormDistMap1, NormDistMap2, CubeMap, DistanceMap, miniMaxi1, miniMaxi2, miniMaxi3, Il, Nl);
+          float3 l = Hit(x, R, N, NormDistMap1, NormDistMap2, CubeMap, DistanceMap, miniMaxi1, miniMaxi2, miniMaxi3, Il, Nl);
           if(Il.a == 0)
           {
+                  //I = readCubeMap(CubeMap, l);
                    depth += 1;           
           }
@@ -372 +363 @@
           N = normalize(Nl);
           V = R;                   
-        }
-        
-        if(I.a == 0)
-           I = readCubeMap(CubeMap, l);
-        Irefr = I;
+        }  
             
-        I = Irefl * F + (1.0 - F) * Irefr;
-    }
-        return I;
+        I *= (1.0 - F); 
+    
+        return I;
 }
 

GTP/trunk/App/Demos/Illum/Ogre/Media/materials/GTPAdvancedEnvMap/multibounce/multipleReflectionMinMax/GTPMultipleReflectionMinMax.material

@@ -35 +35 @@
                                 get_minmax true
                                 min_var_name min
-                                max_var_name max                                
+                                max_var_name Max                                
                         }
                         RenderTechnique ColorCubeMap