texture.h

/* *   Copyright (c) 2011-2017 Luke Benstead https://simulant-engine.appspot.com
 *
 *     This file is part of Simulant.
 *
 *     Simulant is free software: you can redistribute it and/or modify
 *     it under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 *     Simulant is distributed in the hope that it will be useful,
 *     but WITHOUT ANY WARRANTY; without even the implied warranty of
 *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *     GNU Lesser General Public License for more details.
 *
 *     You should have received a copy of the GNU Lesser General Public License
 *     along with Simulant.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef TEXTURE_H_INCLUDED
#define TEXTURE_H_INCLUDED
 
#include "asset.h"
#include "assets/texture_flags.h"
#include "generic/identifiable.h"
#include "generic/managed.h"
#include "interfaces.h"
#include "loadable.h"
#include "path.h"
#include "types.h"
#include <cstdint>
#include <memory>
#include <queue>
#include <vector>
 
namespace smlt {
 
enum BlurType {
    BLUR_TYPE_SIMPLE,
    BLUR_TYPE_GAUSSIAN,
};
 
/*
 * Simulant intentionally only supports a handful of formats for portability.
 *
 * This list isn't fixed though, if you need more, just file an issue.
 *
 * Format is:
 *
 * {ORDER}_{COUNT}{TYPE}_{LAYOUT}_{COMPRESSION}_{TWIDDLED}
 *
 * Where TYPE is UB (unsigned byte), US (unsigned short)
 * or UI (unsigned int)
 *
 * In some compressed formats the count+type don't make sense
 * in which case they are omitted.
 */
enum TextureFormat {
    TEXTURE_FORMAT_INVALID = 0,
 
    // Standard formats
    TEXTURE_FORMAT_R_1UB_8,
    TEXTURE_FORMAT_RGB_3UB_888,
    TEXTURE_FORMAT_RGBA_4UB_8888,
 
    // Packed short formats
    TEXTURE_FORMAT_RGB_1US_565,
    TEXTURE_FORMAT_RGBA_1US_4444,
    TEXTURE_FORMAT_RGBA_1US_5551,
    TEXTURE_FORMAT_ARGB_1US_1555,
    TEXTURE_FORMAT_ARGB_1US_4444,
    TEXTURE_FORMAT_RGB_1US_565_TWID,
    TEXTURE_FORMAT_ARGB_1US_4444_TWID,
    TEXTURE_FORMAT_ARGB_1US_1555_TWID,
 
    // Paletted formats
    TEXTURE_FORMAT_RGB8_PALETTED4,
    TEXTURE_FORMAT_RGBA8_PALETTED4,
    TEXTURE_FORMAT_RGB565_PALETTED4,
    TEXTURE_FORMAT_RGB8_PALETTED8,
    TEXTURE_FORMAT_RGBA8_PALETTED8,
    TEXTURE_FORMAT_RGB565_PALETTED8,
 
    // Dreamcast PVR VQ compressed
    TEXTURE_FORMAT_RGB_1US_565_VQ_TWID,
    TEXTURE_FORMAT_ARGB_1US_4444_VQ_TWID,
    TEXTURE_FORMAT_ARGB_1US_1555_VQ_TWID,
 
    // PVR VQ Compressed but with mipmap data included
    TEXTURE_FORMAT_RGB_1US_565_VQ_TWID_MIP,
    TEXTURE_FORMAT_ARGB_1US_4444_VQ_TWID_MIP,
    TEXTURE_FORMAT_ARGB_1US_1555_VQ_TWID_MIP
};
 
std::size_t texture_format_stride(TextureFormat format);
std::size_t texture_format_channels(TextureFormat format);
 
bool texture_format_contains_mipmaps(TextureFormat format);
 
class Renderer;
 
enum TextureChannel {
    TEXTURE_CHANNEL_RED,
    TEXTURE_CHANNEL_GREEN,
    TEXTURE_CHANNEL_BLUE,
    TEXTURE_CHANNEL_ALPHA,
    TEXTURE_CHANNEL_ZERO,
    TEXTURE_CHANNEL_ONE,
    TEXTURE_CHANNEL_INVERSE_RED,
};
 
struct Pixel {
    Pixel() = default;
    Pixel(uint8_t r, uint8_t g, uint8_t b, uint8_t a) :
        rgba{r, g, b, a} {}
 
    uint8_t rgba[4];
 
    std::vector<uint8_t> to_format(TextureFormat fmt);
};
 
typedef std::array<TextureChannel, 4> TextureChannelSet;
 
