video.h

Go to the documentation of this file.

//       _________ __                 __
//      /   _____//  |_____________ _/  |______     ____  __ __  ______
//      \_____  \\   __\_  __ \__  \\   __\__  \   / ___\|  |  \/  ___/
//      /        \|  |  |  | \// __ \|  |  / __ \_/ /_/  >  |  /\___ |
//     /_______  /|__|  |__|  (____  /__| (____  /\___  /|____//____  >
//             \/                  \/          \//_____/            \/
//  ______________________                           ______________________
//                        T H E   W A R   B E G I N S
//         Stratagus - A free fantasy real time strategy game engine
//
//
//      (c) Copyright 1999-2011 by Lutz Sammer, Nehal Mistry, Jimmy Salmon and
//                                 Pali Rohár
//
//      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; only version 2 of the License.
//
//      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, write to the Free Software
//      Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
//      02111-1307, USA.
//
 
#ifndef __VIDEO_H__
#define __VIDEO_H__
 
 
#include "SDL.h"
#include "shaders.h"
#include "guichan.h"
 
#include "color.h"
#include "vec2i.h"
 
class CFont;
 
extern SDL_Window *TheWindow;
extern SDL_Renderer *TheRenderer;
extern SDL_Surface *TheScreen;
extern SDL_Texture *TheTexture;
 
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
#define RSHIFT  16
#define GSHIFT  8
#define BSHIFT  0
#define ASHIFT  24
#define RMASK   0x00ff0000
#define GMASK   0x0000ff00
#define BMASK   0x000000ff
#define AMASK   0xff000000
#else
#define RSHIFT  8
#define GSHIFT  16
#define BSHIFT  24
#define ASHIFT  0
#define RMASK   0x0000ff00
#define GMASK   0x00ff0000
#define BMASK   0xff000000
#define AMASK   0x000000ff
#endif
 
using pixelModifier = uint32_t(*)(const uint32_t, const uint32_t, const uint32_t); // type alias
 
class PixelModifier
{
public:
        static uint32_t CopyWithSrcAlphaKey(const uint32_t srcPixel, const uint32_t dstPixel, const uint32_t reqAlpha)
        {
                uint32_t srcAlpha = (srcPixel >> ASHIFT) & 0xFF;
                if (srcAlpha) {
                        srcAlpha = (srcAlpha * reqAlpha) >> 8;
                        return (srcPixel - (srcPixel & AMASK)) + (srcAlpha << ASHIFT);
                }
                return dstPixel;
        }
};
 
class CGraphic : public gcn::Image
{
public:
        struct frame_pos_t {
                short int x;
                short int y;
        };
 
protected:
        CGraphic() : Surface(NULL), SurfaceFlip(NULL), frame_map(NULL),
                Width(0), Height(0), NumFrames(1), GraphicWidth(0), GraphicHeight(0),
                Refs(1), Resized(false)
        {
                frameFlip_map = NULL;
        }
        ~CGraphic() {}
 
public:
        // Draw
        void DrawClip(int x, int y,
                                  SDL_Surface *surface = TheScreen) const;
        void DrawSub(int gx, int gy, int w, int h, int x, int y,
                                 SDL_Surface *surface = TheScreen) const;
 
        void DrawSubCustomMod(int gx, int gy, int w, int h, int x, int y,
                                              pixelModifier modifier, 
                                                  const uint32_t param,
                                                  SDL_Surface *surface = TheScreen) const;
 
        void DrawSubClip(int gx, int gy, int w, int h, int x, int y,
                                         SDL_Surface *surface = TheScreen) const;
        void DrawSubTrans(int gx, int gy, int w, int h, int x, int y,
                                          unsigned char alpha,
                                          SDL_Surface *surface = TheScreen) const;
        void DrawSubClipTrans(int gx, int gy, int w, int h, int x, int y,
                                                  unsigned char alpha, 
                                                  SDL_Surface *surface = TheScreen) const;
 
        void DrawSubClipCustomMod(int gx, int gy, int w, int h, int x, int y,
                                                          pixelModifier modifier, 
                                                          const uint32_t param,
                                                          SDL_Surface *surface = TheScreen) const;
 
        // Draw frame
        void DrawFrame(unsigned frame, int x, int y,
                                   SDL_Surface *surface = TheScreen) const;
        void DrawFrameClip(unsigned frame, int x, int y,
                                           SDL_Surface *surface = TheScreen) const;
        void DrawFrameTrans(unsigned frame, int x, int y, int alpha,
                                                SDL_Surface *surface = TheScreen) const;
        void DrawFrameClipTrans(unsigned frame, int x, int y, int alpha, 
                                                        SDL_Surface *surface = TheScreen) const;
 
