godot-angle-static/util/shader_utils.cpp

//
// Copyright 2014 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//

#include "util/shader_utils.h"

#include <cstring>
#include <fstream>
#include <iostream>
#include <vector>

#include "common/utilities.h"
#include "util/test_utils.h"

namespace
{
GLuint CompileProgramInternal(const char *vsSource,
                              const char *tcsSource,
                              const char *tesSource,
                              const char *gsSource,
                              const char *fsSource,
                              const std::function<void(GLuint)> &preLinkCallback)
{
    GLuint program = glCreateProgram();

    GLuint vs = CompileShader(GL_VERTEX_SHADER, vsSource);
    GLuint fs = CompileShader(GL_FRAGMENT_SHADER, fsSource);

    if (vs == 0 || fs == 0)
    {
        glDeleteShader(fs);
        glDeleteShader(vs);
        glDeleteProgram(program);
        return 0;
    }

    glAttachShader(program, vs);
    glDeleteShader(vs);

    glAttachShader(program, fs);
    glDeleteShader(fs);

    GLuint tcs = 0;
    GLuint tes = 0;
    GLuint gs  = 0;

    if (strlen(tcsSource) > 0)
    {
        tcs = CompileShader(GL_TESS_CONTROL_SHADER_EXT, tcsSource);
        if (tcs == 0)
        {
            glDeleteShader(vs);
            glDeleteShader(fs);
            glDeleteProgram(program);
            return 0;
        }

        glAttachShader(program, tcs);
        glDeleteShader(tcs);
    }

    if (strlen(tesSource) > 0)
    {
        tes = CompileShader(GL_TESS_EVALUATION_SHADER_EXT, tesSource);
        if (tes == 0)
        {
            glDeleteShader(vs);
            glDeleteShader(fs);
            glDeleteShader(tcs);
            glDeleteProgram(program);
            return 0;
        }

        glAttachShader(program, tes);
        glDeleteShader(tes);
    }

    if (strlen(gsSource) > 0)
    {
        gs = CompileShader(GL_GEOMETRY_SHADER_EXT, gsSource);
        if (gs == 0)
        {
            glDeleteShader(vs);
            glDeleteShader(fs);
            glDeleteShader(tcs);
            glDeleteShader(tes);
            glDeleteProgram(program);
            return 0;
        }

        glAttachShader(program, gs);
        glDeleteShader(gs);
    }

    if (preLinkCallback)
    {
        preLinkCallback(program);
    }

    glLinkProgram(program);

    return CheckLinkStatusAndReturnProgram(program, true);
}

const void *gCallbackChainUserParam;

void KHRONOS_APIENTRY DebugMessageCallback(GLenum source,
                                           GLenum type,
                                           GLuint id,
                                           GLenum severity,
                                           GLsizei length,
                                           const GLchar *message,
                                           const void *userParam)
{
    std::string sourceText   = gl::GetDebugMessageSourceString(source);
    std::string typeText     = gl::GetDebugMessageTypeString(type);
    std::string severityText = gl::GetDebugMessageSeverityString(severity);
    std::cerr << sourceText << ", " << typeText << ", " << severityText << ": " << message << "\n";

    GLDEBUGPROC callbackChain = reinterpret_cast<GLDEBUGPROC>(const_cast<void *>(userParam));
    if (callbackChain)
    {
        callbackChain(source, type, id, severity, length, message, gCallbackChainUserParam);
    }
}

void GetPerfCounterValue(const CounterNameToIndexMap &counterIndexMap,
                         std::vector<angle::PerfMonitorTriplet> &triplets,
                         const char *name,
                         GLuint64 *counterOut)
{
    auto iter = counterIndexMap.find(name);
    ASSERT(iter != counterIndexMap.end());
    GLuint counterIndex = iter->second;

    for (const angle::PerfMonitorTriplet &triplet : triplets)
    {
        ASSERT(triplet.group == 0);
        if (triplet.counter == counterIndex)
        {
            *counterOut = triplet.value;
            return;
        }
    }

    UNREACHABLE();
}
}  // namespace

GLuint CompileShader(GLenum type, const char *source)
{
    GLuint shader = glCreateShader(type);

    const char *sourceArray[1] = {source};
    glShaderSource(shader, 1, sourceArray, nullptr);
    glCompileShader(shader);

    GLint compileResult;
    glGetShaderiv(shader, GL_COMPILE_STATUS, &compileResult);

    if (compileResult == 0)
    {
        GLint infoLogLength;
        glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLength);

        // Info log length includes the null terminator, so 1 means that the info log is an empty
        // string.
        if (infoLogLength > 1)
        {
            std::vector<GLchar> infoLog(infoLogLength);
            glGetShaderInfoLog(shader, static_cast<GLsizei>(infoLog.size()), nullptr, &infoLog[0]);
            std::cerr << "shader compilation failed: " << &infoLog[0];
        }
        else
        {
            std::cerr << "shader compilation failed. <Empty log message>";
        }

        std::cerr << std::endl;

        glDeleteShader(shader);
        shader = 0;
    }

    return shader;
}

