overte/libraries/render-utils/src/DeferredBuffer.slh

<!
//  DeferredBuffer.slh
//  libraries/render-utils/src
//
//  Created by Sam Gateau on 1/12/15.
//  Copyright 2013 High Fidelity, Inc.
//
//  Distributed under the Apache License, Version 2.0.
//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
!>
<@if not DEFERRED_BUFFER_SLH@>
<@def DEFERRED_BUFFER_SLH@>


// the diffuse texture
uniform sampler2D diffuseMap;

// the normal texture
uniform sampler2D normalMap;

// the specular texture
uniform sampler2D specularMap;

// the depth texture
uniform sampler2D depthMap;

// the lighting texture
uniform sampler2D lightingMap;


struct DeferredTransform { 
    mat4 projection;
    mat4 viewInverse;

    vec4 stereoSide_spareABC;
};

layout(std140) uniform deferredTransformBuffer {
    DeferredTransform _deferredTransform;
};
DeferredTransform getDeferredTransform() {
    return _deferredTransform;
}

bool getStereoMode(DeferredTransform deferredTransform) {
    return (deferredTransform.stereoSide_spareABC.x != 0.0);
}
float getStereoSide(DeferredTransform deferredTransform) {
    return  (deferredTransform.stereoSide_spareABC.x);
}

vec4 evalEyePositionFromZ(DeferredTransform deferredTransform, float depthVal, vec2 texcoord) {
    vec3 nPos = vec3(texcoord.xy * 2.0f - 1.0f, depthVal * 2.0f - 1.0f);

    // compute the view space position using the depth
    // basically manually pick the proj matrix components to do the inverse
    float Ze = -deferredTransform.projection[3][2] / (nPos.z + deferredTransform.projection[2][2]);
    float Xe = (-Ze * nPos.x - Ze * deferredTransform.projection[2][0] - deferredTransform.projection[3][0]) /  deferredTransform.projection[0][0];
    float Ye = (-Ze * nPos.y - Ze * deferredTransform.projection[2][1] - deferredTransform.projection[3][1]) /  deferredTransform.projection[1][1];
    return vec4(Xe, Ye, Ze, 1.0f);
}

struct DeferredFragment {
    float depthVal;
    vec4 normalVal;
    vec4 diffuseVal;
    vec4 specularVal;
    vec4 position;
    vec3 normal;
    vec3 diffuse;
    float obscurance;
    vec3 specular;
    float gloss;
    int mode;
};

const int LIGHT_MAPPED = 1;

DeferredFragment unpackDeferredFragment(DeferredTransform deferredTransform, vec2 texcoord) {
    DeferredFragment frag;
    frag.depthVal = texture(depthMap, texcoord).r;
    frag.normalVal = texture(normalMap, texcoord);
    frag.diffuseVal = texture(diffuseMap, texcoord);
    frag.specularVal = texture(specularMap, texcoord);

    if (getStereoMode(deferredTransform)) {
        if (texcoord.x > 0.5) {
            texcoord.x -= 0.5;
        }
        texcoord.x *= 2.0;
    }
    frag.position = evalEyePositionFromZ(deferredTransform, frag.depthVal, texcoord);

    // Unpack the normal from the map
    frag.normal = normalize(frag.normalVal.xyz * 2.0 - vec3(1.0));
    
    frag.mode = 0;
    if ((frag.normalVal.a >= 0.45) && (frag.normalVal.a <= 0.55)) {
        frag.mode = LIGHT_MAPPED;
    }

    frag.diffuse = frag.diffuseVal.xyz;
    frag.obscurance = frag.diffuseVal.w;
    frag.specular = frag.specularVal.xyz;
    frag.gloss = frag.specularVal.w;

    return frag;
}


<@endif@>