        void DrawFrameClipCustomMod(unsigned frame, int x, int y, 
                                                                pixelModifier modifier, 
                                                                const uint32_t param,
                                                                SDL_Surface *surface = TheScreen) const;
 
        // Draw frame flipped horizontally
        void DrawFrameX(unsigned frame, int x, int y,
                                        SDL_Surface *surface = TheScreen) const;
        void DrawFrameClipX(unsigned frame, int x, int y,
                                                SDL_Surface *surface = TheScreen) const;
        void DrawFrameTransX(unsigned frame, int x, int y, int alpha,
                                                 SDL_Surface *surface = TheScreen) const;
        void DrawFrameClipTransX(unsigned frame, int x, int y, int alpha,
                                                         SDL_Surface *surface = TheScreen) const;
 
 
        static CGraphic *New(const std::string &file, int w = 0, int h = 0);
        static CGraphic *ForceNew(const std::string &file, int w = 0, int h = 0);
        static CGraphic *Get(const std::string &file);
 
        static void Free(CGraphic *g);
 
        void Load(bool grayscale = false);
        void Flip();
        void Resize(int w, int h);
        void SetOriginalSize();
        bool TransparentPixel(int x, int y);
        void SetPaletteColor(int idx, int r, int g, int b);
        void MakeShadow(int xOffset, int yOffset);
 
        // minor programmatic editing features
        void OverlayGraphic(CGraphic *other, bool mask = false);
 
        inline bool IsLoaded(bool flipped = false) const { return Surface != NULL && (!flipped || SurfaceFlip != NULL); }
 
        //guichan
        virtual void *_getData() const { return Surface; }
        virtual int getWidth() const { return Width; }
        virtual int getHeight() const { return Height; }
 
        std::string File;          
        std::string HashFile;      
        SDL_Surface *Surface;      
        SDL_Surface *SurfaceFlip;  
        frame_pos_t *frame_map;
        frame_pos_t *frameFlip_map;
        void GenFramesMap();
        int Width;                 
        int Height;                
        int NumFrames;             
        int GraphicWidth;          
        int GraphicHeight;         
        int Refs;                  
        bool Resized;              
 
        friend class CFont;
};
 
class CPlayerColorGraphic : public CGraphic
{
protected:
        CPlayerColorGraphic()
        {
        }
 
public:
        void DrawPlayerColorFrameClipX(int colorIndex, unsigned frame, int x, int y,
                                                                   SDL_Surface *surface = TheScreen);
        void DrawPlayerColorFrameClip(int colorIndex, unsigned frame, int x, int y,
                                                                  SDL_Surface *surface = TheScreen);
 
        static CPlayerColorGraphic *New(const std::string &file, int w = 0, int h = 0);
        static CPlayerColorGraphic *ForceNew(const std::string &file, int w = 0, int h = 0);
        static CPlayerColorGraphic *Get(const std::string &file);
 
        CPlayerColorGraphic *Clone(bool grayscale = false) const;
};
 
#ifdef USE_MNG
#ifdef WIN32
#ifdef HAVE_STDDEF_H
#undef HAVE_STDDEF_H
#endif
#endif
#include <libmng.h>
#ifdef WIN32
#ifndef HAVE_STDDEF_H
#undef HAVE_STDDEF_H
#endif
#endif
 
class Mng : public gcn::Image
{
        Mng();
        ~Mng();
 
        uint32_t refcnt = 0;
 
public:
        static Mng *New(const std::string &name);
        static void Free(Mng *mng);
        bool Load();
        void Reset();
        void Draw(int x, int y);
 
        //guichan
        virtual void *_getData() const;
        virtual int getWidth() const { return surface->w; }
        virtual int getHeight() const { return surface->h; }
        virtual bool isDirty() const { return true; }
 
        static uint32_t MaxFPS;
 
        mutable bool is_dirty;
        std::string name;
        FILE *fd;
        mng_handle handle;
        SDL_Surface *surface;
        unsigned char *buffer;
        unsigned long ticks;
        int iteration;
};
#else
class Mng : public gcn::Image
{
        Mng() {};
        ~Mng() {};
public:
        static Mng *New(const std::string &name) { return NULL; }
        static void Free(Mng *mng) {};
        bool Load() { return false; };
        void Reset() {};
        void Draw(int x, int y) {};
 