GLuint CompileShaderFromFile(GLenum type, const std::string &sourcePath)
{
    std::string source;
    if (!angle::ReadEntireFileToString(sourcePath.c_str(), &source))
    {
        std::cerr << "Error reading shader file: " << sourcePath << "\n";
        return 0;
    }

    return CompileShader(type, source.c_str());
}

GLuint CheckLinkStatusAndReturnProgram(GLuint program, bool outputErrorMessages)
{
    if (glGetError() != GL_NO_ERROR)
        return 0;

    GLint linkStatus;
    glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
    if (linkStatus == 0)
    {
        if (outputErrorMessages)
        {
            GLint infoLogLength;
            glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLogLength);

            // Info log length includes the null terminator, so 1 means that the info log is an
            // empty string.
            if (infoLogLength > 1)
            {
                std::vector<GLchar> infoLog(infoLogLength);
                glGetProgramInfoLog(program, static_cast<GLsizei>(infoLog.size()), nullptr,
                                    &infoLog[0]);

                std::cerr << "program link failed: " << &infoLog[0];
            }
            else
            {
                std::cerr << "program link failed. <Empty log message>";
            }
        }

        glDeleteProgram(program);
        return 0;
    }

    return program;
}

GLuint GetProgramShader(GLuint program, GLint requestedType)
{
    static constexpr GLsizei kMaxShaderCount = 16;
    GLuint attachedShaders[kMaxShaderCount]  = {0u};
    GLsizei count                            = 0;
    glGetAttachedShaders(program, kMaxShaderCount, &count, attachedShaders);
    for (int i = 0; i < count; ++i)
    {
        GLint type = 0;
        glGetShaderiv(attachedShaders[i], GL_SHADER_TYPE, &type);
        if (type == requestedType)
        {
            return attachedShaders[i];
        }
    }

    return 0;
}

GLuint CompileProgramWithTransformFeedback(
    const char *vsSource,
    const char *fsSource,
    const std::vector<std::string> &transformFeedbackVaryings,
    GLenum bufferMode)
{
    auto preLink = [&](GLuint program) {
        if (transformFeedbackVaryings.size() > 0)
        {
            std::vector<const char *> constCharTFVaryings;

            for (const std::string &transformFeedbackVarying : transformFeedbackVaryings)
            {
                constCharTFVaryings.push_back(transformFeedbackVarying.c_str());
            }

            glTransformFeedbackVaryings(program,
                                        static_cast<GLsizei>(transformFeedbackVaryings.size()),
                                        &constCharTFVaryings[0], bufferMode);
        }
    };

    return CompileProgramInternal(vsSource, "", "", "", fsSource, preLink);
}

GLuint CompileProgram(const char *vsSource, const char *fsSource)
{
    return CompileProgramInternal(vsSource, "", "", "", fsSource, nullptr);
}

GLuint CompileProgram(const char *vsSource,
                      const char *fsSource,
                      const std::function<void(GLuint)> &preLinkCallback)
{
    return CompileProgramInternal(vsSource, "", "", "", fsSource, preLinkCallback);
}

GLuint CompileProgramWithGS(const char *vsSource, const char *gsSource, const char *fsSource)
{
    return CompileProgramInternal(vsSource, "", "", gsSource, fsSource, nullptr);
}

GLuint CompileProgramWithTESS(const char *vsSource,
                              const char *tcsSource,
                              const char *tesSource,
                              const char *fsSource)
{
    return CompileProgramInternal(vsSource, tcsSource, tesSource, "", fsSource, nullptr);
}

GLuint CompileProgramFromFiles(const std::string &vsPath, const std::string &fsPath)
{
    std::string vsSource;
    if (!angle::ReadEntireFileToString(vsPath.c_str(), &vsSource))
    {
        std::cerr << "Error reading shader: " << vsPath << "\n";
        return 0;
    }

    std::string fsSource;
    if (!angle::ReadEntireFileToString(fsPath.c_str(), &fsSource))
    {
        std::cerr << "Error reading shader: " << fsPath << "\n";
        return 0;
    }

    return CompileProgram(vsSource.c_str(), fsSource.c_str());
}

