Texture.hpp

Go to the documentation of this file.

/**************************************************************************************/
/*                                                                                    */
/*  Visualization Library                                                             */
/*  http://visualizationlibrary.org                                                   */
/*                                                                                    */
/*  Copyright (c) 2005-2020, Michele Bosi                                             */
/*  All rights reserved.                                                              */
/*                                                                                    */
/*  Redistribution and use in source and binary forms, with or without modification,  */
/*  are permitted provided that the following conditions are met:                     */
/*                                                                                    */
/*  - Redistributions of source code must retain the above copyright notice, this     */
/*  list of conditions and the following disclaimer.                                  */
/*                                                                                    */
/*  - Redistributions in binary form must reproduce the above copyright notice, this  */
/*  list of conditions and the following disclaimer in the documentation and/or       */
/*  other materials provided with the distribution.                                   */
/*                                                                                    */
/*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND   */
/*  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED     */
/*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE            */
/*  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR  */
/*  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES    */
/*  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;      */
/*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON    */
/*  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT           */
/*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS     */
/*  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                      */
/*                                                                                    */
/**************************************************************************************/

#ifndef Texture_INCUDE_DEFINE
#define Texture_INCUDE_DEFINE

#include <vlCore/String.hpp>
#include <vlCore/Vector4.hpp>
#include <vlCore/Image.hpp>
#include <vlGraphics/BufferObject.hpp>

namespace vl
{
  class OpenGLContext;

  //------------------------------------------------------------------------------
  // TexParameter
  //------------------------------------------------------------------------------
  class VLGRAPHICS_EXPORT TexParameter: public Object
  {
    VL_INSTRUMENT_CLASS(vl::TexParameter, Object)
    friend class Texture;

  public:
    TexParameter();

    void apply(ETextureDimension dimension, OpenGLContext* gl) const;

    ETexParamFilter minFilter()   const { return mMinFilter; }
    ETexParamFilter magFilter()   const { return mMagfilter; }
    ETexParamWrap wrapS()         const { return mWrapS; }
    ETexParamWrap wrapT()         const { return mWrapT; }
    ETexParamWrap wrapR()         const { return mWrapR; }
    fvec4 borderColor()           const { return mBorderColor; }
    float anisotropy()            const { return mAnisotropy; }
    bool generateMipmap()         const { return mGenerateMipmap; }
    ETexCompareMode compareMode() const { return mCompareMode; }
    ETexCompareFunc compareFunc() const { return mCompareFunc; }
    EDepthTextureMode depthTextureMode() const { return mDepthTextureMode; }

    void setMinFilter(ETexParamFilter minfilter) { mDirty = true; mMinFilter = minfilter; }
    void setMagFilter(ETexParamFilter magfilter);
    void setWrap(ETexParamWrap wrap)             { setWrapS(wrap); setWrapT(wrap); setWrapR(wrap); }
    void setWrapS(ETexParamWrap texturewrap)     { mDirty = true; mWrapS = texturewrap; }
    void setWrapT(ETexParamWrap texturewrap)     { mDirty = true; mWrapT = texturewrap; }
    void setWrapR(ETexParamWrap texturewrap)     { mDirty = true; mWrapR = texturewrap; }
    void setBorderColor(fvec4 bordercolor)       { mDirty = true; mBorderColor = bordercolor; }
    void setAnisotropy(float anisotropy)         { mDirty = true; mAnisotropy = anisotropy; }
    void setGenerateMipmap(bool generate_mipmap) { mDirty = true; mGenerateMipmap = generate_mipmap; }
    void setCompareMode(ETexCompareMode mode) { mDirty = true; mCompareMode = mode; }
    void setCompareFunc(ETexCompareFunc func) { mDirty = true; mCompareFunc = func; }
    void setDepthTextureMode(EDepthTextureMode mode) { mDirty = true; mDepthTextureMode = mode; }

    void setDirty(bool dirty) const { mDirty = dirty; }

    bool dirty() const { return mDirty; }

  protected:
    ETexParamFilter mMinFilter;
    ETexParamFilter mMagfilter;
    ETexParamWrap mWrapS;
    ETexParamWrap mWrapT;
    ETexParamWrap mWrapR;
    ETexCompareMode mCompareMode;
    ETexCompareFunc mCompareFunc;
    EDepthTextureMode mDepthTextureMode;
    fvec4 mBorderColor;
    float mAnisotropy;
    bool mGenerateMipmap;

