// This code contains NVIDIA Confidential Information and is disclosed to you
// under a form of NVIDIA software license agreement provided separately to you.
//
// Notice
// NVIDIA Corporation and its licensors retain all intellectual property and
// proprietary rights in and to this software and related documentation and
// any modifications thereto. Any use, reproduction, disclosure, or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA Corporation is strictly prohibited.
//
// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
//
// Information and code furnished is believed to be accurate and reliable.
// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
// information or for any infringement of patents or other rights of third parties that may
// result from its use. No license is granted by implication or otherwise under any patent
// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
// This code supersedes and replaces all information previously supplied.
// NVIDIA Corporation products are not authorized for use as critical
// components in life support devices or systems without express written approval of
// NVIDIA Corporation.
//
// Copyright (c) 2008-2021 NVIDIA Corporation. All rights reserved.

#if SUPPORT_GL

#include "Shaders_GL.h"

using namespace GFSDK::SSAO::GL;

//--------------------------------------------------------------------------------
static char* g_FullscreenTriangle_VS_GLSL = 
    (char*) STRINGIFY(
        out vec4 VtxGeoOutput1;
        void main()
        {
            vec2 TexCoords = vec2( (gl_VertexID << 1) & 2, gl_VertexID & 2 );
            gl_Position = vec4( TexCoords * vec2( 2.0, 2.0 ) + vec2( -1.0, -1.0) , 0.0, 1.0 );
            VtxGeoOutput1 = vec4( TexCoords, 0.0, 0.0 );
        }
    );

//--------------------------------------------------------------------------------
void GLSLPrograms::CopyDepth_PS::Create(const GFSDK_SSAO_GLFunctions& GL, const char *FragmentShaderSource)
{
    GLSLProgram::Create(GL, g_FullscreenTriangle_VS_GLSL, FragmentShaderSource);

    m_DepthTexture = GetUniformLocation(GL, "g_t0");
    ASSERT(m_DepthTexture != -1);
}

//--------------------------------------------------------------------------------
void GLSLPrograms::LinearizeDepth_PS::Create(const GFSDK_SSAO_GLFunctions& GL, const char *FragmentShaderSource)
{
    GLSLProgram::Create(GL, g_FullscreenTriangle_VS_GLSL, FragmentShaderSource);

    m_DepthTexture          = GetUniformLocation(GL, "g_t0");
    m_GlobalUniformBlock    = GetUniformBlockIndex(GL, "GlobalConstantBuffer");

    GL.glUniformBlockBinding(m_Program, m_GlobalUniformBlock, BaseConstantBuffer::BINDING_POINT_GLOBAL_UBO);
    ASSERT_GL_ERROR(GL);
}

//--------------------------------------------------------------------------------
void GLSLPrograms::DeinterleaveDepth_PS::Create(const GFSDK_SSAO_GLFunctions& GL, const char *FragmentShaderSource)
{
    GLSLProgram::Create(GL, g_FullscreenTriangle_VS_GLSL, FragmentShaderSource);

    m_DepthTexture          = GetUniformLocation(GL, "g_t0");
    m_GlobalUniformBlock    = GetUniformBlockIndex(GL, "GlobalConstantBuffer");
    m_PerPassUniformBlock   = GetUniformBlockIndex(GL, "PerPassConstantBuffer");

    GL.glUniformBlockBinding(m_Program, m_GlobalUniformBlock, BaseConstantBuffer::BINDING_POINT_GLOBAL_UBO);
    GL.glUniformBlockBinding(m_Program, m_PerPassUniformBlock, BaseConstantBuffer::BINDING_POINT_PER_PASS_UBO);
    ASSERT_GL_ERROR(GL);
}

//--------------------------------------------------------------------------------
void GLSLPrograms::ReconstructNormal_PS::Create(const GFSDK_SSAO_GLFunctions& GL, const char *FragmentShaderSource)
{
    GLSLProgram::Create(GL, g_FullscreenTriangle_VS_GLSL, FragmentShaderSource);

    m_FullResDepthTexture       = GetUniformLocation(GL, "g_t0");
    m_FullResNormalTexture      = GetUniformLocation(GL, "g_t1");
    m_GlobalUniformBlock        = GetUniformBlockIndex(GL, "GlobalConstantBuffer");

    if (m_GlobalUniformBlock != GL_INVALID_INDEX)
    {
        GL.glUniformBlockBinding(m_Program, m_GlobalUniformBlock, BaseConstantBuffer::BINDING_POINT_GLOBAL_UBO);
    }

    ASSERT_GL_ERROR(GL);
}

