updated example map generator python script

[dragonfireclient.git] / src / irrlichtwrapper.h

diff --git a/src/irrlichtwrapper.h b/src/irrlichtwrapper.h
index 2506af012833bffd7a26415f36916e2010bbd0e0..55e021bdac03eea7f9c6a88568e1c5ce412ba30b 100644 (file)
--- a/src/irrlichtwrapper.h
+++ b/src/irrlichtwrapper.h
@@ -24,11 +24,17 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "common_irrlicht.h"
 #include "debug.h"
 #include "utility.h"
+#include "texture.h"
+#include "iirrlichtwrapper.h"
 
 #include <jmutex.h>
 #include <jmutexautolock.h>
 #include <string>
 
+/*
+       NOTE: This is deprecated and should be removed completely
+*/
+
 /*
        A thread-safe texture pointer cache.
        
@@ -37,6 +43,10 @@ with this program; if not, write to the Free Software Foundation, Inc.,
        background threads.
 */
 
+#if 0
+/*
+       A thread-safe texture pointer cache
+*/
 class TextureCache
 {
 public:
@@ -46,22 +56,22 @@ class TextureCache
                assert(m_mutex.IsInitialized());
        }
        
-       void set(std::string name, video::ITexture *texture)
+       void set(const TextureSpec &spec, video::ITexture *texture)
        {
                if(texture == NULL)
                        return;
                
                JMutexAutoLock lock(m_mutex);
 
-               m_textures[name] = texture;
+               m_textures[spec] = texture;
        }
        
-       video::ITexture* get(const std::string &name)
+       video::ITexture* get(const TextureSpec &spec)
        {
                JMutexAutoLock lock(m_mutex);
 
-               core::map<std::string, video::ITexture*>::Node *n;
-               n = m_textures.find(name);
+               core::map<TextureSpec, video::ITexture*>::Node *n;
+               n = m_textures.find(spec);
 
                if(n != NULL)
                        return n->getValue();
@@ -70,28 +80,41 @@ class TextureCache
        }
 
 private:
-       core::map<std::string, video::ITexture*> m_textures;
+       core::map<TextureSpec, video::ITexture*> m_textures;
        JMutex m_mutex;
 };
+#endif
 
 /*
        A thread-safe wrapper for irrlicht, to be accessed from
        background worker threads.
 
        Queues tasks to be done in the main thread.
+
+       Also caches texture specification strings to ids and textures.
+
+       TODO: Remove this and move all texture functionality to TextureSource
 */
 
-class IrrlichtWrapper
+class IrrlichtWrapper : public IIrrlichtWrapper
 {
 public:
        /*
                These are called from the main thread
        */
+
        IrrlichtWrapper(IrrlichtDevice *device);
+
+       ~IrrlichtWrapper();
        
        // Run queued tasks
        void Run();
 
+       // Shutdown wrapper; this disables queued texture fetching
+       void Shutdown(bool shutdown);
+
+       IrrlichtDevice* getDevice();
+       
        /*
                These are called from other threads
        */
@@ -102,31 +125,62 @@ class IrrlichtWrapper
        {
                return m_device->getTimer()->getRealTime();
        }
-       
-    /*
-               Path can contain stuff like
-               "/usr/share/minetest/stone.png[[mod:mineral0[[mod:crack3"
+
+#if 0
+       /*
+               Format of a texture name:
+                       "stone.png" (filename in image data directory)
+                       "[crack1" (a name starting with "[" is a special feature)
+                       "[progress1.0" (a name starting with "[" is a special feature)
+       */
+       /*
+               Loads texture defined by "name" and assigns a texture id to it.
+               If texture has to be generated, generates it.
+               If the texture has already been loaded, returns existing id.
        */
-       video::ITexture* getTexture(const std::string &spec);
+       textureid_t getTextureId(const std::string &name);
+       // The reverse of the above
+       std::string getTextureName(textureid_t id);
+       // Gets a texture based on a filename
+       video::ITexture* getTexture(const std::string &filename);
+       // Gets a texture based on a TextureSpec (a textureid_t is fine too)
+       video::ITexture* getTexture(const TextureSpec &spec);
+#endif
        
 private:
        /*
                Non-thread-safe variants of stuff, for internal use
        */
-       video::ITexture* getTextureDirect(const std::string &spec);
+
+       // Constructs a texture according to spec
+       //video::ITexture* getTextureDirect(const TextureSpec &spec);
        
        /*
                Members
        */
+
+       bool m_running;
        
+       // The id of the thread that can (and has to) use irrlicht directly
        threadid_t m_main_thread;
-
+       
+       // The irrlicht device
        JMutex m_device_mutex;
        IrrlichtDevice *m_device;
+       
+#if 0
+       // Queued texture fetches (to be processed by the main thread)
+       RequestQueue<TextureSpec, video::ITexture*, u8, u8> m_get_texture_queue;
 
+       // Cache of textures by spec
        TextureCache m_texturecache;
-       
-       RequestQueue<std::string, video::ITexture*, u8, u8> m_get_texture_queue;
+
+       // Cached or generated source images by texture name
+       core::map<std::string, video::IImage*> m_imagecache;
+
+       // A mapping from texture id to string spec
+       MutexedIdGenerator<std::string> m_namecache;
+#endif
 };
 
 #endif