Mirrors/overte-JulianGro
3
0
Fork 0
mirror of https://github.com/JulianGro/overte.git synced 2025-04-06 02:02:43 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Fixup shader interfaces

Browse source
This commit is contained in:
Brad Davis 2018-10-29 00:33:02 -07:00 committed by Karol Suprynowicz
parent 4b6db42d3d
commit 17e2c0f99e
8 changed files with 137 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
libraries/gpu/src/gpu/DrawColor.slf
View file

@ -13,6 +13,7 @@
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
struct DrawColorParams {
vec4 color;
};
@ -21,6 +22,8 @@ UNIFORM_BUFFER(0, drawColorParamsBuffer) {
DrawColorParams params;
};
// Unused, but needed to match the vertex shader
INPUT(0, vec2, varTexCoord0);
OUTPUT(0, vec4, outFragColor);
void main(void) {

4
libraries/render-utils/src/grid.slf
View file

@ -31,6 +31,10 @@ UNIFORM_BUFFER(0, gridBuffer) {
Grid getGrid() { return grid; }
// unused, but needed for shader interface matching
INPUT(GPU_ATTR_POSITION, vec3, varPosition);
INPUT(GPU_ATTR_NORMAL, vec3, varNormal);
INPUT(GPU_ATTR_TEXCOORD0, vec2, varTexCoord0);
INPUT(GPU_ATTR_COLOR, vec4, varColor);

3
libraries/render-utils/src/ssao_debugOcclusion.slf
View file

@ -34,6 +34,9 @@ vec2 getDebugCursorTexcoord(){
return debugParams.pixelInfo.xy;
}
// Unused, but needed to match the vertex shader
INPUT(0, vec2, varTexCoord0);
OUTPUT(0, vec4, outFragColor);
void main(void) {

2
libraries/render-utils/src/ssao_makeOcclusion.slf
View file

@ -19,9 +19,11 @@
<$declarePackOcclusionDepth()$>
// Unused, but needed to match the vertex shader
#define SSAO_HBAO_MAX_RADIUS 300.0
INPUT(0, vec2, varTexCoord0);
OUTPUT(0, vec4, outFragColor);
void main(void) {

6
libraries/render-utils/src/ssao_makePyramid.slf
View file

@ -16,6 +16,12 @@
TEXTURE(0, sampler2D, depthMap);
const ivec2 horizontal = ivec2(1,0);
<$declareBlurPass(horizontal)$>
// Unused, but needed to match the vertex shader
INPUT(0, vec2, varTexCoord0);
OUTPUT(0, vec4, outFragColor);
void main(void) {

2
libraries/render-utils/src/subsurfaceScattering_makeProfile.slf
View file

@ -14,7 +14,9 @@
<@include SubsurfaceScattering.slh@>
<$declareSubsurfaceScatteringGenerateProfileMap()$>
// Unused, but needed to match the vertex shader
INPUT(0, vec2, varTexCoord0);
OUTPUT(0, vec4, outFragColor);
void main(void) {

3
libraries/render-utils/src/surfaceGeometry_makeLinearDepth.slf
View file

@ -18,6 +18,9 @@
TEXTURE(RENDER_UTILS_TEXTURE_SG_DEPTH, sampler2D, depthMap);
// Unused, but needed to match the vertex shader
INPUT(0, vec2, varTexCoord0);
OUTPUT(0, vec4, outFragColor);
void main(void) {

114
tests/shaders/src/ShaderTests.cpp
View file

@ -419,6 +419,102 @@ void rebuildSource(shader::Dialect dialect, shader::Variant variant, const shade
qWarning() << error.what();
}
}
#endif
template <typename K, typename V>
std::unordered_map<V, K> invertMap(const std::unordered_map<K, V>& map) {
std::unordered_map<V, K> result;
for (const auto& entry : map) {
result[entry.second] = entry.first;
}
if (result.size() != map.size()) {
throw std::runtime_error("Map inversion failure, result size does not match input size");
}
return result;
}
uint32_t makeProgramId(uint32_t vertexId, uint32_t fragmentId) {
return (vertexId << 16) | fragmentId;
}
std::unordered_map<uint32_t, std::list<uint32_t>> shaderToProgramMap;
std::unordered_map<uint32_t, std::unordered_set<uint32_t>> problemShaderIds;
static void verifyInterface(const gpu::Shader::Source& vertexSource,
const gpu::Shader::Source& fragmentSource,
shader::Dialect dialect,
shader::Variant variant) {
auto programId = makeProgramId(vertexSource.id, fragmentSource.id);
shaderToProgramMap[vertexSource.id].push_back(programId);
shaderToProgramMap[fragmentSource.id].push_back(programId);
const auto& fragmentReflection = fragmentSource.getReflection(dialect, variant);
const auto& fragmentInputs = fragmentReflection.inputs;
const auto& vertexReflection = vertexSource.getReflection(dialect, variant);
const auto& vertexOutputs = vertexReflection.outputs;
bool named = false;
for (const auto& input : fragmentInputs) {
const auto& slot = input.second;
if (!vertexReflection.validOutput(slot)) {
problemShaderIds[fragmentSource.id].insert(vertexSource.id);
if (!named) {
named = true;
qWarning() << vertexSource.name.c_str() << " " << fragmentSource.name.c_str();
}
qWarning() << "Fragment shader reads slot " << slot << " not written by vertex shader";
}
}
for (const auto& output : vertexOutputs) {
const auto& slot = output.second;
if (!fragmentReflection.validInput(slot)) {
problemShaderIds[vertexSource.id].insert(fragmentSource.id);
if (!named) {
named = true;
qWarning() << vertexSource.name.c_str() << " " << fragmentSource.name.c_str();
}
qWarning() << "Vertex shader writes slot " << slot << " not read by fragment shader";
}
}
//if (fragmentInputs.empty()) {
// return;
//}
//const auto& fragIn = fragmentReflection.inputs;
//if (vertexReflection.outputs.empty()) {
// throw std::runtime_error("No vertex outputs for fragment inputs");
//}
//const auto& vout = vertexReflection.outputs;
//auto vrev = invertMap(vout);
//for (const auto entry : fragIn) {
// const auto& name = entry.first;
// if (0 == vout.count(name)) {
// throw std::runtime_error("Vertex outputs missing");
// }
// const auto& inLocation = entry.second;
// const auto& outLocation = vout.at(name);
// if (inLocation != outLocation) {
// throw std::runtime_error("Mismatch in vertex / fragment interface");
// }
//}
}
static void verifyInterface(const gpu::Shader::Source& vertexSource, const gpu::Shader::Source& fragmentSource) {
for (const auto& dialect : shader::allDialects()) {
verifyInterface(vertexSource, fragmentSource, dialect, shader::Variant::Mono);
//for (const auto& variant : shader::allVariants()) {
// verifyInterface(vertexSource, fragmentSource, dialect, variant);
//}
}
}
#if RUNTIME_SHADER_COMPILE_TEST
#endif
void validateDialectVariantSource(const shader::DialectVariantSource& source) {
@ -519,6 +615,8 @@ void ShaderTests::testShaderLoad() {
const auto& fragmentSource = shader::Source::get(fragmentId);
verifyInterface(vertexSource, fragmentSource);
continue;
auto program = gpu::Shader::createProgram(programId);
auto glBackend = std::static_pointer_cast<gpu::gl::GLBackend>(_gpuContext->getBackend());
auto glshader = gpu::gl::GLShader::sync(*glBackend, *program);
@ -529,6 +627,22 @@ void ShaderTests::testShaderLoad() {
QFAIL("Program link error");
}
}
for (const auto& entry : problemShaderIds) {
const auto& shaderId = entry.first;
const auto& otherShadersSet = entry.second;
auto name = shader::Source::get(shaderId).name;
for (const auto& programId : shaderToProgramMap[shaderId]) {
auto vertexId = (programId >> 16) & 0xFFFF;
auto fragmentId = programId & 0xFFFF;
auto otherShaderId = shaderId == vertexId ? fragmentId : vertexId;
if (otherShadersSet.count(otherShaderId) != 0) {
continue;
}
auto otherName = shader::Source::get(otherShaderId).name;
qWarning() << "Shader id " << name.c_str() << " used with shader " << otherName.c_str();
}
}
} catch (const std::runtime_error& error) {
QFAIL(error.what());
}