/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2003 Robert Osfield 
 *
 * This library is open source and may be redistributed and/or modified under  
 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
 * (at your option) any later version.  The full license is in LICENSE file
 * included with this distribution, and on the openscenegraph.org website.
 * 
 * This library 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 
 * OpenSceneGraph Public License for more details.
*/

#ifndef OSG_TEXTURECUBEMAP
#define OSG_TEXTURECUBEMAP 1

#include <osg/Texture>

#ifndef GL_TEXTURE_CUBE_MAP
#define GL_TEXTURE_CUBE_MAP 0x8513
#endif

namespace osg {

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

    public :
        
        TextureCubeMap();

        /** Copy constructor using CopyOp to manage deep vs shallow copy.*/
        TextureCubeMap(const TextureCubeMap& cm,const CopyOp& copyop=CopyOp::SHALLOW_COPY);

        META_StateAttribute(osg, TextureCubeMap,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_CUBE_MAP);
        }

        enum Face {
            POSITIVE_X=0,
            NEGATIVE_X=1,
            POSITIVE_Y=2,
            NEGATIVE_Y=3,
            POSITIVE_Z=4,
            NEGATIVE_Z=5
        };

        /** Set the texture image for specified face. */
        void setImage(Face, Image* image);

        /** Get the texture image for specified face. */
        Image* getImage(Face);

        /** Get the const texture image for specified face. */
        const Image* getImage(Face) const;


        /** Set the texture width and height. If width or height are zero then
          * the repsective size value is calculated from the source image sizes. */
        inline void setTextureSize(int width, int height) const
        {
            _textureWidth = width;
            _textureHeight = height;
        }

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


        class SubloadCallback : public Referenced
        {
            public:
                virtual void load(const TextureCubeMap& texture,State& state) const = 0;
                virtual void subload(const TextureCubeMap& texture,State& state) const = 0;
        };
        
        void setSubloadCallback(SubloadCallback* cb) { _subloadCallback = cb;; }
        
        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;
        

        /** Extensions class which encapsulates the querring of extensions and
          * associated function pointers, and provide convinience wrappers to 
          * check for the extensions or use the associated functions.*/        
        class Extensions : public osg::Referenced
        {
            public:
                Extensions();

                Extensions(const Extensions& rhs);
                
                void lowestCommonDenominator(const Extensions& rhs);
                
                void setupGLExtenions();

                bool isCubeMapSupported() const { return _isCubeMapSupported; }

            protected:

                ~Extensions() {}
                
                bool    _isCubeMapSupported;

        };
        
        /** Function to call to get the extension of a specified context.
          * If the Exentsion object for that context has not yet been created then 
          * and the 'createIfNotInitalized' flag been set to false then returns NULL.
          * If 'createIfNotInitalized' is true then the Extensions object is 
          * automatically created.  However, in this case the extension object 
          * only be created with the graphics context associated with ContextID..*/
        static const Extensions* getExtensions(unsigned int contextID,bool createIfNotInitalized);

        /** setExtensions allows users to override the extensions across graphics contexts.
          * typically used when you have different extensions supported across graphics pipes
          * but need to ensure that they all use the same low common denominator extensions.*/
        static void setExtensions(unsigned int contextID,Extensions* extensions);


    protected :

        virtual ~TextureCubeMap();
        
        bool imagesValid() const;
        
        virtual void computeInternalFormat() const;

        mutable ref_ptr<Image> _images[6];

        // 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;

        ref_ptr<SubloadCallback> _subloadCallback;
};

}

#endif