---

video_base.h

//FILE:         video_base.h
//AUTHOR:       Nathan Cournia <nathan@cournia.com>

#ifndef COURNIA_VIDEO_BASE_H
#define COURNIA_VIDEO_BASE_H 1

#include "gl.h"
#include "ttf.h"
#include "clocker.h"


class video_base
{
protected:
        unsigned int m_width; 
        unsigned int m_height; 
        bool m_fullscreen; 
        unsigned int m_bpp; 
        bool m_error; 
        std::string m_error_msg; 
        clocker m_clock; 
        int m_2d_enabled; 

        double m_fps; 
        double m_avg_fps; 
        double m_fps_sum; 
        unsigned int m_frame_count; 

        inline void clear_error( void ) {
                m_error = false;
                m_error_msg = "none";
        }

        inline void set_error( const std::string& msg ) {
                m_error = true;
                m_error_msg = msg;
        }

public:
        video_base( void ): 
                m_error( false ), m_error_msg( "none" ), 
                m_2d_enabled( 0 ),
                m_fps( 0.0 ), m_avg_fps( 0.0 ), m_fps_sum( 0.0 ), m_frame_count( 0 )
                { }
        
        virtual ~video_base( void ) { };


        virtual bool init( unsigned int w, unsigned int h, unsigned int bpp, 
                bool fs ) = 0;
        
        virtual void set_title( const std::string& title ) = 0;
        
        virtual void resize( unsigned int width, unsigned int height ) = 0;
        

        virtual void start_frame( void ) = 0;
        

        virtual void end_frame( void ) = 0;
        
        virtual void toggle_fullscreen( void ) = 0;
        

        virtual void shutdown( void ) = 0;

        inline unsigned int get_width( void ) const {
                return m_width;
        }
        
        inline unsigned int get_height( void ) const {
                return m_height;
        }

        inline bool error( void ) const {
                return m_error;
        }

        inline std::string get_error( void ) {
                std::string msg( m_error_msg );
                clear_error( );
                return msg;
        }


        inline double get_fps( void ) const {
                return m_fps;
        }


        inline double get_average_fps( void ) const {
                return m_avg_fps;
        }

        inline double get_elapsed( void ) const {
                return m_clock.elapsed( );
        }

        inline bool get_2d( void ) const {
                return (m_2d_enabled > 0 );
        }
        
        inline void enable_2d( void ) {
                ++m_2d_enabled;
                gl::enable_2d( m_width, m_height );
        }

        inline void disable_2d( void ) {
                --m_2d_enabled;
                gl::disable_2d( );
        }


        void render_string( real_t &x, real_t &y, const gl::ttf *font, real_t size,
                const std::string& text );


        void render_shadowed_string( real_t &x, real_t &y, const gl::ttf *font, 
                real_t size, real_t shadow_offset,
                const std::string& text );


        void render_image( const rectf& rect, const gl::texture& texture );
};

#endif

---