//--------------------------------------------------------------------------------
void GLSLPrograms::CoarseAO_PS::Create(const GFSDK_SSAO_GLFunctions& GL, const char *FragmentShaderSource)
{
    static const char *VertexShaderSource = 
        STRINGIFY(
            void main()
            {
                gl_Position = vec4(0);
            }
        );

    static const char *GeometryShaderSource = 
        // Must match the uniform declaration from shaders/out/GL/CoarseAO_PS.cpp
        STRINGIFY(
            layout(std140) uniform;
            struct PerPassConstantBuffer_0_Type
            {
                vec4 f4Jitter;
                vec2 f2Offset;
                float fSliceIndex;
                uint uSliceIndex;
            };
            uniform PerPassConstantBuffer
            {
                PerPassConstantBuffer_0_Type PerPassConstantBuffer_0;
            };
        )
        STRINGIFY(
            layout(points) in;
            layout(triangle_strip, max_vertices = 3) out;

            void main()
            {
                gl_Layer = int(PerPassConstantBuffer_0.uSliceIndex);

                for (int VertexID = 0; VertexID < 3; VertexID++)
                {
                    vec2 texCoords = vec2( (VertexID << 1) & 2, VertexID & 2 );
                    gl_Position = vec4( texCoords * vec2( 2.0, 2.0 ) + vec2( -1.0, -1.0) , 0.0, 1.0 );
                    EmitVertex();
                }
                EndPrimitive();
            }
        );

    GLSLProgram::Create(GL, VertexShaderSource, GeometryShaderSource, FragmentShaderSource);

    m_QuarterResDepthTexture    = GetUniformLocation(GL, "g_t0");
    m_FullResNormalTexture      = GetUniformLocation(GL, "g_t1");
    m_GlobalUniformBlock        = GetUniformBlockIndex(GL, "GlobalConstantBuffer");
    m_PerPassUniformBlock       = GetUniformBlockIndex(GL, "PerPassConstantBuffer");

    GL.glUniformBlockBinding(m_Program, m_GlobalUniformBlock, BaseConstantBuffer::BINDING_POINT_GLOBAL_UBO);
    GL.glUniformBlockBinding(m_Program, m_PerPassUniformBlock, BaseConstantBuffer::BINDING_POINT_PER_PASS_UBO);
    ASSERT_GL_ERROR(GL);
}

//--------------------------------------------------------------------------------
void GLSLPrograms::ReinterleaveAO_PS::Create(const GFSDK_SSAO_GLFunctions& GL, const char *FragmentShaderSource)
{
    GLSLProgram::Create(GL, g_FullscreenTriangle_VS_GLSL, FragmentShaderSource);

    m_AOTexture             = GetUniformLocation(GL, "g_t0");
    m_DepthTexture          = GetUniformLocation(GL, "g_t1");
    m_GlobalUniformBlock    = GetUniformBlockIndex(GL, "GlobalConstantBuffer");

    if (m_GlobalUniformBlock != GL_INVALID_INDEX)
    {
        GL.glUniformBlockBinding(m_Program, m_GlobalUniformBlock, BaseConstantBuffer::BINDING_POINT_GLOBAL_UBO);
        ASSERT_GL_ERROR(GL);
    }
}

//--------------------------------------------------------------------------------
void GLSLPrograms::Blur_PS::Create(const GFSDK_SSAO_GLFunctions& GL, const char *FragmentShaderSource)
{
    GLSLProgram::Create(GL, g_FullscreenTriangle_VS_GLSL, FragmentShaderSource);

    m_AODepthTextureNearest = GetUniformLocation(GL, "g_t0");
    m_AODepthTextureLinear  = GetUniformLocation(GL, "g_t1");
    m_GlobalUniformBlock    = GetUniformBlockIndex(GL, "GlobalConstantBuffer");

    GL.glUniformBlockBinding(m_Program, m_GlobalUniformBlock, BaseConstantBuffer::BINDING_POINT_GLOBAL_UBO);
    ASSERT_GL_ERROR(GL);
}

//--------------------------------------------------------------------------------

namespace GFSDK
{
namespace SSAO
{
namespace GL
{

#include "shaders/out/GL/CopyDepth_PS.cpp"
#include "shaders/out/GL/LinearizeDepth_PS.cpp"
#include "shaders/out/GL/DeinterleaveDepth_PS.cpp"
#include "shaders/out/GL/DebugNormals_PS.cpp"
#include "shaders/out/GL/ReconstructNormal_PS.cpp"
#include "shaders/out/GL/ReinterleaveAO_PS.cpp"
#include "shaders/out/GL/BlurX_PS.cpp"
#include "shaders/out/GL/BlurY_PS.cpp"
#include "shaders/out/GL/CoarseAO_PS.cpp"

} // namespace GL
} // namespace SSAO
} // namespace GFSDK

#endif // SUPPORT_GL