src/tile.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 TILE_HEADER
  21 #define TILE_HEADER
  22
  23 #include "common_irrlicht.h"
  24 #include "threads.h"
  25 #include "utility.h"
  26 #include <string>
  27
  28 /*
  29         Specifies a texture in an atlas.
  30
  31         This is used to specify single textures also.
  32
  33         This has been designed to be small enough to be thrown around a lot.
  34 */
  35 struct AtlasPointer
  36 {
  37         u32 id; // Texture id
  38         video::ITexture *atlas; // Atlas in where the texture is
  39         v2f pos; // Position in atlas
  40         v2f size; // Size in atlas
  41         u16 tiled; // X-wise tiling count. If 0, width of atlas is width of image.
  42
  43         AtlasPointer(
  44                         u16 id_,
  45                         video::ITexture *atlas_=NULL,
  46                         v2f pos_=v2f(0,0),
  47                         v2f size_=v2f(1,1),
  48                         u16 tiled_=1
  49                 ):
  50                 id(id_),
  51                 atlas(atlas_),
  52                 pos(pos_),
  53                 size(size_),
  54                 tiled(tiled_)
  55         {
  56         }
  57
  58         bool operator==(const AtlasPointer &other)
  59         {
  60                 return (
  61                         id == other.id
  62                 );
  63                 /*return (
  64                         id == other.id &&
  65                         atlas == other.atlas &&
  66                         pos == other.pos &&
  67                         size == other.size &&
  68                         tiled == other.tiled
  69                 );*/
  70         }
  71
  72         float x0(){ return pos.X; }
  73         float x1(){ return pos.X + size.X; }
  74         float y0(){ return pos.Y; }
  75         float y1(){ return pos.Y + size.Y; }
  76 };
  77
  78 /*
  79         An internal variant of the former with more data.
  80 */
  81 struct SourceAtlasPointer
  82 {
  83         std::string name;
  84         AtlasPointer a;
  85         video::IImage *atlas_img; // The source image of the atlas
  86         // Integer variants of position and size
  87         v2s32 intpos;
  88         v2u32 intsize;
  89
  90         SourceAtlasPointer(
  91                         const std::string &name_,
  92                         AtlasPointer a_=AtlasPointer(0, NULL),
  93                         video::IImage *atlas_img_=NULL,
  94                         v2s32 intpos_=v2s32(0,0),
  95                         v2u32 intsize_=v2u32(0,0)
  96                 ):
  97                 name(name_),
  98                 a(a_),
  99                 atlas_img(atlas_img_),
 100                 intpos(intpos_),
 101                 intsize(intsize_)
 102         {
 103         }
 104 };
 105
 106 /*
 107         Creates and caches textures.
 108 */
 109 class TextureSource
 110 {
 111 public:
 112         TextureSource(IrrlichtDevice *device);
 113         ~TextureSource();
 114
 115         /*
 116                 Processes queued texture requests from other threads.
 117
 118                 Shall be called from the main thread.
 119         */
 120         void processQueue();
 121
 122         /*
 123                 Example case:
 124                 Now, assume a texture with the id 1 exists, and has the name
 125                 "stone.png^mineral1".
 126                 Then a random thread calls getTextureId for a texture called
 127                 "stone.png^mineral1^crack0".
 128                 ...Now, WTF should happen? Well:
 129                 - getTextureId strips off stuff recursively from the end until
 130                   the remaining part is found, or nothing is left when
 131                   something is stripped out
 132
 133                 But it is slow to search for textures by names and modify them
 134                 like that?
 135                 - ContentFeatures is made to contain ids for the basic plain
 136                   textures
 137                 - Crack textures can be slow by themselves, but the framework
 138                   must be fast.
 139
 140                 Example case #2:
 141                 - Assume a texture with the id 1 exists, and has the name
 142                   "stone.png^mineral1" and is specified as a part of some atlas.
 143                 - Now MapBlock::getNodeTile() stumbles upon a node which uses
 144                   texture id 1, and finds out that NODEMOD_CRACK must be applied
 145                   with progression=0
 146                 - It finds out the name of the texture with getTextureName(1),
 147                   appends "^crack0" to it and gets a new texture id with
 148                   getTextureId("stone.png^mineral1^crack0")
 149
 150         */
 151
 152         /*
 153                 Gets a texture id from cache or
 154                 - if main thread, from getTextureIdDirect
 155                 - if other thread, adds to request queue and waits for main thread
 156         */
 157         u32 getTextureId(const std::string &name);
 158
 159         /*
 160                 Example names:
 161                 "stone.png"
 162                 "stone.png^crack2"
 163                 "stone.png^blit:mineral_coal.png"
 164                 "stone.png^blit:mineral_coal.png^crack1"
 165
 166                 - If texture specified by name is found from cache, return the
 167                   cached id.
 168                 - Otherwise generate the texture, add to cache and return id.
 169                   Recursion is used to find out the largest found part of the
 170                   texture and continue based on it.
 171
 172                 The id 0 points to a NULL texture. It is returned in case of error.
 173         */
 174         u32 getTextureIdDirect(const std::string &name);
 175
 176         /*
 177                 Finds out the name of a cached texture.
 178         */
 179         std::string getTextureName(u32 id);
 180
 181         /*
 182                 If texture specified by the name pointed by the id doesn't
 183                 exist, create it, then return the cached texture.
 184
 185                 Can be called from any thread. If called from some other thread
 186                 and not found in cache, the call is queued to the main thread
 187                 for processing.
 188         */
 189         AtlasPointer getTexture(u32 id);
 190
 191         AtlasPointer getTexture(const std::string &name)
 192         {
 193                 return getTexture(getTextureId(name));
 194         }
 195
 196         // Gets a separate texture
 197         video::ITexture* getTextureRaw(const std::string &name)
 198         {
 199                 AtlasPointer ap = getTexture(name);
 200                 return ap.atlas;
 201         }
 202
 203 private:
 204         /*
 205                 Build the main texture atlas which contains most of the
 206                 textures.
 207
 208                 This is called by the constructor.
 209         */
 210         void buildMainAtlas();
 211
 212         // The id of the thread that is allowed to use irrlicht directly
 213         threadid_t m_main_thread;
 214         // The irrlicht device
 215         IrrlichtDevice *m_device;
 216
 217         // A texture id is index in this array.
 218         // The first position contains a NULL texture.
 219         core::array<SourceAtlasPointer> m_atlaspointer_cache;
 220         // Maps a texture name to an index in the former.
 221         core::map<std::string, u32> m_name_to_id;
 222         // The two former containers are behind this mutex
 223         JMutex m_atlaspointer_cache_mutex;
 224
 225         // Main texture atlas. This is filled at startup and is then not touched.
 226         video::IImage *m_main_atlas_image;
 227         video::ITexture *m_main_atlas_texture;
 228
 229         // Queued texture fetches (to be processed by the main thread)
 230         RequestQueue<std::string, u32, u8, u8> m_get_texture_queue;
 231 };
 232
 233 enum MaterialType{
 234         MATERIAL_ALPHA_NONE,
 235         MATERIAL_ALPHA_VERTEX,
 236         MATERIAL_ALPHA_SIMPLE, // >127 = opaque
 237         MATERIAL_ALPHA_BLEND,
 238 };
 239
 240 // Material flags
 241 #define MATERIAL_FLAG_BACKFACE_CULLING 0x01
 242
 243 /*
 244         This fully defines the looks of a tile.
 245         The SMaterial of a tile is constructed according to this.
 246
 247         TODO: Change this to use an AtlasPointer
 248 */
 249 struct TileSpec
 250 {
 251         TileSpec():
 252                 texture(0),
 253                 alpha(255),
 254                 material_type(MATERIAL_ALPHA_NONE),
 255                 // Use this so that leaves don't need a separate material
 256                 //material_type(MATERIAL_ALPHA_SIMPLE),
 257                 material_flags(
 258                         MATERIAL_FLAG_BACKFACE_CULLING
 259                 )
 260         {
 261         }
 262
 263         bool operator==(TileSpec &other)
 264         {
 265                 return (
 266                         texture == other.texture &&
 267                         alpha == other.alpha &&
 268                         material_type == other.material_type &&
 269                         material_flags == other.material_flags
 270                 );
 271         }
 272
 273         // Sets everything else except the texture in the material
 274         void applyMaterialOptions(video::SMaterial &material)
 275         {
 276                 if(alpha != 255 && material_type != MATERIAL_ALPHA_VERTEX)
 277                         dstream<<"WARNING: TileSpec: alpha != 255 "
 278                                         "but not MATERIAL_ALPHA_VERTEX"
 279                                         <<std::endl;
 280
 281                 if(material_type == MATERIAL_ALPHA_NONE)
 282                         material.MaterialType = video::EMT_SOLID;
 283                 else if(material_type == MATERIAL_ALPHA_VERTEX)
 284                         material.MaterialType = video::EMT_TRANSPARENT_VERTEX_ALPHA;
 285                 else if(material_type == MATERIAL_ALPHA_SIMPLE)
 286                         material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
 287                 else if(material_type == MATERIAL_ALPHA_BLEND)
 288                         material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
 289
 290                 material.BackfaceCulling = (material_flags & MATERIAL_FLAG_BACKFACE_CULLING) ? true : false;
 291         }
 292
 293         // NOTE: Deprecated, i guess?
 294         void setTexturePos(u8 tx_, u8 ty_, u8 tw_, u8 th_)
 295         {
 296                 texture.pos = v2f((float)tx_/256.0, (float)ty_/256.0);
 297                 texture.size = v2f(((float)tw_ + 1.0)/256.0, ((float)th_ + 1.0)/256.0);
 298         }
 299
 300         AtlasPointer texture;
 301         // Vertex alpha
 302         u8 alpha;
 303         // Material type
 304         u8 material_type;
 305         // Material flags
 306         u8 material_flags;
 307 };
 308
 309 #endif