Phong.glsl

Phong.glsl

#ifdef GL_ES
precision mediump float;
#endif

// Кількість джерел світла
#define LIGHT_COUNT 3

// Вхідні начення нормалі поверхні моделі
varying vec4 v_normal;

// Поточне значення часу
uniform float u_time;

// Позиція камери
vec3 cameraPosition = vec3(0.0, 0.0, 1.0);

// Швидкість обертання джерела світла
const float lightSpeed = 3.0;

void main() {

    // фінальний колір пикселя, обчислений у шейдері
    vec3 finalColor = vec3(0.0);

    // Колір моделі
    vec3 modelColor = vec3(1.0);

    // Нормаль поверхні
    vec3 normal = normalize(v_normal.xyz);

    // Кольори джерел світла
    vec3 lightColors[LIGHT_COUNT];
    lightColors[0] = vec3(1.0, 1.0, 1.0);
    lightColors[1] = vec3(1.0, 0.0, 0.0);
    lightColors[2] = vec3(0.0, 1.0, 0.0);

    // Позиції джерел світла
    vec3 lightPositions[LIGHT_COUNT];
    lightPositions[0] = vec3(0.0, 0.0, 1.0);
    lightPositions[1] = vec3(0.0, 0.0, 1.0);
    lightPositions[2] = vec3(0.0, 0.0, 1.0);

    // Значення освітлення
    vec3 lighting = vec3(.0);

    // Цикл по джерелам світла
    for (int i = 0; i < LIGHT_COUNT; i++)
    {
        // Обераємо джерела світла
        float rad = (3.1415 * 2.0) / float(LIGHT_COUNT) * float(i);
        lightPositions[i].x = cos(u_time * lightSpeed + rad);
        lightPositions[i].z = sin(u_time * lightSpeed + rad);

        // Обчислюємо значення diffuse освітлення,
        // використовуючи скалярне множення вектора до джерела світла 
        // на нормаль поверхні
        float fresnelDiffuse = dot(normalize(lightPositions[i]), normal);
        // Відкидаємо значення нижче нуля
        fresnelDiffuse = max(0.0, fresnelDiffuse);

        // Помножуємо значення diffuse освітлення 
        // на колір джерела світла
        vec3 difuseLight = fresnelDiffuse * lightColors[i] * .75;

        // Додаємо до значення освітлення diffuse освітлення
        lighting += difuseLight;

        // Отримуємо віддзеркалений від поверхні моделі вектор 
        // від джерела світла
        vec3 reflection = normalize(reflect(-lightPositions[i], normal));

        // Обчислюємо значення specular освітлення,
        // використовуючи скалярне множення вектора камери 
        // на дзеркально відбитий вектор від джерела світла
        float specular = dot(normalize(cameraPosition), reflection);

        // Відкидаємо значення нижче нуля
        specular = max(0.0, specular);

        // Зводимо значення спекулар освітлення в ступінь 64, 
        // щоб отримати яскравіші відблиски світла
        specular = pow(specular, 64.0);

        // Помножуємо значення specular освітлення 
        // на колір джерела світла
        vec3 specularLight = specular * lightColors[i];
        
        // Додаємо до значення освітлення specular освітлення
        lighting += specularLight;
    }

    // Ambient освітлення віддзеркалений від поверхні моделі вектор
    vec3 ambientLighting = vec3(0.2);

    // Додаємо до значення освітлення Ambient освітлення 
    lighting += ambientLighting;

    // Фінальний колір пікселя = колір моделі * значення освітлення
    finalColor = lighting * modelColor;

    // Виводимо обчислений колір пікселя
    gl_FragColor = vec4(finalColor, 1.0);
}