From 0586e184490fd132f99acb1a67c788959cfdbade Mon Sep 17 00:00:00 2001 From: Juan Linietsky Date: Sat, 27 Jul 2019 10:23:24 -0300 Subject: Custom material support seems complete. --- servers/visual/rasterizer_rd/shader_rd.cpp | 350 +++++++++++++++++++++++++++++ 1 file changed, 350 insertions(+) create mode 100644 servers/visual/rasterizer_rd/shader_rd.cpp (limited to 'servers/visual/rasterizer_rd/shader_rd.cpp') diff --git a/servers/visual/rasterizer_rd/shader_rd.cpp b/servers/visual/rasterizer_rd/shader_rd.cpp new file mode 100644 index 0000000000..d4b3db60ac --- /dev/null +++ b/servers/visual/rasterizer_rd/shader_rd.cpp @@ -0,0 +1,350 @@ +/*************************************************************************/ +/* shader_rd.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#include "shader_rd.h" +#include "core/string_builder.h" +#include "servers/visual/rendering_device.h" + +void ShaderRD::setup(const char *p_vertex_code, const char *p_fragment_code, const char *p_name) { + + name = p_name; + //split vertex and shader code (thank you, shader compiler programmers from you know what company). + { + String defines_tag = "\nVERSION_DEFINES"; + String globals_tag = "\nVERTEX_SHADER_GLOBALS"; + String material_tag = "\nMATERIAL_UNIFORMS"; + String code_tag = "\nVERTEX_SHADER_CODE"; + String code = p_vertex_code; + + int cpos = code.find(defines_tag); + if (cpos != -1) { + vertex_codev = code.substr(0, cpos).ascii(); + code = code.substr(cpos + defines_tag.length(), code.length()); + } + + cpos = code.find(material_tag); + + if (cpos == -1) { + vertex_code0 = code.ascii(); + } else { + vertex_code0 = code.substr(0, cpos).ascii(); + code = code.substr(cpos + material_tag.length(), code.length()); + + cpos = code.find(globals_tag); + + if (cpos == -1) { + vertex_code1 = code.ascii(); + } else { + + vertex_code1 = code.substr(0, cpos).ascii(); + String code2 = code.substr(cpos + globals_tag.length(), code.length()); + + cpos = code2.find(code_tag); + if (cpos == -1) { + vertex_code2 = code2.ascii(); + } else { + + vertex_code2 = code2.substr(0, cpos).ascii(); + vertex_code3 = code2.substr(cpos + code_tag.length(), code2.length()).ascii(); + } + } + } + } + + { + String defines_tag = "\nVERSION_DEFINES"; + String globals_tag = "\nFRAGMENT_SHADER_GLOBALS"; + String material_tag = "\nMATERIAL_UNIFORMS"; + String code_tag = "\nFRAGMENT_SHADER_CODE"; + String light_code_tag = "\nLIGHT_SHADER_CODE"; + String code = p_fragment_code; + + int cpos = code.find(defines_tag); + if (cpos != -1) { + fragment_codev = code.substr(0, cpos).ascii(); + code = code.substr(cpos + defines_tag.length(), code.length()); + } + + cpos = code.find(material_tag); + if (cpos == -1) { + fragment_code0 = code.ascii(); + } else { + fragment_code0 = code.substr(0, cpos).ascii(); + //print_line("CODE0:\n"+String(fragment_code0.get_data())); + code = code.substr(cpos + material_tag.length(), code.length()); + cpos = code.find(globals_tag); + + if (cpos == -1) { + fragment_code1 = code.ascii(); + } else { + + fragment_code1 = code.substr(0, cpos).ascii(); + //print_line("CODE1:\n"+String(fragment_code1.get_data())); + + String code2 = code.substr(cpos + globals_tag.length(), code.length()); + cpos = code2.find(light_code_tag); + + if (cpos == -1) { + fragment_code2 = code2.ascii(); + } else { + + fragment_code2 = code2.substr(0, cpos).ascii(); + //print_line("CODE2:\n"+String(fragment_code2.get_data())); + + String code3 = code2.substr(cpos + light_code_tag.length(), code2.length()); + + cpos = code3.find(code_tag); + if (cpos == -1) { + fragment_code3 = code3.ascii(); + } else { + + fragment_code3 = code3.substr(0, cpos).ascii(); + //print_line("CODE3:\n"+String(fragment_code3.get_data())); + fragment_code4 = code3.substr(cpos + code_tag.length(), code3.length()).ascii(); + //print_line("CODE4:\n"+String(fragment_code4.get_data())); + } + } + } + } + } +} + +RID ShaderRD::version_create() { + + //initialize() was never called + ERR_FAIL_COND_V(variant_defines.size() == 0, RID()); + + Version version; + version.dirty = true; + version.valid = false; + version.initialize_needed = true; + version.variants = NULL; + return version_owner.make_rid(version); +} + +void ShaderRD::_clear_version(Version *p_version) { + //clear versions if they exist + if (p_version->variants) { + for (int i = 0; i < variant_defines.size(); i++) { + RD::get_singleton()->free(p_version->variants[i]); + } + + memdelete_arr(p_version->variants); + p_version->variants = NULL; + } +} +void ShaderRD::_compile_version(Version *p_version) { + + _clear_version(p_version); + + p_version->valid = false; + p_version->dirty = false; + + p_version->variants = memnew_arr(RID, variant_defines.size()); + + for (int i = 0; i < variant_defines.size(); i++) { + + Vector stages; + + { + //vertex stage + + StringBuilder builder; + + builder.append(vertex_codev.get_data()); // version info (if exists) + builder.append("\n"); //make sure defines begin at newline + builder.append(general_defines.get_data()); + builder.append(variant_defines[i].get_data()); + + for (int j = 0; j < p_version->custom_defines.size(); j++) { + builder.append(p_version->custom_defines[j].get_data()); + } + + builder.append(vertex_code0.get_data()); //first part of vertex + + builder.append(p_version->uniforms.get_data()); //uniforms (same for vertex and fragment) + + builder.append(vertex_code1.get_data()); //second part of vertex + + builder.append(p_version->vertex_globals.get_data()); // vertex globals + + builder.append(vertex_code2.get_data()); //third part of vertex + + builder.append(p_version->vertex_code.get_data()); // code + + builder.append(vertex_code3.get_data()); //fourth of vertex + + RD::ShaderStageSource stage; + stage.shader_source = builder.as_string(); + stage.shader_stage = RD::SHADER_STAGE_VERTEX; + + stages.push_back(stage); + } + + { + //fragment stage + + StringBuilder builder; + + builder.append(fragment_codev.get_data()); // version info (if exists) + builder.append("\n"); //make sure defines begin at newline + + builder.append(general_defines.get_data()); + builder.append(variant_defines[i].get_data()); + for (int j = 0; j < p_version->custom_defines.size(); j++) { + builder.append(p_version->custom_defines[j].get_data()); + } + + builder.append(fragment_code0.get_data()); //first part of fragment + + builder.append(p_version->uniforms.get_data()); //uniforms (same for fragment and fragment) + + builder.append(fragment_code1.get_data()); //first part of fragment + + builder.append(p_version->fragment_globals.get_data()); // fragment globals + + builder.append(fragment_code2.get_data()); //third part of fragment + + builder.append(p_version->fragment_light.get_data()); // fragment light + + builder.append(fragment_code3.get_data()); //fourth part of fragment + + builder.append(p_version->fragment_code.get_data()); // fragment code + + builder.append(fragment_code4.get_data()); //fourth part of fragment + + RD::ShaderStageSource stage; + stage.shader_source = builder.as_string(); + stage.shader_stage = RD::SHADER_STAGE_FRAGMENT; +#if 0 + if (stage.shader_stage == RD::SHADER_STAGE_FRAGMENT && p_version->uniforms.length()) { + print_line(stage.shader_source.get_with_code_lines()); + } +#endif + stages.push_back(stage); + } + + String error; + RD::ShaderStage error_stage; + RID shader = RD::get_singleton()->shader_create_from_source(stages, &error, &error_stage); + + if (shader.is_null() && error != String()) { + ERR_PRINT("Error compiling shader, variant #" + itos(i) + " (" + variant_defines[i].get_data() + ")."); + ERR_PRINT(error); + +#ifdef DEBUG_ENABLED + if (error_stage < RD::SHADER_STAGE_MAX) { + ERR_PRINT("code:\n" + stages[error_stage].shader_source.get_with_code_lines()); + } +#endif + //clear versions if they exist + for (int j = 0; j < i; j++) { + RD::get_singleton()->free(p_version->variants[j]); + } + + memdelete_arr(p_version->variants); + p_version->variants = NULL; + return; + } + + p_version->variants[i] = shader; + } + + p_version->valid = true; +} + +void ShaderRD::version_set_code(RID p_version, const String &p_uniforms, const String &p_vertex_globals, const String &p_vertex_code, const String &p_fragment_globals, const String &p_fragment_light, const String &p_fragment_code, const Vector &p_custom_defines) { + + Version *version = version_owner.getornull(p_version); + ERR_FAIL_COND(!version); + version->vertex_globals = p_vertex_globals.utf8(); + version->vertex_code = p_vertex_code.utf8(); + version->fragment_light = p_fragment_light.utf8(); + version->fragment_globals = p_fragment_globals.utf8(); + version->fragment_code = p_fragment_code.utf8(); + version->uniforms = p_uniforms.utf8(); + + version->custom_defines.clear(); + for (int i = 0; i < p_custom_defines.size(); i++) { + version->custom_defines.push_back(p_custom_defines[i].utf8()); + } + + version->dirty = true; + if (version->initialize_needed) { + _compile_version(version); + version->initialize_needed = false; + } +} + +bool ShaderRD::version_is_valid(RID p_version) { + Version *version = version_owner.getornull(p_version); + ERR_FAIL_COND_V(!version, false); + + if (version->dirty) { + _compile_version(version); + } + + return version->valid; +} + +bool ShaderRD::version_free(RID p_version) { + + if (version_owner.owns(p_version)) { + Version *version = version_owner.getornull(p_version); + _clear_version(version); + version_owner.free(p_version); + } else { + return false; + } + + return true; +} + +void ShaderRD::initialize(const Vector &p_variant_defines, const String &p_general_defines) { + ERR_FAIL_COND(variant_defines.size()); + ERR_FAIL_COND(p_variant_defines.size() == 0); + general_defines = p_general_defines.utf8(); + for (int i = 0; i < p_variant_defines.size(); i++) { + + variant_defines.push_back(p_variant_defines[i].utf8()); + } +} + +ShaderRD::~ShaderRD() { + List remaining; + version_owner.get_owned_list(&remaining); + if (remaining.size()) { + ERR_PRINT(itos(remaining.size()) + " shaders of type " + name + " were never freed"); + while (remaining.size()) { + version_free(remaining.front()->get()); + remaining.pop_front(); + } + } +} -- cgit v1.2.3 From 4fe3ee1730167b90ec8ae70c871c1dad032981d5 Mon Sep 17 00:00:00 2001 From: Juan Linietsky Date: Sun, 28 Jul 2019 19:58:32 -0300 Subject: Moved the shader source compilation code outside RenderingDevice and Vulkan --- servers/visual/rasterizer_rd/shader_rd.cpp | 65 ++++++++++++++++++++---------- 1 file changed, 43 insertions(+), 22 deletions(-) (limited to 'servers/visual/rasterizer_rd/shader_rd.cpp') diff --git a/servers/visual/rasterizer_rd/shader_rd.cpp b/servers/visual/rasterizer_rd/shader_rd.cpp index d4b3db60ac..945fc25cab 100644 --- a/servers/visual/rasterizer_rd/shader_rd.cpp +++ b/servers/visual/rasterizer_rd/shader_rd.cpp @@ -171,7 +171,12 @@ void ShaderRD::_compile_version(Version *p_version) { for (int i = 0; i < variant_defines.size(); i++) { - Vector stages; + Vector stages; + + String error; + String current_source; + RD::ShaderStage current_stage = RD::SHADER_STAGE_VERTEX; + bool build_ok=true; { //vertex stage @@ -201,15 +206,21 @@ void ShaderRD::_compile_version(Version *p_version) { builder.append(vertex_code3.get_data()); //fourth of vertex - RD::ShaderStageSource stage; - stage.shader_source = builder.as_string(); - stage.shader_stage = RD::SHADER_STAGE_VERTEX; + current_source = builder.as_string(); + RD::ShaderStageData stage; + stage.spir_v = RD::get_singleton()->shader_compile_from_source(RD::SHADER_STAGE_VERTEX,current_source,RD::SHADER_LANGUAGE_GLSL,&error); + if (stage.spir_v.size()==0) { + build_ok=false; + } else { - stages.push_back(stage); + stage.shader_stage = RD::SHADER_STAGE_VERTEX; + stages.push_back(stage); + } } - { + if (build_ok){ //fragment stage + current_stage =RD::SHADER_STAGE_FRAGMENT; StringBuilder builder; @@ -240,29 +251,26 @@ void ShaderRD::_compile_version(Version *p_version) { builder.append(fragment_code4.get_data()); //fourth part of fragment - RD::ShaderStageSource stage; - stage.shader_source = builder.as_string(); - stage.shader_stage = RD::SHADER_STAGE_FRAGMENT; -#if 0 - if (stage.shader_stage == RD::SHADER_STAGE_FRAGMENT && p_version->uniforms.length()) { - print_line(stage.shader_source.get_with_code_lines()); + current_source = builder.as_string(); + RD::ShaderStageData stage; + stage.spir_v = RD::get_singleton()->shader_compile_from_source(RD::SHADER_STAGE_FRAGMENT,current_source,RD::SHADER_LANGUAGE_GLSL,&error); + if (stage.spir_v.size()==0) { + build_ok=false; + } else { + + stage.shader_stage = RD::SHADER_STAGE_FRAGMENT; + stages.push_back(stage); } -#endif - stages.push_back(stage); + } - String error; - RD::ShaderStage error_stage; - RID shader = RD::get_singleton()->shader_create_from_source(stages, &error, &error_stage); - if (shader.is_null() && error != String()) { - ERR_PRINT("Error compiling shader, variant #" + itos(i) + " (" + variant_defines[i].get_data() + ")."); + if (!build_ok) { + ERR_PRINT("Error compiling " + String(current_stage == RD::SHADER_STAGE_VERTEX ? "Vertex" : "Fragment") + " shader, variant #" + itos(i) + " (" + variant_defines[i].get_data() + ")."); ERR_PRINT(error); #ifdef DEBUG_ENABLED - if (error_stage < RD::SHADER_STAGE_MAX) { - ERR_PRINT("code:\n" + stages[error_stage].shader_source.get_with_code_lines()); - } + ERR_PRINT("code:\n" + current_source.get_with_code_lines()); #endif //clear versions if they exist for (int j = 0; j < i; j++) { @@ -274,6 +282,19 @@ void ShaderRD::_compile_version(Version *p_version) { return; } + RID shader = RD::get_singleton()->shader_create(stages); + + if (shader.is_null()) { + //clear versions if they exist + for (int j = 0; j < i; j++) { + RD::get_singleton()->free(p_version->variants[j]); + } + + memdelete_arr(p_version->variants); + p_version->variants = NULL; + return; + } + p_version->variants[i] = shader; } -- cgit v1.2.3 From c613ead5fa2361296cf8d9a80d4648492ff4e16f Mon Sep 17 00:00:00 2001 From: Juan Linietsky Date: Mon, 29 Jul 2019 12:59:18 -0300 Subject: Added a spinlock template as well as a thread work pool class. Also, optimized shader compilation to happen on threads. --- servers/visual/rasterizer_rd/shader_rd.cpp | 198 ++++++++++++++++------------- 1 file changed, 107 insertions(+), 91 deletions(-) (limited to 'servers/visual/rasterizer_rd/shader_rd.cpp') diff --git a/servers/visual/rasterizer_rd/shader_rd.cpp b/servers/visual/rasterizer_rd/shader_rd.cpp index 945fc25cab..58596f6a72 100644 --- a/servers/visual/rasterizer_rd/shader_rd.cpp +++ b/servers/visual/rasterizer_rd/shader_rd.cpp @@ -30,6 +30,7 @@ #include "shader_rd.h" #include "core/string_builder.h" +#include "rasterizer_rd.h" #include "servers/visual/rendering_device.h" void ShaderRD::setup(const char *p_vertex_code, const char *p_fragment_code, const char *p_name) { @@ -160,142 +161,157 @@ void ShaderRD::_clear_version(Version *p_version) { p_version->variants = NULL; } } -void ShaderRD::_compile_version(Version *p_version) { - _clear_version(p_version); +void ShaderRD::_compile_variant(uint32_t p_variant, Version *p_version) { - p_version->valid = false; - p_version->dirty = false; + Vector stages; - p_version->variants = memnew_arr(RID, variant_defines.size()); + String error; + String current_source; + RD::ShaderStage current_stage = RD::SHADER_STAGE_VERTEX; + bool build_ok = true; - for (int i = 0; i < variant_defines.size(); i++) { + { + //vertex stage - Vector stages; + StringBuilder builder; - String error; - String current_source; - RD::ShaderStage current_stage = RD::SHADER_STAGE_VERTEX; - bool build_ok=true; + builder.append(vertex_codev.get_data()); // version info (if exists) + builder.append("\n"); //make sure defines begin at newline + builder.append(general_defines.get_data()); + builder.append(variant_defines[p_variant].get_data()); - { - //vertex stage + for (int j = 0; j < p_version->custom_defines.size(); j++) { + builder.append(p_version->custom_defines[j].get_data()); + } - StringBuilder builder; + builder.append(vertex_code0.get_data()); //first part of vertex - builder.append(vertex_codev.get_data()); // version info (if exists) - builder.append("\n"); //make sure defines begin at newline - builder.append(general_defines.get_data()); - builder.append(variant_defines[i].get_data()); + builder.append(p_version->uniforms.get_data()); //uniforms (same for vertex and fragment) - for (int j = 0; j < p_version->custom_defines.size(); j++) { - builder.append(p_version->custom_defines[j].get_data()); - } + builder.append(vertex_code1.get_data()); //second part of vertex - builder.append(vertex_code0.get_data()); //first part of vertex + builder.append(p_version->vertex_globals.get_data()); // vertex globals - builder.append(p_version->uniforms.get_data()); //uniforms (same for vertex and fragment) + builder.append(vertex_code2.get_data()); //third part of vertex - builder.append(vertex_code1.get_data()); //second part of vertex + builder.append(p_version->vertex_code.get_data()); // code - builder.append(p_version->vertex_globals.get_data()); // vertex globals + builder.append(vertex_code3.get_data()); //fourth of vertex - builder.append(vertex_code2.get_data()); //third part of vertex + current_source = builder.as_string(); + RD::ShaderStageData stage; + stage.spir_v = RD::get_singleton()->shader_compile_from_source(RD::SHADER_STAGE_VERTEX, current_source, RD::SHADER_LANGUAGE_GLSL, &error); + if (stage.spir_v.size() == 0) { + build_ok = false; + } else { - builder.append(p_version->vertex_code.get_data()); // code + stage.shader_stage = RD::SHADER_STAGE_VERTEX; + stages.push_back(stage); + } + } - builder.append(vertex_code3.get_data()); //fourth of vertex + if (build_ok) { + //fragment stage + current_stage = RD::SHADER_STAGE_FRAGMENT; - current_source = builder.as_string(); - RD::ShaderStageData stage; - stage.spir_v = RD::get_singleton()->shader_compile_from_source(RD::SHADER_STAGE_VERTEX,current_source,RD::SHADER_LANGUAGE_GLSL,&error); - if (stage.spir_v.size()==0) { - build_ok=false; - } else { + StringBuilder builder; - stage.shader_stage = RD::SHADER_STAGE_VERTEX; - stages.push_back(stage); - } + builder.append(fragment_codev.get_data()); // version info (if exists) + builder.append("\n"); //make sure defines begin at newline + + builder.append(general_defines.get_data()); + builder.append(variant_defines[p_variant].get_data()); + for (int j = 0; j < p_version->custom_defines.size(); j++) { + builder.append(p_version->custom_defines[j].get_data()); } - if (build_ok){ - //fragment stage - current_stage =RD::SHADER_STAGE_FRAGMENT; + builder.append(fragment_code0.get_data()); //first part of fragment - StringBuilder builder; + builder.append(p_version->uniforms.get_data()); //uniforms (same for fragment and fragment) - builder.append(fragment_codev.get_data()); // version info (if exists) - builder.append("\n"); //make sure defines begin at newline + builder.append(fragment_code1.get_data()); //first part of fragment - builder.append(general_defines.get_data()); - builder.append(variant_defines[i].get_data()); - for (int j = 0; j < p_version->custom_defines.size(); j++) { - builder.append(p_version->custom_defines[j].get_data()); - } + builder.append(p_version->fragment_globals.get_data()); // fragment globals - builder.append(fragment_code0.get_data()); //first part of fragment + builder.append(fragment_code2.get_data()); //third part of fragment - builder.append(p_version->uniforms.get_data()); //uniforms (same for fragment and fragment) + builder.append(p_version->fragment_light.get_data()); // fragment light - builder.append(fragment_code1.get_data()); //first part of fragment + builder.append(fragment_code3.get_data()); //fourth part of fragment - builder.append(p_version->fragment_globals.get_data()); // fragment globals + builder.append(p_version->fragment_code.get_data()); // fragment code - builder.append(fragment_code2.get_data()); //third part of fragment + builder.append(fragment_code4.get_data()); //fourth part of fragment - builder.append(p_version->fragment_light.get_data()); // fragment light + current_source = builder.as_string(); + RD::ShaderStageData stage; + stage.spir_v = RD::get_singleton()->shader_compile_from_source(RD::SHADER_STAGE_FRAGMENT, current_source, RD::SHADER_LANGUAGE_GLSL, &error); + if (stage.spir_v.size() == 0) { + build_ok = false; + } else { - builder.append(fragment_code3.get_data()); //fourth part of fragment + stage.shader_stage = RD::SHADER_STAGE_FRAGMENT; + stages.push_back(stage); + } + } - builder.append(p_version->fragment_code.get_data()); // fragment code + if (!build_ok) { + variant_set_mutex.lock(); //properly print the errors + ERR_PRINT("Error compiling " + String(current_stage == RD::SHADER_STAGE_VERTEX ? "Vertex" : "Fragment") + " shader, variant #" + itos(p_variant) + " (" + variant_defines[p_variant].get_data() + ")."); + ERR_PRINT(error); - builder.append(fragment_code4.get_data()); //fourth part of fragment +#ifdef DEBUG_ENABLED + ERR_PRINT("code:\n" + current_source.get_with_code_lines()); +#endif - current_source = builder.as_string(); - RD::ShaderStageData stage; - stage.spir_v = RD::get_singleton()->shader_compile_from_source(RD::SHADER_STAGE_FRAGMENT,current_source,RD::SHADER_LANGUAGE_GLSL,&error); - if (stage.spir_v.size()==0) { - build_ok=false; - } else { + variant_set_mutex.unlock(); + return; + } - stage.shader_stage = RD::SHADER_STAGE_FRAGMENT; - stages.push_back(stage); - } + RID shader = RD::get_singleton()->shader_create(stages); - } + variant_set_mutex.lock(); + p_version->variants[p_variant] = shader; + variant_set_mutex.unlock(); +} +void ShaderRD::_compile_version(Version *p_version) { - if (!build_ok) { - ERR_PRINT("Error compiling " + String(current_stage == RD::SHADER_STAGE_VERTEX ? "Vertex" : "Fragment") + " shader, variant #" + itos(i) + " (" + variant_defines[i].get_data() + ")."); - ERR_PRINT(error); + _clear_version(p_version); -#ifdef DEBUG_ENABLED - ERR_PRINT("code:\n" + current_source.get_with_code_lines()); -#endif - //clear versions if they exist - for (int j = 0; j < i; j++) { - RD::get_singleton()->free(p_version->variants[j]); - } + p_version->valid = false; + p_version->dirty = false; - memdelete_arr(p_version->variants); - p_version->variants = NULL; - return; - } + p_version->variants = memnew_arr(RID, variant_defines.size()); +#if 1 - RID shader = RD::get_singleton()->shader_create(stages); + RasterizerRD::thread_work_pool.do_work(variant_defines.size(), this, &ShaderRD::_compile_variant, p_version); +#else + for (int i = 0; i < variant_defines.size(); i++) { - if (shader.is_null()) { - //clear versions if they exist - for (int j = 0; j < i; j++) { - RD::get_singleton()->free(p_version->variants[j]); - } + _compile_variant(i, p_version); + } +#endif - memdelete_arr(p_version->variants); - p_version->variants = NULL; - return; + bool all_valid = true; + for (int i = 0; i < variant_defines.size(); i++) { + if (p_version->variants[i].is_null()) { + all_valid = false; + break; } + } - p_version->variants[i] = shader; + if (!all_valid) { + //clear versions if they exist + for (int i = 0; i < variant_defines.size(); i++) { + if (!p_version->variants[i].is_null()) { + RD::get_singleton()->free(p_version->variants[i]); + } + } + memdelete_arr(p_version->variants); + p_version->variants = NULL; + return; } p_version->valid = true; -- cgit v1.2.3 From 263bebe0237b85b1343ba17b117c8c43287ecc57 Mon Sep 17 00:00:00 2001 From: Juan Linietsky Date: Wed, 25 Sep 2019 16:44:44 -0300 Subject: Untested support for compute shaders --- servers/visual/rasterizer_rd/shader_rd.cpp | 121 +++++++++++++++++++++++++++-- 1 file changed, 115 insertions(+), 6 deletions(-) (limited to 'servers/visual/rasterizer_rd/shader_rd.cpp') diff --git a/servers/visual/rasterizer_rd/shader_rd.cpp b/servers/visual/rasterizer_rd/shader_rd.cpp index 58596f6a72..98e0c99c2e 100644 --- a/servers/visual/rasterizer_rd/shader_rd.cpp +++ b/servers/visual/rasterizer_rd/shader_rd.cpp @@ -33,11 +33,11 @@ #include "rasterizer_rd.h" #include "servers/visual/rendering_device.h" -void ShaderRD::setup(const char *p_vertex_code, const char *p_fragment_code, const char *p_name) { +void ShaderRD::setup(const char *p_vertex_code, const char *p_fragment_code, const char *p_compute_code, const char *p_name) { name = p_name; //split vertex and shader code (thank you, shader compiler programmers from you know what company). - { + if (p_vertex_code) { String defines_tag = "\nVERSION_DEFINES"; String globals_tag = "\nVERTEX_SHADER_GLOBALS"; String material_tag = "\nMATERIAL_UNIFORMS"; @@ -79,7 +79,7 @@ void ShaderRD::setup(const char *p_vertex_code, const char *p_fragment_code, con } } - { + if (p_fragment_code) { String defines_tag = "\nVERSION_DEFINES"; String globals_tag = "\nFRAGMENT_SHADER_GLOBALS"; String material_tag = "\nMATERIAL_UNIFORMS"; @@ -135,6 +135,50 @@ void ShaderRD::setup(const char *p_vertex_code, const char *p_fragment_code, con } } } + + if (p_compute_code) { + is_compute = true; + + String defines_tag = "\nVERSION_DEFINES"; + String globals_tag = "\nCOMPUTE_SHADER_GLOBALS"; + String material_tag = "\nMATERIAL_UNIFORMS"; + String code_tag = "\nCOMPUTE_SHADER_CODE"; + String code = p_compute_code; + + int cpos = code.find(defines_tag); + if (cpos != -1) { + compute_codev = code.substr(0, cpos).ascii(); + code = code.substr(cpos + defines_tag.length(), code.length()); + } + + cpos = code.find(material_tag); + + if (cpos == -1) { + compute_code0 = code.ascii(); + } else { + compute_code0 = code.substr(0, cpos).ascii(); + code = code.substr(cpos + material_tag.length(), code.length()); + + cpos = code.find(globals_tag); + + if (cpos == -1) { + compute_code1 = code.ascii(); + } else { + + compute_code1 = code.substr(0, cpos).ascii(); + String code2 = code.substr(cpos + globals_tag.length(), code.length()); + + cpos = code2.find(code_tag); + if (cpos == -1) { + compute_code2 = code2.ascii(); + } else { + + compute_code2 = code2.substr(0, cpos).ascii(); + compute_code3 = code2.substr(cpos + code_tag.length(), code2.length()).ascii(); + } + } + } + } } RID ShaderRD::version_create() { @@ -171,7 +215,7 @@ void ShaderRD::_compile_variant(uint32_t p_variant, Version *p_version) { RD::ShaderStage current_stage = RD::SHADER_STAGE_VERTEX; bool build_ok = true; - { + if (!is_compute) { //vertex stage StringBuilder builder; @@ -211,7 +255,7 @@ void ShaderRD::_compile_variant(uint32_t p_variant, Version *p_version) { } } - if (build_ok) { + if (!is_compute && build_ok) { //fragment stage current_stage = RD::SHADER_STAGE_FRAGMENT; @@ -256,9 +300,50 @@ void ShaderRD::_compile_variant(uint32_t p_variant, Version *p_version) { } } + if (is_compute) { + //compute stage + current_stage = RD::SHADER_STAGE_COMPUTE; + + StringBuilder builder; + + builder.append(compute_codev.get_data()); // version info (if exists) + builder.append("\n"); //make sure defines begin at newline + builder.append(general_defines.get_data()); + builder.append(variant_defines[p_variant].get_data()); + + for (int j = 0; j < p_version->custom_defines.size(); j++) { + builder.append(p_version->custom_defines[j].get_data()); + } + + builder.append(compute_code0.get_data()); //first part of compute + + builder.append(p_version->uniforms.get_data()); //uniforms (same for compute and fragment) + + builder.append(compute_code1.get_data()); //second part of compute + + builder.append(p_version->compute_globals.get_data()); // compute globals + + builder.append(compute_code2.get_data()); //third part of compute + + builder.append(p_version->compute_code.get_data()); // code + + builder.append(compute_code3.get_data()); //fourth of compute + + current_source = builder.as_string(); + RD::ShaderStageData stage; + stage.spir_v = RD::get_singleton()->shader_compile_from_source(RD::SHADER_STAGE_COMPUTE, current_source, RD::SHADER_LANGUAGE_GLSL, &error); + if (stage.spir_v.size() == 0) { + build_ok = false; + } else { + + stage.shader_stage = RD::SHADER_STAGE_COMPUTE; + stages.push_back(stage); + } + } + if (!build_ok) { variant_set_mutex.lock(); //properly print the errors - ERR_PRINT("Error compiling " + String(current_stage == RD::SHADER_STAGE_VERTEX ? "Vertex" : "Fragment") + " shader, variant #" + itos(p_variant) + " (" + variant_defines[p_variant].get_data() + ")."); + ERR_PRINT("Error compiling " + String(current_stage == RD::SHADER_STAGE_COMPUTE ? "Compute " : (current_stage == RD::SHADER_STAGE_VERTEX ? "Vertex" : "Fragment")) + " shader, variant #" + itos(p_variant) + " (" + variant_defines[p_variant].get_data() + ")."); ERR_PRINT(error); #ifdef DEBUG_ENABLED @@ -319,6 +404,8 @@ void ShaderRD::_compile_version(Version *p_version) { void ShaderRD::version_set_code(RID p_version, const String &p_uniforms, const String &p_vertex_globals, const String &p_vertex_code, const String &p_fragment_globals, const String &p_fragment_light, const String &p_fragment_code, const Vector &p_custom_defines) { + ERR_FAIL_COND(is_compute); + Version *version = version_owner.getornull(p_version); ERR_FAIL_COND(!version); version->vertex_globals = p_vertex_globals.utf8(); @@ -340,6 +427,28 @@ void ShaderRD::version_set_code(RID p_version, const String &p_uniforms, const S } } +void ShaderRD::version_set_compute_code(RID p_version, const String &p_uniforms, const String &p_compute_globals, const String &p_compute_code, const Vector &p_custom_defines) { + + ERR_FAIL_COND(!is_compute); + + Version *version = version_owner.getornull(p_version); + ERR_FAIL_COND(!version); + version->compute_globals = p_compute_globals.utf8(); + version->compute_code = p_compute_code.utf8(); + version->uniforms = p_uniforms.utf8(); + + version->custom_defines.clear(); + for (int i = 0; i < p_custom_defines.size(); i++) { + version->custom_defines.push_back(p_custom_defines[i].utf8()); + } + + version->dirty = true; + if (version->initialize_needed) { + _compile_version(version); + version->initialize_needed = false; + } +} + bool ShaderRD::version_is_valid(RID p_version) { Version *version = version_owner.getornull(p_version); ERR_FAIL_COND_V(!version, false); -- cgit v1.2.3 From db81928e08cb58d5f67908c6dfcf9433e572ffe8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=A9mi=20Verschelde?= Date: Tue, 11 Feb 2020 14:01:43 +0100 Subject: Vulkan: Move thirdparty code out of drivers, style fixes - `vk_enum_string_helper.h` is a generated file taken from the SDK (Vulkan-ValidationLayers). - `vk_mem_alloc.h` is a library from GPUOpen: https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator --- servers/visual/rasterizer_rd/shader_rd.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'servers/visual/rasterizer_rd/shader_rd.cpp') diff --git a/servers/visual/rasterizer_rd/shader_rd.cpp b/servers/visual/rasterizer_rd/shader_rd.cpp index 98e0c99c2e..cc6c13f598 100644 --- a/servers/visual/rasterizer_rd/shader_rd.cpp +++ b/servers/visual/rasterizer_rd/shader_rd.cpp @@ -5,8 +5,8 @@ /* GODOT ENGINE */ /* https://godotengine.org */ /*************************************************************************/ -/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */ +/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */ /* */ /* Permission is hereby granted, free of charge, to any person obtaining */ /* a copy of this software and associated documentation files (the */ -- cgit v1.2.3