src/irrlichtwrapper.h

   1 /*
   2 Minetest-c55
   3 Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #ifndef IRRLICHTWRAPPER_HEADER
  21 #define IRRLICHTWRAPPER_HEADER
  22
  23 #include "threads.h"
  24 #include "common_irrlicht.h"
  25 #include "debug.h"
  26 #include "utility.h"
  27
  28 #include <jmutex.h>
  29 #include <jmutexautolock.h>
  30 #include <string>
  31
  32 /*
  33         A thread-safe texture pointer cache.
  34
  35         This is used so that irrlicht doesn't get called from many
  36         threads, because texture pointers have to be handled in
  37         background threads.
  38 */
  39
  40 class TextureCache
  41 {
  42 public:
  43         TextureCache()
  44         {
  45                 m_mutex.Init();
  46                 assert(m_mutex.IsInitialized());
  47         }
  48
  49         void set(std::string name, video::ITexture *texture)
  50         {
  51                 if(texture == NULL)
  52                         return;
  53
  54                 JMutexAutoLock lock(m_mutex);
  55
  56                 m_textures[name] = texture;
  57         }
  58
  59         video::ITexture* get(std::string name)
  60         {
  61                 JMutexAutoLock lock(m_mutex);
  62
  63                 core::map<std::string, video::ITexture*>::Node *n;
  64                 n = m_textures.find(name);
  65
  66                 if(n != NULL)
  67                         return n->getValue();
  68
  69                 return NULL;
  70         }
  71
  72 private:
  73         core::map<std::string, video::ITexture*> m_textures;
  74         JMutex m_mutex;
  75 };
  76
  77 struct TextureMod
  78 {
  79         /*
  80                 Returns a new texture which can be based on the original.
  81                 Shall not modify or delete the original texture.
  82         */
  83         virtual video::ITexture * make(video::ITexture *original,
  84                         const char *newname, video::IVideoDriver* driver) = 0;
  85 };
  86
  87 struct CrackTextureMod: public TextureMod
  88 {
  89         CrackTextureMod(u16 a_progression)
  90         {
  91                 progression = a_progression;
  92         }
  93
  94         virtual video::ITexture * make(video::ITexture *original,
  95                         const char *newname, video::IVideoDriver* driver);
  96
  97         u16 progression;
  98 };
  99
 100 /*
 101         A class for specifying a requested texture
 102 */
 103 struct TextureSpec
 104 {
 105         TextureSpec()
 106         {
 107                 mod = NULL;
 108         }
 109         TextureSpec(const std::string &a_name, const std::string &a_path,
 110                         TextureMod *a_mod)
 111         {
 112                 name = a_name;
 113                 path = a_path;
 114                 mod = a_mod;;
 115         }
 116         ~TextureSpec()
 117         {
 118         }
 119         bool operator==(const TextureSpec &other)
 120         {
 121                 return name == other.name;
 122         }
 123         // An unique name for the texture. Usually the same as the path.
 124         // Note that names and paths reside the same namespace.
 125         std::string name;
 126         // This is the path of the base texture
 127         std::string path;
 128         // Modification to do to the base texture
 129         // NOTE: This is deleted by the one who processes the request
 130         TextureMod *mod;
 131 };
 132
 133 /*
 134         A thread-safe wrapper for irrlicht, to be accessed from
 135         background worker threads.
 136
 137         Queues tasks to be done in the main thread.
 138 */
 139
 140 class IrrlichtWrapper
 141 {
 142 public:
 143         /*
 144                 These are called from the main thread
 145         */
 146         IrrlichtWrapper(IrrlichtDevice *device);
 147
 148         // Run queued tasks
 149         void Run();
 150
 151         /*
 152                 These are called from other threads
 153         */
 154
 155         // Not exactly thread-safe but this needs to be fast.
 156         // getTimer()->getRealTime() only reads one variable anyway.
 157         u32 getTime()
 158         {
 159                 return m_device->getTimer()->getRealTime();
 160         }
 161
 162         video::ITexture* getTexture(TextureSpec spec);
 163         video::ITexture* getTexture(const std::string &path);
 164
 165 private:
 166         /*
 167                 Non-thread-safe variants of stuff, for internal use
 168         */
 169         video::ITexture* getTextureDirect(TextureSpec spec);
 170
 171         /*
 172                 Members
 173         */
 174
 175         threadid_t m_main_thread;
 176
 177         JMutex m_device_mutex;
 178         IrrlichtDevice *m_device;
 179
 180         TextureCache m_texturecache;
 181
 182         RequestQueue<TextureSpec, video::ITexture*, u8, u8> m_get_texture_queue;
 183 };
 184
 185 #endif
 186