screen.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/>.
 *
 */
 
#ifndef ULTIMA4_GFX_SCREEN_H
#define ULTIMA4_GFX_SCREEN_H
 
#include "common/file.h"
#include "graphics/screen.h"
#include "ultima/ultima4/core/config.h"
#include "ultima/ultima4/core/types.h"
#include "ultima/ultima4/gfx/scale.h"
#include "ultima/ultima4/map/direction.h"
#include "ultima/ultima4/map/map_tile.h"
 
namespace Ultima {
namespace Ultima4 {
 
#define SCR_CYCLE_PER_SECOND 4
#define SCR_CYCLE_MAX 16
#define SCREEN_FRAME_TIME 50
#define SCREEN_WIDTH 320
#define SCREEN_HEIGHT 200
 
/*
 * bitmasks for LOS shadows
 */
#define ____H 0x01    // obscured along the horizontal face
#define ___C_ 0x02    // obscured at the center
#define __V__ 0x04    // obscured along the vertical face
#define _N___ 0x80    // start of new raster
 
#define ___CH 0x03
#define __VCH 0x07
#define __VC_ 0x06
 
#define _N__H 0x81
#define _N_CH 0x83
#define _NVCH 0x87
#define _NVC_ 0x86
#define _NV__ 0x84
 
 
enum LayoutType {
    LAYOUT_STANDARD,
    LAYOUT_GEM,
    LAYOUT_DUNGEONGEM
};
 
enum MouseCursor {
    MC_DEFAULT,
    MC_WEST,
    MC_NORTH,
    MC_EAST,
    MC_SOUTH
};
 
class Image;
class Map;
class Tile;
class TileView;
class Coords;
class TileAnimSet;
class ImageInfo;
 
struct MouseCursorSurface : public Graphics::ManagedSurface {
    Common::Point _hotspot;
};
 
struct MouseArea {
    int _nPoints;
    struct {
        int x, y;
    } _point[3];
    MouseCursor _cursor;
    Direction _direction;
};
 
struct Layout {
    Common::String _name;
    LayoutType _type;
    Common::Point _tileShape;
    Common::Rect _viewport;
};
 
class Screen : public Graphics::Screen {
private:
    MouseCursorSurface *_mouseCursors[5];
    int _currentMouseCursor;
 
    Common::Array<TileAnimSet *> _tileAnimSets;
    Layout *_gemLayout;
    Common::HashMap<Common::String, int> _dungeonTileChars;
    ImageInfo *_charSetInfo;
    ImageInfo *_gemTilesInfo;
 
    int _needPrompt;
    Common::Point _cursorPos;
    int _cursorStatus;
    int _cursorEnabled;
    int _los[VIEWPORT_W][VIEWPORT_H];
    //bool _continueScreenRefresh;
    uint32 _priorFrameTime;
 
public:
    Common::Array<Common::String> _gemLayoutNames;
    Common::Array<Common::String> _filterNames;
    Common::Array<Common::String> _lineOfSightStyles;
    int _currentCycle;
    TileAnimSet *_tileAnims;
private:
    void loadMouseCursors();
 
    MouseCursorSurface *loadMouseCursor(Common::File &src);
 
    void screenLoadGraphicsFromConf();
    Layout *screenLoadLayoutFromConf(const ConfigElement &conf);
 
    void screenShowGemTile(Layout *layout, Map *map, MapTile &t, bool focus, int x, int y);
 
    void screenFindLineOfSight(Common::Array<MapTile> viewportTiles[VIEWPORT_W][VIEWPORT_H]);
 
    void screenFindLineOfSightDOS(Common::Array<MapTile> viewportTiles[VIEWPORT_W][VIEWPORT_H]);
 
    void screenFindLineOfSightEnhanced(Common::Array<MapTile> viewportTiles[VIEWPORT_W][VIEWPORT_H]);
 
    void screenGetLineTerms(int x1, int y1, int x2, int y2, double *a, double *b);
 
    int screenPointsOnSameSideOfLine(int x1, int y1, int x2, int y2, double a, double b);
 
    int screenPointInTriangle(int x, int y, int tx1, int ty1, int tx2, int ty2, int tx3, int ty3);
    Layout *screenGetGemLayout(const Map *map);
public:
    Common::Array<Layout *> _layouts;
    Scaler _filterScaler;
 
public:
    Screen();
    ~Screen();
 
    void init();
 
    void clear();
 
    void setMouseCursor(MouseCursor cursor);
 
    void screenReInit();
    void screenWait(int numberOfAnimationFrames);
 
    void screenDrawImage(const Common::String &name, int x = 0, int y = 0);
    void screenDrawImageInMapArea(const Common::String &bkgd);
 
    void screenFrame();
    void screenCycle();
    void screenEraseMapArea();
    void screenEraseTextArea(int x, int y, int width, int height);
    void screenGemUpdate();
 
    void screenMessage(const char *fmt, ...);
    void screenPrompt();
    void screenRedrawMapArea();
    void screenRedrawTextArea(int x, int y, int width, int height);
 
    void screenScrollMessageArea();
 
    void screenShake(int iterations);
 
    void screenShowChar(int chr, int x, int y);
    void screenTextAt(int x, int y, const char *fmt, ...);
 
    void screenTextColor(int color);
    bool screenTileUpdate(TileView *view, const Coords &coords, bool redraw = true); //Returns true if the screen was affected
 
    void screenUpdate(TileView *view, bool showmap, bool blackout);
    void screenUpdateCursor();
    void screenUpdateMoons();
    void screenUpdateWind();
    Common::Array<MapTile> screenViewportTile(uint width, uint height, int x, int y, bool &focus);
 
    void screenShowCursor();
    void screenHideCursor();
    void screenEnableCursor();
    void screenDisableCursor();
    void screenSetCursorPos(int x, int y);
 
    int screenPointInMouseArea(int x, int y, const MouseArea *area);
 
    Image *screenScale(Image *src, int scale, int n, int filter);
 
    Image *screenScaleDown(Image *src, int scale);
};
 
extern Screen *g_screen;
 
extern const Common::Array<Common::String> &screenGetGemLayoutNames();
extern const Common::Array<Common::String> &screenGetFilterNames();
extern const Common::Array<Common::String> &screenGetLineOfSightStyles();
 
} // End of namespace Ultima4
} // End of namespace Ultima
 
#endif