Drawing.h

Go to the documentation of this file.

/*                                              -*- mode:C++ -*-
  Drawing.h SDL_Surface rendering toolkit
  Copyright (C) 2014 The Regents of the University of New Mexico.  All rights reserved.

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This 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 for more details.

  You should have received a copy of the GNU General Public License
  along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
  USA
*/

#ifndef DRAWING_H
#define DRAWING_H

#include "AssetManager.h"
#include "itype.h"
#include "SDL.h"         /* For SDL_Surface, SDL_Color */
#include "SDL_ttf.h"     /* For TTF_Font, at least */
#include "Rect.h"
#include "Tile.h"

namespace MFM {

  class Drawing
  {
    Rect m_rect;

    u32 m_bgColor;

    u32 m_fgColor;

    SDL_Surface * m_dest;

    TTF_Font* m_font;

    static void SetSDLColor(SDL_Color & set, const u32 from) ;
    static void GetSDLColor(const SDL_Color & from, u32 & to) ;

  public:

    static const int WHITE   = 0xffffffff;
    static const int BLACK   = 0xff000000;
    static const int RED     = 0xffff0000;
    static const int GREEN   = 0xff00ff00;
    static const int BLUE    = 0xff0000ff;
    static const int CYAN    = 0xff00ffff;
    static const int MAGENTA = 0xffff00ff;
    static const int YELLOW  = 0xffffff00;

    static const int GREY05  = 0xff0c0c0c;
    static const int GREY10  = 0xff191919;
    static const int GREY20  = 0xff333333;
    static const int GREY30  = 0xff4c4c4c;
    static const int GREY40  = 0xff666666;
    static const int GREY50  = 0xff7f7f7f;
    static const int GREY60  = 0xff999999;
    static const int GREY70  = 0xffb2b2b2;
    static const int GREY80  = 0xffcccccc;
    static const int GREY90  = 0xffe5e5e5;
    static const int GREY95  = 0xfff2f2f2;

    static const int GREY = GREY50;
    static const int DARK_PURPLE = 0xff200020;
    static const int ORANGE = 0xffff6600;

    static u32 HalfColor(u32 input)
    {
      u8 r, g, b;
      r = (input & 0xff0000) >> 17;
      g = (input & 0x00ff00) >> 9;
      b = (input & 0xff) >> 1;

      return 0xff000000 | (r << 16) | (g << 8) | b;
    }

    Drawing(SDL_Surface * dest = 0, TTF_Font * font = 0) ;

    static u32 InterpolateColors(const u32 color1, const u32 color2, u32 percentOfColor1);

    void TransformWindow(const Rect & rect) ;

    static void TransformWindow(const Rect & existing, const Rect & newTransform, Rect & result) ;

    void GetWindow(Rect & rect) const ;

    void SetWindow(const Rect & rect) ;

    void Reset(SDL_Surface * dest, TTF_Font * font);

    void Clear();

    u32 GetBackground() const
    {
      return m_bgColor;
    }

    u32 SetBackground(const u32 color)
    {
      u32 old = m_bgColor;
      m_bgColor = color;
      return old;
    }

    u32 GetForeground() const
    {
      return m_fgColor;
    }

    u32 SetForeground(const u32 color)
    {
      u32 old = m_fgColor;
      m_fgColor = color;
      return old;
    }

    TTF_Font* GetFont() const
    {
      return m_font;
    }

    TTF_Font* SetFont(TTF_Font * newFont)
    {
      TTF_Font* old = m_font;
      m_font = newFont;
      return old;
    }

    TTF_Font* SetFont(FontAsset asset)
    {
      return SetFont(AssetManager::Get(asset));
    }

    void DrawHLine(int y, int startX, int endX) const;

    void DrawVLine(int x, int startY, int endY) const;

    void DrawRectangle(const Rect & rect) const;

    void FillRect(int x, int y, int w, int h) const;

    void FillRect(int x, int y, int w, int h, u32 color) const;

    void FillRect(const Rect & rect) const
    {
      FillRect(rect.GetX(), rect.GetY(), rect.GetWidth(), rect.GetHeight());
    }

     void FillCircle(int x, int y, int w, int h, int radius) const;


    void BlitText(const char* message, UPoint loc, UPoint size) const;

    void BlitBackedText(const char* message, UPoint loc, UPoint size);

    void BlitBackedTextCentered(const char* message, UPoint loc, UPoint size);

    SPoint GetTextSize(const char* message) ;

    SPoint GetTextSizeInFont(const char* message, TTF_Font * thisFont) ;

    void BlitImage(SDL_Surface* image, UPoint loc, UPoint maxSize) const;

    void BlitAsset(Asset asset, UPoint loc, UPoint maxSize) const;


    static void Convert(const Rect & rect, SDL_Rect & toFill) ;

  private:
    // Let's try to deprecate SetPixel.  Bounds-checking every pixel is
    // slow, and SDL_FillRect is (like SSE) fast and also clips against
    // the surface cliprect so it's bounds-checking anyway?
    static inline void SetPixel(SDL_Surface* dest,
                                u32 x, u32 y,
                                u32 color)
    {
      if(x >= 0 && y >= 0 && x < (u32)dest->w && y < (u32)dest->h)
        {
          ((u32*)dest->pixels)[x + y * dest->w] = color;
        }
    }
  };
} /* namespace MFM */

#endif /*DRAWING_H*/