OSDLOpenGL.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2003-2009 Olivier Boudeville
 *
 * This file is part of the OSDL library.
 *
 * The OSDL library is free software: you can redistribute it and/or modify
 * it under the terms of either the GNU Lesser General Public License or
 * the GNU General Public License, as they are published by the Free Software
 * Foundation, either version 3 of these Licenses, or (at your option) 
 * any later version.
 *
 * The OSDL 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
 * GNU Lesser General Public License and the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License and of the GNU General Public License along with the OSDL library.
 * If not, see <http://www.gnu.org/licenses/>.
 *
 * Author: Olivier Boudeville (olivier.boudeville@esperide.com)
 *
 */


#ifndef OSDL_OPENGL_H_
#define OSDL_OPENGL_H_


#include "OSDLVideoTypes.h"  // for VideoException
#include "OSDLPixel.h"       // for ColorDefinition, ColorMask, etc.
#include "OSDLPoint2D.h"     // for Point2D::Origin

#include "Ceylan.h"          // for Uint8, Uint32, inheritance




#if ! defined(OSDL_USES_SDL) || OSDL_USES_SDL 

    #include "SDL_opengl.h"      // for GLfloat
    #include "SDL.h"             // for ColorDefinition (SDL_Color)



namespace OSDL
{

    
    namespace Video
    {
        
            
        namespace OpenGL
        {
        
        
            typedef SDL_GLattr GLAttribute ;    

        }
        
    }
    
    
}

    
#else // OSDL_USES_SDL



namespace OSDL
{

    
    namespace Video
    {
        
            
        namespace OpenGL
        {
        
        
            typedef int GLAttribute ;   

        }
        
    }
    
}


    /*
     * libnds used to define it already for the ARM9 in videoGL.h: 
     * '#define GLfloat float'. Not true anymore.
     *
     */
    
     
    #if defined(OSDL_ARCH_NINTENDO_DS) && OSDL_ARCH_NINTENDO_DS 

        #include "OSDLConfigForNintendoDS.h"
        
        /*
         * Currently not using int instead of Ceylan::Float32 to (possibly)
         * avoid adding a floating-point emulation library: it would require
         * to eliminate many warnings (converting to 'GLLength' or
         * 'GLCoordinate' from 'float').
         *
         */
        typedef Ceylan::Float32 GLfloat ;

    #endif // on OSDL_ARCH_NINTENDO_DS


#endif // OSDL_USES_SDL not available



#include <string>





namespace OSDL
{

    
    
    namespace Video
    {
    
    
    
        
        namespace OpenGL
        {


        
        
            class OSDL_DLL OpenGLException : public VideoException
            {
            
                public:
                
                
                    OpenGLException( const std::string & reason ) ;
                    
                    
                    virtual ~OpenGLException() throw() ;
                                
            } ;
            
            
            
        
            extern OSDL_DLL Pixels::ColorMask RedMask ;
            
            
            
            extern OSDL_DLL Pixels::ColorMask GreenMask ;
            
            
            
            extern OSDL_DLL Pixels::ColorMask BlueMask ;
            
            
            
            extern OSDL_DLL Pixels::ColorMask AlphaMask ;
        
        
        
            typedef GLfloat GLLength ;
    
    
    
            typedef GLfloat GLCoordinate ;  
            
            
            
            typedef unsigned int GLBitField ;   
            
            
            
            typedef unsigned int GLEnumeration ;    
            


            enum Flavour { None, OpenGLFor2D, OpenGLFor3D, Reload } ;




            enum Feature { 
            
                /*
                 * If enabled, computed fragment color values will be
                 * blended with the values in the color buffers.
                 * 
                 */
                Alphablending = GL_BLEND,
                
                
                /*
                 * If enabled, and no fragment shader is active, 
                 * two-dimensional texturing is performed
                 * (unless three-dimensional or cube-mapped texturing 
                 * is also enabled).
                 *
                 */
                TwoDimensionalTexturing = GL_TEXTURE_2D,
                
                
                /*
                 * If enabled, culls polygons based on their winding in 
                 * window coordinates.
                 *
                 */
                CullPolygons = GL_CULL_FACE,
                
                
                /*
                 * If enabled, depth comparisons will be done and the depth
                 * buffer will be updated.
                 *
                 */
                DepthTests = GL_DEPTH_TEST,
                
                
                
                
                // Lighting section.
                
                
                /*
                 * If enabled, and no vertex shader is active, the current
                 * lighting parameters will be used to compute the vertex 
                 * color or index.
                 * Otherwise, simply associates the current color or index
                 * with each vertex.
                 *
                 */
                Lighting = GL_LIGHTING,
                
                
                /*
                 * If enabled, includes light 1 in the evaluation of the
                 * lighting equation.
                 *
                 */
                Light_1 = GL_LIGHT0,