class Texture:
    public Asset,
    public Loadable,
    public generic::Identifiable<AssetID>,
    public RefCounted<Texture>,
    public RenderTarget,
    public ChainNameable<Texture> {
 
public:
    static const TextureChannelSet DEFAULT_SOURCE_CHANNELS;
 
    struct BuiltIns {
        static const std::string CHECKERBOARD;
        static const std::string BUTTON;
    };
 
    typedef std::shared_ptr<Texture> ptr;
    typedef std::vector<uint8_t> Data;
 
    Texture(AssetID id, AssetManager* asset_manager, uint16_t width,
            uint16_t height,
            TextureFormat format = TEXTURE_FORMAT_RGBA_4UB_8888);
    ~Texture();
 
    TextureFormat format() const;
    void set_format(TextureFormat format);
 
    bool is_paletted_format() const;
 
    uint32_t palette_size() const;
 
    bool update_palette(const uint8_t* palette);
 
    /* Applies a blur to the texture, this must be called before
     * a texture is uploaded to the GPU. This function will return false
     * if the blur type is unimplemented (patches welcome!) or the
     * texture data is empty */
    bool blur(BlurType blur_type, std::size_t radius);
 
    /* Returns the byte color data for the specified location. Will return
     * nothing if the texture data is empty, or it's a compressed texture */
    smlt::optional<Pixel> pixel(std::size_t x, std::size_t y);
 
    bool convert(
        TextureFormat new_format,
        const TextureChannelSet& channels = Texture::DEFAULT_SOURCE_CHANNELS);
 
    void resize(uint16_t width, uint16_t height, uint32_t data_size);
 
    void resize(uint16_t width, uint16_t height);
 
    void flip_vertically();
 
    void set_source(const smlt::Path& source);
 
    void set_texture_filter(TextureFilter filter);
 
    void set_free_data_mode(TextureFreeData mode);
 
    void set_texture_wrap(TextureWrap wrap_u, TextureWrap wrap_v,
                          TextureWrap wrap_w);
    void set_texture_wrap_u(TextureWrap wrap_u);
    void set_texture_wrap_v(TextureWrap wrap_v);
    void set_texture_wrap_w(TextureWrap wrap_w);
 
    void set_auto_upload(bool v = true);
    void set_mipmap_generation(MipmapGenerate type);
 
    std::vector<uint8_t> data_copy() const;
 
    const uint8_t* data() const;
 
    uint32_t data_size() const;
 
    static std::size_t required_data_size(TextureFormat fmt, uint16_t width,
                                          uint16_t height);
 
    void set_data(const uint8_t* data, std::size_t size);
    void set_data(const std::vector<uint8_t>& data);
 
    void free();
 
    bool has_data() const;
 
    void flush();
 
    typedef std::function<void(uint8_t*, uint16_t, uint16_t, TextureFormat)>
        MutationFunc;
 
    void mutate_data(MutationFunc func);
 
    uint16_t width() const override;
    uint16_t height() const override;
    Vec2 dimensions() const {
        return Vec2(width(), height());
    }
 
    bool is_compressed() const;
 
    uint8_t channels() const;
 
    void save_to_file(const Path& filename);
 
    Path source() const;
    TextureFilter texture_filter() const;
    TextureWrap wrap_u() const;
    TextureWrap wrap_v() const;
    TextureWrap wrap_w() const;
    MipmapGenerate mipmap_generation() const;
    TextureFreeData free_data_mode() const;
 
    bool on_init() override;
    void on_clean_up() override;
 
    bool has_mipmaps() const;
 
    bool auto_upload() const;
 
    void _set_renderer_specific_id(const uint32_t id);
    uint32_t _renderer_specific_id() const;
 
    void _set_params_clean();
 
    bool _data_dirty() const;
 
    void _set_data_clean();
 
    bool _params_dirty() const;
    void _set_has_mipmaps(bool v);
 
    uint8_t* _stash_paletted_data();
 
private:
    Renderer* renderer_ = nullptr;
 
    uint16_t width_ = 0;
    uint16_t height_ = 0;
 
    TextureFormat format_ = TEXTURE_FORMAT_RGBA_4UB_8888;
 
    Path source_;
 
    bool auto_upload_ =
        true; /* If true, the texture is uploaded by the renderer asap */
 
    void resize_data(uint32_t byte_size);
 
    bool data_dirty_ = true;
    uint8_t* data_ = nullptr;
    uint32_t data_size_ = 0;
 
    /* This is used to store the palette, followed by the index data if:
     * - The format is a paletted format
     * - OES_compressed_paletted_texture is unsupported.
     *
     * If OES_compressed_paletted_texture is supported then paletted data is
     * uploaded directly. If it is not, then we store the paletted_data here
     * and keep it resident in RAM so we can update the main data if the palette
     * changes */
    uint8_t* paletted_data_ = nullptr;
 
    TextureFreeData free_data_mode_ = TEXTURE_FREE_DATA_AFTER_UPLOAD;
 
    MipmapGenerate mipmap_generation_ = MIPMAP_GENERATE_COMPLETE;
    bool has_mipmaps_ = false;
 
    bool params_dirty_ = true;
    TextureFilter filter_ = TEXTURE_FILTER_POINT;
    TextureWrap wrap_u_ = TEXTURE_WRAP_REPEAT;
    TextureWrap wrap_v_ = TEXTURE_WRAP_REPEAT;
    TextureWrap wrap_w_ = TEXTURE_WRAP_REPEAT;
 
    uint32_t renderer_id_ = 0;
};
 
} // namespace smlt
 
#endif // TEXTURE_H_INCLUDED