angle/util/shader_utils.cpp

884 строки
21 KiB
C++

//
// 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
{
bool ReadEntireFile(const std::string &filePath, std::string *contentsOut)
{
constexpr uint32_t kMaxBufferSize = 2000;
char buffer[kMaxBufferSize] = {};
if (!angle::ReadEntireFileToString(filePath.c_str(), buffer, kMaxBufferSize) ||
strlen(buffer) == 0)
return false;
*contentsOut = buffer;
return true;
}
GLuint CompileProgramInternal(const char *vsSource,
const char *tcsSource,
const char *tesSource,
const char *gsSource,
const char *fsSource,
const std::function<void(GLuint)> &preLinkCallback)
{
GLuint vs = CompileShader(GL_VERTEX_SHADER, vsSource);
GLuint fs = CompileShader(GL_FRAGMENT_SHADER, fsSource);
if (vs == 0 || fs == 0)
{
glDeleteShader(fs);
glDeleteShader(vs);
return 0;
}
GLuint program = glCreateProgram();
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,
GLuint *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 (!ReadEntireFile(sourcePath, &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 (!ReadEntireFile(vsPath, &vsSource))
{
std::cerr << "Error reading shader: " << vsPath << "\n";
return 0;
}
std::string fsSource;
if (!ReadEntireFile(fsPath, &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;
}
CounterNameToIndexMap 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 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 = 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 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);
})";
}
} // 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 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