OSDLSprite.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_SPRITE_H_
#define OSDL_SPRITE_H_



#include "OSDLVideoRenderer.h"        // for VideoRenderingException
#include "OSDLVideoTypes.h"           // for Length


/*

#include "OSDLEvents.h"               // for RenderingTick

#include "OSDLException.h"            // for Exception

#include <list>

*/


#include "Ceylan.h"                   // for inheritance


#include <string>




namespace OSDL
{



    namespace Engine 
    {

        class BoundingBox2D ;
        
    }
    
    
    
        
    namespace Video 
    {


        namespace OpenGL
        {
        
            // Sprites may use a texture with OpenGL:
            class GLTexture ;
            
        }
        
            
    }
    
    
        
        
    namespace Rendering 
    {
    

        class OSDL_DLL SpriteException: public VideoRenderingException
        {
        
            public:
                explicit SpriteException( const std::string & message ) ;
                
                virtual ~SpriteException() throw() ;
                            
        } ;




        class OSDL_DLL Sprite: public Ceylan::View
        {
        
        
            public:
            
            
            
                typedef Ceylan::Uint8 Shape ;
            
            
            
                explicit Sprite( const std::string & frameFilename ) ;
                
                
                
                virtual ~Sprite() throw() ;
            


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

                
                
                
                // Static section.

                
                
                // Sprite shape section.
                


                /*
                 * Convention is to name basic shapes 'ATimesB' for AxB,
                 * A being the sprite width, B being the sprite height, in
                 * pixels.
                 * 
                 * Typing shapes this way is convenient for tile-based platforms
                 * like the Nintendo DS.
                 *
                 * For other platforms, like the PC, differents shapes are
                 * usually used, like 'PowersOfTwo'.
                 *
                 * @note Not enum (int), as one byte is largely enough.
                 *
                 */
                
                
                // Section with an height of 8 pixels.
                
                
                static const Shape EightTimesEight ;
                
                
                static const Shape SixteenTimesEight ;
                
                
                static const Shape ThirtyTwoTimesEight ;
                
                
        
                
                // Section with an height of 16 pixels.
                
                
                static const Shape EightTimesSixteen ;
                
                
                static const Shape SixteenTimesSixteen ;
                
                
                static const Shape ThirtyTwoTimesSixteen ;
                
                
                
                
                // Section with an height of 32 pixels.
                
                
                static const Shape EightTimesThirtyTwo ;
                
                
                static const Shape SixteenTimesThirtyTwo ;
                
                
                static const Shape ThirtyTwoTimesThirtyTwo ;
                
                
                static const Shape SixtyFourTimesThirtyTwo ;
                
                
                
                
                // Section with an height of 64 pixels.
                
                                
                static const Shape ThirtyTwoTimesSixtyFour ;
                
                
                static const Shape SixtyFourTimesSixtyFour ;


                static const Shape PowersOfTwo ;

                
                
                static std::string DescribeShape( Shape shape ) ;
                
                
                
                static Shape GetSmallestEnclosingShape( 
                    OSDL::Video::Length width,
                    OSDL::Video::Length height ) ;
                    
                    
                
                static OSDL::Video::Length GetShapeWidthFor( Shape shape ) ;
                
                
                
                static OSDL::Video::Length GetShapeHeightFor( Shape shape ) ;
                
                
                
                
            protected:
            
            

                bool _ownBoundingBox ;
                
                
                
                Engine::BoundingBox2D * _box ;
        
        
        
                Shape _shape ;
                
                
#if defined(OSDL_ARCH_NINTENDO_DS) && OSDL_ARCH_NINTENDO_DS 

                // TileMap + Frame?
                
#else // OSDL_ARCH_NINTENDO_DS

                Video::OpenGL::GLTexture * _texture ;
                
#endif // OSDL_ARCH_NINTENDO_DS
                 
                 
                        
            private:
            
            
            
                Sprite( const Sprite & source ) ;
            
            
            
                Sprite & operator = ( const Sprite & source ) ;
                
                
        } ;
        

    }

}



#endif // OSDL_SPRITE_H_

---