render.hpp

   1 #ifndef _render__hpp__included__
   2 #define _render__hpp__included__
   3
   4 #include <cstdint>
   5 #include <string>
   6 #include <list>
   7 #include <vector>
   8 #include <stdexcept>
   9
  10 /**
  11  * \brief Low color (32768 colors) screen from buffer.
  12  */
  13 struct lcscreen
  14 {
  15 /**
  16  * \brief Create new screen from bsnes output data.
  17  *
  18  * \param mem The output buffer from bsnes.
  19  * \param hires True if in hires mode (512-wide lines instead of 256-wide).
  20  * \param interlace True if in interlace mode.
  21  * \param overscan True if overscan is enabled.
  22  * \param region True if PAL, false if NTSC.
  23  */
  24         lcscreen(const uint16_t* mem, bool hires, bool interlace, bool overscan, bool region) throw();
  25
  26         lcscreen() throw();
  27         lcscreen(const uint16_t* mem, uint32_t _width, uint32_t _height) throw();
  28         lcscreen(const lcscreen& ls) throw(std::bad_alloc);
  29         lcscreen& operator=(const lcscreen& ls) throw(std::bad_alloc, std::runtime_error);
  30         void load(const std::vector<char>& data) throw(std::bad_alloc, std::runtime_error);
  31         void save(std::vector<char>& data) throw(std::bad_alloc);
  32         void save_png(const std::string& file) throw(std::bad_alloc, std::runtime_error);
  33
  34 /**
  35  * \brief Destructor.
  36  */
  37         ~lcscreen();
  38
  39 /**
  40  * \brief True if memory is allocated by new[] and should be freed by the destructor., false otherwise.
  41  */
  42         bool user_memory;
  43
  44 /**
  45  * \brief Memory, 1 element per pixel in left-to-right, top-to-bottom order, 15 low bits of each element used.
  46  */
  47         const uint16_t* memory;
  48
  49 /**
  50  * \brief Number of elements (not bytes) between two successive scanlines.
  51  */
  52         uint32_t pitch;
  53
  54 /**
  55  * \brief Width of image.
  56  */
  57         uint32_t width;
  58
  59 /**
  60  * \brief Height of image.
  61  */
  62         uint32_t height;
  63
  64 /**
  65  * \brief Image allocated size (only valid for user_memory).
  66  */
  67         size_t allocated;
  68 };
  69
  70 /**
  71  * \brief Truecolor modifiable screen.
  72  */
  73 struct screen
  74 {
  75 /**
  76  * \brief Create new screen
  77  *
  78  * Creates screen. The screen dimensions are initially 0x0.
  79  */
  80         screen() throw();
  81
  82 /**
  83  * \brief Destructor.
  84  */
  85         ~screen() throw();
  86
  87 /**
  88  * \brief Set the screen to use specified backing memory.
  89  *
  90  * Sets the backing memory for screen. The specified memory is not freed if screen is reallocated or destroyed.
  91  *
  92  * \param _memory The memory buffer.
  93  * \param _width Width of screen.
  94  * \param _height Height of screen.
  95  * \param _originx X coordinate for origin.
  96  * \param _originy Y coordinate for origin.
  97  * \param _pitch Distance in bytes between successive scanlines.
  98  */
  99         void set(uint32_t* _memory, uint32_t _width, uint32_t _height, uint32_t _originx, uint32_t _originy,
 100                 uint32_t _pitch) throw();
 101
 102 /**
 103  * \brief Set new size for screen, reallocating backing memory.
 104  *
 105  * Sets the size of the screen. The memory is freed if screen is reallocated or destroyed.
 106  *
 107  * \param _width Width of screen.
 108  * \param _height Height of screen.
 109  * \param _originx X coordinate for origin.
 110  * \param _originy Y coordinate for origin.
 111  * \param upside_down If true, image is upside down in memory.
 112  * \throws std::bad_alloc Not enough memory.
 113  */
 114         void reallocate(uint32_t _width, uint32_t _height, uint32_t _originx, uint32_t _originy,
 115                 bool upside_down = false) throw(std::bad_alloc);
 116
 117 /**
 118  * \brief Paint low-color screen into screen.
 119  *
 120  * Paints low-color screen into screen. The upper-left of image will be at origin. Scales the image by given factors.
 121  * If the image does not fit with specified scale factors, it is clipped.
 122  *
 123  * \param scr The screen to paint.
 124  * \param hscale Horizontal scale factor.
 125  * \param vscale Vertical scale factor.
 126  */
 127         void copy_from(lcscreen& scr, uint32_t hscale, uint32_t vscale) throw();
 128
 129 /**
 130  * \brief Get pointer into specified row.
 131  *
 132  * \param row Number of row (must be less than height).
 133  */
 134         uint32_t* rowptr(uint32_t row) throw();
 135
 136 /**
 137  * \brief Backing memory for this screen.
 138  */
 139         uint32_t* memory;
 140
 141 /**
 142  * \brief True if memory is given by user and must not be freed.
 143  */
 144         bool user_memory;
 145
 146 /**
 147  * \brief Width of screen.
 148  */
 149         uint32_t width;
 150
 151 /**
 152  * \brief Height of screen.
 153  */
 154         uint32_t height;
 155
 156 /**
 157  * \brief Distance between lines in bytes.
 158  */
 159         size_t pitch;
 160
 161 /**
 162  * \brief True if image is upside down in memory.
 163  */
 164         bool flipped;
 165
 166 /**
 167  * \brief X-coordinate of origin.
 168  */
 169         uint32_t originx;
 170
 171 /**
 172  * \brief Y-coordinate of origin.
 173  */
 174         uint32_t originy;
 175
 176 /**
 177  * \brief Palette.
 178  */
 179         uint32_t palette[32768];
 180
 181 /**
 182  * \brief Set the palette shifts.
 183  *
 184  * Sets the palette shifts, converting the existing image.
 185  *
 186  * \param rshift Shift for red component.
 187  * \param gshift Shift for green component.
 188  * \param bshift Shift for blue component.
 189  */
 190         void set_palette(uint32_t rshift, uint32_t gshift, uint32_t bshift) throw();
 191
 192 /**
 193  * \brief Return a color value.
 194  *
 195  * Returns color value with specified (r,g,b) values (scale 0-255).
 196  *
 197  * \param r Red component.
 198  * \param g Green component.
 199  * \param b Blue component.
 200  * \return color element value.
 201  */
 202         uint32_t make_color(uint8_t r, uint8_t g, uint8_t b) throw();
 203
 204 /**
 205  * \brief Current red component shift.
 206  */
 207         uint32_t active_rshift;
 208
 209 /**
 210  * \brief Current green component shift.
 211  */
 212         uint32_t active_gshift;
 213
 214 /**
 215  * \brief Current blue component shift.
 216  */
 217         uint32_t active_bshift;
 218 private:
 219         screen(const screen&);
 220         screen& operator=(const screen&);
 221 };
 222
 223 /**
 224  * \brief Base class for objects to render.
 225  */
 226 struct render_object
 227 {
 228 /**
 229  * \brief Destructor.
 230  */
 231         virtual ~render_object() throw();
 232
 233 /**
 234  * \brief Draw the object.
 235  *
 236  * \param scr The screen to draw it on.
 237  */
 238         virtual void operator()(struct screen& scr) throw() = 0;
 239 };
 240
 241 /**
 242  * \brief Queue of render operations.
 243  */
 244 struct render_queue
 245 {
 246 /**
 247  * \brief Add object to render queue.
 248  *
 249  * Adds new object to render queue. The object must be allocated by new.
 250  *
 251  * \param obj The object to add
 252  * \throws std::bad_alloc Not enough memory.
 253  */
 254         void add(struct render_object& obj) throw(std::bad_alloc);
 255
 256 /**
 257  * \brief Apply all objects in order.
 258  *
 259  * Applies all objects in the queue in order, freeing them in progress.
 260  *
 261  * \param scr The screen to apply queue to.
 262  */
 263         void run(struct screen& scr) throw();
 264
 265 /**
 266  * \brief Clear the queue.
 267  *
 268  * Frees all objects in the queue.
 269  *
 270  */
 271         void clear() throw();
 272
 273 /**
 274  * \brief Destructor.
 275  */
 276         ~render_queue() throw();
 277 private:
 278         std::list<struct render_object*> q;
 279 };
 280
 281 /**
 282  * \brief Read font data for glyph.
 283  *
 284  * \param codepoint Code point of glyph.
 285  * \param x X position to render into.
 286  * \param y Y position to render into.
 287  * \param orig_x X position at start of row.
 288  * \param next_x X position for next glyph is written here.
 289  * \param next_y Y position for next glyph is written here.
 290  * \return Two components: First is width of character, second is its offset in font data (0 if blank glyph).
 291  */
 292 std::pair<uint32_t, size_t> find_glyph(uint32_t codepoint, int32_t x, int32_t y, int32_t orig_x,
 293         int32_t& next_x, int32_t& next_y) throw();
 294
 295
 296 /**
 297  * \brief Render text into screen.
 298  *
 299  * \param _x The x position to render to (relative to origin).
 300  * \param _y The y position to render to (relative to origin).
 301  * \param _text The text to render.
 302  * \param _fg Foreground color.
 303  * \param _fgalpha Foreground alpha (0-256).
 304  * \param _bg Background color.
 305  * \param _bgalpha Background alpha (0-256).
 306  */
 307 void render_text(struct screen& scr, int32_t _x, int32_t _y, const std::string& _text, uint32_t _fg = 0xFFFFFFFFU,
 308                 uint16_t _fgalpha = 255, uint32_t _bg = 0, uint16_t _bgalpha = 0) throw(std::bad_alloc);
 309
 310 #endif