include/cinder/gl/Texture.h

Go to the documentation of this file.

/*
 Copyright (c) 2010, The Barbarian Group
 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.
*/

#pragma once

#include "cinder/Cinder.h"
#include "cinder/gl/gl.h"
#include "cinder/Surface.h"
#include "cinder/Rect.h"
#include "cinder/Stream.h"

#include <vector>
#include <utility>

namespace cinder { namespace gl {

class Texture;
typedef std::shared_ptr<Texture>    TextureRef;

class Texture {
  public:
    struct Format;

    // Create analogs for constructors
    static TextureRef create( int width, int height, Format format = Format() ) { return std::make_shared<Texture>( width, height, format ); }
    static TextureRef create( const unsigned char *data, int dataFormat, int width, int height, Format format = Format() ) { return std::make_shared<Texture>( data, dataFormat, width, height, format ); }
    static TextureRef create( const Surface8u &surface, Format format = Format() ) { return std::make_shared<Texture>( surface, format ); }
    static TextureRef create( const Surface32f &surface, Format format = Format() ) { return std::make_shared<Texture>( surface, format ); }
    static TextureRef create( const Channel8u &channel, Format format = Format() ) { return std::make_shared<Texture>( channel, format ); }
    static TextureRef create( const Channel32f &channel, Format format = Format() ) { return std::make_shared<Texture>( channel, format ); }
    static TextureRef create( ImageSourceRef imageSource, Format format = Format() ) { return std::make_shared<Texture>( imageSource, format ); }
    static TextureRef create( GLenum target, GLuint textureId, int width, int height, bool doNotDispose ) { return std::make_shared<Texture>( target, textureId, width, height, doNotDispose ); }

  public:
    Texture() {}
    Texture( int aWidth, int aHeight, Format format = Format() );
    Texture( const unsigned char *data, int dataFormat, int aWidth, int aHeight, Format format = Format() );
    Texture( const Surface8u &surface, Format format = Format() );
    Texture( const Surface32f &surface, Format format = Format() );
    Texture( const Channel8u &channel, Format format = Format() );
    Texture( const Channel32f &channel, Format format = Format() );
    Texture( ImageSourceRef imageSource, Format format = Format() );
    Texture( GLenum aTarget, GLuint aTextureID, int aWidth, int aHeight, bool aDoNotDispose );

  public:
    void            setDoNotDispose( bool aDoNotDispose = true ) { mObj->mDoNotDispose = aDoNotDispose; }
    void            setDeallocator( void(*aDeallocatorFunc)( void * ), void *aDeallocatorRefcon );
    void            setWrap( GLenum wrapS, GLenum wrapT ) { setWrapS( wrapS ); setWrapT( wrapT ); }
    void            setWrapS( GLenum wrapS );
    void            setWrapT( GLenum wrapT );
    void            setMinFilter( GLenum minFilter );   
    void            setMagFilter( GLenum magFilter );

    void            setCleanTexCoords( float maxU, float maxV );

    void            update( const Surface &surface );
    void            update( const Surface32f &surface );
    void            update( const Surface &surface, const Area &area );
    void            update( const Channel32f &channel );
    void            update( const Channel8u &channel, const Area &area );
    
    GLint           getWidth() const;
    GLint           getHeight() const;
    GLint           getCleanWidth() const;
    GLint           getCleanHeight() const;
    Vec2i           getSize() const { return Vec2i( getWidth(), getHeight() ); }    
    float           getAspectRatio() const { return getWidth() / (float)getHeight(); }
    Area            getBounds() const { return Area( 0, 0, getWidth(), getHeight() ); }
    Area            getCleanBounds() const { return Area( 0, 0, getCleanWidth(), getCleanHeight() ); }
    bool            hasAlpha() const;
    float           getLeft() const;
    float           getRight() const;   
    float           getTop() const;     
    float           getBottom() const;  
    float           getMaxU() const;
    float           getMaxV() const;
    Rectf           getAreaTexCoords( const Area &area ) const;
    GLint           getInternalFormat() const;
    GLuint          getId() const { return mObj->mTextureID; }
    GLenum          getTarget() const { return mObj->mTarget; }
    bool            isFlipped() const { return mObj->mFlipped; }
    void            setFlipped( bool aFlipped = true ) { mObj->mFlipped = aFlipped; }

    void            enableAndBind() const;
    void            disable() const;
    void            bind( GLuint textureUnit = 0 ) const;
    void            unbind( GLuint textureUnit = 0 ) const;

    static Texture  loadDds( IStreamRef ddsStream, Format format );

    static void     SurfaceChannelOrderToDataFormatAndType( const SurfaceChannelOrder &sco, GLint *dataFormat, GLenum *type );
    static bool     dataFormatHasAlpha( GLint dataFormat );
    static bool     dataFormatHasColor( GLint dataFormat );

    Texture         weakClone() const;

#if ! defined( CINDER_GLES )    

    operator    ImageSourceRef() const;
#endif
    
    struct Format {
        Format();
        