                /*
                 * If enabled, includes light 2 in the evaluation of the
                 * lighting equation.
                 *
                 */
                Light_2 = GL_LIGHT1,


                /*
                 * If enabled, includes light 3 in the evaluation of the
                 * lighting equation.
                 *
                 */
                Light_3 = GL_LIGHT2,
            
            
                /*
                 * If enabled, includes light 4 in the evaluation of the
                 * lighting equation.
                 *
                 */
                Light_4 = GL_LIGHT3,


                /*
                 * If enabled, includes light 5 in the evaluation of the
                 * lighting equation.
                 *
                 */
                Light_5 = GL_LIGHT4,


                /*
                 * If enabled, includes light 6 in the evaluation of the
                 * lighting equation.
                 *
                 */
                Light_6 = GL_LIGHT5,


                /*
                 * If enabled, includes light 7 in the evaluation of the
                 * lighting equation.
                 *
                 */
                Light_7 = GL_LIGHT6,


                /*
                 * If enabled, includes light 8 in the evaluation of the
                 * lighting equation.
                 *
                 */
                Light_8 = GL_LIGHT7


            } ;
                
                    
                             
             
            class OSDL_DLL OpenGLContext : public Ceylan::TextDisplayable
            {

            
            
                public:
                
                    
                    
                    enum ProjectionMode { Orthographic, Perspective } ;
                    
                    
                    
                    enum ShadingModel { Flat, Smooth } ;
                    
                    
                    
                    enum CulledFacet { Front, Back, FrontAndBack } ;
                     
                    
                    
                    enum FrontOrientation { Clockwise, CounterClockwise } ;
                    
                    
                      
                    OpenGLContext( OpenGL::Flavour flavour, 
                        BitsPerPixel plannedBpp,
                        Length viewportWidth,
                        Length viewportHeight ) ;
        
        
                        
                    virtual ~OpenGLContext() throw() ;
                
                
                
                    virtual void selectFlavour( OpenGL::Flavour flavour ) ;
    
    
    
                    virtual void set2DFlavour() ;
                
                
                
                    virtual void set3DFlavour() ;
                
                
                    
                    virtual void blank() ;
                     
                
                
                    virtual void reload() ;
                    
                    
                
                    virtual void setBlendingFunction( 
                        GLEnumeration sourceFactor,
                        GLEnumeration destinationFactor ) ;

                
                
                     virtual void setShadingModel( 
                        ShadingModel newShadingModel = Smooth ) ;
    
    
                     
                    virtual void setCullingStatus( bool newStatus ) ;
    
    
                
                    virtual void setCulling( CulledFacet culledFacet = Back, 
                        FrontOrientation frontOrientation = CounterClockwise, 
                        bool autoEnable = true ) ;
                        
                
                
                    virtual void setDepthBufferStatus( bool newStatus ) ;
                    




                    // Viewport section.
                    
                    
                    
                    virtual void setViewPort( Length width, Length height, 
                        const TwoDimensional::Point2D & lowerLeftCorner = 
                            TwoDimensional::Point2D::Origin ) ;
                        
                        
                        
                    virtual void setOrthographicProjection( GLLength width, 
                        GLCoordinate near = -DefaultNearClippingPlaneFor3D, 
                        GLCoordinate far  = -DefaultFarClippingPlaneFor3D ) ;
                        
                        
                        
                    virtual void setOrthographicProjectionFor2D( 
                        GLLength width, GLLength height ) ;
                        
            
            
                    virtual void setClearColor( 
                        const Video::Pixels::ColorDefinition & color ) ;
                    
                    
                    
                    virtual void clearViewport() ;
                    
                    
                    
                    virtual void clearDepthBuffer() ;
                    
                    
                    
                    virtual void pushAttribute( GLBitField attributeField ) ;
                    
                    
                    
                    virtual void popAttribute() ;
                    
                        
                        
                    virtual const std::string toString( 
                        Ceylan::VerbosityLevels level = Ceylan::high ) const ;
                    
                    
                    
                    
                    
                    /*
                     * Static section.
                     *
                     * All static state-changing methods should probably set
                     * as member methods of a context instance, even if it
                     * would force the caller of always retrieving the 
                     * context.
                     *
                     */
                                        
                
                    
                    static void SetUpForFlavour( OpenGL::Flavour flavour,
                        bool safest = false ) ;
                        
                        
                        
                    static void EnableFeature( OpenGL::Feature feature ) ;
                    
                    
                    
                    static void DisableFeature( OpenGL::Feature feature ) ;




                    /*
                     * Following methods are static, as they are to be issued
                     * before a VideoModule::setMode call (otherwise they 
                     * will not be taken into account until the next setMode
                     * call), and no OpenGL context may already exist.
                     *
                     */
                     
                     
                
                    static bool GetDoubleBufferStatus() ;
                            
                                    
                