    mutable bool mDirty;
  };
  //------------------------------------------------------------------------------
  class TextureSampler;
  //------------------------------------------------------------------------------
  // Texture
  //------------------------------------------------------------------------------
  class VLGRAPHICS_EXPORT Texture: public Object
  {
    VL_INSTRUMENT_CLASS(vl::Texture, Object)
    friend class TextureSampler;

  public:
    class SetupParams: public Object
    {
    public:
      SetupParams()
      {
        mDimension  = TD_TEXTURE_2D;
        mFormat     = TF_RGBA;
        mBorder     = false;
        mGenMipmaps = false;
        mWidth = mHeight = mDepth = 0;
        mSamples = 0;
        mFixedSamplesLocation = true;
      }

      void setImagePath(const String& path) { mImagePath = path; }
      const String& imagePath() const { return mImagePath; }

      void setImage(const Image* image) { mImage = image; }
      const Image* image() const { return mImage.get(); }

      const BufferObject* bufferObject() const { return mBufferObject.get(); }
      BufferObject* bufferObject() { return mBufferObject.get(); }
      void setBufferObject(BufferObject* bo) { mBufferObject = bo; }

      void setDimension(ETextureDimension dimension) { mDimension = dimension; }
      ETextureDimension dimension() const { return mDimension; }

      void setFormat(ETextureFormat format) { mFormat = format; }
      ETextureFormat format() const { return mFormat; }

      void setBorder(bool on) { mBorder = on; }
      bool border() const { return mBorder; }

      void setGenMipmaps(bool on) { mGenMipmaps = on; }
      bool genMipmaps() const { return mGenMipmaps; }

      void setWidth(int w) { mWidth = w; }
      int width() const { return mWidth; }

      void setHeight(int h) { mHeight = h; }
      int height() const { return mHeight; }

      void setDepth(int d) { mDepth = d; }
      int depth() const { return mDepth; }

      int samples() const { return mSamples; }
      void setSamples(int samples) { mSamples = samples; }

      bool fixedSamplesLocations() const { return mFixedSamplesLocation; }
      void setFixedSamplesLocations(bool fixed) { mFixedSamplesLocation = fixed; }

    protected:
      String mImagePath;
      ref<BufferObject> mBufferObject;
      ref<Image> mImage;
      ETextureDimension mDimension;
      ETextureFormat mFormat;
      int mWidth, mHeight, mDepth; // used when no image is specified.
      int mSamples;
      bool mBorder;
      bool mGenMipmaps;
      bool mFixedSamplesLocation;
    };

  public:
    Texture(const String& image_path, ETextureFormat format = TF_RGBA, bool mipmaps = true, bool border=false);

    Texture(const Image* image, ETextureFormat format = TF_RGBA, bool mipmaps = true, bool border=false);

    Texture(int width, ETextureFormat format = TF_RGBA, bool border=false);

    Texture(int width, int height, ETextureFormat format = TF_RGBA, bool border=false);

    Texture(int width, int height, int depth, ETextureFormat format = TF_RGBA, bool border=false);

    Texture();

    ~Texture();

    TexParameter* getTexParameter() { return mTexParameter.get(); }

    const TexParameter* getTexParameter() const { return mTexParameter.get(); }

    const TexParameter* getTexParameterOverride() const { return mTexParameterOverride.get(); }

    BufferObject* bufferObject() { return mBufferObject.get(); }

    const BufferObject* bufferObject() const { return mBufferObject.get(); }

    void destroyTexture();

    bool createTexture();

    bool createTexture(ETextureDimension tex_dimension, ETextureFormat tex_format, int w, int h, int d, bool border, BufferObject* bo, int samples, bool fixedsamplelocations);

    bool setMipLevel(int mip_level, const Image* img, bool gen_mipmaps);

    void prepareTexture1D(int width, ETextureFormat format, bool border=false)
    {
      prepareTexture1D(NULL, format, false, border);
      mSetupParams->setWidth(width);
    }

    bool createTexture1D(int width, ETextureFormat format, bool border=false)
    {
      prepareTexture1D(width, format, border);
      return createTexture();
    }

    void prepareTexture1D(const String& image_path, ETextureFormat format, bool mipmaps=true, bool border=false)
    {
      prepareTexture1D(NULL, format, mipmaps, border);
      mSetupParams->setImagePath(image_path);
    }

    bool createTexture1D(const String& image_path, ETextureFormat format, bool mipmaps=true, bool border=false)
    {
      prepareTexture1D(image_path, format, mipmaps, border);
      return createTexture();
    }

