Fix bug that was leading to oversized tooltips containing multiline text when it...

[dragonfireclient.git] / src / shader.cpp

diff --git a/src/shader.cpp b/src/shader.cpp
index a6d18e1bef374881e8334a9bd127e38475b555df..e13ab8df30ef264282f2e823851a4c6fc16d2d5c 100644 (file)
--- a/src/shader.cpp
+++ b/src/shader.cpp
@@ -35,7 +35,6 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "EShaderTypes.h"
 #include "log.h"
 #include "gamedef.h"
-#include "strfnd.h" // trim()
 #include "client/tile.h"
 
 /*
@@ -328,7 +327,7 @@ class ShaderSource : public IWritableShaderSource, public IShaderConstantSetterR
        // The first position contains a dummy shader.
        std::vector<ShaderInfo> m_shaderinfo_cache;
        // The former container is behind this mutex
-       JMutex m_shaderinfo_cache_mutex;
+       Mutex m_shaderinfo_cache_mutex;
 
        // Queued shader fetches (to be processed by the main thread)
        RequestQueue<std::string, u32, u8, u8> m_get_shader_queue;
@@ -367,7 +366,7 @@ ShaderSource::ShaderSource(IrrlichtDevice *device):
 
        m_shader_callback = new ShaderCallback(this, "default");
 
-       m_main_thread = get_current_thread_id();
+       m_main_thread = thr_get_current_thread_id();
 
        // Add a dummy ShaderInfo as the first index, named ""
        m_shaderinfo_cache.push_back(ShaderInfo());
@@ -379,7 +378,7 @@ ShaderSource::ShaderSource(IrrlichtDevice *device):
 ShaderSource::~ShaderSource()
 {
        for (std::vector<IShaderConstantSetter*>::iterator iter = m_global_setters.begin();
-                       iter != m_global_setters.end(); iter++) {
+                       iter != m_global_setters.end(); ++iter) {
                delete *iter;
        }
        m_global_setters.clear();
@@ -397,7 +396,7 @@ u32 ShaderSource::getShader(const std::string &name,
                Get shader
        */
 
-       if(get_current_thread_id() == m_main_thread){
+       if (thr_is_current_thread(m_main_thread)) {
                return getShaderIdDirect(name, material_type, drawtype);
        } else {
                /*errorstream<<"getShader(): Queued: name=\""<<name<<"\""<<std::endl;*/
@@ -456,7 +455,7 @@ u32 ShaderSource::getShaderIdDirect(const std::string &name,
        /*
                Calling only allowed from main thread
        */
-       if(get_current_thread_id() != m_main_thread){
+       if (!thr_is_current_thread(m_main_thread)) {
                errorstream<<"ShaderSource::getShaderIdDirect() "
                                "called not from main thread"<<std::endl;
                return 0;
@@ -469,7 +468,7 @@ u32 ShaderSource::getShaderIdDirect(const std::string &name,
                Add shader to caches (add dummy shaders too)
        */
 
-       JMutexAutoLock lock(m_shaderinfo_cache_mutex);
+       MutexAutoLock lock(m_shaderinfo_cache_mutex);
 
        u32 id = m_shaderinfo_cache.size();
        m_shaderinfo_cache.push_back(info);
@@ -483,7 +482,7 @@ u32 ShaderSource::getShaderIdDirect(const std::string &name,
 
 ShaderInfo ShaderSource::getShaderInfo(u32 id)
 {
-       JMutexAutoLock lock(m_shaderinfo_cache_mutex);
+       MutexAutoLock lock(m_shaderinfo_cache_mutex);
 
        if(id >= m_shaderinfo_cache.size())
                return ShaderInfo();
@@ -504,14 +503,14 @@ void ShaderSource::insertSourceShader(const std::string &name_of_shader,
                        "name_of_shader=\""<<name_of_shader<<"\", "
                        "filename=\""<<filename<<"\""<<std::endl;*/
 
-       sanity_check(get_current_thread_id() == m_main_thread);
+       sanity_check(thr_is_current_thread(m_main_thread));
 
        m_sourcecache.insert(name_of_shader, filename, program, true);
 }
 
 void ShaderSource::rebuildShaders()
 {
-       JMutexAutoLock lock(m_shaderinfo_cache_mutex);
+       MutexAutoLock lock(m_shaderinfo_cache_mutex);
 
        /*// Oh well... just clear everything, they'll load sometime.
        m_shaderinfo_cache.clear();
@@ -731,8 +730,11 @@ ShaderInfo generate_shader(std::string name, u8 material_type, u8 drawtype,
                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 1\n";
@@ -761,22 +763,25 @@ ShaderInfo generate_shader(std::string name, u8 material_type, u8 drawtype,
        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";
+
        // 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();
+       }
        s32 shadermat = -1;
        if(is_highlevel){
                infostream<<"Compiling high level shaders for "<<name<<std::endl;
@@ -786,7 +791,7 @@ ShaderInfo generate_shader(std::string name, u8 material_type, u8 drawtype,
                        video::EVST_VS_1_1,   // Vertex shader version
                        pixel_program_ptr,    // Pixel shader program
                        "pixelMain",          // Pixel shader entry point
-                       video::EPST_PS_1_1,   // Pixel shader version
+                       video::EPST_PS_1_2,   // Pixel shader version
                        geometry_program_ptr, // Geometry shader program
                        "geometryMain",       // Geometry shader entry point
                        video::EGST_GS_4_0,   // Geometry shader version
@@ -802,6 +807,9 @@ ShaderInfo generate_shader(std::string name, u8 material_type, u8 drawtype,
                                        "failed to generate \""<<name<<"\", "
                                        "addHighLevelShaderMaterial failed."
                                        <<std::endl;
+                       dumpShaderProgram(warningstream, "Vertex", vertex_program);
+                       dumpShaderProgram(warningstream, "Pixel", pixel_program);
+                       dumpShaderProgram(warningstream, "Geometry", geometry_program);
                        return shaderinfo;
                }
        }
@@ -820,6 +828,8 @@ ShaderInfo generate_shader(std::string name, u8 material_type, u8 drawtype,
                                        "failed to generate \""<<name<<"\", "
                                        "addShaderMaterial failed."
                                        <<std::endl;
+                       dumpShaderProgram(warningstream, "Vertex", vertex_program);
+                       dumpShaderProgram(warningstream,"Pixel", pixel_program);
                        return shaderinfo;
                }
        }
@@ -865,3 +875,21 @@ void load_shaders(std::string name, SourceShaderCache *sourcecache,
        }
 
 }
+
+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;
+}