rom bge import logic

g = logic objlist = g.getCurrentScene().objects

-------------------------------------

ShaderObjects = [objlist['Room'] ] MaterialIndexList = [0]

-------------------------------------

cont = g.getCurrentController() own = cont.owner

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.08 - 0.04;

vec3 vv     = normalize(vvec);

//offset thing to prevent texture swim

float depth_at_1 = texture2D(h, srcUV).r;

texUV = srcUV + (vvv)0.1;

if ( depth_at_1 < 0.52) { texUV = srcUV + (vvv)0.5; }

if ( depth_at_1 < 0.38) { texUV = srcUV + (vvv)0.7; }

if ( depth_at_1 < 0.32) { texUV = srcUV + (v*vv); }

//texUV = srcUV + (v*vv);

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*texture2D(h, texUV)*specular_color;   
gl_FragColor.rgb = (vec3(0.1,0.1,0.1)*0.0 + diff_pass.rgb + spec_pass.rgb);


// clipping UV coords for silhouette

if (0.99 < texUV.y)
{
gl_FragColor.a = texUV.y;
}
if (0.01 > texUV.y)
{
gl_FragColor.a = 1.0 - texUV.y;
}


if (0.99 < texUV.x)
{
gl_FragColor.a = texUV.x;
}
if (0.01 > texUV.x)
{
gl_FragColor.a = 1.0 - texUV.x;
}

gl_FragColor.a = 1.0 - gl_FragColor.a;

} """

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

    mesh_index = 0
    mesh = obj.meshes[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
        if mesh_index < len(obj.meshes):
            mesh = obj.meshes[mesh_index]
        else:
            mesh = None