    void prepareTexture1D(const Image* image, ETextureFormat format, bool mipmaps=true, bool border=false)
    {
      mSetupParams = new SetupParams;
      mSetupParams->setImage(image);
      mSetupParams->setDimension(TD_TEXTURE_1D);
      mSetupParams->setFormat(format);
      mSetupParams->setGenMipmaps(mipmaps);
      mSetupParams->setBorder(border);
    }

    bool createTexture1D(const Image* image, ETextureFormat format, bool mipmaps=true, bool border=false)
    {
      prepareTexture1D(image, format, mipmaps, border);
      return createTexture();
    }

    void prepareTexture2D(int width, int height, ETextureFormat format, bool border=false)
    {
      prepareTexture2D(NULL, format, false, border);
      mSetupParams->setWidth(width);
      mSetupParams->setHeight(height);
    }

    bool createTexture2D(int width, int height, ETextureFormat format, bool border=false)
    {
      prepareTexture2D(width, height, format, border);
      return createTexture();
    }

    void prepareTexture2D(const String& image_path, ETextureFormat format, bool mipmaps=true, bool border=false)
    {
      prepareTexture2D(NULL, format, mipmaps, border);
      mSetupParams->setImagePath(image_path);
    }

    bool createTexture2D(const String& image_path, ETextureFormat format, bool mipmaps=true, bool border=false)
    {
      prepareTexture2D(image_path, format, mipmaps, border);
      return createTexture();
    }

    void prepareTexture2D(const Image* image, ETextureFormat format, bool mipmaps=true, bool border=false)
    {
      mSetupParams = new SetupParams;
      mSetupParams->setImage(image);
      mSetupParams->setDimension(TD_TEXTURE_2D);
      mSetupParams->setFormat(format);
      mSetupParams->setGenMipmaps(mipmaps);
      mSetupParams->setBorder(border);
    }

    bool createTexture2D(const Image* image, ETextureFormat format, bool mipmaps=true, bool border=false)
    {
      prepareTexture2D(image, format, mipmaps, border);
      return createTexture();
    }

    void prepareTexture3D(int width, int height, int depth, ETextureFormat format, bool border=false)
    {
      prepareTexture3D(NULL, format, false, border);
      mSetupParams->setWidth(width);
      mSetupParams->setHeight(height);
      mSetupParams->setDepth(depth);
    }

    bool createTexture3D(int width, int height, int depth, ETextureFormat format, bool border=false)
    {
      prepareTexture3D(width, height, depth, format, border);
      return createTexture();
    }

    void prepareTexture3D(const String& image_path, ETextureFormat format, bool mipmaps=true, bool border=false)
    {
      prepareTexture3D(NULL, format, mipmaps, border);
      mSetupParams->setImagePath(image_path);
    }

    bool createTexture3D(const String& image_path, ETextureFormat format, bool mipmaps=true, bool border=false)
    {
      prepareTexture3D(image_path, format, mipmaps, border);
      return createTexture();
    }

    void prepareTexture3D(const Image* image, ETextureFormat format, bool mipmaps=true, bool border=false)
    {
      mSetupParams = new SetupParams;
      mSetupParams->setImage(image);
      mSetupParams->setDimension(TD_TEXTURE_3D);
      mSetupParams->setFormat(format);
      mSetupParams->setGenMipmaps(mipmaps);
      mSetupParams->setBorder(border);
    }

    bool createTexture3D(const Image* image, ETextureFormat format, bool mipmaps=true, bool border=false)
    {
      prepareTexture3D(image, format, mipmaps, border);
      return createTexture();
    }

    void prepareTextureCubemap(int width, int height, ETextureFormat format, bool border=false)
    {
      prepareTextureCubemap(NULL, format, false, border);
      mSetupParams->setWidth(width);
      mSetupParams->setHeight(height);
    }

    bool createTextureCubemap(int width, int height, ETextureFormat format, bool border=false)
    {
      prepareTextureCubemap(width, height, format, border);
      return createTexture();
    }

    void prepareTextureCubemap(const String& image_path, ETextureFormat format, bool mipmaps=true, bool border=false)
    {
      prepareTextureCubemap(NULL, format, mipmaps, border);
      mSetupParams->setImagePath(image_path);
    }

    bool createTextureCubemap(const String& image_path, ETextureFormat format, bool mipmaps=true, bool border=false)
    {
      prepareTextureCubemap(image_path, format, mipmaps, border);
      return createTexture();
    }

    void prepareTextureCubemap(const Image* image, ETextureFormat format, bool mipmaps=true, bool border=false)
    {
      mSetupParams = new SetupParams;
      mSetupParams->setImage(image);
      mSetupParams->setDimension(TD_TEXTURE_CUBE_MAP);
      mSetupParams->setFormat(format);
      mSetupParams->setGenMipmaps(mipmaps);
      mSetupParams->setBorder(border);
    }

