Backgrounds.hpp

/* $Id: Backgrounds.hpp,v 1.1.1.1 2005/04/22 17:18:53 ndsdev Exp $ */

#ifndef LIBPR_BACKGROUNDS_HPP
#define LIBPR_BACKGROUNDS_HPP

#ifndef ARM9
#error Video is only available on the ARM9
#endif

#include <NDS/NDS.h>

enum TileManagerScreen {
  TOP_SCREEN,                   
  BOTTOM_SCREEN,                
};

enum TileManagerColors {
  COLORS_16 = BG_16_COLOR,      
  COLORS_256 = BG_256_COLOR,    
};

#define CALCULATE_TILE_MANAGER_COLORS(palette) \
((sizeof(palette) / sizeof(uint16) > 16) ? COLORS_256 : COLORS_16)

enum TileErrorCode {
  TM_NO_ERROR,                  
  TM_TILE_MAP_COLLISION,        
  TM_NO_DATA_PREPARED,          
  TM_BAD_DATA,                  
};

class TileManagerBase {
public:
  TileManagerBase(TileManagerScreen screen, int tile_index, int map_index,
                  TileManagerColors bg_colors, int bg_num);

  virtual ~TileManagerBase();

  virtual uint32 displayCr(void) const;

  virtual TileErrorCode prepare(const uint16* tile_data,
                                uint32 bytes_of_tiles,
                                const uint16* palette_data,
                                uint32 bytes_of_palette);
  virtual TileErrorCode load(void);

  uint16* map(void);

protected:
  TileErrorCode loadTileData(const uint16* data, uint32 bytes_of_data);

  TileErrorCode loadPalette(const uint16* data, uint32 bytes_of_data);

  uint16* copy16(uint16* dest, const uint16* src, uint32 bytes_of_data);

  TileManagerScreen _bg_screen;

  int _tile_index;

  int _map_index;

  int _bg_num;

  TileManagerColors _bg_colors;

  uint16* _bg_tiles;

  uint16* _bg_map;

  uint16* _bg_palette;

  const uint16* _bg_tile_data;

  uint32  _bg_tile_data_size;

  const uint16* _bg_palette_data;

  uint32  _bg_palette_data_size;
};

class BackgroundMap : public TileManagerBase {
  typedef TileManagerBase inherited;
public:
  BackgroundMap(TileManagerScreen screen, int tile_index, int map_index,
                TileManagerColors bg_colors, int bg_num = 0);

  TileErrorCode load(const uint16* bg_map = 0);
};

class TileMap : public TileManagerBase {
  typedef TileManagerBase inherited;
public:
  TileMap(TileManagerScreen screen, int tile_index, int map_index,
          TileManagerColors bg_colors, int bg_num = 1);
};

class TextMap : public TileManagerBase {
  typedef TileManagerBase inherited;
public:
  TextMap(TileManagerScreen screen, int tile_index, int map_index,
          TileManagerColors bg_colors, int bg_num = 2);

  TileErrorCode prepare(const uint16* font_data, uint32 bytes_of_fonts,
                        const uint16* font_palette, uint32 bytes_of_palette,
                        int font_width, int font_height);

  TileErrorCode load(void);

  void clear(void);

  int screenWidth(void) const;

  int screenHeight(void) const;

  void setForegroundColor(uint16 color);

  void setBackgroundColor(uint16 color);

  TileErrorCode setCursorPosition(int x, int y);

  int xPos(void) const;

  int yPos(void) const;

  TextMap& operator<<(const char* msg);

  TextMap& operator<<(char c);

  TextMap& operator<<(uint32 n);

  TextMap& operator<<(int32 n);

  //protected:
  void writeString(const char* text);

  int _font_width;      
  int _font_height;     

  int _font_tile_width; 
  int _font_tile_height;

  int _font_tiles;      

  int _screen_width;    
  int _screen_height;   

  int _cur_x;           
  int _cur_y;           

  int _radix;           
  bool _showbase;       

  int _tab_size;        
};

#endif

---