Динамическое освещение и неограниченное количество источников произвольной формы в 2D

Я даже удивился, когда увидел этот пост, потому что я использую ту же самую технику. Конечно нормал маппинг давно известен, но, на сколько я знаю, в пиксель-арте он начал применяться совсем недавно, я бы даже сказал что это один из первых постов.

//вершинный
varying vec4 texCoord;

void main(){
    gl_Position = gl_ModelViewProjectionMatrix*gl_Vertex;
    texCoord = gl_MultiTexCoord0;
}

//фрагментный
uniform sampler2D colorMap;
uniform sampler2D normalMap;
varying vec4 texCoord;
uniform vec2 light;
uniform vec2 screen;
uniform float dist;

void main() {
    vec3 normal = texture2D(normalMap, texCoord.st).rgb;
    normal = 2.0*normal-1.0;
    vec3 n = normalize(normal);
    vec3 l = normalize(vec3((gl_FragCoord.xy-light.xy)/screen, dist));
    float a = dot(n, l);
    gl_FragColor = a*texture2D(colorMap, texCoord.st);
}

//вершинный
varying vec4 texCoord;
varying vec4 nmTexCoord;
varying vec2 lightMapTexCoord; //координаты среднего пикселя лайтмапа
varying vec2 lightMapTexCoordX1; //координаты левого пикселя лайтмапа
varying vec2 lightMapTexCoordX2; //координаты правого пикселя лайтмапа
varying vec2 lightMapTexCoordY1; //координаты верхнего пикселя лайтмапа
varying vec2 lightMapTexCoordY2; //координаты нижнего пикселя лайтмапа
//да, я знаю, что можно было использовать массив. Но так нагляднее
uniform vec2 fieldSize; // размер игровой карты

const float spriteSize = 16.0; //размер зазора между соседними пикселями лайтмапа

void main() {
	gl_Position = gl_ModelViewProjectionMatrix*gl_Vertex;
	texCoord = gl_MultiTexCoord0;
	nmTexCoord = gl_MultiTexCoord1;
	//вычисляем текстурные координаты выборочных пикселей лайтмапа.
	lightMapTexCoordX1 = vec2(gl_Vertex.x/(fieldSize.x-1.0/spriteSize), gl_Vertex.y/fieldSize.y);
	lightMapTexCoordX2 = vec2(gl_Vertex.x/(fieldSize.x+1.0/spriteSize), gl_Vertex.y/fieldSize.y);
	lightMapTexCoordY1 = vec2(gl_Vertex.x/fieldSize.x, gl_Vertex.y/(fieldSize.y-1.0/spriteSize));
	lightMapTexCoordY2 = vec2(gl_Vertex.x/fieldSize.x, gl_Vertex.y/(fieldSize.y+1.0/spriteSize));
	lightMapTexCoord = vec2(gl_Vertex.x/fieldSize.x, gl_Vertex.y/fieldSize.y);
}

//---------------------------------------------------------------------------------------------------------------
//фрагментный
varying vec4 texCoord;
varying vec4 nmTexCoord;
varying vec2 lightMapTexCoord;
varying vec2 lightMapTexCoordX1;
varying vec2 lightMapTexCoordX2;
varying vec2 lightMapTexCoordY1;
varying vec2 lightMapTexCoordY2;

uniform sampler2D colorMap; //в этом атласе и диффузная карта и карта нормалей
uniform sampler2D lightMap;
uniform float ambientIntensity; //рассеянное освещение
uniform float lightIntensity; //коэффициент усиление интенсивности света

const float shadowIntensity = 8.0; //коэффициент усиления вектора направления света
const vec3 av = vec3(0.33333); //константа для вычисления среднего арифмитического

void main() {
	vec4 lmc = texture2D(lightMap, lightMapTexCoord)*2,0; //текущий пиксель из лайтмапа. Он умножается на два, потому что в проекте максимальное значение компоненты цвета равно 0.5, а не 1.0 (условно). В таком случае цвет можно разбить на две части, обработать, а потом сложить их.  Это нужно для того, что бы сверхяркий свет в итоге переходил в белый.
	// x и y - разница между соседними пикселями лайтмапа
	float x = (dot(texture2D(lightMap, lightMapTexCoordX1).rgb, av)-
			   dot(texture2D(lightMap, lightMapTexCoordX2).rgb, av))*shadowIntensity;
	float y = (dot(texture2D(lightMap, lightMapTexCoordY2).rgb, av)-
			   dot(texture2D(lightMap, lightMapTexCoordY1).rgb, av))*shadowIntensity;
	float br = dot(lmc.rgb, av); //среднее арифмитическое всех трех компонент лайтмапа - яркость пикселя
	vec3 l = vec3(x, y, br); //создаем вектор из полученых значений, по z позиции устанавливаем яркость пикселя, для того что бы при нормализации получить вектор, характеризующий не только направление, но и яркость пикселя
	l = normalize(l)*br; //нормализуем и еще дополнительно умножаем на яркость
	vec3 normal = 2.0*texture2D(colorMap, nmTexCoord.st).rgb-1.0;
	float a = dot(normal, l)*lightIntensity;
	a = max(a, 0.0);
	vec4 c = texture2D(colorMap, texCoord.st);
	c = a*min(c, lmc)+ambientIntensity*c; //вычисляем цвет пикселя на основе рассеянного и направленного света
	float m = 0.0; //теперь находим максимальное значение из трех компонент результирующего пикселя, это нужно для того, что бы сверхяркий свет в итоге переходил в белый (см. на видео или gif в шапке). Назовем его избыточным цветом.
	m = max(m, c.r);
	m = max(m, c.g);
	m = max(m, c.b);
	gl_FragColor = c+max(0.0, m-1.0); //складываем результирующий и избыточный цвета.
}