    bool createTextureCubemap(const Image* image, ETextureFormat format, bool mipmaps=true, bool border=false)
    {
      prepareTextureCubemap(image, format, mipmaps, border);
      return createTexture();
    }

    void prepareTexture1DArray(int width, int count, ETextureFormat format)
    {
      prepareTexture1DArray(NULL, format, false);
      mSetupParams->setWidth(width);
      mSetupParams->setHeight(count);
    }

    bool createTexture1DArray(int width, int count, ETextureFormat format)
    {
      prepareTexture1DArray(width, count, format);
      return createTexture();
    }

    void prepareTexture1DArray(const String& image_path, ETextureFormat format, bool mipmaps=true)
    {
      prepareTexture1DArray(NULL, format, mipmaps);
      mSetupParams->setImagePath(image_path);
    }

    bool createTexture1DArray(const String& image_path, ETextureFormat format, bool mipmaps=true)
    {
      prepareTexture1DArray(image_path, format, mipmaps);
      return createTexture();
    }

    void prepareTexture1DArray(const Image* image, ETextureFormat format, bool mipmaps=true)
    {
      mSetupParams = new SetupParams;
      mSetupParams->setImage(image);
      mSetupParams->setDimension(TD_TEXTURE_1D_ARRAY);
      mSetupParams->setFormat(format);
      mSetupParams->setGenMipmaps(mipmaps);
      mSetupParams->setBorder(false);
    }

    bool createTexture1DArray(const Image* image, ETextureFormat format, bool mipmaps=true)
    {
      prepareTexture1DArray(image, format, mipmaps);
      return createTexture();
    }

    void prepareTexture2DArray(int width, int height, int count, ETextureFormat format)
    {
      prepareTexture2DArray(NULL, format, false);
      mSetupParams->setWidth(width);
      mSetupParams->setHeight(height);
      mSetupParams->setDepth(count);
    }

    bool createTexture2DArray(int width, int height, int count, ETextureFormat format)
    {
      prepareTexture2DArray(width, height, count, format);
      return createTexture();
    }

    void prepareTexture2DArray(const String& image_path, ETextureFormat format, bool mipmaps=true)
    {
      prepareTexture2DArray(NULL, format, mipmaps);
      mSetupParams->setImagePath(image_path);
    }

    bool createTexture2DArray(const String& image_path, ETextureFormat format, bool mipmaps=true)
    {
      prepareTexture2DArray(image_path, format, mipmaps);
      return createTexture();
    }

    void prepareTexture2DArray(const Image* image, ETextureFormat format, bool mipmaps=true)
    {
      mSetupParams = new SetupParams;
      mSetupParams->setImage(image);
      mSetupParams->setDimension(TD_TEXTURE_2D_ARRAY);
      mSetupParams->setFormat(format);
      mSetupParams->setGenMipmaps(mipmaps);
      mSetupParams->setBorder(false);
    }

    bool createTexture2DArray(const Image* image, ETextureFormat format, bool mipmaps=true)
    {
      prepareTexture2DArray(image, format, mipmaps);
      return createTexture();
    }

    void prepareTextureRectangle(int width, int height, ETextureFormat format)
    {
      prepareTextureRectangle(NULL, format);
      mSetupParams->setWidth(width);
      mSetupParams->setHeight(height);
    }

    bool createTextureRectangle(int width, int height, ETextureFormat format)
    {
      prepareTextureRectangle(width, height, format);
      return createTexture();
    }

    void prepareTextureRectangle(const String& image_path, ETextureFormat format)
    {
      prepareTextureRectangle(NULL, format);
      mSetupParams->setImagePath(image_path);
    }

    bool createTextureRectangle(const String& image_path, ETextureFormat format)
    {
      prepareTextureRectangle(image_path, format);
      return createTexture();
    }

    void prepareTextureRectangle(const Image* image, ETextureFormat format)
    {
      mSetupParams = new SetupParams;
      mSetupParams->setImage(image);
      mSetupParams->setDimension(TD_TEXTURE_RECTANGLE);
      mSetupParams->setFormat(format);
      mSetupParams->setGenMipmaps(false);
      mSetupParams->setBorder(false);
    }

    bool createTextureRectangle(const Image* image, ETextureFormat format)
    {
      prepareTextureRectangle(image, format);
      return createTexture();
    }

