//C++ header - Open Scene Graph - Copyright (C) 1998-2002 Robert Osfield
//Distributed under the terms of the GNU Library General Public License (LGPL)
//as published by the Free Software Foundation.

// -*-c++-*-

#define TEXTURE_USE_DEPRECATED_API
#ifdef TEXTURE_USE_DEPRECATED_API

#ifndef OSG_TEXTURE
#define OSG_TEXTURE 1

#include <osg/TextureBase>
namespace osg {

/** Texture state class which encapsulates OpenGl texture functionality.*/
class SG_EXPORT Texture : public TextureBase
{

    public :
        
        Texture();

        /** Copy constructor using CopyOp to manage deep vs shallow copy.*/
        Texture(const Texture& text,const CopyOp& copyop=CopyOp::SHALLOW_COPY);
        
        META_StateAttribute(osg, Texture,TEXTURE);

        /** return -1 if *this < *rhs, 0 if *this==*rhs, 1 if *this>*rhs.*/
        virtual int compare(const StateAttribute& rhs) const;

        virtual void getAssociatedModes(std::vector<GLMode>& modes) const 
        {
            modes.push_back(GL_TEXTURE_2D);
        }

        /** Set the texture image. */
        void setImage(Image* image);

        /** Get the texture image. */
        Image* getImage() { return _image.get(); }

        /** Get the const texture image. */
        inline const Image* getImage() const { return _image.get(); }

        /** Copy pixels into a 2D texture image.As per glCopyTexImage2D.
          * Creates an OpenGL texture object from the current OpenGL background
          * framebuffer contents at pos \a x, \a y with width \a width and
          * height \a height. \a width and \a height must be a power of two.
          */
        void copyTexImage2D(State& state, int x, int y, int width, int height );

        /** Copy a two-dimensional texture subimage. As per glCopyTexSubImage2D.
          * Updates portion of an existing OpenGL texture object from the current OpenGL background
          * framebuffer contents at pos \a x, \a y with width \a width and
          * height \a height. \a width and \a height must be a power of two,
          * and writing into the texture with offset \a xoffset and \a yoffset.
          */
        void copyTexSubImage2D(State& state, int xoffset, int yoffset, int x, int y, int width, int height );



        /** Set the internal format to use when creating OpenGL textures.
          * Also sets the internalFormatMode to USE_USER_DEFINED_FORMAT.
          */
        inline void setInternalFormatValue(const int internalFormat)
        {
            _internalFormatMode = USE_USER_DEFINED_FORMAT;
            _internalFormat = internalFormat;
        }

        /** Get the internal format to use when creating OpenGL textures.*/
        inline const int getInternalFormatValue() const { return _internalFormat; }
        

        enum SubloadMode {
            OFF,
            AUTO,
            IF_DIRTY,
            USE_CALLBACK
        };

        /** Set the texture subload mode. */
        inline void setSubloadMode(const SubloadMode mode) { _subloadMode = mode; }

        /** Get the texture subload mode. */
        inline const SubloadMode getSubloadMode() const { return _subloadMode; }

        /** Set the texture subload texture offsets. */
        inline void setSubloadTextureOffset(const int x, const int y)
        {
            _subloadTextureOffsetX = x;
            _subloadTextureOffsetY = y;
        }

        /** Get the texture subload texture offsets. */
        inline void getSubloadTextureOffset(int& x, int& y) const
        {
            x = _subloadTextureOffsetX;
            y = _subloadTextureOffsetY;
        }
        
        /** Set the texture subload width. If width or height are zero then
          * the repsective size value is calculated from the source image sizes. */
        inline void setSubloadTextureSize(const int width, const int height) const
        {
            _textureWidth = width;
            _textureHeight = height;
        }

        /** Get the texture subload width. */
        inline void getSubloadTextureSize(int& width, int& height) const
        {
            width = _textureWidth;
            height = _textureHeight;
        }


        /** Set the subload image offsets. */
        inline void setSubloadImageOffset(const int x, const int y)
        {
            _subloadImageOffsetX = x;
            _subloadImageOffsetY = y;
        }

        /** Get the subload image offsets. */
        inline void getSubloadImageOffset(int& x, int& y) const
        {
            x = _subloadImageOffsetX;
            y = _subloadImageOffsetY;
        }

        /** Set the image subload width. If width or height are zero then
          * the repsective size value is calculated from the source image sizes. */
        inline void setSubloadImageSize(const int width, const int height)
        {
            _subloadImageWidth = width;
            _subloadImageHeight = height;
        }

        /** Get the image subload width. */
        inline void getSubloadImageSize(int& width, int& height) const
        {
            width = _subloadImageWidth;
            height = _subloadImageHeight;
        }

        class SubloadCallback : public Referenced
        {
            public:
                virtual void load(GLenum target, const Texture& texture,State& state) const = 0;
                virtual void subload(GLenum target, const Texture& texture,State& state) const = 0;
        };
        
        void setSubloadCallback(SubloadCallback* cb) { _subloadCallback = cb; _subloadMode = cb ? USE_CALLBACK:OFF; }
        
        SubloadCallback* getSubloadCallback() { return _subloadCallback.get(); }

        const SubloadCallback* getSubloadCallback() const { return _subloadCallback.get(); }

        /** Set the number of mip map levels the the texture has been created with,
            should only be called within an osg::Texuture::apply() and custom OpenGL texture load.*/
        void setNumMipmapLevels(unsigned int num) const { _numMimpmapLevels=num; }

        /** Get the number of mip map levels the the texture has been created with.*/
        unsigned int getNumMipmapLevels() const { return _numMimpmapLevels; }
        
        /** On first apply (unless already compiled), create the minmapped 
          * texture and bind it, subsequent apply will simple bind to texture.*/
        virtual void apply(State& state) const;

    protected :

        virtual ~Texture();

        virtual void computeInternalFormat() const;

        // not ideal that _image is mutable, but its required since
        // Image::ensureDimensionsArePowerOfTwo() can only be called
        // in a valid OpenGL context, a therefore within an Texture::apply
        // which is const...
        mutable ref_ptr<Image> _image;

        // subloaded images can have different texture and image sizes.
        mutable GLsizei _textureWidth, _textureHeight;
        
        // number of mip map levels the the texture has been created with,        
        mutable GLsizei _numMimpmapLevels;

        SubloadMode _subloadMode;
        GLint _subloadTextureOffsetX, _subloadTextureOffsetY;
        GLint _subloadImageOffsetX, _subloadImageOffsetY;
        GLsizei _subloadImageWidth, _subloadImageHeight;

        ref_ptr<SubloadCallback> _subloadCallback;
};

}


#endif

#else // USE_DEPRECATED_API

#include <osg/Texture2D>

namespace osg {

    typedef Texture2D Texture;

}

#endif // USE_DEPRECATED_API