gdraw.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *
 * Based on the original sources
 *   Faery Tale II -- The Halls of the Dead
 *   (c) 1993-1996 The Wyrmkeep Entertainment Co.
 */
 
#ifndef SAGA2_GDRAW_H
#define SAGA2_GDRAW_H
 
#include "saga2/rect.h"
 
namespace Saga2 {
 
/* ===================================================================== *
                                Drawing Pens
 * ===================================================================== */
 
//  A drawing pen. Note that this should later be a class?
 
typedef uint8       gPen;               // a pen index number
 
/* ============================================================================ *
   PixelMap: defines a chunky bitmap
 * ============================================================================ */
 
//  A general purpose image
 
struct StaticPixelMap {
    StaticPoint16 size;
    uint8 *data;
 
    int32 bytes() {
        return size.x * size.y;
    }
};
 
class gPixelMap {
public:
    Extent16        _size;                   // image size
    uint8           *_data;
 
    gPixelMap() : _data(nullptr) {}
 
    gPixelMap(StaticPixelMap m) : _size(m.size), _data(m.data) {}
 
    //  Compute the number of bytes in the pixel map
    int32 bytes() {
        return _size.x * _size.y;
    }
};
 
//  The simplest kind of pixel map is a static image
 
class gStaticImage : public gPixelMap {
public:
    //  constructors:
 
    gStaticImage() {
        _size.x = _size.y = 0;
        _data = NULL;
    }
    gStaticImage(int w, int h, uint8 *buffer) {
        _size.x = w;
        _size.y = h;
        _data = buffer;
    }
};
 
//  Automatically-remapped images: Eacn image adds itself to a
//  chain at the time it is constructed, and will automatically
//  remap to a new palette by calling the global remap() function.
 
class gMappedImage : public gPixelMap {
    static gMappedImage *_head;              // first image in map chain
 
    gMappedImage    *_next;                  // next image to remap
    gPixelMap       _original;
 
public:
    //  Constructor and destructor
    gMappedImage(int w, int h, uint8 *buffer);
    virtual ~gMappedImage() {
        if (_data) free(_data);
    }
    static void remap(gPen[]);
};
 
/* ============================================================================ *
   gFont: A bitmapped font structure
 * ============================================================================ */
 
struct gFont {
    uint16          height;                 // height of the font
    uint16          baseLine;               // baseline of the font
    uint16          rowMod;                 // row modulus for char data
 
    uint16          charXOffset[256];     // offset of each char in data
 
    int8            charWidth[256],       // width of character in pixels
                    charKern[256],        // character kern value
                    charSpace[256];       // character space value
 
    // followed by (row_mod * height) bytes of character data
    byte            *fontdata;
};
 
//  Prototypes
 
gFont *LoadFont(char *fontname);
void DisposeFont(gFont *font);
int16 TextWidth(gFont *font, const char *s, int16 length, int16 styles);
int16 WhichChar(gFont *font, uint8 *s, int16 length, int16 maxLen);
int16 WhichIChar(gFont *font, uint8 *s, int16 length, int16 maxLen);
int32 GTextWrap(gFont *font, char *mark, uint16 &count, uint16 width, int16 styles);
 
/* ============================================================================ *
   gPenState: Used by gPorts to save the current state
 * ============================================================================ */
 
struct gPenState {
    gPen            fgPen,                  // current foregroung pen
                    bgPen,                  // current drawing mode
                    olPen,                  // text outline pen
                    shPen;                  // text shadow pen
    uint8           drawMode;               // current drawing mode
};
 
/* ============================================================================ *
   gPort: Facilitates redering operations on PixelMaps
 * ============================================================================ */
 
enum DrawModes {
    kDrawModeMatte = 0,                      // use transparency
    kDrawModeColor,                          // solid color, use transparency
    kDrawModeReplace,                        // don't use transparency
    kDrawModeComplement,                     // blit in complement mode
 
