51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#ifndef TILE_HEADER
-#define TILE_HEADER
+#pragma once
#include "irrlichttypes.h"
-#include "irr_v2d.h"
#include "irr_v3d.h"
#include <ITexture.h>
-#include <IrrlichtDevice.h>
-#include "threads.h"
#include <string>
#include <vector>
+#include <SMaterial.h>
+#include <memory>
+#include "util/numeric.h"
class IGameDef;
+struct TileSpec;
+struct TileDef;
+
+typedef std::vector<video::SColor> Palette;
/*
tile.{h,cpp}: Texture handling stuff.
namespace irr {namespace scene {class IMesh;}}
struct TextureFromMeshParams
{
- scene::IMesh *mesh;
+ scene::IMesh *mesh = nullptr;
core::dimension2d<u32> dim;
std::string rtt_texture_name;
bool delete_texture_on_shutdown;
class ISimpleTextureSource
{
public:
- ISimpleTextureSource(){}
- virtual ~ISimpleTextureSource(){}
+ ISimpleTextureSource() = default;
+
+ virtual ~ISimpleTextureSource() = default;
+
virtual video::ITexture* getTexture(
- const std::string &name, u32 *id = NULL) = 0;
+ const std::string &name, u32 *id = nullptr) = 0;
};
class ITextureSource : public ISimpleTextureSource
{
public:
- ITextureSource(){}
- virtual ~ITextureSource(){}
+ ITextureSource() = default;
+
+ virtual ~ITextureSource() = default;
+
virtual u32 getTextureId(const std::string &name)=0;
virtual std::string getTextureName(u32 id)=0;
virtual video::ITexture* getTexture(u32 id)=0;
virtual video::ITexture* getTexture(
- const std::string &name, u32 *id = NULL)=0;
- virtual IrrlichtDevice* getDevice()=0;
+ const std::string &name, u32 *id = nullptr)=0;
+ virtual video::ITexture* getTextureForMesh(
+ const std::string &name, u32 *id = nullptr) = 0;
+ /*!
+ * Returns a palette from the given texture name.
+ * The pointer is valid until the texture source is
+ * destructed.
+ * Should be called from the main thread.
+ */
+ virtual Palette* getPalette(const std::string &name) = 0;
virtual bool isKnownSourceImage(const std::string &name)=0;
virtual video::ITexture* generateTextureFromMesh(
const TextureFromMeshParams ¶ms)=0;
virtual video::ITexture* getNormalTexture(const std::string &name)=0;
+ virtual video::SColor getTextureAverageColor(const std::string &name)=0;
+ virtual video::ITexture *getShaderFlagsTexture(bool normalmap_present)=0;
};
class IWritableTextureSource : public ITextureSource
{
public:
- IWritableTextureSource(){}
- virtual ~IWritableTextureSource(){}
+ IWritableTextureSource() = default;
+
+ virtual ~IWritableTextureSource() = default;
+
virtual u32 getTextureId(const std::string &name)=0;
virtual std::string getTextureName(u32 id)=0;
virtual video::ITexture* getTexture(u32 id)=0;
virtual video::ITexture* getTexture(
- const std::string &name, u32 *id = NULL)=0;
- virtual IrrlichtDevice* getDevice()=0;
+ const std::string &name, u32 *id = nullptr)=0;
virtual bool isKnownSourceImage(const std::string &name)=0;
virtual video::ITexture* generateTextureFromMesh(
const TextureFromMeshParams ¶ms)=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;
+ virtual video::SColor getTextureAverageColor(const std::string &name)=0;
+ virtual video::ITexture *getShaderFlagsTexture(bool normalmap_present)=0;
};
-IWritableTextureSource* createTextureSource(IrrlichtDevice *device);
+IWritableTextureSource *createTextureSource();
#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
TILE_MATERIAL_LIQUID_TRANSPARENT,
TILE_MATERIAL_LIQUID_OPAQUE,
TILE_MATERIAL_WAVING_LEAVES,
- TILE_MATERIAL_WAVING_PLANTS
+ TILE_MATERIAL_WAVING_PLANTS,
+ TILE_MATERIAL_OPAQUE
};
// Material flags
// Should the crack be drawn on transparent pixels (unset) or not (set)?
// Ignored if MATERIAL_FLAG_CRACK is not set.
#define MATERIAL_FLAG_CRACK_OVERLAY 0x04
-// 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
+#define MATERIAL_FLAG_ANIMATION 0x08
+//#define MATERIAL_FLAG_HIGHLIGHTED 0x10
+#define MATERIAL_FLAG_TILEABLE_HORIZONTAL 0x20
+#define MATERIAL_FLAG_TILEABLE_VERTICAL 0x40
/*
This fully defines the looks of a tile.
*/
struct FrameSpec
{
- FrameSpec():
- texture_id(0),
- texture(NULL),
- normal_texture(NULL)
- {
- }
- u32 texture_id;
- video::ITexture *texture;
- video::ITexture *normal_texture;
+ FrameSpec() = default;
+
+ u32 texture_id = 0;
+ video::ITexture *texture = nullptr;
+ video::ITexture *normal_texture = nullptr;
+ video::ITexture *flags_texture = nullptr;
};
-struct TileSpec
+#define MAX_TILE_LAYERS 2
+
+//! Defines a layer of a tile.
+struct TileLayer
{
- 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)
- {
- }
+ TileLayer() = default;
- bool operator==(const TileSpec &other) const
+ /*!
+ * Two layers are equal if they can be merged.
+ */
+ bool operator==(const TileLayer &other) const
{
- return (
+ return
texture_id == other.texture_id &&
- /* texture == other.texture && */
- alpha == other.alpha &&
material_type == other.material_type &&
material_flags == other.material_flags &&
- rotation == other.rotation
- );
+ color == other.color &&
+ scale == other.scale;
}
- bool operator!=(const TileSpec &other) const
+ /*!
+ * Two tiles are not equal if they must have different vertices.
+ */
+ bool operator!=(const TileLayer &other) const
{
return !(*this == other);
}
-
+
// Sets everything else except the texture in the material
void applyMaterialOptions(video::SMaterial &material) const
{
switch (material_type) {
- case TILE_MATERIAL_BASIC:
- material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
- break;
- case TILE_MATERIAL_ALPHA:
- material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
- break;
- case TILE_MATERIAL_LIQUID_TRANSPARENT:
- material.MaterialType = video::EMT_TRANSPARENT_VERTEX_ALPHA;
- break;
+ case TILE_MATERIAL_OPAQUE:
case TILE_MATERIAL_LIQUID_OPAQUE:
material.MaterialType = video::EMT_SOLID;
break;
+ case TILE_MATERIAL_BASIC:
case TILE_MATERIAL_WAVING_LEAVES:
- material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
- break;
case TILE_MATERIAL_WAVING_PLANTS:
material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
break;
+ case TILE_MATERIAL_ALPHA:
+ case TILE_MATERIAL_LIQUID_TRANSPARENT:
+ material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
+ break;
+ default:
+ break;
+ }
+ material.BackfaceCulling = (material_flags & MATERIAL_FLAG_BACKFACE_CULLING) != 0;
+ if (!(material_flags & MATERIAL_FLAG_TILEABLE_HORIZONTAL)) {
+ material.TextureLayer[0].TextureWrapU = video::ETC_CLAMP_TO_EDGE;
+ }
+ if (!(material_flags & MATERIAL_FLAG_TILEABLE_VERTICAL)) {
+ material.TextureLayer[0].TextureWrapV = video::ETC_CLAMP_TO_EDGE;
}
- material.BackfaceCulling = (material_flags & MATERIAL_FLAG_BACKFACE_CULLING)
- ? true : false;
}
void applyMaterialOptionsWithShaders(video::SMaterial &material) const
{
- material.BackfaceCulling = (material_flags & MATERIAL_FLAG_BACKFACE_CULLING)
- ? true : false;
+ material.BackfaceCulling = (material_flags & MATERIAL_FLAG_BACKFACE_CULLING) != 0;
+ if (!(material_flags & MATERIAL_FLAG_TILEABLE_HORIZONTAL)) {
+ material.TextureLayer[0].TextureWrapU = video::ETC_CLAMP_TO_EDGE;
+ material.TextureLayer[1].TextureWrapU = video::ETC_CLAMP_TO_EDGE;
+ }
+ if (!(material_flags & MATERIAL_FLAG_TILEABLE_VERTICAL)) {
+ material.TextureLayer[0].TextureWrapV = video::ETC_CLAMP_TO_EDGE;
+ material.TextureLayer[1].TextureWrapV = video::ETC_CLAMP_TO_EDGE;
+ }
+ }
+
+ bool isTileable() const
+ {
+ return (material_flags & MATERIAL_FLAG_TILEABLE_HORIZONTAL)
+ && (material_flags & MATERIAL_FLAG_TILEABLE_VERTICAL);
+ }
+
+ // Ordered for size, please do not reorder
+
+ video::ITexture *texture = nullptr;
+ video::ITexture *normal_texture = nullptr;
+ video::ITexture *flags_texture = nullptr;
+
+ u32 shader_id = 0;
+
+ u32 texture_id = 0;
+
+ u16 animation_frame_length_ms = 0;
+ u8 animation_frame_count = 1;
+
+ u8 material_type = TILE_MATERIAL_BASIC;
+ u8 material_flags =
+ //0 // <- DEBUG, Use the one below
+ MATERIAL_FLAG_BACKFACE_CULLING |
+ MATERIAL_FLAG_TILEABLE_HORIZONTAL|
+ MATERIAL_FLAG_TILEABLE_VERTICAL;
+
+ //! If true, the tile has its own color.
+ bool has_color = false;
+
+ std::shared_ptr<std::vector<FrameSpec>> frames = nullptr;
+
+ /*!
+ * The color of the tile, or if the tile does not own
+ * a color then the color of the node owning this tile.
+ */
+ video::SColor color;
+
+ u8 scale;
+};
+
+/*!
+ * Defines a face of a node. May have up to two layers.
+ */
+struct TileSpec
+{
+ TileSpec() {
+ for (auto &layer : layers)
+ layer = TileLayer();
+ }
+
+ /*!
+ * Returns true if this tile can be merged with the other tile.
+ */
+ bool isTileable(const TileSpec &other) const {
+ for (int layer = 0; layer < MAX_TILE_LAYERS; layer++) {
+ if (layers[layer] != other.layers[layer])
+ return false;
+ if (!layers[layer].isTileable())
+ return false;
+ }
+ return rotation == 0
+ && rotation == other.rotation
+ && emissive_light == other.emissive_light;
}
-
- 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::vector<FrameSpec> frames;
-
- u8 rotation;
+
+ //! If true, the tile rotation is ignored.
+ bool world_aligned = false;
+ //! Tile rotation.
+ u8 rotation = 0;
+ //! This much light does the tile emit.
+ u8 emissive_light = 0;
+ //! The first is base texture, the second is overlay.
+ TileLayer layers[MAX_TILE_LAYERS];
};
-#endif
+const std::vector<std::string> &getTextureDirs();
projects / minetest.git / blobdiff