For the arrays you need to change the Python code too.
Here the full code with the necessary Python changes.
# Shader code implemented by HG1, taken from Blender sources
# Works since this commit https://developer.blender.org/D1690
# (works for sun/spot variance/simple shadows) 01/19/2016
# Youle with the help of Kupoman for MultiLamps
import bge
from bgl import *
VertexShader = """
////////////////////Shadows////////////////////////
uniform mat4 m_c2l[10];
varying vec4 ShadowCoord[3];
////////////////////Shadows////////////////////////
void main(void)
{
/////////////////Shadows///////////////////////
vec4 position = gl_ModelViewMatrix * gl_Vertex;
// for (int i = 0; i < numlights; i++)
ShadowCoord[0] = m_c2l[0] * position;
ShadowCoord[1] = m_c2l[1] * position;
ShadowCoord[2] = m_c2l[2] * position;
gl_Position = gl_ProjectionMatrix * position;
gl_FrontColor = gl_Color;
////////////////Shadows////////////////////////
}
"""
FragmentShader = """
///////////////////Shadows/////////////////////////
uniform sampler2DShadow shadowMap[3];
uniform float shadowbias[3];
uniform int shadowmaptype[3];
uniform vec3 shadowColor[3];
uniform int shadowactive[3];
varying vec4 ShadowCoord[3];
//////////////////Shadows//////////////////////////
//////////////////Shadows///////////////////////////
float shadowbuf(sampler2DShadow shadowmap, vec4 co, float shadowbias)
{
float result = 0.0;
//vec4 co = shadowpersmat*vec4(rco, 1.0); //from original Blender code
//co.z -= shadowbias*co.w; //from original Blender code ???
co.z -= shadowbias/co.w;
if (co.w > 0.0 && co.x > 0.0 && co.x/co.w < 1.0 && co.y > 0.0 && co.y/co.w < 1.0)
result = shadow2DProj(shadowmap, co).x;
else
result = 1.0;
return result;
}
float shadowbuf_vsm(sampler2DShadow shadowmap, vec4 co, float shadowbias)
{
float result = 0.0;
if (co.w > 0.0 && co.x > 0.0 && co.x/co.w < 1.0 && co.y > 0.0 && co.y/co.w < 1.0)
{
//vec2 moments = texture2DProj(shadowmap, co).rg;
vec2 moments = shadow2DProj(shadowmap, co).rg;
float dist = co.z/co.w;
float p = 0.0;
//if(dist <= moments.x)
// p = 1.0;
float variance = moments.y - (moments.x*moments.x);
variance = max(variance, shadowbias/10.0);
float d = moments.x - dist;
float p_max = variance / (variance + d*d);
// Now reduce light-bleeding by removing the [0, x] tail and linearly rescaling (x, 1]
p_max = clamp((p_max)/(1.0), 0.0, 1.0);
result = max(p, p_max);
}
else
{
result = 1.0;
}
return result;
}
vec4 mainShadows(sampler2DShadow shadowmap, vec4 ShadowCoord, vec3 shadowColor, int shadowmaptype, int shadowactive, float shadowbias)
{
vec4 result = vec4(1.0);
float bias;
float shadfac;
if (bool(shadowactive)) {
if (shadowmaptype == 1) // variance
{
shadfac = shadowbuf_vsm(shadowmap, ShadowCoord, shadowbias);
}
else // simple
{
shadfac = shadowbuf(shadowmap, ShadowCoord, shadowbias);
}
result -= (1.0 - shadfac) * (vec4(1.0) - vec4(shadowColor, 0.0));
}
else {
result = vec4(0.0);
}
return result;
}
//////////////////////Shadows////////////////////////
void main()
{
/////////////////////Shadows/////////////////////////
vec4 shadows[10];
vec4 result = vec4(1.0);
float bias = 0.0;
float shadfac = 0.0;
if (bool(shadowactive[0])) {
if (shadowmaptype[0] == 1) // variance
{
shadfac = shadowbuf_vsm(shadowMap[0], ShadowCoord[0], shadowbias[0]);
}
else // simple
{
shadfac = shadowbuf(shadowMap[0], ShadowCoord[0], shadowbias[0]);
}
result -= (1.0 - shadfac) * (vec4(1.0) - vec4(shadowColor[0], 0.0));
}
else {
result = vec4(0.0);
}
shadows[0] = result;
if (bool(shadowactive[1])) {
if (shadowmaptype[1] == 1) // variance
{
shadfac = shadowbuf_vsm(shadowMap[1], ShadowCoord[1], shadowbias[1]);
}
else // simple
{
shadfac = shadowbuf(shadowMap[1], ShadowCoord[1], shadowbias[1]);
}
result -= (1.0 - shadfac) * (vec4(1.0) - vec4(shadowColor[1], 0.0));
}
else {
result = vec4(0.0);
}
shadows[1] = result;
if (bool(shadowactive[2])) {
if (shadowmaptype[2] == 1) // variance
{
shadfac = shadowbuf_vsm(shadowMap[2], ShadowCoord[2], shadowbias[2]);
}
else // simple
{
shadfac = shadowbuf(shadowMap[2], ShadowCoord[2], shadowbias[2]);
}
result -= (1.0 - shadfac) * (vec4(1.0) - vec4(shadowColor[2], 0.0));
}
else {
result = vec4(0.0);
}
shadows[2] = result;
/////////////////////Shadows/////////////////////////
/////Write your own material shader here/////////
vec4 materialColor = vec4(0.5, 0.7, 0.9, 1.0);
materialColor *= shadows[0];
materialColor *= shadows[1];
materialColor *= shadows[2];
gl_FragColor = materialColor;
}
"""
scene = bge.logic.getCurrentScene() # The scene
object = scene.objects['Plane'] # The shader object
if "lightList" not in scene:
scene["lightList"] = [lamp for lamp in scene.objects if lamp.name.startswith("Lamp")]
scene["numlights"] = len(scene["lightList"])
for mesh in object.meshes:
for material in mesh.materials:
shader = material.getShader()
if shader != None:
if not shader.isValid():
shader.setSource(VertexShader, FragmentShader, True)
#######################Shadows##############################
# bind shadowmaps
for i in range(scene["numlights"]):
glActiveTexture(GL_TEXTURE0 + scene["lightList"][i].shadowBindId)
glBindTexture(GL_TEXTURE_2D, scene["lightList"][i].shadowBindId)
for i, light in enumerate(scene["lightList"]):
shader.setUniform1i("shadowMap[%s]"%i, light.shadowBindId)
shader.setUniform3f("shadowColor[%s]"%i, *light.shadowColor)
shader.setUniform1f("shadowbias[%s]"%i, light.shadowBias * 0.005)
#shader.setUniform1f("shadowbleedbias[%s]"%i, light.shadowBleedBias)
shader.setUniform1i("shadowmaptype[%s]"%i, light.shadowMapType)
shader.setUniform1i("shadowactive[%s]"%i, light.useShadow)
#shader.setUniform1i('numlights', scene["numlights"])
for i, light in enumerate(scene["lightList"]):
shader.setUniformMatrix4("m_c2l[%s]"%i, light.shadowMatrix)
#########################Shadows#################################
# bind your own uniforms here
