OSDLVideo.h

Go to the documentation of this file.

/*
 * Copyright (C) 2003-2010 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_VIDEO_H_
#define OSDL_VIDEO_H_


#include "OSDLSurface.h"     // for Surface
#include "OSDLPixel.h"       // for PixelFormat
#include "OSDLVideoTypes.h"  // for Length, Coordinate, etc.
#include "OSDLOpenGL.h"      // for Flavour, etc.

#include "Ceylan.h"          // for Uint8, Flags, etc.

#include <string>
#include <list>
#include <utility>           // for std::pair





namespace OSDL
{



    // Video module is created by common module.
    class CommonModule ;



    namespace Rendering
    {

        // Video module can make use of a video renderer.
        class VideoRenderer ;

    }



    namespace Video
    {



        // Video module manages the screen surface.
        class Surface ;


        namespace OpenGL
        {

            // The Video module may have to manage OpenGL contexts.
            class OpenGLContext ;

        }



        typedef Ceylan::Uint8 IconMask ;



        typedef std::pair<Length, Length> Definition ;



        enum StandardScreenSize
        {

            Size_FullScreen = 0,
            Size_640x480    = 1,
            Size_800x600    = 2,
            Size_1024x780   = 3,
            Size_1280x1024  = 4,
            Size_1680x1050  = 5

        } ;



        class OSDL_DLL VideoModule : public Ceylan::Module
        {



            // The common module has to create the video module.
            friend class OSDL::CommonModule ;



            public:



                bool hasScreenSurface() const ;



                virtual Surface & getScreenSurface() const ;



                virtual void setScreenSurface( Surface & newScreenSurface ) ;



                virtual bool hasRenderer() const ;



                virtual Rendering::VideoRenderer & getRenderer() const ;



                virtual void setRenderer(
                    Rendering::VideoRenderer & newRenderer ) ;



                virtual bool hasOpenGLContext() const ;



                virtual void setOpenGLContext(
                    OpenGL::OpenGLContext & newOpenGLContext ) ;



                virtual OpenGL::OpenGLContext & getOpenGLContext() const ;



                 virtual BitsPerPixel getBestColorDepthForMode(
                    Length width, Length height,
                    BitsPerPixel askedBpp, Ceylan::Flags flags ) ;



                virtual bool isDisplayInitialized() const ;


                virtual bool isGUIEnabled() const ;



                virtual void setGUIEnableStatus( bool newStatus ) ;



                virtual Ceylan::Flags setMode( Length width, Length height,
                    BitsPerPixel askedBpp, Ceylan::Flags flags,
                    OpenGL::Flavour flavour = OpenGL::None ) ;



                static const BitsPerPixel UseCurrentColorDepth ;



                virtual void resize( Length newWidth, Length newHeight ) ;



                virtual void redraw() ;



                virtual void toggleFullscreen() ;



                virtual void makeBMPScreenshot(
                    const std::string & screenshotFilename ) ;



                virtual bool getEndPointDrawState() const ;



                virtual void setEndPointDrawState( bool newState ) ;




                virtual bool getAntiAliasingState() const ;



                virtual void setAntiAliasingState( bool newState ) ;




                virtual std::string getDriverName() const ;




                virtual void setWindowCaption( const std::string & newTitle,
                    const std::string & iconName ) ;



                virtual void getWindowCaption( std::string & title,
                    std::string & iconName ) ;




                virtual void setWindowIcon( const std::string & filename ) ;



                virtual bool iconifyWindow() ;



                virtual Ceylan::Float32 getAverageRefreshRate() ;



                virtual bool isUsingOpenGL() const ;



                virtual const std::string toString(
                    Ceylan::VerbosityLevels level = Ceylan::high ) const ;





                // Static section.



                static bool IsDisplayInitialized() ;



                static bool GetEndPointDrawState() ;



                static bool GetAntiAliasingState() ;



                static std::string GetDriverName() ;



                static std::string InterpretFlags( Ceylan::Flags flags ) ;



                static bool HardwareSurfacesCanBeCreated() ;



                static bool WindowManagerAvailable() ;




                // Hardware to hardware section.



                static bool HardwareToHardwareBlitsAccelerated() ;



                static bool HardwareToHardwareColorkeyBlitsAccelerated() ;



                static bool HardwareToHardwareAlphaBlitsAccelerated() ;




                // Software to hardware section.



                static bool SoftwareToHardwareBlitsAccelerated() ;



                static bool SoftwareToHardwareColorkeyBlitsAccelerated() ;



                static bool SoftwareToHardwareAlphaBlitsAccelerated() ;



                static bool ColorFillsAccelerated() ;



                static Ceylan::Uint32 GetVideoMemorySize() ;



                static Pixels::PixelFormat GetVideoDevicePixelFormat() ;



                static std::string DescribeVideoCapabilities() ;



                static bool AreDefinitionsRestricted(
                    std::list<Definition> & definitions,
                    Ceylan::Flags flags,
                    Pixels::PixelFormat * pixelFormat = 0 ) ;



                static std::string DescribeAvailableDefinitions(
                    Ceylan::Flags flags,
                    Pixels::PixelFormat * pixelFormat = 0 ) ;




                static StandardScreenSize ToStandardScreenSize(
                    const std::string & standardScreenSizeInText ) ;


                static void ToScreenDimensions( StandardScreenSize screenSize,
                    Length & screenWidth, Length & screenHeight ) ;



                static std::string DescribeEnvironmentVariables() ;



                static bool IsUsingOpenGL() ;


                static bool IsUsingDrawingPrimitives() ;




                /*
                 * These flags can apply to Surfaces <b>created by setMode</b>,
                 * i.e. all the Display Surfaces, and only them.
                 *
                 * The legal flags for setMode form a subset of the Surface
                 * flags, with one flag being added, NoFrame.
                 *
                 * @note These flags are not to be mixed up with the Surface
                 * flags' ones.
                 *
                 * @see OSDL::Video::Surface
                 *
                 */



                static const Ceylan::Flags SoftwareSurface ;



                static const Ceylan::Flags HardwareSurface ;



                static const Ceylan::Flags AsynchronousBlit ;



                static const Ceylan::Flags AnyPixelFormat ;



                static const Ceylan::Flags ExclusivePalette ;



                static const Ceylan::Flags DoubleBuffered ;



                static const Ceylan::Flags FullScreen ;



                static const Ceylan::Flags OpenGL ;



                static const Ceylan::Flags Resizable ;



                static const Ceylan::Flags NoFrame ;





            protected:




                // Variables section.



                Surface * _screen ;



                bool _displayInitialized ;



                bool _isGuiEnabled ;



                Rendering::VideoRenderer * _renderer ;



                static bool _IsUsingOpenGL ;



                static bool _DrawEndPoint ;



                static bool _AntiAliasing ;



                static const Ceylan::Uint16 DriverNameMaximumLength ;



            private:



                OpenGL::OpenGLContext * _openGLcontext ;



                bool _drawEndPoint ;



                bool _antiAliasing ;



                /*
                 * Not specified directly in the screen surface, as otherwise
                 * the creation of any surface would take useless time, to
                 * retrieve the current time:
                 *
                 */


                Ceylan::System::Second _screenStartingSecond ;


                Ceylan::System::Microsecond _screenStartingMicrosecond ;




                VideoModule() ;



                virtual ~VideoModule() throw() ;




                explicit VideoModule( const VideoModule & source ) ;



                VideoModule & operator = ( const VideoModule & source ) ;



                static const std::string _SDLEnvironmentVariables[] ;



        } ;


    }

}



#endif // OSDL_VIDEO_H_

---