    void prepareTextureBuffer(vl::ETextureFormat format, BufferObject* bo)
    {
      mSetupParams = new SetupParams;
      mSetupParams->setDimension(TD_TEXTURE_BUFFER);
      mSetupParams->setFormat(format);
      mSetupParams->setBufferObject(bo);
      mSetupParams->setGenMipmaps(false);
      mSetupParams->setBorder(false);
    }

    bool createTextureBuffer(vl::ETextureFormat format, BufferObject* bo)
    {
      prepareTextureBuffer(format, bo);
      return createTexture();
    }

    void prepareTexture2DMultisample(int width, int height, vl::ETextureFormat format, int samples, bool fixedsamplelocations)
    {
      mSetupParams = new SetupParams;
      mSetupParams->setDimension(TD_TEXTURE_2D_MULTISAMPLE);
      mSetupParams->setWidth(width);
      mSetupParams->setHeight(height);
      mSetupParams->setFormat(format);
      mSetupParams->setSamples(samples);
      mSetupParams->setFixedSamplesLocations(fixedsamplelocations);
      mSetupParams->setGenMipmaps(false);
      mSetupParams->setBorder(false);
    }

    bool createTexture2DMultisample(int width, int height, vl::ETextureFormat format, int samples, bool fixedsamplelocations)
    {
      prepareTexture2DMultisample(width, height, format, samples, fixedsamplelocations);
      return createTexture();
    }

    void prepareTexture2DMultisampleArray(int width, int height, int depth, vl::ETextureFormat format, int samples, bool fixedsamplelocations)
    {
      mSetupParams = new SetupParams;
      mSetupParams->setDimension(TD_TEXTURE_2D_MULTISAMPLE_ARRAY);
      mSetupParams->setWidth(width);
      mSetupParams->setHeight(height);
      mSetupParams->setDepth(depth);
      mSetupParams->setFormat(format);
      mSetupParams->setSamples(samples);
      mSetupParams->setFixedSamplesLocations(fixedsamplelocations);
      mSetupParams->setGenMipmaps(false);
      mSetupParams->setBorder(false);
    }

    bool createTexture2DMultisampleArray(int width, int height, int depth, vl::ETextureFormat format, int samples, bool fixedsamplelocations)
    {
      prepareTexture2DMultisampleArray(width, height, depth, format, samples, fixedsamplelocations);
      return createTexture();
    }

    void setHandle(unsigned int id, bool managed = true ) { mHandle = id; mManaged = managed; }
    unsigned int handle() const { return mHandle; }

    void setManaged( bool managed ) { mManaged = managed; }
    bool managed() const { return mManaged; }

    void setDimension(ETextureDimension dimension) { mDimension = dimension; }
    ETextureDimension dimension() const { return mDimension; }

    void setInternalFormat(ETextureFormat format) { mFormat = format; }
    ETextureFormat internalFormat() const { return mFormat; }

    void setWidth(int x)  { mWidth = x; }
    int width() const { return mWidth; }

    void setHeight(int y) { mHeight = y; }
    int height() const { return mHeight; }

    void setDepth(int z)  { mDepth = z; }
    int depth() const { return mDepth; }

    void setBorder(bool border) { mBorder = border; }
    bool border() const { return mBorder; }

    void setSamples(int samples) { mSamples = samples; }
    int samples() const { return mSamples; }

    void setFixedSamplesLocation(bool fixed) { mFixedSamplesLocation = fixed; }
    bool fixedSamplesLocation() const { return mFixedSamplesLocation; }

    void setSetupParams(SetupParams* setup_params) { mSetupParams = setup_params; }

    const SetupParams* setupParams() const { return mSetupParams.get(); }

    SetupParams* setupParams() { return mSetupParams.get(); }

    bool isValid() const;

    bool isDepthTexture() const;

    void clone(const Texture& other);

    static bool supports(ETextureDimension tex_dimension, ETextureFormat tex_format, int mip_level, EImageDimension img_dimension, int w, int h, int d, bool border, int samples, bool fixedsamplelocations, bool verbose);

    static bool isCompressedFormat(int format);

  private:
    Texture(const Texture& other): Object(other) {}
    void operator=(const Texture&) {}
    // TexParameter is not reset but is marked dirty
    void reset();

  protected:
    unsigned int mHandle;
    bool mManaged;
    ref<TexParameter> mTexParameter;
    mutable ref<TexParameter> mTexParameterOverride;
    ref<SetupParams> mSetupParams;
    ref<BufferObject> mBufferObject;
    ETextureFormat mFormat;
    ETextureDimension mDimension;
    int mWidth;
    int mHeight;
    int mDepth;
    int mSamples;
    bool mBorder;
    bool mFixedSamplesLocation;
  };
}

#endif