projects / oweals / minetest.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Noise: Prevent unittest crash caused by division by zero
[oweals/minetest.git] / src / shader.cpp
diff --git a/src/shader.cpp b/src/shader.cpp
index 79485025b30675169d4fc034aecf1b21c1f6cb50..e6e5e7b1fc097e2d3167215ef5f9056f766391e1 100644 (file)
--- a/src/shader.cpp
+++ b/src/shader.cpp
@@ -32,6 +32,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include <IMaterialRenderer.h>
 #include <IMaterialRendererServices.h>
 #include <IShaderConstantSetCallBack.h>
+#include "client/renderingengine.h"
 #include "EShaderTypes.h"
 #include "log.h"
 #include "gamedef.h"
@@ -177,7 +178,7 @@ class ShaderCallback : public video::IShaderConstantSetCallBack
        std::vector<IShaderConstantSetter*> m_setters;
 
 public:
-       ShaderCallback(const std::vector<IShaderConstantSetterFactory*> &factories)
+       ShaderCallback(const std::vector<IShaderConstantSetterFactory *> &factories)
        {
                for (u32 i = 0; i < factories.size(); ++i)
                        m_setters.push_back(factories[i]->create());
@@ -260,7 +261,7 @@ public:
 class ShaderSource : public IWritableShaderSource
 {
 public:
-       ShaderSource(IrrlichtDevice *device);
+       ShaderSource();
        ~ShaderSource();
 
        /*
@@ -308,9 +309,7 @@ public:
 private:
 
        // The id of the thread that is allowed to use irrlicht directly
-       threadid_t m_main_thread;
-       // The irrlicht device
-       IrrlichtDevice *m_device;
+       std::thread::id m_main_thread;
 
        // Cache of source shaders
        // This should be only accessed from the main thread
@@ -320,7 +319,7 @@ private:
        // The first position contains a dummy shader.
        std::vector<ShaderInfo> m_shaderinfo_cache;
        // The former container is behind this mutex
-       Mutex m_shaderinfo_cache_mutex;
+       std::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;
@@ -332,18 +331,17 @@ private:
        std::vector<ShaderCallback *> 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,
-               u8 material_type, u8 drawtype,
-               IrrlichtDevice *device, std::vector<ShaderCallback *> &callbacks,
-               const std::vector<IShaderConstantSetterFactory*> &setter_factories,
+ShaderInfo generate_shader(const std::string &name,
+               u8 material_type, u8 drawtype, std::vector<ShaderCallback *> &callbacks,
+               const std::vector<IShaderConstantSetterFactory *> &setter_factories,
                SourceShaderCache *sourcecache);
 
 /*
@@ -354,12 +352,9 @@ void load_shaders(std::string name, SourceShaderCache *sourcecache,
                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); // Pre-condition
-
-       m_main_thread = thr_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());
@@ -387,7 +382,7 @@ u32 ShaderSource::getShader(const std::string &name,
                Get shader
        */
 
-       if (thr_is_current_thread(m_main_thread)) {
+       if (std::this_thread::get_id() == m_main_thread) {
                return getShaderIdDirect(name, material_type, drawtype);
        } else {
                /*errorstream<<"getShader(): Queued: name=\""<<name<<"\""<<std::endl;*/
@@ -446,14 +441,14 @@ u32 ShaderSource::getShaderIdDirect(const std::string &name,
        /*
                Calling only allowed from main thread
        */
-       if (!thr_is_current_thread(m_main_thread)) {
+       if (std::this_thread::get_id() != m_main_thread) {
                errorstream<<"ShaderSource::getShaderIdDirect() "
                                "called not from main thread"<<std::endl;
                return 0;
        }
 
        ShaderInfo info = generate_shader(name, material_type, drawtype,
-                       m_device, m_callbacks, m_setter_factories, &m_sourcecache);
+                       m_callbacks, m_setter_factories, &m_sourcecache);
 
        /*
                Add shader to caches (add dummy shaders too)
@@ -494,7 +489,7 @@ void ShaderSource::insertSourceShader(const std::string &name_of_shader,
                        "name_of_shader=\""<<name_of_shader<<"\", "
                        "filename=\""<<filename<<"\""<<std::endl;*/
 
-       sanity_check(thr_is_current_thread(m_main_thread));
+       sanity_check(std::this_thread::get_id() == m_main_thread);
 
        m_sourcecache.insert(name_of_shader, filename, program, true);
 }
@@ -518,16 +513,16 @@ void ShaderSource::rebuildShaders()
                ShaderInfo *info = &m_shaderinfo_cache[i];
                if(info->name != ""){
                        *info = generate_shader(info->name, info->material_type,
-                                       info->drawtype, m_device, m_callbacks,
+                                       info->drawtype, m_callbacks,
                                        m_setter_factories, &m_sourcecache);
                }
        }
 }
 
 
-ShaderInfo generate_shader(std::string name, u8 material_type, u8 drawtype,
-               IrrlichtDevice *device, std::vector<ShaderCallback *> &callbacks,
-               const std::vector<IShaderConstantSetterFactory*> &setter_factories,
+ShaderInfo generate_shader(const std::string &name, u8 material_type, u8 drawtype,
+               std::vector<ShaderCallback *> &callbacks,
+               const std::vector<IShaderConstantSetterFactory *> &setter_factories,
                SourceShaderCache *sourcecache)
 {
        ShaderInfo shaderinfo;
@@ -535,24 +530,19 @@ ShaderInfo generate_shader(std::string name, u8 material_type, u8 drawtype,
        shaderinfo.material_type = material_type;
        shaderinfo.drawtype = drawtype;
        shaderinfo.material = video::EMT_SOLID;
-       switch(material_type){
-               case TILE_MATERIAL_BASIC:
-                       shaderinfo.base_material = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
-                       break;
-               case TILE_MATERIAL_ALPHA:
-                       shaderinfo.base_material = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
-                       break;
-               case TILE_MATERIAL_LIQUID_TRANSPARENT:
-                       shaderinfo.base_material = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
-                       break;
-               case TILE_MATERIAL_LIQUID_OPAQUE:
-                       shaderinfo.base_material = video::EMT_SOLID;
-                       break;
-               case TILE_MATERIAL_WAVING_LEAVES:
-                       shaderinfo.base_material = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
-                       break;
-               case TILE_MATERIAL_WAVING_PLANTS:
-                       shaderinfo.base_material = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
+       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;
        }
 
@@ -560,8 +550,7 @@ ShaderInfo generate_shader(std::string name, u8 material_type, u8 drawtype,
        if (!enable_shaders)
                return shaderinfo;
 
-       video::IVideoDriver* driver = device->getVideoDriver();
-       sanity_check(driver);
+       video::IVideoDriver *driver = RenderingEngine::get_video_driver();
 
        video::IGPUProgrammingServices *gpu = driver->getGPUProgrammingServices();
        if(!gpu){
@@ -629,7 +618,8 @@ ShaderInfo generate_shader(std::string name, u8 material_type, u8 drawtype,
                "NDT_NODEBOX",
                "NDT_GLASSLIKE_FRAMED",
                "NDT_FIRELIKE",
-               "NDT_GLASSLIKE_FRAMED_OPTIONAL"
+               "NDT_GLASSLIKE_FRAMED_OPTIONAL",
+               "NDT_PLANTLIKE_ROOTED",
        };
 
        for (int i = 0; i < 14; i++){
@@ -646,10 +636,11 @@ ShaderInfo generate_shader(std::string name, u8 material_type, u8 drawtype,
                "TILE_MATERIAL_LIQUID_TRANSPARENT",
                "TILE_MATERIAL_LIQUID_OPAQUE",
                "TILE_MATERIAL_WAVING_LEAVES",
-               "TILE_MATERIAL_WAVING_PLANTS"
+               "TILE_MATERIAL_WAVING_PLANTS",
+               "TILE_MATERIAL_OPAQUE"
        };
 
-       for (int i = 0; i < 6; i++){
+       for (int i = 0; i < 7; i++){
                shaders_header += "#define ";
                shaders_header += materialTypes[i];
                shaders_header += " ";
Unnamed repository; edit this file 'description' to name the repository.