#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.
background threads.
*/
+#if 0
+/*
+ A thread-safe texture pointer cache
+*/
class TextureCache
{
public:
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(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();
}
private:
- core::map<std::string, video::ITexture*> m_textures;
+ core::map<TextureSpec, video::ITexture*> m_textures;
JMutex m_mutex;
};
-
-struct TextureMod
-{
- /*
- Returns a new texture which can be based on the original.
- Shall not modify or delete the original texture.
- */
- virtual video::ITexture * make(video::ITexture *original,
- const char *newname, video::IVideoDriver* driver) = 0;
-};
-
-struct CrackTextureMod: public TextureMod
-{
- CrackTextureMod(u16 a_progression)
- {
- progression = a_progression;
- }
-
- virtual video::ITexture * make(video::ITexture *original,
- const char *newname, video::IVideoDriver* driver);
-
- u16 progression;
-};
-
-struct ProgressBarTextureMod: public TextureMod
-{
- // value is from 0.0 to 1.0
- ProgressBarTextureMod(float a_value)
- {
- value = a_value;
- }
-
- virtual video::ITexture * make(video::ITexture *original,
- const char *newname, video::IVideoDriver* driver);
-
- float value;
-};
-
-/*
- A class for specifying a requested texture
-*/
-struct TextureSpec
-{
- TextureSpec()
- {
- mod = NULL;
- }
- TextureSpec(const std::string &a_name, const std::string &a_path,
- TextureMod *a_mod)
- {
- name = a_name;
- path = a_path;
- mod = a_mod;;
- }
- ~TextureSpec()
- {
- }
- bool operator==(const TextureSpec &other)
- {
- return name == other.name;
- }
- // An unique name for the texture. Usually the same as the path.
- // Note that names and paths reside the same namespace.
- std::string name;
- // This is the path of the base texture
- std::string path;
- // Modification to do to the base texture
- // NOTE: This is deleted by the one who processes the request
- TextureMod *mod;
-};
+#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
*/
{
return m_device->getTimer()->getRealTime();
}
-
- video::ITexture* getTexture(TextureSpec spec);
- video::ITexture* getTexture(const std::string &path);
+#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.
+ */
+ 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(TextureSpec 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;
-
- TextureCache m_texturecache;
+#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;
+
+ // 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