GLuint CompileComputeProgram(const char *csSource, bool outputErrorMessages)
{
    GLuint program = glCreateProgram();

    GLuint cs = CompileShader(GL_COMPUTE_SHADER, csSource);
    if (cs == 0)
    {
        glDeleteProgram(program);
        return 0;
    }

    glAttachShader(program, cs);

    glLinkProgram(program);

    return CheckLinkStatusAndReturnProgram(program, outputErrorMessages);
}

GLuint LoadBinaryProgramOES(const std::vector<uint8_t> &binary, GLenum binaryFormat)
{
    GLuint program = glCreateProgram();
    glProgramBinaryOES(program, binaryFormat, binary.data(), static_cast<GLint>(binary.size()));
    return CheckLinkStatusAndReturnProgram(program, true);
}

GLuint LoadBinaryProgramES3(const std::vector<uint8_t> &binary, GLenum binaryFormat)
{
    GLuint program = glCreateProgram();
    glProgramBinary(program, binaryFormat, binary.data(), static_cast<GLint>(binary.size()));
    return CheckLinkStatusAndReturnProgram(program, true);
}

bool LinkAttachedProgram(GLuint program)
{
    glLinkProgram(program);
    return (CheckLinkStatusAndReturnProgram(program, true) != 0);
}

void EnableDebugCallback(GLDEBUGPROC callbackChain, const void *userParam)
{
    gCallbackChainUserParam = userParam;

    glEnable(GL_DEBUG_OUTPUT);
    glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
    // Enable medium and high priority messages.
    glDebugMessageControlKHR(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_HIGH, 0, nullptr,
                             GL_TRUE);
    glDebugMessageControlKHR(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_MEDIUM, 0, nullptr,
                             GL_TRUE);
    // Disable low and notification priority messages.
    glDebugMessageControlKHR(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_LOW, 0, nullptr,
                             GL_FALSE);
    glDebugMessageControlKHR(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_NOTIFICATION, 0, nullptr,
                             GL_FALSE);
    // Disable performance messages to reduce spam.
    glDebugMessageControlKHR(GL_DONT_CARE, GL_DEBUG_TYPE_PERFORMANCE, GL_DONT_CARE, 0, nullptr,
                             GL_FALSE);
    glDebugMessageCallbackKHR(DebugMessageCallback, reinterpret_cast<const void *>(callbackChain));
}

CounterNameToIndexMap BuildCounterNameToIndexMap()
{
    GLint numCounters = 0;
    glGetPerfMonitorCountersAMD(0, &numCounters, nullptr, 0, nullptr);
    if (glGetError() != GL_NO_ERROR)
    {
        return {};
    }

    std::vector<GLuint> counterIndexes(numCounters, 0);
    glGetPerfMonitorCountersAMD(0, nullptr, nullptr, numCounters, counterIndexes.data());
    if (glGetError() != GL_NO_ERROR)
    {
        return {};
    }

    CounterNameToIndexMap indexMap;

    for (GLuint counterIndex : counterIndexes)
    {
        static constexpr size_t kBufSize = 1000;
        char buffer[kBufSize]            = {};
        glGetPerfMonitorCounterStringAMD(0, counterIndex, kBufSize, nullptr, buffer);
        if (glGetError() != GL_NO_ERROR)
        {
            return {};
        }

        indexMap[buffer] = counterIndex;
    }

    return indexMap;
}

std::vector<angle::PerfMonitorTriplet> GetPerfMonitorTriplets()
{
    GLuint resultSize = 0;
    glGetPerfMonitorCounterDataAMD(0, GL_PERFMON_RESULT_SIZE_AMD, sizeof(GLuint), &resultSize,
                                   nullptr);
    if (glGetError() != GL_NO_ERROR || resultSize == 0)
    {
        return {};
    }

    std::vector<angle::PerfMonitorTriplet> perfResults(resultSize /
                                                       sizeof(angle::PerfMonitorTriplet));
    glGetPerfMonitorCounterDataAMD(
        0, GL_PERFMON_RESULT_AMD, static_cast<GLsizei>(perfResults.size() * sizeof(perfResults[0])),
        &perfResults.data()->group, nullptr);

    if (glGetError() != GL_NO_ERROR)
    {
        return {};
    }

    return perfResults;
}

