Split settings into seperate source and header files

[oweals/minetest.git] / src / tile.h

diff --git a/src/tile.h b/src/tile.h
index b748c092ea9ef0c21c6784fb678d7badfe55fa37..78aaef00e2be36c0971f7efbbf0e7644080fbe6a 100644 (file)
--- a/src/tile.h
+++ b/src/tile.h
@@ -27,6 +27,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include <IrrlichtDevice.h>
 #include "threads.h"
 #include <string>
+#include <map>
 
 class IGameDef;
 
@@ -97,7 +98,6 @@ public:
        ITextureSource(){}
        virtual ~ITextureSource(){}
        virtual u32 getTextureId(const std::string &name)=0;
-       virtual u32 getTextureIdDirect(const std::string &name)=0;
        virtual std::string getTextureName(u32 id)=0;
        virtual video::ITexture* getTexture(u32 id)=0;
        virtual video::ITexture* getTexture(
@@ -106,6 +106,7 @@ public:
        virtual bool isKnownSourceImage(const std::string &name)=0;
        virtual video::ITexture* generateTextureFromMesh(
                        const TextureFromMeshParams &params)=0;
+       virtual video::ITexture* getNormalTexture(const std::string &name)=0;
 };
 
 class IWritableTextureSource : public ITextureSource
@@ -114,7 +115,6 @@ public:
        IWritableTextureSource(){}
        virtual ~IWritableTextureSource(){}
        virtual u32 getTextureId(const std::string &name)=0;
-       virtual u32 getTextureIdDirect(const std::string &name)=0;
        virtual std::string getTextureName(u32 id)=0;
        virtual video::ITexture* getTexture(u32 id)=0;
        virtual video::ITexture* getTexture(
@@ -127,17 +127,37 @@ public:
        virtual void processQueue()=0;
        virtual void insertSourceImage(const std::string &name, video::IImage *img)=0;
        virtual void rebuildImagesAndTextures()=0;
+       virtual video::ITexture* getNormalTexture(const std::string &name)=0;
 };
 
 IWritableTextureSource* createTextureSource(IrrlichtDevice *device);
 
+#ifdef __ANDROID__
+/**
+ * @param size get next npot2 value
+ * @return npot2 value
+ */
+inline unsigned int npot2(unsigned int size)
+{
+       if (size == 0) return 0;
+       unsigned int npot = 1;
+
+       while ((size >>= 1) > 0) {
+               npot <<= 1;
+       }
+       return npot;
+}
+
+video::IImage * Align2Npot2(video::IImage * image, video::IVideoDriver* driver);
+#endif
+
 enum MaterialType{
        TILE_MATERIAL_BASIC,
        TILE_MATERIAL_ALPHA,
        TILE_MATERIAL_LIQUID_TRANSPARENT,
        TILE_MATERIAL_LIQUID_OPAQUE,
-       TILE_MATERIAL_LEAVES,
-       TILE_MATERIAL_PLANTS
+       TILE_MATERIAL_WAVING_LEAVES,
+       TILE_MATERIAL_WAVING_PLANTS
 };
 
 // Material flags
@@ -151,22 +171,38 @@ enum MaterialType{
 // Animation made up by splitting the texture to vertical frames, as
 // defined by extra parameters
 #define MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES 0x08
+#define MATERIAL_FLAG_HIGHLIGHTED 0x10
 
 /*
        This fully defines the looks of a tile.
        The SMaterial of a tile is constructed according to this.
 */
+struct FrameSpec
+{
+       FrameSpec():
+               texture_id(0),
+               texture(NULL),
+               normal_texture(NULL)
+       {
+       }
+       u32 texture_id;
+       video::ITexture *texture;
+       video::ITexture *normal_texture;
+};
+
 struct TileSpec
 {
        TileSpec():
                texture_id(0),
                texture(NULL),
+               normal_texture(NULL),
                alpha(255),
                material_type(TILE_MATERIAL_BASIC),
                material_flags(
                        //0 // <- DEBUG, Use the one below
                        MATERIAL_FLAG_BACKFACE_CULLING
                ),
+               shader_id(0),
                animation_frame_count(1),
                animation_frame_length_ms(0),
                rotation(0)
@@ -206,55 +242,36 @@ struct TileSpec
                case TILE_MATERIAL_LIQUID_OPAQUE:
                        material.MaterialType = video::EMT_SOLID;
                        break;
-               case TILE_MATERIAL_LEAVES:
+               case TILE_MATERIAL_WAVING_LEAVES:
                        material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
                        break;
-               case TILE_MATERIAL_PLANTS:
+               case TILE_MATERIAL_WAVING_PLANTS:
                        material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
                break;
                }
                material.BackfaceCulling = (material_flags & MATERIAL_FLAG_BACKFACE_CULLING) ? true : false;
        }
-       void applyMaterialOptionsWithShaders(video::SMaterial &material,
-                       const video::E_MATERIAL_TYPE &basic,
-                       const video::E_MATERIAL_TYPE &liquid,
-                       const video::E_MATERIAL_TYPE &alpha,
-                       const video::E_MATERIAL_TYPE &leaves,
-                       const video::E_MATERIAL_TYPE &plants) const
+
+       void applyMaterialOptionsWithShaders(video::SMaterial &material) const
        {
-               switch(material_type){
-               case TILE_MATERIAL_BASIC:
-                       material.MaterialType = basic;
-                       break;
-               case TILE_MATERIAL_ALPHA:
-                       material.MaterialType = alpha;
-                       break;
-               case TILE_MATERIAL_LIQUID_TRANSPARENT:
-                       material.MaterialType = liquid;
-                       break;
-               case TILE_MATERIAL_LIQUID_OPAQUE:
-                       material.MaterialType = liquid;
-                       break;
-               case TILE_MATERIAL_LEAVES:
-                       material.MaterialType = leaves;
-                       break;
-               case TILE_MATERIAL_PLANTS:
-                       material.MaterialType = plants;
-                       break;
-               }
                material.BackfaceCulling = (material_flags & MATERIAL_FLAG_BACKFACE_CULLING) ? true : false;
        }
        
        u32 texture_id;
        video::ITexture *texture;
+       video::ITexture *normal_texture;
+       
        // Vertex alpha (when MATERIAL_ALPHA_VERTEX is used)
        u8 alpha;
        // Material parameters
        u8 material_type;
        u8 material_flags;
+       u32 shader_id;
        // Animation parameters
        u8 animation_frame_count;
        u16 animation_frame_length_ms;
+       std::map<u32, FrameSpec> frames;
+
        u8 rotation;
 };