    kNumDrawModes
};
 
enum {
    kTextStyleOutline    = (1 << 0),         // outline the characters
    kTextStyleShadow     = (1 << 1),         // drop shadow the characters
    kTextStyleUnderScore = (1 << 2),         // underscore all chars
    kTextStyleUnderBar   = (1 << 3),         // underscore char after a '_'
    kTextStyleHiLiteBar  = (1 << 4),         // highlight char after a '_'
    kTextStyleThickOutline = (1 << 5),       // extra-thick outline
    kTextStyleBold       = (1 << 6),         // bold
    kTextStyleItalics    = (1 << 7)          // italic
};
 
enum TextPositions {
    kTextPosLeft         = (1 << 0),
    kTextPosRight        = (1 << 1),
    kTextPosHigh         = (1 << 2),
    kTextPosLow          = (1 << 3)
};
 
class gPort {
public:
    gPixelMap       *_map;                   // pointer to map
 
    //  Added by Talin to speed up rendering and allow inverted
    //  gPorts for WinG compatibility
 
    uint8           *_baseRow;               // address of row 0
    int16           _rowMod;                 // modulus or row
 
    Point16         _origin;                 // origin drawing point
    Rect16          _clip;                   // clip region DrawPort
    gPen            _fgPen,                  // current foregroung pen
                    _bgPen,                  // current drawing mode
                    _olPen,                  // text outline pen
                    _shPen;                  // text shadow pen
    gPen            *_penMap;                // indirect pen map
    DrawModes       _drawMode;               // current drawing mode
    Point16         _penPos;                 // current pen position
    gFont           *_font;                  // current font
    int16           _textSpacing;            // extra space between characters
    uint16          _textStyles;             // text style bits
 
    //  Constructor
    gPort() {
        _map = nullptr;
        _baseRow = nullptr;
 
        _rowMod = 0;
        _penMap = nullptr;
        _drawMode = kDrawModeMatte;
        _font = nullptr;
        _textSpacing = 0;
        _textStyles = 0;
        _fgPen = _bgPen = _olPen = _shPen = 0;
    }
 
    virtual ~gPort() {}
 
    //  Set attributes
 
    virtual void setMap(gPixelMap *newmap, bool inverted = false);
 
    //  Direct colors
 
    void setColor(gPen color)              {
        _fgPen = color;
    }
    void setBgColor(gPen color)            {
        _bgPen = color;
    }
    void setShadowColor(gPen color)        {
        _shPen = color;
    }
    void setOutlineColor(gPen color)       {
        _olPen = color;
    }
 
    //  Indirect colors
 
    void setPenMap(gPen *pmap)              {
        _penMap = pmap;
    }
    void setIndirectColor(uint8 color) {
        _fgPen = _penMap[color];
    }
    void setIndirectBgColor(uint8 color)   {
        _bgPen = _penMap[color];
    }
    void setIndirectShColor(uint8 color)   {
        _shPen = _penMap[color];
    }
    void setIndirectOLColor(uint8 color)   {
        _olPen = _penMap[color];
    }
 
    //  modes & styles
 
    void setMode(DrawModes mode) {
        _drawMode = mode;
    }
    void setStyle(int style)               {
        _textStyles = style;
    }
 
    //  Pen states
 
    void setState(gPenState &);
    void getState(gPenState &);
 
    //  REM: calc intersection of pixel map rect...
 
    void setClip(const Rect16 &newclip)    {
        _clip = newclip;
    }
    void getClip(Rect16 &r)                {
        r = _clip;
    }
 
    void setOrigin(Point16 pt)         {
        _origin = pt;
    }
    Point16 getOrigin()                {
        return _origin;
    }
 
    //  Pen position movement
 
    void move(int16 x, int16 y)    {
        _penPos.x += x;
        _penPos.y += y;
    }
    void move(Vector16 v)          {
        _penPos += v;
    }
    void moveTo(int16 x, int16 y)  {
        _penPos.x = x;
        _penPos.y = y;
    }
    void moveTo(Point16 p)     {
        _penPos = p;
    }
 
    //  Simple drawing functions
    //  REM: This should clip!
 
    virtual void clear() {
        memset(_map->_data, (int)_fgPen, (int)_map->bytes());
    }
 
    //  Functions to set a single pixel
    //  NOTE: should this actually be a function pointer to deal
    //  with drawing mode?
 
