OpenSubdiv/examples/paintTest/paintShader.glsl

//
//     Copyright (C) Pixar. All rights reserved.
//
//     This license governs use of the accompanying software. If you
//     use the software, you accept this license. If you do not accept
//     the license, do not use the software.
//
//     1. Definitions
//     The terms "reproduce," "reproduction," "derivative works," and
//     "distribution" have the same meaning here as under U.S.
//     copyright law.  A "contribution" is the original software, or
//     any additions or changes to the software.
//     A "contributor" is any person or entity that distributes its
//     contribution under this license.
//     "Licensed patents" are a contributor's patent claims that read
//     directly on its contribution.
//
//     2. Grant of Rights
//     (A) Copyright Grant- Subject to the terms of this license,
//     including the license conditions and limitations in section 3,
//     each contributor grants you a non-exclusive, worldwide,
//     royalty-free copyright license to reproduce its contribution,
//     prepare derivative works of its contribution, and distribute
//     its contribution or any derivative works that you create.
//     (B) Patent Grant- Subject to the terms of this license,
//     including the license conditions and limitations in section 3,
//     each contributor grants you a non-exclusive, worldwide,
//     royalty-free license under its licensed patents to make, have
//     made, use, sell, offer for sale, import, and/or otherwise
//     dispose of its contribution in the software or derivative works
//     of the contribution in the software.
//
//     3. Conditions and Limitations
//     (A) No Trademark License- This license does not grant you
//     rights to use any contributor's name, logo, or trademarks.
//     (B) If you bring a patent claim against any contributor over
//     patents that you claim are infringed by the software, your
//     patent license from such contributor to the software ends
//     automatically.
//     (C) If you distribute any portion of the software, you must
//     retain all copyright, patent, trademark, and attribution
//     notices that are present in the software.
//     (D) If you distribute any portion of the software in source
//     code form, you may do so only under this license by including a
//     complete copy of this license with your distribution. If you
//     distribute any portion of the software in compiled or object
//     code form, you may only do so under a license that complies
//     with this license.
//     (E) The software is licensed "as-is." You bear the risk of
//     using it. The contributors give no express warranties,
//     guarantees or conditions. You may have additional consumer
//     rights under your local laws which this license cannot change.
//     To the extent permitted under your local laws, the contributors
//     exclude the implied warranties of merchantability, fitness for
//     a particular purpose and non-infringement.
//

#line 58
vec4 PTexLookup(vec4 patchCoord,
                sampler2DArray data,
                samplerBuffer packings,
                isamplerBuffer pages)
{
    vec2 uv = patchCoord.xy;
    int faceID = int(patchCoord.w);
    int page = texelFetch(pages, faceID).x;
    vec4 packing = texelFetch(packings, faceID);
    vec3 coords = vec3( packing.x + uv.x * packing.z,
                        packing.y + uv.y * packing.w,
                        page);

    return texture(data, coords);
}

uniform sampler2DArray textureImage_Data;
uniform samplerBuffer textureImage_Packing;
uniform isamplerBuffer textureImage_Pages;

vec4 displacement(vec4 position, vec3 normal, vec4 patchCoord)
{
    float disp = PTexLookup(patchCoord,
                            textureImage_Data,
                            textureImage_Packing,
                            textureImage_Pages).x;
    return position + 0.01*vec4(disp * normal, 0);
}

//--------------------------------------------------------------
// Vertex Shader
//--------------------------------------------------------------
#ifdef VERTEX_SHADER

layout (location=0) in vec4 position;

out block {
    OutputVertex v;
} output;

void main()
{
    output.v.position = ModelViewMatrix * position;
}

#endif

//--------------------------------------------------------------
// Geometry Shader
//--------------------------------------------------------------
#ifdef GEOMETRY_SHADER

layout(triangles) in;

layout(triangle_strip, max_vertices = 3) out;

in block {
   OutputVertex v;
} input[3];

out block {
    OutputVertex v;
    vec4 depthPosition;
} output;

void emit(int index, vec4 position)
{
    vec2 uv = vec2(input[index].v.patchCoord.xy);
    output.v.position    = ProjectionMatrix * position;
    output.depthPosition = ProjectionWithoutPickMatrix * position;
    output.v.patchCoord  = input[index].v.patchCoord;
    gl_Position          = vec4(uv*2-vec2(1.0), 0, 1);
    EmitVertex();
}

void main()
{
    gl_PrimitiveID = gl_PrimitiveIDIn;

    vec4 patchCoord[3];
    vec4 position[3];

    // patch coords are computed in tessellation shader
    patchCoord[0] = input[0].v.patchCoord;
    patchCoord[1] = input[1].v.patchCoord;
    patchCoord[2] = input[2].v.patchCoord;

#ifdef USE_PTEX_DISPLACEMENT
    position[0] = displacement(input[0].v.position, input[0].v.normal, patchCoord[0]);
    position[1] = displacement(input[1].v.position, input[1].v.normal, patchCoord[1]);
    position[2] = displacement(input[2].v.position, input[2].v.normal, patchCoord[2]);
#else
    position[0] = input[0].v.position;
    position[1] = input[1].v.position;
    position[2] = input[2].v.position;
#endif

    emit(0, position[0]);
    emit(1, position[1]);
    emit(2, position[2]);
    EndPrimitive();
}

#endif

//--------------------------------------------------------------
// Fragment Shader
//--------------------------------------------------------------
#ifdef FRAGMENT_SHADER

in block {
    OutputVertex v;
    vec4 depthPosition;
} input;

layout(size1x32) uniform image2DArray outTextureImage;
uniform sampler2D paintTexture;
uniform sampler2D depthTexture;
uniform int imageSize = 256;

void
main()
{
    vec4 p = input.v.position;
    p.xyz /= p.w;

    vec4 wp = input.depthPosition;
    wp.z -= 0.001;
    wp.xyz /= wp.w;

    vec4 c = texture(paintTexture, p.xy*0.5+0.5);
    float depth = texture(depthTexture, wp.xy*0.5+0.5).x;
    if (wp.z*0.5+0.5 >= depth) return;
    
    ivec3 pos = ivec3(input.v.patchCoord.x * imageSize,
                      input.v.patchCoord.y * imageSize,
                      int(input.v.patchCoord.w));

    vec4 d = imageLoad(outTextureImage, pos);
    c = c + d;
    imageStore(outTextureImage, pos, c);
    discard;
}

#endif