How to add lighting to shader of instancing

How can I add lighting ( ambient + directional ) to the shader that used with InstancedBufferGeometry?

For example, I want to add lighting to this: https://threejs.org/examples/?q=inst#webgl_buffergeometry_instancing_dynamic

Here is my vertex shader:

precision highp float;
uniform mat4 modelViewMatrix;
uniform mat4 projectionMatrix;
uniform mat3 normalMatrix;
attribute vec3 position;
attribute vec3 offset;
attribute vec3 normal;
attribute vec2 uv;
attribute vec4 orientation;
varying vec2 vUv;

// lighting
struct DirectionalLight {
    vec3 direction;
    vec3 color;
    int shadow;
    float shadowBias;
    float shadowRadius;
    vec2 shadowMapSize;
    };
uniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];
uniform vec3 ambientLightColor;
varying vec3 vLightFactor;
//

void main() {
    vec3 vPosition = position;
    vec3 vcV = cross(orientation.xyz, vPosition);
    vPosition = vcV * (2.0 * orientation.w) + (cross(orientation.xyz, vcV) * 2.0 + vPosition);
    vUv = uv;
    gl_Position = projectionMatrix * modelViewMatrix * vec4( offset + vPosition, 1.0 );

    // lighting
    vec4 ecPosition = modelViewMatrix*vec4(offset + vPosition,1.0);
    vec3 ecNormal= -(normalize(normalMatrix*normal));
    vec3 fromLight = normalize(directionalLights[0].direction);
    vec3 toLight = -fromLight;
    vec3 reflectLight = reflect(toLight,ecNormal);
    vec3 viewDir = normalize(-ecPosition.xyz);
    float ndots = dot(ecNormal, toLight);
    float vdotr = max(0.0,dot(viewDir,reflectLight));
    vec3 ambi = ambientLightColor;
    vec3 diff = directionalLights[0].color * ndots;
    vLightFactor = ambi + diff;     
    //

}

Here is my fragment shader:

precision highp float;
uniform sampler2D map;
varying vec2 vUv;

// lighting
varying vec3 vLightFactor;
//

void main() {
    gl_FragColor = texture2D(map, vUv) * vec4(vLightFactor,1.0);
}

Here is my material:

var uniforms = Object.assign( 
    THREE.UniformsLib['lights'], 
    {
    map: { value: texture }
    }
);  

var material = new THREE.RawShaderMaterial({
    lights: true,
    uniforms: uniforms, 
    vertexShader: document.getElementById( 'vertexShader' ).textContent,
    fragmentShader: document.getElementById( 'fragmentShader' ).textContent,
});

Thanks

Solution

In a rendering, each mesh of the scene usually is transformed by the model matrix, the view matrix and the projection matrix.

The model matrix defines the location, orientation and the relative size of an mesh in the scene. The model matrix transforms the vertex positions from of the mesh to the world space.

The view matrix describes the direction and position from which the scene is looked at. The view matrix transforms from the world space to the view (eye) space.

Note, The model view matrix modelViewMatrix is the combination of the view matrix and the model matrix. But in your case, the model matrix is possibly the identity matrix, and the modelViewMatrix is possibly equal to the view matrix. I assume that, because you don't do the model transformations by a model matrix, but by the vectors orientation and offset.

The light can either be calculated in view space or in world space.
If the light is calculated in view space the light positions and light directions have to be transformed from world space to view space. Commonly this is done on the CPU (before every frame) and the light parameters uniforms are set up with view space coordinates. Since the view position is (0, 0, 0) in view space, is the view vector the the normalized and inverse vertex position (in view space).
If the light calculations are done in world space, then the view vector has to be calculated by the difference of the view position (eye position) and the vertex position (of course in world space).

You can do the light calculations in view space, because the light direction and position is set up in view space (see three.js - Light). You have to transform the normal vector to world space first and then you have to convert from world space to view space. This has to be done similar as you do it for the vertex position. Add the normal vector to the vertex position. Transform this position to world space. The normal vector in world space, is the difference of the calculated position and the vertex position in world space.

vec3 wNPosition = position + normal;
vec3 wNV        = cross(orientation.xyz, wNPosition);
wNPosition      = wNV * 2.0 * orientation.w + cross(orientation.xyz, wNV) * 2.0 + wNPosition;
vec3 wNormal    = normalize( wNPosition - vPosition );

