Texture.h

/*
  COPYRIGHT (c) 2012-2024 Esri R&D Center Zurich
  TRADE SECRETS: ESRI PROPRIETARY AND CONFIDENTIAL
  Unpublished material - all rights reserved under the
  Copyright Laws of the United States and applicable international
  laws, treaties, and conventions.

  For additional information, contact:
  Environmental Systems Research Institute, Inc.
  Attn: Contracts and Legal Services Department
  380 New York Street
  Redlands, California, 92373
  USA

  email: contracts@esri.com
*/

#ifndef PRTX_ITEXTURE_H_
#define PRTX_ITEXTURE_H_

#include "prtx/prtx.h"
#include "prtx/URI.h"
#include "prtx/Attributable.h"
#include "prtx/Content.h"

#ifdef _MSC_VER
#   pragma warning(push)
#   pragma warning(disable : 4275 4251)
#endif

#include <memory>


namespace prtx {


class Texture;
typedef std::shared_ptr<Texture> TexturePtr;            
typedef std::vector<TexturePtr>  TexturePtrVector;      


class PRTX_EXPORTS_API Texture : public Attributable, public ComparableContent {
protected:
    Texture();

public:
    virtual ~Texture();

    enum PixelFormat {
        GREY8   = 1, 
        GREY16  = 2, 
        RGB8    = 3, 
        RGBA8   = 4, 
        FLOAT32 = 5, 
    };

    static const std::wstring METADATA_KEY_WIDTH;           
    static const std::wstring METADATA_KEY_HEIGHT;          
    static const std::wstring METADATA_KEY_BYTESPERPIXEL;   
    static const std::wstring METADATA_KEY_FORMAT;          

    static const std::wstring METADATA_KEY_OFFSET;          
    static const std::wstring METADATA_KEY_SCALE;           
    static const std::wstring METADATA_KEY_NODATAVALUE;     
    static const std::wstring METADATA_KEY_GEOTRANSFORM;    
    static const std::wstring METADATA_KEY_UNIT;            
    static const std::wstring METADATA_KEY_PROJECTIONREF;   

    // deprecated, do not use anymore
    static const std::wstring METADATA_KEY_DEPTH;           

    static const double       METADATA_NODATAVALUE_NONE;    

    static uint8_t getBytesPerPixel(PixelFormat format);
    static uint8_t getChannelCount(PixelFormat format);
    static bool hasAlpha(PixelFormat format);
    template<typename S> static S getFormatAsString(PixelFormat format);
    static PixelFormat getFormatFromString(const wchar_t* string);


    virtual prtx::URIPtr getURI() const = 0;

    virtual bool                isValid() const = 0;

    virtual const uint8_t*      getBuffer() const = 0;
    virtual size_t              getBufferSize() const = 0;

    virtual uint32_t            getWidth()  const = 0;
    virtual uint32_t            getHeight() const = 0;
    virtual PixelFormat         getFormat() const = 0;

    virtual const std::wstring& getWarnings() const = 0;
};


template<> PRTX_EXPORTS_API std::wstring Texture::getFormatAsString<std::wstring>(PixelFormat format);
template<> PRTX_EXPORTS_API std::string Texture::getFormatAsString<std::string>(PixelFormat format);


class PRTX_EXPORTS_API TextureBuilder : public AttributableSetter {
public:
    TextureBuilder();
    TextureBuilder(const TextureBuilder&) = delete;
    TextureBuilder& operator=(const TextureBuilder&) = delete;
    virtual ~TextureBuilder();

    TexturePtr createTexture(const prtx::URIPtr& uri, uint32_t width, uint32_t height, const Texture::PixelFormat& format, uint8_t* buffer);
    TexturePtr createTextureAndReset(const prtx::URIPtr& uri, uint32_t width, uint32_t height, const Texture::PixelFormat& format, uint8_t* buffer);

    virtual void setBool            (const std::wstring& key, Bool                       val);
    virtual void setInt             (const std::wstring& key, int32_t                    val);
    virtual void setFloat           (const std::wstring& key, double                     val);
    virtual void setString          (const std::wstring& key, const std::wstring&        val);

    virtual void setBoolArray       (const std::wstring& key, const std::vector<Bool>&   val);
    virtual void setIntArray        (const std::wstring& key, const std::vector<int>&    val);
    virtual void setFloatArray      (const std::wstring& key, const std::vector<double>& val);
    virtual void setStringArray     (const std::wstring& key, const WStringVector&       val);

    virtual void setBlindData       (const std::wstring& key, void*                      val);

private:
    void* mPrivateData;
};


} /* namespace prtx */


#ifdef _MSC_VER
#   pragma warning(pop)
#endif


#endif /* PRTX_ITEXTURE_H_ */