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 struct ProgressBarTextureMod: public TextureMod
 101 {
 102         // value is from 0.0 to 1.0
 103         ProgressBarTextureMod(float a_value)
 104         {
 105                 value = a_value;
 106         }
 107
 108         virtual video::ITexture * make(video::ITexture *original,
 109                         const char *newname, video::IVideoDriver* driver);
 110
 111         float value;
 112 };
 113
 114 /*
 115         A class for specifying a requested texture
 116 */
 117 struct TextureSpec
 118 {
 119         TextureSpec()
 120         {
 121                 mod = NULL;
 122         }
 123         TextureSpec(const std::string &a_name, const std::string &a_path,
 124                         TextureMod *a_mod)
 125         {
 126                 name = a_name;
 127                 path = a_path;
 128                 mod = a_mod;;
 129         }
 130         ~TextureSpec()
 131         {
 132         }
 133         bool operator==(const TextureSpec &other)
 134         {
 135                 return name == other.name;
 136         }
 137         // An unique name for the texture. Usually the same as the path.
 138         // Note that names and paths reside the same namespace.
 139         std::string name;
 140         // This is the path of the base texture
 141         std::string path;
 142         // Modification to do to the base texture
 143         // NOTE: This is deleted by the one who processes the request
 144         TextureMod *mod;
 145 };
 146
 147 /*
 148         A thread-safe wrapper for irrlicht, to be accessed from
 149         background worker threads.
 150
 151         Queues tasks to be done in the main thread.
 152 */
 153
 154 class IrrlichtWrapper
 155 {
 156 public:
 157         /*
 158                 These are called from the main thread
 159         */
 160         IrrlichtWrapper(IrrlichtDevice *device);
 161
 162         // Run queued tasks
 163         void Run();
 164
 165         /*
 166                 These are called from other threads
 167         */
 168
 169         // Not exactly thread-safe but this needs to be fast.
 170         // getTimer()->getRealTime() only reads one variable anyway.
 171         u32 getTime()
 172         {
 173                 return m_device->getTimer()->getRealTime();
 174         }
 175
 176         video::ITexture* getTexture(TextureSpec spec);
 177         video::ITexture* getTexture(const std::string &path);
 178
 179 private:
 180         /*
 181                 Non-thread-safe variants of stuff, for internal use
 182         */
 183         video::ITexture* getTextureDirect(TextureSpec spec);
 184
 185         /*
 186                 Members
 187         */
 188
 189         threadid_t m_main_thread;
 190
 191         JMutex m_device_mutex;
 192         IrrlichtDevice *m_device;
 193
 194         TextureCache m_texturecache;
 195
 196         RequestQueue<TextureSpec, video::ITexture*, u8, u8> m_get_texture_queue;
 197 };
 198
 199 #endif
 200