angle::VulkanPerfCounters GetPerfCounters(const CounterNameToIndexMap &indexMap)
{
    std::vector<angle::PerfMonitorTriplet> perfResults = GetPerfMonitorTriplets();

    angle::VulkanPerfCounters counters;

#define ANGLE_UNPACK_PERF_COUNTER(COUNTER) \
    GetPerfCounterValue(indexMap, perfResults, #COUNTER, &counters.COUNTER);

    ANGLE_VK_PERF_COUNTERS_X(ANGLE_UNPACK_PERF_COUNTER)

#undef ANGLE_UNPACK_PERF_COUNTER

    return counters;
}

CounterNameToValueMap BuildCounterNameToValueMap()
{
    CounterNameToIndexMap indexMap                     = BuildCounterNameToIndexMap();
    std::vector<angle::PerfMonitorTriplet> perfResults = GetPerfMonitorTriplets();

    CounterNameToValueMap valueMap;

    for (const auto &iter : indexMap)
    {
        const std::string &name = iter.first;
        GLuint index            = iter.second;

        valueMap[name] = perfResults[index].value;
    }

    return valueMap;
}

namespace angle
{

namespace essl1_shaders
{

const char *PositionAttrib()
{
    return "a_position";
}
const char *ColorUniform()
{
    return "u_color";
}

const char *Texture2DUniform()
{
    return "u_tex2D";
}

namespace vs
{

// A shader that sets gl_Position to zero.
const char *Zero()
{
    return R"(void main()
{
    gl_Position = vec4(0);
})";
}

// A shader that sets gl_Position to attribute a_position.
const char *Simple()
{
    return R"(precision highp float;
attribute vec4 a_position;

void main()
{
    gl_Position = a_position;
})";
}

// A shader that sets gl_Position to attribute a_position, and sets gl_PointSize to 1.
const char *SimpleForPoints()
{
    return R"(precision highp float;
attribute vec4 a_position;

void main()
{
    gl_Position = a_position;
    gl_PointSize = 1.0;
})";
}

// A shader that simply passes through attribute a_position, setting it to gl_Position and varying
// v_position.
const char *Passthrough()
{
    return R"(precision highp float;
attribute vec4 a_position;
varying vec4 v_position;

void main()
{
    gl_Position = a_position;
    v_position = a_position;
})";
}

// A shader that simply passes through attribute a_position, setting it to gl_Position and varying
// texcoord.
const char *Texture2D()
{
    return R"(precision highp float;
attribute vec4 a_position;
varying vec2 v_texCoord;

void main()
{
    gl_Position = a_position;
    v_texCoord = a_position.xy * 0.5 + vec2(0.5);
})";
}

const char *Texture2DArray()
{
    return R"(#version 300 es
out vec2 v_texCoord;
in vec4 a_position;
void main()
{
    gl_Position = vec4(a_position.xy, 0.0, 1.0);
    v_texCoord = (a_position.xy * 0.5) + 0.5;
})";
}

}  // namespace vs

namespace fs
{

// A shader that renders a simple checker pattern of red and green. X axis and y axis separate the
// different colors. Needs varying v_position.
const char *Checkered()
{
    return R"(precision highp float;
varying vec4 v_position;

void main()
{
    bool isLeft = v_position.x < 0.0;
    bool isTop = v_position.y < 0.0;
    if (isLeft)
    {
        if (isTop)
        {
            gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
        }
        else
        {
            gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);
        }
    }
    else
    {
        if (isTop)
        {
            gl_FragColor = vec4(0.0, 0.0, 1.0, 1.0);
        }
        else
        {
            gl_FragColor = vec4(1.0, 1.0, 0.0, 1.0);
        }
    }
})";
}

// A shader that fills with color taken from uniform named "color".
const char *UniformColor()
{
    return R"(uniform mediump vec4 u_color;
void main(void)
{
    gl_FragColor = u_color;
})";
}

// A shader that fills with 100% opaque red.
const char *Red()
{
    return R"(precision mediump float;

void main()
{
    gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
})";
}

// A shader that fills with 100% opaque green.
const char *Green()
{
    return R"(precision mediump float;

void main()
{
    gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);
})";
}

// A shader that fills with 100% opaque blue.
const char *Blue()
{
    return R"(precision mediump float;

void main()
{
    gl_FragColor = vec4(0.0, 0.0, 1.0, 1.0);
})";
}

// A shader that samples the texture.
const char *Texture2D()
{
    return R"(precision mediump float;
uniform sampler2D u_tex2D;
varying vec2 v_texCoord;

void main()
{
    gl_FragColor = texture2D(u_tex2D, v_texCoord);
})";
}

