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(const 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 /*
  78         A thread-safe wrapper for irrlicht, to be accessed from
  79         background worker threads.
  80
  81         Queues tasks to be done in the main thread.
  82 */
  83
  84 class IrrlichtWrapper
  85 {
  86 public:
  87         /*
  88                 These are called from the main thread
  89         */
  90         IrrlichtWrapper(IrrlichtDevice *device);
  91
  92         // Run queued tasks
  93         void Run();
  94
  95         /*
  96                 These are called from other threads
  97         */
  98
  99         // Not exactly thread-safe but this needs to be fast.
 100         // getTimer()->getRealTime() only reads one variable anyway.
 101         u32 getTime()
 102         {
 103                 return m_device->getTimer()->getRealTime();
 104         }
 105
 106     /*
 107                 Path can contain stuff like
 108                 "/usr/share/minetest/stone.png[[mod:mineral0[[mod:crack3"
 109         */
 110         video::ITexture* getTexture(const std::string &spec);
 111
 112 private:
 113         /*
 114                 Non-thread-safe variants of stuff, for internal use
 115         */
 116         video::ITexture* getTextureDirect(const std::string &spec);
 117
 118         /*
 119                 Members
 120         */
 121
 122         threadid_t m_main_thread;
 123
 124         JMutex m_device_mutex;
 125         IrrlichtDevice *m_device;
 126
 127         TextureCache m_texturecache;
 128
 129         RequestQueue<std::string, video::ITexture*, u8, u8> m_get_texture_queue;
 130 };
 131
 132 #endif
 133