Introduction
Downloads
Documentation
Tutorials
Pixie Lite
Forum

Home

Bitmap.h

Go to the documentation of this file.

#ifndef __Bitmap_H__
#define __Bitmap_H__

// Includes
#include "StringId.h"

// Forward declares
class Asset;

// Bitmap
class Bitmap
   {
   public:
      Bitmap();

      virtual StringId GetType() = 0;


      virtual ~Bitmap() { };


      virtual unsigned short* GetColorData() const;

      virtual unsigned char* GetAlphaData() const;

      virtual int GetHPitch() const;
      
      virtual int GetVPitch() const;

      virtual int GetHOffset() const;
      
      virtual int GetVOffset() const;

      virtual void Clear();


      virtual void Fill(
         unsigned short color,   
         unsigned char alpha = 255 
         );


      virtual void Fill(
         int x1,  
         int y1,  
         int x2, 
         int y2, 
         unsigned short color,   
         unsigned char alpha = 255 
         );
                     

      virtual void FillAlpha(
         unsigned char alpha 
         );

      virtual void FillAlpha(
         int x1,  
         int y1,  
         int x2, 
         int y2, 
         unsigned char alpha 
         );
            
      enum Transformation
         {
         NoTransformation, 
         Rotate_90,  
         Rotate_180, 
         Rotate_270, 
         Mirror_X,   
         Mirror_Y,   
         Transformations_Count   
         };


      virtual int GetWidth(
         Transformation transformation = NoTransformation 
         ) const;
      

      virtual int GetHeight(
         Transformation transformation = NoTransformation   
         ) const;


      virtual unsigned short  GetPixelColor(
         int x,   
         int y,   
         Transformation transformation  = NoTransformation  
         ) const;

      virtual unsigned char  GetPixelAlpha(
         int x,   
         int y,   
         Transformation transformation = NoTransformation   
         ) const;

      virtual void SetPixelColor(
         int x,   
         int y,   
         unsigned short color,   
         Transformation transformation = NoTransformation   
         );

      virtual void SetPixelAlpha(
         int x,   
         int y,   
         unsigned char alpha, 
         Transformation transformation = NoTransformation   
         );


      virtual void BlendPixel(
         int x,   
         int y,   
         unsigned short color,   
         unsigned char alpha, 
         Transformation transformation = NoTransformation   
         );

      virtual void Blit(
         Bitmap& target, 
         int x,   
         int y,   
         unsigned short modulate = 0xffff,   
         unsigned char alpha = 255, 
         Transformation transformation = NoTransformation   
         ) const;

      virtual void Blit(
         int x1, 
         int y1,  
         int x2,  
         int y2,  
         Bitmap& target, 
         int x,   
         int y,   
         unsigned short modulate = 0xffff,
         unsigned char alpha = 255, 
         Transformation transformation = NoTransformation 
         ) const;

      virtual void Copy(
         Bitmap& target, 
         int x,   
         int y,   
         unsigned short modulate = 0xffff,
         Transformation transformation = NoTransformation   
         ) const;

      virtual void Copy(
         int x1, 
         int y1,  
         int x2,  
         int y2,  
         Bitmap& target, 
         int x,   
         int y,   
         unsigned short modulate = 0xffff,
         Transformation transformation = NoTransformation 
         ) const;

      virtual void Save(Asset& asset) const = 0;
      virtual void Load(const Asset& asset) = 0;

      virtual void WriteToAsset(Asset* asset) const = 0;
      virtual void ReadFromAsset(const Asset* asset) = 0;

   protected:
      inline void TransformCoordinates(
         int& x, 
         int& y, 
         Transformation transformation 
         ) const
         {
         int xp=x;
         int yp=y;
         switch (transformation)
            {
            case NoTransformation:
               {
               return;
               } break;

            case Rotate_90:
               {
               xp=y;
               yp=(GetHeight()-1)-x;
               } break;

            case Rotate_180:
               {
               xp=(GetWidth()-1)-x;
               yp=(GetHeight()-1)-y;
               } break;

            case Rotate_270:
               {
               xp=(GetWidth()-1)-y;
               yp=x;
               } break;

            case Mirror_X:
               {
               xp=(GetWidth()-1)-x;
               } break;

            case Mirror_Y:
               {
               yp=(GetHeight()-1)-y;
               } break;

            }
         x=xp;
         y=yp;
         }


      bool Clip(int& sourceX, int& sourceY, int& sourceWidth, int& sourceHeight, int& targetX, int& targetY, int targetWidth, int targetHeight, Transformation transformation ) const
         {

         // First, make sure source is in valid range
         
         // Is left side negative?
         if (sourceX<0)
            {
            targetX+=-sourceX;   // Compensate destination position 
            sourceWidth-=-sourceX; // Compensate width
            sourceX=0; // Clamp left side
            }

         // Is top side negative?
         if (sourceY<0) 
            {
            targetY+=-sourceY;   // Compensate destination position 
            sourceHeight-=-sourceY; // Compensate height
            sourceY=0; // Clamp top side
            }

         // Is right side out of range?
         if (sourceX+sourceWidth>GetWidth(transformation)) 
            {
            sourceWidth-=(sourceX+sourceWidth)-GetWidth(transformation); // Truncate width
            }

         // Is bottom  side out of range?
         if (sourceY+sourceHeight>GetHeight(transformation)) 
            {
            sourceHeight-=(sourceY+sourceHeight)-GetHeight(transformation); // Truncate height
            }

         // Next, make sure target is in valid range

         // Is left side negative?
         if (targetX<0)
            {
            sourceX+=-targetX;   // Compensate source position 
            sourceWidth-=-targetX; // Compensate width
            targetX=0; // Clamp left side
            }

         // Is top side negative?
         if (targetY<0)
            {
            sourceY+=-targetY;   // Compensate source position 
            sourceHeight-=-targetY; // Compensate width
            targetY=0; // Clamp left side
            }

         // Is right side out of range?
         if (targetX+sourceWidth>targetWidth)
            {
            sourceWidth-=(targetX+sourceWidth)-targetWidth; // Truncate width
            }

         // Is bottom side out of range?
         if (targetY+sourceHeight>targetHeight) 
            {
            sourceHeight-=(targetY+sourceHeight)-targetHeight; // Truncate height
            }

         // Check if there's something left to draw
         if (sourceWidth<=0 || sourceHeight<=0)
            {
            return false;
            }
         
         return true;
         }

   protected:
      unsigned short* color_; 
      unsigned char* alpha_;  
      int width_;    
      int height_;   
      int hPitch_;   
      int vPitch_;   
      int hOffset_;  
      int vOffset_;  
   };




#endif /* __Bitmap16_H__ */
   

---

Pixie University and the Pixie Game Engine is created and managed by Mattias Gustavsson.
Reproduction/republishing of any material on this site without permission is strictly prohibited.