                    static void SetDoubleBufferStatus( bool newStatus ) ;
                
                     
                     
                    static Ceylan::Uint8 GetDepthBufferSize() ;
                                    
                
                    
                    static void SetDepthBufferSize( 
                        Ceylan::Uint8 bitsNumber = 16 ) ;
                     
                     
                     
                    static Ceylan::Uint8 GetFullScreenAntialiasingStatus() ;
                        
                        
                        
                    static void SetFullScreenAntialiasingStatus( 
                        bool newStatus,
                        Ceylan::Uint8 samplesPerPixelNumber = 4 ) ;
                    
                     
                     
                    static bool GetHardwareAccelerationStatus() ;
                        
                        
                        
                    static void SetHardwareAccelerationStatus( 
                        bool newStatus ) ;
                    
                    
                    
                    static bool GetVerticalBlankSynchronizationStatus() ;
                        
                        
                        
                    static void SetVerticalBlankSynchronizationStatus( 
                        bool newStatus ) ;
                    
                    
                    
                    static bool TrySettingVerticalBlankSynchronizationStatus(
                        bool newStatus ) ;
                        
                        
                                            
                     static OSDL::Video::BitsPerPixel GetColorDepth( 
                        OSDL::Video::BitsPerPixel & redSize, 
                        OSDL::Video::BitsPerPixel & greenSize, 
                        OSDL::Video::BitsPerPixel & blueSize, 
                        OSDL::Video::BitsPerPixel & alphaSize ) ;
                 
                 
                 
                    static void SetColorDepth( 
                        OSDL::Video::BitsPerPixel plannedBpp ) ;
                
                
                 
                    static void SetColorDepth( 
                        OSDL::Video::BitsPerPixel redSize, 
                        OSDL::Video::BitsPerPixel greenSize, 
                        OSDL::Video::BitsPerPixel blueSize ) ;
                
                
                
                    static std::string InterpretFeatureAvailability() ;
                
                
                
                    static std::string ToString( OpenGL::Flavour flavour ) ;    





                    // OpenGL context behaviour.



                    static const bool ContextCanBeLost ;
            
            
            
                    static const bool ContextIsLostOnResize ;
            

            
                    static const bool ContextIsLostOnApplicationSwitch ;
            
            
            
                    static const bool ContextIsLostOnColorDepthChange ;
            


            
                    static const GLLength DefaultOrthographicWidth ;
                    
                    
                    
                    static const GLCoordinate DefaultNearClippingPlaneFor2D ;
                    
                    
                    
                    static const GLCoordinate DefaultFarClippingPlaneFor2D ;
                    
                    
                    
                    static const GLCoordinate DefaultNearClippingPlaneFor3D ;
                    
                    
                    
                    static const GLCoordinate DefaultFarClippingPlaneFor3D ;
                    
                    
                    
                    
                    
            protected:
            
            
            
                    virtual void updateProjection() ;
                    
                    

                    static bool HasGLAttribute( GLAttribute attribute ) ;
                    
                    
            
                    static int GetGLAttribute( GLAttribute attribute ) ;
                    
                    
                    
                    static void SetGLAttribute( GLAttribute attribute,
                        int value ) ;
                                    
                    
                    
                    static bool TrySettingGLAttribute( GLAttribute attribute,
                        int value ) ;
                                    
                    
                    
                    static std::string GLAttributeToString( 
                        GLAttribute attribute ) ;
                                    
                    
                    
                    
                    
                    // Internal OpenGL context state.
                    
                    
                    
                    OpenGL::Flavour _flavour ;
                            
                                            
                                                    
                    OSDL::Video::BitsPerPixel _redSize ; 
                    
                    
                    
                    OSDL::Video::BitsPerPixel _greenSize ;
                    
                    
                    
                    OSDL::Video::BitsPerPixel _blueSize ;



                    OSDL::Video::BitsPerPixel _alphaSize ;


                    
                    Length _viewportWidth ;
                    
                    
                    
                    Length _viewportHeight ;
                    
                    
                    
                    ProjectionMode _projectionMode ;
                    
                    
                    
                    GLLength _projectionWidth ;
                    
                    
                    
                    GLCoordinate _nearClippingPlane ;
                    
                    
                    
                    GLCoordinate _farClippingPlane ;
                    
                    
                    
                    Pixels::ColorDefinition _clearColor ; 
                    
                    
                    
                    
            private:
                
                        
                                    
                    OpenGLContext( const OpenGLContext & source ) ;
            
            
            
                    OpenGLContext & operator = ( const OpenGLContext & source );
            
            
            } ;
        
        
        
        
            namespace GLU
            {
            
                typedef Ceylan::Uint32 Int ;
            
            }
            
            
                        
        }
        
    }
    
}



#endif // OSDL_OPENGL_H_

---