Revision: 34700
          
http://projects.blender.org/scm/viewvc.php?view=rev&root=bf-blender&revision=34700
Author:   lmg
Date:     2011-02-07 21:57:40 +0000 (Mon, 07 Feb 2011)
Log Message:
-----------
GLSL shader part

bump-mapping update to properly support
multiple textures in different bump-spaces.

Modified Paths:
--------------
    trunk/blender/source/blender/gpu/intern/gpu_material.c
    trunk/blender/source/blender/gpu/intern/gpu_shader_material.glsl
    trunk/blender/source/blender/gpu/intern/gpu_shader_material.glsl.c

Modified: trunk/blender/source/blender/gpu/intern/gpu_material.c
===================================================================
--- trunk/blender/source/blender/gpu/intern/gpu_material.c      2011-02-07 
21:55:54 UTC (rev 34699)
+++ trunk/blender/source/blender/gpu/intern/gpu_material.c      2011-02-07 
21:57:40 UTC (rev 34700)
@@ -892,6 +892,8 @@
        char *lastuvname = NULL;
        float one = 1.0f, norfac, ofs[3];
        int tex_nr, rgbnor, talpha;
+       int init_done = 0, iBumpSpacePrev;
+       GPUNodeLink *vNorg, *vNacc, *fPrevMagnitude;
 
        GPU_link(mat, "set_value", GPU_uniform(&one), &stencil);
 