const char *Texture2DArray()
{
    return R"(#version 300 es
precision highp float;
uniform highp sampler2DArray tex2DArray;
uniform int slice;
in vec2 v_texCoord;
out vec4 fragColor;
void main()
{
    fragColor = texture(tex2DArray, vec3(v_texCoord, float(slice)));
})";
}

}  // namespace fs
}  // namespace essl1_shaders

namespace essl3_shaders
{

const char *PositionAttrib()
{
    return "a_position";
}
const char *Texture2DUniform()
{
    return "u_tex2D";
}
const char *LodUniform()
{
    return "u_lod";
}

namespace vs
{

// A shader that sets gl_Position to zero.
const char *Zero()
{
    return R"(#version 300 es
void main()
{
    gl_Position = vec4(0);
})";
}

// A shader that sets gl_Position to attribute a_position.
const char *Simple()
{
    return R"(#version 300 es
in vec4 a_position;
void main()
{
    gl_Position = a_position;
})";
}

// A shader that sets gl_Position to attribute a_position, and sets gl_PointSize to 1.
const char *SimpleForPoints()
{
    return R"(#version 300 es
in vec4 a_position;
void main()
{
    gl_Position = a_position;
    gl_PointSize = 1.0;
})";
}

// A shader that simply passes through attribute a_position, setting it to gl_Position and varying
// v_position.
const char *Passthrough()
{
    return R"(#version 300 es
in vec4 a_position;
out vec4 v_position;
void main()
{
    gl_Position = a_position;
    v_position = a_position;
})";
}

// A shader that simply passes through attribute a_position, setting it to gl_Position and varying
// texcoord.
const char *Texture2DLod()
{
    return R"(#version 300 es
in vec4 a_position;
out vec2 v_texCoord;

void main()
{
    gl_Position = vec4(a_position.xy, 0.0, 1.0);
    v_texCoord = a_position.xy * 0.5 + vec2(0.5);
})";
}

}  // namespace vs

namespace fs
{

// A shader that fills with 100% opaque red.
const char *Red()
{
    return R"(#version 300 es
precision highp float;
out vec4 my_FragColor;
void main()
{
    my_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
})";
}

// A shader that fills with 100% opaque green.
const char *Green()
{
    return R"(#version 300 es
precision highp float;
out vec4 my_FragColor;
void main()
{
    my_FragColor = vec4(0.0, 1.0, 0.0, 1.0);
})";
}

// A shader that fills with 100% opaque blue.
const char *Blue()
{
    return R"(#version 300 es
precision highp float;
out vec4 my_FragColor;
void main()
{
    my_FragColor = vec4(0.0, 0.0, 1.0, 1.0);
})";
}

// A shader that samples the texture at a given lod.
const char *Texture2DLod()
{
    return R"(#version 300 es
precision mediump float;
uniform sampler2D u_tex2D;
uniform float u_lod;
in vec2 v_texCoord;
out vec4 my_FragColor;

void main()
{
    my_FragColor = textureLod(u_tex2D, v_texCoord, u_lod);
})";
}

}  // namespace fs
}  // namespace essl3_shaders

namespace essl31_shaders
{

const char *PositionAttrib()
{
    return "a_position";
}

namespace vs
{

// A shader that sets gl_Position to zero.
const char *Zero()
{
    return R"(#version 310 es
void main()
{
    gl_Position = vec4(0);
})";
}

// A shader that sets gl_Position to attribute a_position.
const char *Simple()
{
    return R"(#version 310 es
in vec4 a_position;
void main()
{
    gl_Position = a_position;
})";
}

// A shader that simply passes through attribute a_position, setting it to gl_Position and varying
// v_position.
const char *Passthrough()
{
    return R"(#version 310 es
in vec4 a_position;
out vec4 v_position;
void main()
{
    gl_Position = a_position;
    v_position = a_position;
})";
}

}  // namespace vs

namespace fs
{

// A shader that fills with 100% opaque red.
const char *Red()
{
    return R"(#version 310 es
precision highp float;
out vec4 my_FragColor;
void main()
{
    my_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
})";
}

// A shader that fills with 100% opaque green.
const char *Green()
{
    return R"(#version 310 es
precision highp float;
out vec4 my_FragColor;
void main()
{
    my_FragColor = vec4(0.0, 1.0, 0.0, 1.0);
})";
}

// A shader that renders a simple gradient of red to green. Needs varying v_position.
const char *RedGreenGradient()
{
    return R"(#version 310 es
precision highp float;
in vec4 v_position;
out vec4 my_FragColor;

void main()
{
    my_FragColor = vec4(v_position.xy * 0.5 + vec2(0.5), 0.0, 1.0);
})";
}

}  // namespace fs
}  // namespace essl31_shaders
}  // namespace angle