Diamond75/Panda3DS
1
0
Fork 0
mirror of https://github.com/wheremyfoodat/Panda3DS.git synced 2025-04-06 06:05:40 +12:00
Code Issues Projects Releases Packages Wiki Activity Actions

Shadergen: Minimize shader compilation time by caching the default VS

Browse source
This commit is contained in:
wheremyfoodat 2024-07-19 14:35:01 +03:00
parent ac55c3e324
commit 5c1e2912a3
5 changed files with 57 additions and 37 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
include/PICA/shader_gen.hpp
View file

@ -35,7 +35,7 @@ namespace PICA::ShaderGen {
public:
FragmentGenerator(API api, Language language) : api(api), language(language) {}
std::string generate(const PICARegs& regs, const PICA::FragmentConfig& config);
std::string getVertexShader(const PICARegs& regs);
std::string getDefaultVertexShader();
void setTarget(API api, Language language) {
this->api = api;

3
include/renderer_gl/renderer_gl.hpp
View file

@ -66,6 +66,9 @@ class RendererGL final : public Renderer {
OpenGL::Texture lightLUTTexture;
OpenGL::Framebuffer screenFramebuffer;
OpenGL::Texture blankTexture;
// The "default" vertex shader to use when using specialized shaders but not PICA vertex shader -> GLSL recompilation
// We can compile this once and then link it with all other generated fragment shaders
OpenGL::Shader defaultShadergenVs;
// Cached recompiled fragment shader
struct CachedProgram {

2
src/core/PICA/shader_gen_glsl.cpp
View file

@ -34,7 +34,7 @@ static constexpr const char* uniformDefinition = R"(
// This is particularly intuitive in several places, such as checking if a LUT is enabled
static constexpr int spotlightLutIndex = 2;
std::string FragmentGenerator::getVertexShader(const PICARegs& regs) {
std::string FragmentGenerator::getDefaultVertexShader() {
std::string ret = "";
switch (api) {

8
src/core/renderer_gl/renderer_gl.cpp
View file

@ -162,6 +162,10 @@ void RendererGL::initGraphicsContextInternal() {
OpenGL::setViewport(oldViewport[0], oldViewport[1], oldViewport[2], oldViewport[3]);
reset();
// Initialize the default vertex shader used with shadergen
std::string defaultShadergenVSSource = fragShaderGen.getDefaultVertexShader();
defaultShadergenVs.create({defaultShadergenVSSource.c_str(), defaultShadergenVSSource.size()}, OpenGL::Vertex);
}
// The OpenGL renderer doesn't need to do anything with the GL context (For Qt frontend) or the SDL window (For SDL frontend)
@ -810,12 +814,10 @@ OpenGL::Program& RendererGL::getSpecializedShader() {
OpenGL::Program& program = programEntry.program;
if (!program.exists()) {
std::string vs = fragShaderGen.getVertexShader(regs);
std::string fs = fragShaderGen.generate(regs, fsConfig);
OpenGL::Shader vertShader({vs.c_str(), vs.size()}, OpenGL::Vertex);
OpenGL::Shader fragShader({fs.c_str(), fs.size()}, OpenGL::Fragment);
program.create({vertShader, fragShader});
program.create({defaultShadergenVs, fragShader});
gl.useProgram(program);
// Init sampler objects. Texture 0 goes in texture unit 0, texture 1 in TU 1, texture 2 in TU 2, and the light maps go in TU 3

79
third_party/opengl/opengl.hpp vendored
View file

@ -355,46 +355,57 @@ namespace OpenGL {
}
};
enum ShaderType {
Fragment = GL_FRAGMENT_SHADER,
Vertex = GL_VERTEX_SHADER,
Geometry = GL_GEOMETRY_SHADER,
Compute = GL_COMPUTE_SHADER,
TessControl = GL_TESS_CONTROL_SHADER,
TessEvaluation = GL_TESS_EVALUATION_SHADER
};
enum ShaderType {
Fragment = GL_FRAGMENT_SHADER,
Vertex = GL_VERTEX_SHADER,
Geometry = GL_GEOMETRY_SHADER,
Compute = GL_COMPUTE_SHADER,
TessControl = GL_TESS_CONTROL_SHADER,
TessEvaluation = GL_TESS_EVALUATION_SHADER
};
struct Shader {
GLuint m_handle = 0;
struct Shader {
GLuint m_handle = 0;
Shader() {}
Shader(const std::string_view source, ShaderType type) { create(source, static_cast<GLenum>(type)); }
Shader() {}
Shader(const std::string_view source, ShaderType type) { create(source, static_cast<GLenum>(type)); }
// Returns whether compilation failed or not
bool create(const std::string_view source, GLenum type) {
m_handle = glCreateShader(type);
const GLchar* const sources[1] = { source.data() };
// Returns whether compilation failed or not
bool create(const std::string_view source, GLenum type) {
m_handle = glCreateShader(type);
const GLchar* const sources[1] = {source.data()};
glShaderSource(m_handle, 1, sources, nullptr);
glCompileShader(m_handle);
glShaderSource(m_handle, 1, sources, nullptr);
glCompileShader(m_handle);
GLint success;
glGetShaderiv(m_handle, GL_COMPILE_STATUS, &success);
if (success == GL_FALSE) {
char buf[4096];
glGetShaderInfoLog(m_handle, 4096, nullptr, buf);
fprintf(stderr, "Failed to compile shader\nError: %s\n", buf);
glDeleteShader(m_handle);
GLint success;
glGetShaderiv(m_handle, GL_COMPILE_STATUS, &success);
if (success == GL_FALSE) {
char buf[4096];
glGetShaderInfoLog(m_handle, 4096, nullptr, buf);
fprintf(stderr, "Failed to compile shader\nError: %s\n", buf);
glDeleteShader(m_handle);
m_handle = 0;
}
m_handle = 0;
}
return m_handle != 0;
}
return m_handle != 0;
}
GLuint handle() const { return m_handle; }
bool exists() const { return m_handle != 0; }
};
GLuint handle() const { return m_handle; }
bool exists() const { return m_handle != 0; }
void free() {
if (exists()) {
glDeleteShader(m_handle);
m_handle = 0;
}
}
#ifdef OPENGL_DESTRUCTORS
~Shader() { free(); }
#endif
};
struct Program {
GLuint m_handle = 0;
@ -431,6 +442,10 @@ namespace OpenGL {
m_handle = 0;
}
}
#ifdef OPENGL_DESTRUCTORS
~Program() { free(); }
#endif
};
static void dispatchCompute(GLuint groupsX = 1, GLuint groupsY = 1, GLuint groupsZ = 1) {