X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fshader.cpp;h=3b49a36bad48c25f6753e1f0bb61a9314c6dd010;hb=392e80e3f13c977b5499eb424fa7d65085fb08f5;hp=4006e256f52c5927c83e08a68e40b23798050fdd;hpb=0dc1aec50940140e28f434c524296e284e73d623;p=dragonfireclient.git diff --git a/src/shader.cpp b/src/shader.cpp index 4006e256f..3b49a36ba 100644 --- a/src/shader.cpp +++ b/src/shader.cpp @@ -18,24 +18,25 @@ with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ +#include +#include #include "shader.h" #include "irrlichttypes_extrabloated.h" #include "debug.h" -#include "main.h" // for g_settings #include "filesys.h" #include "util/container.h" #include "util/thread.h" #include "settings.h" -#include #include #include #include #include #include +#include "client/renderingengine.h" #include "EShaderTypes.h" #include "log.h" #include "gamedef.h" -#include "strfnd.h" // trim() +#include "client/tile.h" /* A cache from shader name to shader path @@ -55,7 +56,7 @@ std::string getShaderPath(const std::string &name_of_shader, const std::string &filename) { std::string combined = name_of_shader + DIR_DELIM + filename; - std::string fullpath = ""; + std::string fullpath; /* Check from cache */ @@ -67,8 +68,7 @@ std::string getShaderPath(const std::string &name_of_shader, Check from shader_path */ std::string shader_path = g_settings->get("shader_path"); - if(shader_path != "") - { + if (!shader_path.empty()) { std::string testpath = shader_path + DIR_DELIM + combined; if(fs::PathExists(testpath)) fullpath = testpath; @@ -77,8 +77,7 @@ std::string getShaderPath(const std::string &name_of_shader, /* Check from default data directory */ - if(fullpath == "") - { + if (fullpath.empty()) { std::string rel_path = std::string("client") + DIR_DELIM + "shaders" + DIR_DELIM + name_of_shader + DIR_DELIM @@ -102,18 +101,16 @@ std::string getShaderPath(const std::string &name_of_shader, class SourceShaderCache { public: - void insert(const std::string &name_of_shader, - const std::string &filename, - const std::string &program, - bool prefer_local) + void insert(const std::string &name_of_shader, const std::string &filename, + const std::string &program, bool prefer_local) { std::string combined = name_of_shader + DIR_DELIM + filename; // Try to use local shader instead if asked to if(prefer_local){ std::string path = getShaderPath(name_of_shader, filename); - if(path != ""){ + if(!path.empty()){ std::string p = readFile(path); - if(p != ""){ + if (!p.empty()) { m_programs[combined] = p; return; } @@ -121,42 +118,43 @@ class SourceShaderCache } m_programs[combined] = program; } + std::string get(const std::string &name_of_shader, - const std::string &filename) + const std::string &filename) { std::string combined = name_of_shader + DIR_DELIM + filename; - std::map::iterator n; - n = m_programs.find(combined); - if(n != m_programs.end()) + StringMap::iterator n = m_programs.find(combined); + if (n != m_programs.end()) return n->second; return ""; } + // Primarily fetches from cache, secondarily tries to read from filesystem std::string getOrLoad(const std::string &name_of_shader, - const std::string &filename) + const std::string &filename) { std::string combined = name_of_shader + DIR_DELIM + filename; - std::map::iterator n; - n = m_programs.find(combined); - if(n != m_programs.end()) + StringMap::iterator n = m_programs.find(combined); + if (n != m_programs.end()) return n->second; std::string path = getShaderPath(name_of_shader, filename); - if(path == ""){ - infostream<<"SourceShaderCache::getOrLoad(): No path found for \"" - < m_programs; + StringMap m_programs; + std::string readFile(const std::string &path) { std::ifstream is(path.c_str(), std::ios::binary); @@ -168,115 +166,102 @@ class SourceShaderCache } }; + /* ShaderCallback: Sets constants that can be used in shaders */ -class IShaderConstantSetterRegistry -{ -public: - virtual ~IShaderConstantSetterRegistry(){}; - virtual void onSetConstants(video::IMaterialRendererServices *services, - bool is_highlevel, const std::string &name) = 0; -}; - class ShaderCallback : public video::IShaderConstantSetCallBack { - IShaderConstantSetterRegistry *m_scsr; - std::string m_name; + std::vector m_setters; public: - ShaderCallback(IShaderConstantSetterRegistry *scsr, const std::string &name): - m_scsr(scsr), - m_name(name) - {} - ~ShaderCallback() {} + ShaderCallback(const std::vector &factories) + { + for (IShaderConstantSetterFactory *factory : factories) + m_setters.push_back(factory->create()); + } + + ~ShaderCallback() + { + for (IShaderConstantSetter *setter : m_setters) + delete setter; + } virtual void OnSetConstants(video::IMaterialRendererServices *services, s32 userData) { video::IVideoDriver *driver = services->getVideoDriver(); - assert(driver); + sanity_check(driver != NULL); bool is_highlevel = userData; - m_scsr->onSetConstants(services, is_highlevel, m_name); + for (IShaderConstantSetter *setter : m_setters) + setter->onSetConstants(services, is_highlevel); } }; + /* MainShaderConstantSetter: Set basic constants required for almost everything */ class MainShaderConstantSetter : public IShaderConstantSetter { + CachedVertexShaderSetting m_world_view_proj; + CachedVertexShaderSetting m_world; + public: - MainShaderConstantSetter(IrrlichtDevice *device): - m_device(device) + MainShaderConstantSetter() : + m_world_view_proj("mWorldViewProj"), + m_world("mWorld") {} - ~MainShaderConstantSetter() {} + ~MainShaderConstantSetter() = default; virtual void onSetConstants(video::IMaterialRendererServices *services, bool is_highlevel) { video::IVideoDriver *driver = services->getVideoDriver(); - assert(driver); - - // set inverted world matrix - core::matrix4 invWorld = driver->getTransform(video::ETS_WORLD); - invWorld.makeInverse(); - if(is_highlevel) - services->setVertexShaderConstant("mInvWorld", invWorld.pointer(), 16); - else - services->setVertexShaderConstant(invWorld.pointer(), 0, 4); + sanity_check(driver); - // set clip matrix + // Set clip matrix core::matrix4 worldViewProj; worldViewProj = driver->getTransform(video::ETS_PROJECTION); worldViewProj *= driver->getTransform(video::ETS_VIEW); worldViewProj *= driver->getTransform(video::ETS_WORLD); - if(is_highlevel) - services->setVertexShaderConstant("mWorldViewProj", worldViewProj.pointer(), 16); + if (is_highlevel) + m_world_view_proj.set(*reinterpret_cast(worldViewProj.pointer()), services); else - services->setVertexShaderConstant(worldViewProj.pointer(), 4, 4); + services->setVertexShaderConstant(worldViewProj.pointer(), 0, 4); - // set transposed world matrix - core::matrix4 transWorld = driver->getTransform(video::ETS_WORLD); - transWorld = transWorld.getTransposed(); - if(is_highlevel) - services->setVertexShaderConstant("mTransWorld", transWorld.pointer(), 16); - else - services->setVertexShaderConstant(transWorld.pointer(), 8, 4); - - // set world matrix + // Set world matrix core::matrix4 world = driver->getTransform(video::ETS_WORLD); - if(is_highlevel) - services->setVertexShaderConstant("mWorld", world.pointer(), 16); + if (is_highlevel) + m_world.set(*reinterpret_cast(world.pointer()), services); else - services->setVertexShaderConstant(world.pointer(), 8, 4); + services->setVertexShaderConstant(world.pointer(), 4, 4); } +}; -private: - IrrlichtDevice *m_device; + +class MainShaderConstantSetterFactory : public IShaderConstantSetterFactory +{ +public: + virtual IShaderConstantSetter* create() + { return new MainShaderConstantSetter(); } }; + /* ShaderSource */ -class ShaderSource : public IWritableShaderSource, public IShaderConstantSetterRegistry +class ShaderSource : public IWritableShaderSource { public: - ShaderSource(IrrlichtDevice *device); + ShaderSource(); ~ShaderSource(); - /* - Gets a shader material id from cache or - - if main thread, from getShaderIdDirect - - if other thread, adds to request queue and waits for main thread - */ - u32 getShaderId(const std::string &name); - /* - If shader material specified by name is found from cache, return the cached id. @@ -284,25 +269,22 @@ class ShaderSource : public IWritableShaderSource, public IShaderConstantSetterR The id 0 points to a null shader. Its material is EMT_SOLID. */ - u32 getShaderIdDirect(const std::string &name); - - // Finds out the name of a cached shader. - std::string getShaderName(u32 id); + u32 getShaderIdDirect(const std::string &name, + const u8 material_type, const u8 drawtype); /* If shader specified by the name pointed by the id doesn't - exist, create it, then return the cached shader. + exist, create it, then return id. Can be called from any thread. If called from some other thread and not found in cache, the call is queued to the main thread for processing. */ - ShaderInfo getShader(u32 id); - ShaderInfo getShader(const std::string &name) - { - return getShader(getShaderId(name)); - } + u32 getShader(const std::string &name, + const u8 material_type, const u8 drawtype); + + ShaderInfo getShaderInfo(u32 id); // Processes queued shader requests from other threads. // Shall be called from the main thread. @@ -317,22 +299,15 @@ class ShaderSource : public IWritableShaderSource, public IShaderConstantSetterR // Shall be called from the main thread. void rebuildShaders(); - void addGlobalConstantSetter(IShaderConstantSetter *setter) + void addShaderConstantSetterFactory(IShaderConstantSetterFactory *setter) { - m_global_setters.push_back(setter); + m_setter_factories.push_back(setter); } - void onSetConstants(video::IMaterialRendererServices *services, - bool is_highlevel, const std::string &name); - private: // The id of the thread that is allowed to use irrlicht directly - threadid_t m_main_thread; - // The irrlicht device - IrrlichtDevice *m_device; - // The set-constants callback - ShaderCallback *m_shader_callback; + std::thread::id m_main_thread; // Cache of source shaders // This should be only accessed from the main thread @@ -341,115 +316,96 @@ class ShaderSource : public IWritableShaderSource, public IShaderConstantSetterR // A shader id is index in this array. // The first position contains a dummy shader. std::vector m_shaderinfo_cache; - // Maps a shader name to an index in the former. - std::map m_name_to_id; - // The two former containers are behind this mutex - JMutex m_shaderinfo_cache_mutex; + // The former container is behind this mutex + std::mutex m_shaderinfo_cache_mutex; // Queued shader fetches (to be processed by the main thread) RequestQueue m_get_shader_queue; - // Global constant setters - // TODO: Delete these in the destructor - std::vector m_global_setters; + // Global constant setter factories + std::vector m_setter_factories; + + // Shader callbacks + std::vector m_callbacks; }; -IWritableShaderSource* createShaderSource(IrrlichtDevice *device) +IWritableShaderSource *createShaderSource() { - return new ShaderSource(device); + return new ShaderSource(); } /* Generate shader given the shader name. */ -ShaderInfo generate_shader(std::string name, IrrlichtDevice *device, - video::IShaderConstantSetCallBack *callback, +ShaderInfo generate_shader(const std::string &name, + u8 material_type, u8 drawtype, std::vector &callbacks, + const std::vector &setter_factories, SourceShaderCache *sourcecache); /* Load shader programs */ -void load_shaders(std::string name, SourceShaderCache *sourcecache, +void load_shaders(const std::string &name, SourceShaderCache *sourcecache, video::E_DRIVER_TYPE drivertype, bool enable_shaders, std::string &vertex_program, std::string &pixel_program, std::string &geometry_program, bool &is_highlevel); -ShaderSource::ShaderSource(IrrlichtDevice *device): - m_device(device) +ShaderSource::ShaderSource() { - assert(m_device); - - m_shader_callback = new ShaderCallback(this, "default"); - - m_main_thread = get_current_thread_id(); + m_main_thread = std::this_thread::get_id(); // Add a dummy ShaderInfo as the first index, named "" - m_shaderinfo_cache.push_back(ShaderInfo()); - m_name_to_id[""] = 0; + m_shaderinfo_cache.emplace_back(); // Add main global constant setter - addGlobalConstantSetter(new MainShaderConstantSetter(device)); + addShaderConstantSetterFactory(new MainShaderConstantSetterFactory()); } ShaderSource::~ShaderSource() { - //m_shader_callback->drop(); - - for (std::vector::iterator iter = m_global_setters.begin(); - iter != m_global_setters.end(); iter++) { - delete *iter; + for (ShaderCallback *callback : m_callbacks) { + delete callback; + } + for (IShaderConstantSetterFactory *setter_factorie : m_setter_factories) { + delete setter_factorie; } - m_global_setters.clear(); } -u32 ShaderSource::getShaderId(const std::string &name) +u32 ShaderSource::getShader(const std::string &name, + const u8 material_type, const u8 drawtype) { - //infostream<<"getShaderId(): \""<::iterator n; - n = m_name_to_id.find(name); - if(n != m_name_to_id.end()) - return n->second; - } - /* Get shader */ - if(get_current_thread_id() == m_main_thread){ - return getShaderIdDirect(name); - } else { - /*errorstream<<"getShaderId(): Queued: name=\""< result_queue; + /*errorstream<<"getShader(): Queued: name=\""< result_queue; - while(true) { - GetResult - result = result_queue.pop_frontNoEx(); + // Throw a request in + m_get_shader_queue.add(name, 0, 0, &result_queue); - if (result.key == name) { - return result.item; - } - else { - errorstream << "Got shader with invalid name: " << result.key << std::endl; - } + /* infostream<<"Waiting for shader from main thread, name=\"" + < + result = result_queue.pop_frontNoEx(); + + if (result.key == name) { + return result.item; } + errorstream << "Got shader with invalid name: " << result.key << std::endl; } - infostream<<"getShaderId(): Failed"<name == name && info->material_type == material_type && + info->drawtype == drawtype) + return i; + } + /* Calling only allowed from main thread */ - if(get_current_thread_id() != m_main_thread){ + if (std::this_thread::get_id() != m_main_thread) { errorstream<<"ShaderSource::getShaderIdDirect() " "called not from main thread"<::iterator n; - n = m_name_to_id.find(name); - if(n != m_name_to_id.end()){ - /*infostream<<"getShaderIdDirect(): \""<second; - } - } - - /*infostream<<"getShaderIdDirect(): \""<= m_shaderinfo_cache.size()){ - errorstream<<"ShaderSource::getShaderName(): id="<= m_shaderinfo_cache.size()=" - <= m_shaderinfo_cache.size()) return ShaderInfo(); @@ -539,21 +472,8 @@ ShaderInfo ShaderSource::getShader(u32 id) void ShaderSource::processQueue() { - /* - Fetch shaders - */ - //NOTE this is only thread safe for ONE consumer thread! - if(!m_get_shader_queue.empty()){ - GetRequest - request = m_get_shader_queue.pop(); - /**errorstream<<"ShaderSource::processQueue(): " - <<"got shader request with " - <<"name=\""<name != ""){ - *info = generate_shader(info->name, m_device, - m_shader_callback, &m_sourcecache); + for (ShaderInfo &i : m_shaderinfo_cache) { + ShaderInfo *info = &i; + if (!info->name.empty()) { + *info = generate_shader(info->name, info->material_type, + info->drawtype, m_callbacks, + m_setter_factories, &m_sourcecache); } } } -void ShaderSource::onSetConstants(video::IMaterialRendererServices *services, - bool is_highlevel, const std::string &name) -{ - for(u32 i=0; ionSetConstants(services, is_highlevel); - } -} -ShaderInfo generate_shader(std::string name, IrrlichtDevice *device, - video::IShaderConstantSetCallBack *callback, +ShaderInfo generate_shader(const std::string &name, u8 material_type, u8 drawtype, + std::vector &callbacks, + const std::vector &setter_factories, SourceShaderCache *sourcecache) { - /*infostream<<"generate_shader(): " - "\""<getOrLoad(name, "base.txt")); - for(s32 i = 0; video::sBuiltInMaterialTypeNames[i] != 0; i++){ - if(video::sBuiltInMaterialTypeNames[i] == base_material_name){ - shaderinfo.material = (video::E_MATERIAL_TYPE) i; - break; - } + switch (material_type) { + case TILE_MATERIAL_OPAQUE: + case TILE_MATERIAL_LIQUID_OPAQUE: + shaderinfo.base_material = video::EMT_SOLID; + break; + case TILE_MATERIAL_ALPHA: + case TILE_MATERIAL_LIQUID_TRANSPARENT: + shaderinfo.base_material = video::EMT_TRANSPARENT_ALPHA_CHANNEL; + break; + case TILE_MATERIAL_BASIC: + case TILE_MATERIAL_WAVING_LEAVES: + case TILE_MATERIAL_WAVING_PLANTS: + shaderinfo.base_material = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF; + break; } bool enable_shaders = g_settings->getBool("enable_shaders"); - if(!enable_shaders) + if (!enable_shaders) return shaderinfo; - video::IVideoDriver* driver = device->getVideoDriver(); - assert(driver); + video::IVideoDriver *driver = RenderingEngine::get_video_driver(); video::IGPUProgrammingServices *gpu = driver->getGPUProgrammingServices(); if(!gpu){ @@ -649,9 +564,8 @@ ShaderInfo generate_shader(std::string name, IrrlichtDevice *device, load_shaders(name, sourcecache, driver->getDriverType(), enable_shaders, vertex_program, pixel_program, geometry_program, is_highlevel); - // Check hardware/driver support - if(vertex_program != "" && + if (!vertex_program.empty() && !driver->queryFeature(video::EVDF_VERTEX_SHADER_1_1) && !driver->queryFeature(video::EVDF_ARB_VERTEX_PROGRAM_1)){ infostream<<"generate_shader(): vertex shaders disabled " @@ -659,7 +573,7 @@ ShaderInfo generate_shader(std::string name, IrrlichtDevice *device, <queryFeature(video::EVDF_PIXEL_SHADER_1_1) && !driver->queryFeature(video::EVDF_ARB_FRAGMENT_PROGRAM_1)){ infostream<<"generate_shader(): pixel shaders disabled " @@ -667,7 +581,7 @@ ShaderInfo generate_shader(std::string name, IrrlichtDevice *device, <queryFeature(video::EVDF_GEOMETRY_SHADER)){ infostream<<"generate_shader(): geometry shaders disabled " "because of missing driver/hardware support." @@ -676,56 +590,124 @@ ShaderInfo generate_shader(std::string name, IrrlichtDevice *device, } // If no shaders are used, don't make a separate material type - if(vertex_program == "" && pixel_program == "" && geometry_program == "") + if (vertex_program.empty() && pixel_program.empty() && geometry_program.empty()) return shaderinfo; // Create shaders header std::string shaders_header = "#version 120\n"; - if (g_settings->getBool("generate_normalmaps")){ - shaders_header += "#define GENERATE_NORMALMAPS\n"; - shaders_header += "#define NORMALMAPS_STRENGTH "; - shaders_header += ftos(g_settings->getFloat("normalmaps_strength")); + static const char* drawTypes[] = { + "NDT_NORMAL", + "NDT_AIRLIKE", + "NDT_LIQUID", + "NDT_FLOWINGLIQUID", + "NDT_GLASSLIKE", + "NDT_ALLFACES", + "NDT_ALLFACES_OPTIONAL", + "NDT_TORCHLIKE", + "NDT_SIGNLIKE", + "NDT_PLANTLIKE", + "NDT_FENCELIKE", + "NDT_RAILLIKE", + "NDT_NODEBOX", + "NDT_GLASSLIKE_FRAMED", + "NDT_FIRELIKE", + "NDT_GLASSLIKE_FRAMED_OPTIONAL", + "NDT_PLANTLIKE_ROOTED", + }; + + for (int i = 0; i < 14; i++){ + shaders_header += "#define "; + shaders_header += drawTypes[i]; + shaders_header += " "; + shaders_header += itos(i); shaders_header += "\n"; - float sample_step; - int smooth = (int)g_settings->getFloat("normalmaps_smooth"); - switch (smooth){ - case 0: - sample_step = 0.0078125; // 1.0 / 128.0 - break; - case 1: - sample_step = 0.00390625; // 1.0 / 256.0 - break; - case 2: - sample_step = 0.001953125; // 1.0 / 512.0 - break; - default: - sample_step = 0.0078125; - break; - } - shaders_header += "#define SAMPLE_STEP "; - shaders_header += ftos(sample_step); + } + + static const char* materialTypes[] = { + "TILE_MATERIAL_BASIC", + "TILE_MATERIAL_ALPHA", + "TILE_MATERIAL_LIQUID_TRANSPARENT", + "TILE_MATERIAL_LIQUID_OPAQUE", + "TILE_MATERIAL_WAVING_LEAVES", + "TILE_MATERIAL_WAVING_PLANTS", + "TILE_MATERIAL_OPAQUE" + }; + + for (int i = 0; i < 7; i++){ + shaders_header += "#define "; + shaders_header += materialTypes[i]; + shaders_header += " "; + shaders_header += itos(i); shaders_header += "\n"; } + shaders_header += "#define MATERIAL_TYPE "; + shaders_header += itos(material_type); + shaders_header += "\n"; + shaders_header += "#define DRAW_TYPE "; + shaders_header += itos(drawtype); + shaders_header += "\n"; + + if (g_settings->getBool("generate_normalmaps")) { + shaders_header += "#define GENERATE_NORMALMAPS 1\n"; + } else { + shaders_header += "#define GENERATE_NORMALMAPS 0\n"; + } + shaders_header += "#define NORMALMAPS_STRENGTH "; + shaders_header += ftos(g_settings->getFloat("normalmaps_strength")); + shaders_header += "\n"; + float sample_step; + int smooth = (int)g_settings->getFloat("normalmaps_smooth"); + switch (smooth){ + case 0: + sample_step = 0.0078125; // 1.0 / 128.0 + break; + case 1: + sample_step = 0.00390625; // 1.0 / 256.0 + break; + case 2: + sample_step = 0.001953125; // 1.0 / 512.0 + break; + default: + sample_step = 0.0078125; + break; + } + shaders_header += "#define SAMPLE_STEP "; + shaders_header += ftos(sample_step); + shaders_header += "\n"; + if (g_settings->getBool("enable_bumpmapping")) shaders_header += "#define ENABLE_BUMPMAPPING\n"; if (g_settings->getBool("enable_parallax_occlusion")){ + int mode = g_settings->getFloat("parallax_occlusion_mode"); + float scale = g_settings->getFloat("parallax_occlusion_scale"); + float bias = g_settings->getFloat("parallax_occlusion_bias"); + int iterations = g_settings->getFloat("parallax_occlusion_iterations"); shaders_header += "#define ENABLE_PARALLAX_OCCLUSION\n"; + shaders_header += "#define PARALLAX_OCCLUSION_MODE "; + shaders_header += itos(mode); + shaders_header += "\n"; shaders_header += "#define PARALLAX_OCCLUSION_SCALE "; - shaders_header += ftos(g_settings->getFloat("parallax_occlusion_scale")); + shaders_header += ftos(scale); shaders_header += "\n"; shaders_header += "#define PARALLAX_OCCLUSION_BIAS "; - shaders_header += ftos(g_settings->getFloat("parallax_occlusion_bias")); + shaders_header += ftos(bias); + shaders_header += "\n"; + shaders_header += "#define PARALLAX_OCCLUSION_ITERATIONS "; + shaders_header += itos(iterations); shaders_header += "\n"; } + shaders_header += "#define USE_NORMALMAPS "; if (g_settings->getBool("enable_bumpmapping") || g_settings->getBool("enable_parallax_occlusion")) - shaders_header += "#define USE_NORMALMAPS\n"; + shaders_header += "1\n"; + else + shaders_header += "0\n"; if (g_settings->getBool("enable_waving_water")){ - shaders_header += "#define ENABLE_WAVING_WATER\n"; + shaders_header += "#define ENABLE_WAVING_WATER 1\n"; shaders_header += "#define WATER_WAVE_HEIGHT "; shaders_header += ftos(g_settings->getFloat("water_wave_height")); shaders_header += "\n"; @@ -735,31 +717,46 @@ ShaderInfo generate_shader(std::string name, IrrlichtDevice *device, shaders_header += "#define WATER_WAVE_SPEED "; shaders_header += ftos(g_settings->getFloat("water_wave_speed")); shaders_header += "\n"; + } else{ + shaders_header += "#define ENABLE_WAVING_WATER 0\n"; } + shaders_header += "#define ENABLE_WAVING_LEAVES "; if (g_settings->getBool("enable_waving_leaves")) - shaders_header += "#define ENABLE_WAVING_LEAVES\n"; + shaders_header += "1\n"; + else + shaders_header += "0\n"; + shaders_header += "#define ENABLE_WAVING_PLANTS "; if (g_settings->getBool("enable_waving_plants")) - shaders_header += "#define ENABLE_WAVING_PLANTS\n"; + shaders_header += "1\n"; + else + shaders_header += "0\n"; - if(pixel_program != "") - pixel_program = shaders_header + pixel_program; - if(vertex_program != "") - vertex_program = shaders_header + vertex_program; - if(geometry_program != "") - geometry_program = shaders_header + geometry_program; + if (g_settings->getBool("tone_mapping")) + shaders_header += "#define ENABLE_TONE_MAPPING\n"; + + shaders_header += "#define FOG_START "; + shaders_header += ftos(rangelim(g_settings->getFloat("fog_start"), 0.0f, 0.99f)); + shaders_header += "\n"; // Call addHighLevelShaderMaterial() or addShaderMaterial() const c8* vertex_program_ptr = 0; const c8* pixel_program_ptr = 0; const c8* geometry_program_ptr = 0; - if(vertex_program != "") + if (!vertex_program.empty()) { + vertex_program = shaders_header + vertex_program; vertex_program_ptr = vertex_program.c_str(); - if(pixel_program != "") + } + if (!pixel_program.empty()) { + pixel_program = shaders_header + pixel_program; pixel_program_ptr = pixel_program.c_str(); - if(geometry_program != "") + } + if (!geometry_program.empty()) { + geometry_program = shaders_header + geometry_program; geometry_program_ptr = geometry_program.c_str(); + } + ShaderCallback *cb = new ShaderCallback(setter_factories); s32 shadermat = -1; if(is_highlevel){ infostream<<"Compiling high level shaders for "<addShaderMaterial( vertex_program_ptr, // Vertex shader program pixel_program_ptr, // Pixel shader program - callback, // Set-constant callback - shaderinfo.material, // Base material + cb, // Set-constant callback + shaderinfo.base_material, // Base material 0 // Userdata passed to callback ); @@ -804,9 +804,13 @@ ShaderInfo generate_shader(std::string name, IrrlichtDevice *device, "failed to generate \""<getOrLoad(name, "opengl_fragment.glsl"); geometry_program = sourcecache->getOrLoad(name, "opengl_geometry.glsl"); } - if(vertex_program != "" || pixel_program != "" || geometry_program != ""){ + if (!vertex_program.empty() || !pixel_program.empty() || !geometry_program.empty()){ is_highlevel = true; return; } } } + +void dumpShaderProgram(std::ostream &output_stream, + const std::string &program_type, const std::string &program) +{ + output_stream << program_type << " shader program:" << std::endl << + "----------------------------------" << std::endl; + size_t pos = 0; + size_t prev = 0; + s16 line = 1; + while ((pos = program.find('\n', prev)) != std::string::npos) { + output_stream << line++ << ": "<< program.substr(prev, pos - prev) << + std::endl; + prev = pos + 1; + } + output_stream << line << ": " << program.substr(prev) << std::endl << + "End of " << program_type << " shader program." << std::endl << + " " << std::endl; +}