@@ -1055,12 +1057,13 @@
                                                
                                        } else if( mtex->texflag & 
(MTEX_3TAP_BUMP|MTEX_5TAP_BUMP)) {
                                                /* ntap bumpmap image */
+                                               int iBumpSpace;
                                                float hScale = 0.1f; // 
compatibility adjustment factor for all bumpspace types
                                                float hScaleTex = 13.0f; // 
factor for scaling texspace bumps
                                                
                                                GPUNodeLink *surf_pos = 
GPU_builtin(GPU_VIEW_POSITION);
-                                               GPUNodeLink *vR1, *vR2, *fDet;
-                                               GPUNodeLink *dBs, *dBt, *vN;
+                                               GPUNodeLink *vR1, *vR2;
+                                               GPUNodeLink *dBs, *dBt, *fDet;
                                                
                                                if( mtex->texflag & 
MTEX_BUMP_TEXTURESPACE )
                                                        hScale = hScaleTex;
@@ -1070,16 +1073,50 @@
                                                if(GPU_link_changed(stencil))
                                                        GPU_link(mat, 
"math_multiply", tnorfac, stencil, &tnorfac);
                                                
+                                               if( !init_done ) {
+                                                       // copy shi->vn to 
vNorg and vNacc, set magnitude to 1
+                                                       GPU_link(mat, 
"mtex_bump_normals_init", shi->vn, &vNorg, &vNacc, &fPrevMagnitude);
+                                                       iBumpSpacePrev = 0;
+                                                       init_done = 1;
+                                               }
+                                               
+                                               // find current bump space
                                                if( mtex->texflag & 
MTEX_BUMP_OBJECTSPACE )
-                                                       GPU_link( mat, 
"mtex_bump_init_objspace",
-                                                                         
surf_pos, shi->vn, 
-                                                                 
GPU_builtin(GPU_VIEW_MATRIX), GPU_builtin(GPU_INVERSE_VIEW_MATRIX), 
GPU_builtin(GPU_OBJECT_MATRIX),  GPU_builtin(GPU_INVERSE_OBJECT_MATRIX), 
-                                                                         &vR1, 
&vR2, &fDet, &vN );
+                                                       iBumpSpace = 1;
+                                               else if( mtex->texflag & 
MTEX_BUMP_TEXTURESPACE )
+                                                       iBumpSpace = 2;
                                                else
-                                                       GPU_link( mat, 
"mtex_bump_init_viewspace",
-                                                                         
surf_pos, shi->vn,
-                                                                         &vR1, 
&vR2, &fDet, &vN );
+                                                       iBumpSpace = 4; // 
ViewSpace
                                                
+                                               // re-initialize if bump space 
changed
+                                               if( iBumpSpacePrev != 
iBumpSpace ) {
+                                                       
+                                                       if( mtex->texflag & 
MTEX_BUMP_OBJECTSPACE ) 
+                                                               GPU_link( mat, 
"mtex_bump_init_objspace",
+                                                                               
  surf_pos, vNorg, 
+                                                                         
GPU_builtin(GPU_VIEW_MATRIX), GPU_builtin(GPU_INVERSE_VIEW_MATRIX), 
GPU_builtin(GPU_OBJECT_MATRIX),  GPU_builtin(GPU_INVERSE_OBJECT_MATRIX), 
+                                                                         
fPrevMagnitude, vNacc,
+                                                                               
  &fPrevMagnitude, &vNacc, 
+                                                                         &vR1, 
&vR2, &fDet );
+                                                               
+                                                       else if( mtex->texflag 
& MTEX_BUMP_TEXTURESPACE )
+                                                               GPU_link( mat, 
"mtex_bump_init_texturespace",
+                                                                               
  surf_pos, vNorg, 
+                                                                         
fPrevMagnitude, vNacc,
+                                                                               
  &fPrevMagnitude, &vNacc, 
+                                                                         &vR1, 
&vR2, &fDet );
+                                                               
+                                                       else
+                                                               GPU_link( mat, 
"mtex_bump_init_viewspace",
+                                                                               
  surf_pos, vNorg, 
+                                                                         
fPrevMagnitude, vNacc,
+                                                                               
  &fPrevMagnitude, &vNacc, 
+                                                                         &vR1, 
&vR2, &fDet );
+                                                       
+                                                       iBumpSpacePrev = 
iBumpSpace;
+                                               }
+                                               
+                                               
                                                if( mtex->texflag & 
MTEX_3TAP_BUMP )
                                                        GPU_link( mat, 
"mtex_bump_tap3", 
                                                                  texco, 
GPU_image(tex->ima, &tex->iuser), tnorfac,
@@ -1089,6 +1126,7 @@
                                                                  texco, 
GPU_image(tex->ima, &tex->iuser), tnorfac,
                                                                  &dBs, &dBt );
                                                
+                                               
                                                if( mtex->texflag & 
MTEX_BUMP_TEXTURESPACE ) {
                                                        float ima_x= 512.0f, 
ima_y= 512.f;              // prevent calling textureSize, glsl 1.3 only
                                                        ImBuf *ibuf= 
BKE_image_get_ibuf(tex->ima, &tex->iuser);
@@ -1096,12 +1134,13 @@
                                                                ima_x= ibuf->x; 
ima_y= ibuf->y;
                                                        
                                                        GPU_link( mat, 
"mtex_bump_apply_texspace",
-                                                                 fDet, dBs, 
dBt, vR1, vR2, vN, GPU_image(tex->ima, &tex->iuser), texco,
-                                                                 
GPU_uniform(&ima_x), GPU_uniform(&ima_y), &shi->vn );
+                                                                 fDet, dBs, 
dBt, vR1, vR2, 
+                                                                 
GPU_image(tex->ima, &tex->iuser), texco, GPU_uniform(&ima_x), 
GPU_uniform(&ima_y), vNacc,
+                                                                 &vNacc, 
&shi->vn );
                                                } else
                                                        GPU_link( mat, 
"mtex_bump_apply",
-                                                                 fDet, dBs, 
dBt, vR1, vR2, vN,
-                                                                 &shi->vn );
+                                                                 fDet, dBs, 
dBt, vR1, vR2, vNacc,
+                                                                 &vNacc, 
&shi->vn );
                                                
                                        }
                                }

Modified: trunk/blender/source/blender/gpu/intern/gpu_shader_material.glsl
===================================================================
--- trunk/blender/source/blender/gpu/intern/gpu_shader_material.glsl    
2011-02-07 21:55:54 UTC (rev 34699)
+++ trunk/blender/source/blender/gpu/intern/gpu_shader_material.glsl    
2011-02-07 21:57:40 UTC (rev 34700)
@@ -1102,16 +1102,11 @@
        normal = 2.0*(vec3(color.r, -color.g, color.b) - vec3(0.5, -0.5, 0.5));
 }
 
