texturesource.h

Go to the documentation of this file.

// Luanti
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
#pragma once
 
#include "irrlichttypes.h"
#include <SColor.h>
#include <dimension2d.h>
#include <string>
#include <vector>
 
namespace video
{
        class IImage;
        class ITexture;
}
 
typedef std::vector<video::SColor> Palette;
 
/*
        TextureSource creates and caches textures, which are created from images.
 
        Terminology:
        texture string = e.g. "dirt.png^grass_side.png"
        texture name = can be the same as the texture string
                       or something abstract like "<texture12>"
        texture ID = unique numeric identifier for a texture
        standard texture = refers to a normal 2D texture as you would expect.
                           depending on the support, 2D array textures can exist too.
*/
 
class ISimpleTextureSource
{
public:
        ISimpleTextureSource() = default;
        virtual ~ISimpleTextureSource() = default;
 
        virtual video::ITexture *getTexture(
                        const std::string &name, u32 *id = nullptr) = 0;
};
 
class ITextureSource : public ISimpleTextureSource
{
public:
        ITextureSource() = default;
        virtual ~ITextureSource() = default;
 
        using ISimpleTextureSource::getTexture;
 
        virtual u32 getTextureId(const std::string &image)=0;
 
        virtual std::string getTextureName(u32 id)=0;
 
        virtual video::ITexture *getTexture(u32 id)=0;
 
        virtual video::ITexture *addArrayTexture(
                const std::vector<std::string> &images, u32 *id = nullptr) = 0;
 
        inline video::ITexture *getTextureForMesh(
                        const std::string &image, u32 *id = nullptr)
        {
                if (needFilterForMesh() && !image.empty())
                        return getTexture(image + FILTER_FOR_MESH, id);
                return getTexture(image, id);
        }
 
        virtual bool needFilterForMesh() const = 0;
 
        static constexpr const char *FILTER_FOR_MESH = "^[applyfiltersformesh";
 
        virtual Palette *getPalette(const std::string &image) = 0;
 
        virtual bool isKnownSourceImage(const std::string &name)=0;
 
        virtual core::dimension2du getTextureDimensions(const std::string &image)=0;
 
        virtual video::SColor getTextureAverageColor(const std::string &image)=0;
 
        // Note: this method is here because caching is the decision of the
        // API user, even if his access is read-only.
 
        virtual void setImageCaching(bool enabled) {};
};
 
class IWritableTextureSource : public ITextureSource
{
public:
        IWritableTextureSource() = default;
        virtual ~IWritableTextureSource() = default;
 
        virtual void processQueue()=0;
 
        virtual void insertSourceImage(const std::string &name, video::IImage *img)=0;
 
        virtual void rebuildImagesAndTextures()=0;
};
 
IWritableTextureSource *createTextureSource();