Under this assumption, your shader code might look like this:

vec3 wPosition       = position;
vec3 wV              = cross(orientation.xyz, wPosition);
wPosition            = offset + wV * 2.0 * orientation.w + cross(orientation.xyz, wV) * 2.0 + wPosition;
vec4 ecPosition      = modelViewMatrix * vec4(wPosition, 1.0);
vUv                  = uv;
gl_Position          = projectionMatrix * ecPosition;

// transform normal vector to world space
vec3 wNPosition      = position + normal;
vec3 wNV             = cross(orientation.xyz, wNPosition);
wNPosition           = offset + wNV * 2.0 * orientation.w + cross(orientation.xyz, wNV) * 2.0 + wNPosition;
vec3 ecNormal        = normalize(mat3(modelViewMatrix) * (wNPosition - wPosition));

// ambient light
vLightFactor         = ambientLightColor;

// diffuse light
vec3  ecToLight      = normalize(directionalLights[0].direction);
float NdotL          = max(0.0, dot(ecNormal, ecToLight));
vLightFactor        += NdotL * directionalLights[0].color;

If you want to add specular light you have to do it like this:

// specular light
vec3  ecReflectLight = reflect( ecFromLight, ecNormal );
vec3  ecViewDir      = normalize(-ecPosition.xyz);
float VdotR          = max(0.0, dot(ecViewDir, ecReflectLight));
float kSpecular      = 4.0 * pow( VdotR, 0.3 * shininess ); // <--- set up shininess parameter
vLightFactor        += kSpecular * directionalLights[0].color;

Extension to the answer: Per fragment lighting

While Gouraud shading calculates the light in the the vertex shader, Phong shading calculates the light in the fragment shader.
(see further GLSL fixed function fragment program replacement)

Vertex shader:

precision highp float;

uniform mat4 modelViewMatrix;
uniform mat4 projectionMatrix;
uniform mat3 normalMatrix;

attribute vec3 position;
attribute vec3 offset;
attribute vec3 normal;
attribute vec2 uv;
attribute vec4 orientation;

varying vec2 vUv;
varying vec3 ecPosition;
varying vec3 ecNormal;

void main()
{
    vec3 wPosition   = position;
    vec3 wV          = cross(orientation.xyz, wPosition);
    pos              = offset + wV * 2.0 * orientation.w + cross(orientation.xyz, wV) * 2.0 + wPosition;
    vec4 vPos        = modelViewMatrix * vec4(wPosition, 1.0);
    ecPosition       = vPos.xyz;
    vUv              = uv;
    gl_Position      = projectionMatrix * vPos;

    // transform normal vector to world space
    vec3 wNPosition  = position + normal;
    vec3 wNV         = cross(orientation.xyz, wNPosition);
    wNPosition       = offset + wNV * 2.0 * orientation.w + cross(orientation.xyz, wNV) * 2.0 + wNPosition;
    ecNormal         = normalize(mat3(modelViewMatrix) * (wNPosition - wPosition));
}

Fragment shader:

precision highp float;

varying vec2 vUv;
varying vec3 ecPosition;
varying vec3 ecNormal;

uniform sampler2D map;
uniform mat4 modelViewMatrix;

struct DirectionalLight {
    vec3 direction;
    vec3 color;
    int shadow;
    float shadowBias;
    float shadowRadius;
    vec2 shadowMapSize;
};
uniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];
uniform vec3 ambientLightColor;

void main()
{
    // ambient light
    float lightFactor = ambientLightColor;

    // diffuse light
    vec3  ecToLight      = normalize(directionalLights[0].direction);
    float NdotL          = max(0.0, dot(ecNormal, ecToLight));
    lightFactor         += NdotL * directionalLights[0].color; 

    // specular light
    vec3  ecReflectLight = reflect( ecFromLight, ecNormal );
    vec3  ecViewDir      = normalize(-ecPosition.xyz);
    float VdotR          = max(0.0, dot(ecViewDir, ecReflectLight));
    float kSpecular      = 4.0 * pow( VdotR, 0.3 * shininess ); // <--- set up shininess parameter
    lightFactor         += kSpecular * directionalLights[0].color;

    gl_FragColor = texture2D(map, vUv) * vec4(vec3(lightFactor), 1.0);
}