-void mtex_bump_init_viewspace( vec3 surf_pos, vec3 surf_norm,
-                     out vec3 vR1, out vec3 vR2, out float fDet, out vec3 vN ) 
+void mtex_bump_normals_init( vec3 vN, out vec3 vNorg, out vec3 vNacc, out 
float fPrevMagnitude )
 {
-       vec3 vSigmaS = dFdx( surf_pos );
-       vec3 vSigmaT = dFdy( surf_pos );
-       vN = surf_norm; /* normalized interpolated vertex normal */
-       
-       vR1 = cross( vSigmaT , vN );
-       vR2 = cross( vN , vSigmaS ) ;
-       fDet = dot ( vSigmaS , vR1 );
+       vNorg = vN;
+       vNacc = vN;
+       fPrevMagnitude = 1.0;
 }
 
 /** helper method to extract the upper left 3x3 matrix from a 4x4 matrix */
@@ -1125,27 +1120,68 @@
 }
 
 void mtex_bump_init_objspace( vec3 surf_pos, vec3 surf_norm,
-                              mat4 mView, mat4 mViewInv, mat4 mObj, mat4 
mObjInv,
-                              out vec3 vR1, out vec3 vR2, out float fDet, out 
vec3 vN ) 
+                                                         mat4 mView, mat4 
mViewInv, mat4 mObj, mat4 mObjInv, 
+                                                         float 
fPrevMagnitude_in, vec3 vNacc_in,
+                                                         out float 
fPrevMagnitude_out, out vec3 vNacc_out, 
+                                                         out vec3 vR1, out 
vec3 vR2, out float fDet ) 
 {
        mat3 obj2view = to_mat3(mView * mObj);
        mat3 view2obj = to_mat3(mObjInv * mViewInv);
        
        vec3 vSigmaS = view2obj * dFdx( surf_pos );
        vec3 vSigmaT = view2obj * dFdy( surf_pos );
-       vN = normalize( surf_norm * obj2view );
+       vec3 vN = normalize( surf_norm * obj2view );
 
        vR1 = cross( vSigmaT , vN );
        vR2 = cross( vN , vSigmaS ) ;
        fDet = dot ( vSigmaS , vR1 );
        
-               /* transform back */
+       /* pretransform vNacc (in mtex_bump_apply) using the inverse transposed 
*/
        vR1 = vR1 * view2obj;
        vR2 = vR2 * view2obj;
        vN = vN * view2obj;
+       
+       float fMagnitude = abs(fDet) * length(vN);
+       vNacc_out = vNacc_in * (fMagnitude / fPrevMagnitude_in);
+       fPrevMagnitude_out = fMagnitude;
+}
 
+void mtex_bump_init_texturespace( vec3 surf_pos, vec3 surf_norm, 
+                                                                 float 
fPrevMagnitude_in, vec3 vNacc_in,
+                                                                 out float 
fPrevMagnitude_out, out vec3 vNacc_out, 
+                                                                 out vec3 vR1, 
out vec3 vR2, out float fDet ) 
+{
+       vec3 vSigmaS = dFdx( surf_pos );
+       vec3 vSigmaT = dFdy( surf_pos );
+       vec3 vN = surf_norm; /* normalized interpolated vertex normal */
+       
+       vR1 = normalize( cross( vSigmaT , vN ) );
+       vR2 = normalize( cross( vN , vSigmaS ) );
+       fDet = (dot( vSigmaS , vR1 ) < 0)? (-1): 1;
+       
+       float fMagnitude = abs(fDet);
+       vNacc_out = vNacc_in * (fMagnitude / fPrevMagnitude_in);
+       fPrevMagnitude_out = fMagnitude;
 }
 
