-=[Parallax-Bumpmap]=-

import GameLogic as g
objlist = g.getCurrentScene().getObjectList()
g.setLogicTicRate(60.0)
# -------------------------------------
ShaderObjects = [ objlist['OBCube']]
MaterialIndexList = [0]
# -------------------------------------

VertexShader = """
uniform mat4 mvi;
attribute vec4 Tangent;

varying vec4 vcol;

varying vec3 lvec,vvec;

vec3 TBN(in vec3 by)
{
        vec3 tangent    = (Tangent.xyz);
        vec3 binormal   = cross(gl_Normal, Tangent.xyz)*Tangent.w;
        vec3 normal             = gl_Normal;    

        vec3 tvec;
        tvec.x = dot(tangent,  by);
        tvec.y = dot(binormal, by);
        tvec.z = dot(normal,   by);
        return tvec;
}

void main() {
        gl_Position = ftransform();
        
        vec4 light0     = (mvi*gl_LightSource[0].position)-gl_Vertex;

        vec4 view = mvi[3]-gl_Vertex;

        lvec = TBN(light0.xyz);
        vvec = TBN(view.xyz);

        gl_TexCoord[0] = gl_MultiTexCoord0;

        vcol =gl_Color;
}
"""

FragmentShader = """
varying vec4 vcol;
varying vec3 lvec,vvec,hvec;


uniform sampler2D color;
uniform sampler2D bump;
uniform sampler2D h;

void main() {

        
        vec2 texUV, srcUV = gl_TexCoord[0].xy;
        
        float height = texture2D(h, srcUV).r;
        
        float v = height * 0.04 - 0.02;
        
        vec3 vv         = normalize(vvec);
        
        texUV = srcUV + (vv.xy * v);
        
        vec4 diffuse_color      = vcol*gl_LightSource[0].diffuse;
        vec4 specular_color = gl_FrontMaterial.specular;
        
        vec4 colormap           = texture2D(color, texUV);
        
        vec3 lv         = normalize(lvec);
        
        //vec3 nv       = normalize(2.0*texture2D(bump, gl_TexCoord[0].st).xyz-1.0);
        vec3 nv         = normalize(2.0*texture2D(bump, texUV).xyz-1.0);
        
        float diff      = max(dot(lv, nv), 0.0);
        float spec      = pow(max(dot(reflect(-vv, nv), lv),0.0), gl_FrontMaterial.shininess);

        vec4 diff_pass = colormap*(diff*diffuse_color);
        vec4 spec_pass = spec*specular_color;   
        gl_FragColor = (vec4(0.1,0.1,0.1,1.0) + diff_pass + spec_pass);
}
"""


def MainLoop ():
        # for each object
        for obj in ShaderObjects:

                mesh_index = 0
                mesh = obj.getMesh(mesh_index)

                while mesh != None:

                        for mat in mesh.materials:
                                
                                # regular TexFace materials do NOT have this function
                                if not hasattr(mat, "getMaterialIndex"):
                                        return
                                
                                mat_index = mat.getMaterialIndex()

                                # find an index                         
                                found = 0
                                for i in range(len(MaterialIndexList)):
                                        if mat_index == MaterialIndexList[i]:
                                                found=1
                                                break
                                if not found: continue

                                shader = mat.getShader()
                                if shader != None:
                                        if not shader.isValid():
                                                shader.setSource(VertexShader, FragmentShader,1)

                                        shader.setAttrib(g.SHD_TANGENT)
                                        shader.setUniformDef('mvi', g.MODELVIEWMATRIX_INVERSE)
                                        shader.setSampler('color', 0)
                                        shader.setSampler('bump', 1)
                                        shader.setSampler('h', 2)
                        mesh_index += 1
                        mesh = obj.getMesh(mesh_index)

# -------------------------------------
MainLoop()
# -------------------------------------