        //guichan
        virtual void *_getData() const { return NULL; };
        virtual int getWidth() const { return 0; };
        virtual int getHeight() const { return 0; };
        virtual bool isDirty() const { return false; };
 
        static inline uint32_t MaxFPS = 15;
};
#endif
 
struct EventCallback {
 
        void (*ButtonPressed)(unsigned buttons);
        void (*ButtonReleased)(unsigned buttons);
        void (*MouseMoved)(const PixelPos &screenPos);
        void (*MouseExit)();
 
        void (*KeyPressed)(unsigned keycode, unsigned keychar);
        void (*KeyReleased)(unsigned keycode, unsigned keychar);
        void (*KeyRepeated)(unsigned keycode, unsigned keychar);
 
        void (*NetworkEvent)();
 
};
 
 
class CVideo
{
public:
        CVideo() : Width(0), Height(0), WindowWidth(0), WindowHeight(0), VerticalPixelSize(1), Depth(0), FullScreen(false) {}
 
        void LockScreen();
        void UnlockScreen();
 
        void ClearScreen();
        bool ResizeScreen(int width, int height);
 
        void DrawPixelClip(Uint32 color, int x, int y);
        void DrawTransPixelClip(Uint32 color, int x, int y, unsigned char alpha);
 
        void DrawVLine(Uint32 color, int x, int y, int height);
        void DrawTransVLine(Uint32 color, int x, int y, int height, unsigned char alpha);
        void DrawVLineClip(Uint32 color, int x, int y, int height);
        void DrawTransVLineClip(Uint32 color, int x, int y, int height, unsigned char alpha);
 
        void DrawHLine(Uint32 color, int x, int y, int width);
        void DrawTransHLine(Uint32 color, int x, int y, int width, unsigned char alpha);
        void DrawHLineClip(Uint32 color, int x, int y, int width);
        void DrawTransHLineClip(Uint32 color, int x, int y, int width, unsigned char alpha);
 
        void DrawLine(Uint32 color, int sx, int sy, int dx, int dy);
        void DrawTransLine(Uint32 color, int sx, int sy, int dx, int dy, unsigned char alpha);
        void DrawLineClip(Uint32 color, const PixelPos &pos1, const PixelPos &pos2);
        void DrawTransLineClip(Uint32 color, int sx, int sy, int dx, int dy, unsigned char alpha);
 
        void DrawRectangle(Uint32 color, int x, int y, int w, int h);
        void DrawTransRectangle(Uint32 color, int x, int y, int w, int h, unsigned char alpha);
        void DrawRectangleClip(Uint32 color, int x, int y, int w, int h);
        void DrawTransRectangleClip(Uint32 color, int x, int y, int w, int h, unsigned char alpha);
 
        void FillRectangle(Uint32 color, int x, int y, int w, int h);
        void FillTransRectangle(Uint32 color, int x, int y, int w, int h, unsigned char alpha);
        void FillRectangleClip(Uint32 color, int x, int y, int w, int h);
        void FillTransRectangleClip(Uint32 color, int x, int y, int w, int h, unsigned char alpha);
 
        void DrawCircle(Uint32 color, int x, int y, int r);
        void DrawTransCircle(Uint32 color, int x, int y, int r, unsigned char alpha);
        void DrawCircleClip(Uint32 color, int x, int y, int r);
        void DrawTransCircleClip(Uint32 color, int x, int y, int r, unsigned char alpha);
 
        void DrawEllipseClip(Uint32 color, int x, int y, int rx, int ry);
 
        void FillCircle(Uint32 color, int x, int y, int radius);
        void FillTransCircle(Uint32 color, int x, int y, int radius, unsigned char alpha);
        void FillCircleClip(Uint32 color, const PixelPos &screenPos, int radius);
        void FillTransCircleClip(Uint32 color, int x, int y, int radius, unsigned char alpha);
 