+void mtex_bump_init_viewspace( vec3 surf_pos, vec3 surf_norm, 
+                                                          float 
fPrevMagnitude_in, vec3 vNacc_in,
+                                                          out float 
fPrevMagnitude_out, out vec3 vNacc_out, 
+                                                          out vec3 vR1, out 
vec3 vR2, out float fDet ) 
+{
+       vec3 vSigmaS = dFdx( surf_pos );
+       vec3 vSigmaT = dFdy( surf_pos );
+       vec3 vN = surf_norm; /* normalized interpolated vertex normal */
+       
+       vR1 = cross( vSigmaT , vN );
+       vR2 = cross( vN , vSigmaS ) ;
+       fDet = dot ( vSigmaS , vR1 );
+       
+       float fMagnitude = abs(fDet);
+       vNacc_out = vNacc_in * (fMagnitude / fPrevMagnitude_in);
+       fPrevMagnitude_out = fMagnitude;
+}
+
 void mtex_bump_tap3( vec3 texco, sampler2D ima, float hScale, 
                      out float dBs, out float dBt ) 
 {
@@ -1185,16 +1221,18 @@
        dBt = hScale * (Hu - Hd);
 }
 
-void mtex_bump_apply( float fDet, float dBs, float dBt, vec3 vR1, vec3 vR2, 
vec3 vN,
-                      out vec3 perturbed_norm ) 
+void mtex_bump_apply( float fDet, float dBs, float dBt, vec3 vR1, vec3 vR2, 
vec3 vNacc_in,
+                                         out vec3 vNacc_out, out vec3 
perturbed_norm ) 
 {
        vec3 vSurfGrad = sign(fDet) * ( dBs * vR1 + dBt * vR2 );
-       perturbed_norm = normalize( abs(fDet) * vN - vSurfGrad );
        
+       vNacc_out = vNacc_in - vSurfGrad;
+       perturbed_norm = normalize( vNacc_out );
 }
 
-void mtex_bump_apply_texspace( float fDet, float dBs, float dBt, vec3 vR1, 
vec3 vR2, vec3 vN,
-                               sampler2D ima, vec3 texco, float ima_x, float 
ima_y, out vec3 perturbed_norm ) 
+void mtex_bump_apply_texspace( float fDet, float dBs, float dBt, vec3 vR1, 
vec3 vR2,
+                               sampler2D ima, vec3 texco, float ima_x, float 
ima_y, vec3 vNacc_in,
+                                                          out vec3 vNacc_out, 
out vec3 perturbed_norm ) 
 {
        vec2 TexDx = dFdx(texco.xy);
        vec2 TexDy = dFdy(texco.xy);
@@ -1202,8 +1240,9 @@
        vec3 vSurfGrad = sign(fDet) * ( 
                    dBs / length( vec2(ima_x*TexDx.x, ima_y*TexDx.y) ) * 
normalize(vR1) + 
                    dBt / length( vec2(ima_x*TexDy.x, ima_y*TexDy.y) ) * 
normalize(vR2) );
-       perturbed_norm = normalize( vN - vSurfGrad );
-       
+                               
+       vNacc_out = vNacc_in - vSurfGrad;
+       perturbed_norm = normalize( vNacc_out );
 }
 
 void mtex_negate_texnormal(vec3 normal, out vec3 outnormal)

Modified: trunk/blender/source/blender/gpu/intern/gpu_shader_material.glsl.c
===================================================================
--- trunk/blender/source/blender/gpu/intern/gpu_shader_material.glsl.c  
2011-02-07 21:55:54 UTC (rev 34699)
+++ trunk/blender/source/blender/gpu/intern/gpu_shader_material.glsl.c  
2011-02-07 21:57:40 UTC (rev 34700)
@@ -1,822 +1,864 @@
 /* DataToC output of file <gpu_shader_material_glsl> */
 
-int datatoc_gpu_shader_material_glsl_size= 37417;
+int datatoc_gpu_shader_material_glsl_size= 38764;
 char datatoc_gpu_shader_material_glsl[]= {
- 10,102,108,111, 97,116, 32,101,120,
-112, 95, 98,108,101,110,100,101,114, 40,102,108,111, 97,116, 32,102, 41, 
10,123, 10,  9,114,101,116,117,114,110, 32,112,111,119,

@@ Diff output truncated at 10240 characters. @@
_______________________________________________
Bf-blender-cvs mailing list
[email protected]
http://lists.blender.org/mailman/listinfo/bf-blender-cvs

Reply via email to