        void    setTarget( GLenum target ) { mTarget = target; }
#ifndef CINDER_GLES
        void    setTargetRect() { mTarget = GL_TEXTURE_RECTANGLE_ARB; }
#endif      

        void    enableMipmapping( bool enableMipmapping = true ) { mMipmapping = enableMipmapping; }

        void    setInternalFormat( GLint internalFormat ) { mInternalFormat = internalFormat; }
        void    setAutoInternalFormat() { mInternalFormat = -1; }       
        
        void    setWrap( GLenum wrapS, GLenum wrapT ) { setWrapS( wrapS ); setWrapT( wrapT ); }
        void    setWrapS( GLenum wrapS ) { mWrapS = wrapS; }
        void    setWrapT( GLenum wrapT ) { mWrapT = wrapT; }
        void    setMinFilter( GLenum minFilter ) { mMinFilter = minFilter; }
        void    setMagFilter( GLenum magFilter ) { mMagFilter = magFilter; }
                
        GLenum  getTarget() const { return mTarget; }
        bool    hasMipmapping() const { return mMipmapping; }

        GLint   getInternalFormat() const { return mInternalFormat; }
        bool    isAutoInternalFormat() const { return mInternalFormat == -1; }
        
        GLenum  getWrapS() const { return mWrapS; }
        GLenum  getWrapT() const { return mWrapT; }
        GLenum  getMinFilter() const { return mMinFilter; }
        GLenum  getMagFilter() const { return mMagFilter; }
        
      protected:
        GLenum          mTarget;
        GLenum          mWrapS, mWrapT;
        GLenum          mMinFilter, mMagFilter;
        bool            mMipmapping;
        GLint           mInternalFormat;
        
        friend class Texture;
    };

 protected:
    void    init( const unsigned char *data, int unpackRowLength, GLenum dataFormat, GLenum type, const Format &format );   
    void    init( const float *data, GLint dataFormat, const Format &format );
    void    init( ImageSourceRef imageSource, const Format &format );   
            
    struct Obj {
        Obj() : mWidth( -1 ), mHeight( -1 ), mCleanWidth( -1 ), mCleanHeight( -1 ), mInternalFormat( -1 ), mTextureID( 0 ), mFlipped( false ), mDeallocatorFunc( 0 ) {}
        Obj( int aWidth, int aHeight ) : mInternalFormat( -1 ), mWidth( aWidth ), mHeight( aHeight ), mCleanWidth( aWidth ), mCleanHeight( aHeight ), mFlipped( false ), mTextureID( 0 ), mDeallocatorFunc( 0 )  {}
        ~Obj();

        mutable GLint   mWidth, mHeight, mCleanWidth, mCleanHeight;
        float           mMaxU, mMaxV;
        mutable GLint   mInternalFormat;
        GLenum          mTarget;
        GLuint          mTextureID;
        bool            mDoNotDispose;
        bool            mFlipped;   
        void            (*mDeallocatorFunc)(void *refcon);
        void            *mDeallocatorRefcon;            
    };
    std::shared_ptr<Obj>        mObj;

  public:

    typedef std::shared_ptr<Obj> Texture::*unspecified_bool_type;
    operator unspecified_bool_type() const { return ( mObj.get() == 0 ) ? 0 : &Texture::mObj; }
    void reset() { mObj.reset(); }
};

class TextureCache {
 public:
    TextureCache() {}
    TextureCache( const Surface8u &prototypeSurface, const Texture::Format &format );
    
    gl::Texture     cache( const Surface8u &data );
    
  protected:
    struct Obj {
        Obj( const Surface8u &prototypeSurface, const Texture::Format &format );

        void        markTextureAsFree( int id );

        int             mWidth, mHeight;
        Texture::Format mFormat;
        
        int                                         mNextId;
        std::vector<std::pair<int,gl::Texture> >    mTextures;
        
        static void TextureCacheDeallocator( void *aDeallocatorRefcon );
    };
 
    std::shared_ptr<Obj>        mObj;

  public:

    typedef std::shared_ptr<Obj> TextureCache::*unspecified_bool_type;
    operator unspecified_bool_type() const { return ( mObj.get() == 0 ) ? 0 : &TextureCache::mObj; }
    void reset() { mObj.reset(); }
};


class SurfaceConstraintsGLTexture : public SurfaceConstraints {
 public:
    virtual SurfaceChannelOrder getChannelOrder( bool alpha ) const { return ( alpha ) ? SurfaceChannelOrder::BGRA : SurfaceChannelOrder::BGR; }
    virtual int32_t             getRowBytes( int requestedWidth, const SurfaceChannelOrder &sco, int elementSize ) const { return requestedWidth * elementSize * sco.getPixelInc(); }
};

class TextureDataExc : public std::exception {
public: 
    TextureDataExc( const std::string &log ) throw();
    virtual const char* what() const throw()
    {
        return mMessage;
    }

private:
    char    mMessage[16001];
    GLint   mShaderType;
};


} } // namespace cinder::gl