        inline Uint32 MapRGB(SDL_PixelFormat *f, Uint8 r, Uint8 g, Uint8 b)
        {
                return SDL_MapRGB(f, r, g, b);
        }
        inline Uint32 MapRGB(SDL_PixelFormat *f, const CColor &color)
        {
                return MapRGB(f, color.R, color.G, color.B);
        }
        inline Uint32 MapRGBA(SDL_PixelFormat *f, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
        {
                return SDL_MapRGBA(f, r, g, b, a);
        }
        inline Uint32 MapRGBA(SDL_PixelFormat *f, const CColor &color)
        {
                return MapRGBA(f, color.R, color.G, color.B, color.A);
        }
        inline void GetRGB(Uint32 c, SDL_PixelFormat *f, Uint8 *r, Uint8 *g, Uint8 *b)
        {
                SDL_GetRGB(c, f, r, g, b);
        }
        inline void GetRGBA(Uint32 c, SDL_PixelFormat *f, Uint8 *r, Uint8 *g, Uint8 *b, Uint8 *a)
        {
                SDL_GetRGBA(c, f, r, g, b, a);
        }
 
        int Width;
        int Height;
        int WindowWidth;
        int WindowHeight;
        double VerticalPixelSize;
        SDL_Cursor *blankCursor;
        int Depth;
        bool FullScreen;
};
 
extern CVideo Video;
 
extern int VideoSyncSpeed;
 
extern int SkipFrames;
 
extern char VideoForceFullScreen;
 
extern double NextFrameTicks;
 
extern unsigned long FrameCounter;
 
extern unsigned long SlowFrameCounter;
 
extern void SetPlayersPalette();
 
extern void VideoCclRegister();
 
extern void InitImageLoaders();
 
extern void DeInitImageLoaders();
 
extern void InitVideo();
 
void DeInitVideo();
 
extern int VideoValidResolution(int w, int h);
 
extern void SetVideoSync();
 
extern void InitLineDraw();
 
extern void Invalidate();
 
extern void InvalidateArea(int x, int y, int w, int h);
 
extern void SetClipping(int left, int top, int right, int bottom);
 
extern void RealizeVideoMemory();
 
extern void SaveScreenshotPNG(const char *name);
 
extern void SaveMapPNG(const char *name);
 
extern void SetCallbacks(const EventCallback *callbacks);
extern const EventCallback *GetCallbacks();
 
extern void WaitEventsOneFrame();
 
extern void ToggleFullScreen();
 
extern void PushClipping();
 
extern void PopClipping();
 
extern unsigned long GetTicks();
 
extern const char *SdlKey2Str(int key);
 
extern bool SdlGetGrabMouse();
extern void ToggleGrabMouse(int mode);
 
extern EventCallback GameCallbacks;   
extern EventCallback EditorCallbacks; 
 
extern Uint32 ColorBlack;
extern Uint32 ColorDarkGreen;
extern Uint32 ColorLightBlue;
extern Uint32 ColorBlue;
extern Uint32 ColorOrange;
extern Uint32 ColorWhite;
extern Uint32 ColorLightGray;
extern Uint32 ColorGray;
extern Uint32 ColorDarkGray;
extern Uint32 ColorRed;
extern Uint32 ColorGreen;
extern Uint32 ColorYellow;
 
inline Uint32 IndexToColor(unsigned int index) {
    // FIXME: this only works after video was initialized, so we do it dynamically
    static const Uint32 ColorValues[] = {ColorRed, ColorYellow, ColorGreen, ColorLightGray,
                                         ColorGray, ColorDarkGray, ColorWhite, ColorOrange,
                                         ColorLightBlue, ColorBlue, ColorDarkGreen, ColorBlack};
    return ColorValues[index];
}
 
static const char *ColorNames[] = {"red", "yellow", "green", "light-gray",
                                   "gray", "dark-gray", "white", "orange",
                                   "light-blue", "blue", "dark-green", "black", NULL};
 
inline int GetColorIndexByName(const char *colorName) {
    int i = 0;
    while (ColorNames[i] != NULL) {
        if (!strcmp(colorName, ColorNames[i])) {
            return i;
        }
        i++;
    }
    return -1;
}
 
extern void FreeGraphics();
 
//
//  Color Cycling stuff
//
 
extern void VideoPaletteListAdd(SDL_Surface *surface);
extern void VideoPaletteListRemove(SDL_Surface *surface);
extern void ClearAllColorCyclingRange();
extern void AddColorCyclingRange(unsigned int begin, unsigned int end);
extern unsigned int SetColorCycleSpeed(unsigned int speed);
extern void SetColorCycleAll(bool value);
extern void RestoreColorCyclingSurface();
 
extern void ColorCycle();
 
extern void BlitSurfaceAlphaBlending_32bpp(const SDL_Surface *srcSurface, const SDL_Rect *srcRect, 
                                                                                                 SDL_Surface *dstSurface, const SDL_Rect *dstRect, const bool enableMT = true);
 
 
#endif // !__VIDEO_H__