    virtual void setPixel(int16 x, int16 y, gPen color) {
        if (x >= _clip.x && x < _clip.x + _clip.width
                && y >= _clip.y && y < _clip.y + _clip.height) {
            _baseRow[(y + _origin.y) * _rowMod + x + _origin.x] = color;
        }
    }
    void setPixel(int16 x, int16 y) {
        setPixel(x, y, _fgPen);
    }
    void setPixel(Point16 p, gPen color) {
        setPixel(p.x, p.y, color);
    }
    void setPixel(Point16 p) {
        setPixel(p.x, p.y, _fgPen);
    }
 
    //  pixel query functions
 
    virtual gPen getPixel(int16 x, int16 y) {
        return _baseRow[(y + _origin.y) * _rowMod + x + _origin.x];
    }
    virtual gPen getPixel(Point16 p) {
        return _baseRow[(p.y + _origin.y) * _rowMod + p.x + _origin.x];
    }
 
    //  Rectangle fill functions
 
    virtual void fillRect(const Rect16 r);
    void fillRect(int16 x, int16 y, int16 w, int16 h) {
        fillRect(Rect16(x, y, w, h));
    }
    //  Rectangle frame functions //
 
    virtual void frameRect(const Rect16 r, int16 thick);
    void frameRect(int16 x, int16 y, int16 w, int16 h, int16 thick) {
        frameRect(Rect16(x, y, w, h), thick);
    }
 
    //  Horiztonal and vertical lines
 
    virtual void hLine(int16 x, int16 y, int16 width);
    virtual void vLine(int16 x, int16 y, int16 height);
 
    //  Bresenham line-drawing functions
 
    virtual void line(int16 x1, int16 y1, int16 x2, int16 y2);
    void line(Point16 from, Point16 to) {
        line(from.x, from.y, to.x, to.y);
    }
    void drawTo(int16 x, int16 y) {
        line(_penPos.x, _penPos.y, x, y);
        _penPos.x = x;
        _penPos.y = y;
    }
    void drawTo(Point16 to) {
        line(_penPos, to);
        _penPos = to;
    }
    void draw(int16 x, int16 y) {
        line(_penPos.x, _penPos.y, _penPos.x + x, _penPos.y + y);
        _penPos.x += x;
        _penPos.y += y;
    }
    void draw(Vector16 v) {
        line(_penPos, v);
        _penPos += v;
    }
 
    //  Blitting functions
 
    virtual void bltPixels(const gPixelMap &src,
                           int src_x, int src_y,
                           int dst_x, int dst_y,
                           int width, int height);
 
    virtual void bltPixelMask(gPixelMap     &src,
                              gPixelMap       &msk,
                              int src_x, int src_y,
                              int dst_x, int dst_y,
                              int width, int height);
 
    virtual void scrollPixels(const Rect16 r, int dx, int dy);
 
    //  Text rendering functions
 
    void setFont(gFont *newFont) {
        _font = newFont;
    }
    void setTextSpacing(int16 fs) {
        _textSpacing = fs;
    }
 
private:
    //  Unclipped text rendering
    void drawStringChars(const char *, int16, gPixelMap &, int, int);
    //  Clipped but still low-level
    int16 drawClippedString(const char *str, int16 len, int xpos, int ypos);
public:
 
    //  Draw a text string with the current settings at the
    //  current pen position. If the length is < 0, then use the
    //  natural string length.
    void drawText(const char *str, int16 length = -1);
    void drawTextInBox(const char *str, int16 length,
                       const Rect16 &r, int16 pos,
                       Point16 borders);
};
 
void mapImage(gPort &from, gPort &to, gPen map[]);
void mapImage(gPixelMap &from, gPixelMap &to, gPen map[]);
 
bool NewTempPort(gPort &, int width, int height);
void DisposeTempPort(gPort &);
 
/* ============================================================================ *
   gSavePort: a class which auto-saves and auto-restores the port state
 * ============================================================================ */
 
struct gSavePort {
    gPenState       state;                  // saved state of port
public:
    gPort           &port;                  // port which was saved
 
    gSavePort(gPort &p) : port(p) {
        port.getState(state);
    }
    ~gSavePort() {
        port.setState(state);
    }
};
 
#define SAVE_GPORT_STATE(p) gSavePort sp( p )
 
} // end of namespace Saga2
 
#endif