render.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 MTROPOLIS_RENDER_H
#define MTROPOLIS_RENDER_H

#include "common/events.h"
#include "common/ptr.h"
#include "common/scummsys.h"

#include "graphics/pixelformat.h"

#include "actions.h"

namespace Graphics {

class ManagedSurface;
struct Surface;

} // End of namespace Graphics

namespace MTropolis {

class CursorGraphic;
class Runtime;
class Project;
struct SceneTransitionEffect;

enum TextAlignment {
    kTextAlignmentLeft,
    kTextAlignmentCenter,
    kTextAlignmentRight,
};

struct TextStyleFlags {
    bool bold : 1;
    bool italic : 1;
    bool underline : 1;
    bool outline : 1;
    bool shadow : 1;
    bool condensed : 1;
    bool expanded : 1;

    TextStyleFlags();
    bool load(uint8 dataStyleFlags);
};

struct MacFontFormatting {
    MacFontFormatting();
    MacFontFormatting(uint16 mff_fontID, uint8 mff_fontFlags, uint16 mff_size);

    uint16 fontID;
    uint8 fontFlags;
    uint16 size;
};

struct MacFormattingSpan {
    MacFormattingSpan();

    uint16 spanStart;
    MacFontFormatting formatting;
};

struct WindowParameters {
    Runtime *runtime;
    int32 x;
    int32 y;
    int16 width;
    int16 height;
    const Graphics::PixelFormat format;

    WindowParameters(Runtime *wp_runtime, int32 wp_x, int32 wp_y, int16 wp_width, int16 wp_height, const Graphics::PixelFormat &wp_format);
};

class Window {
public:
    explicit Window(const WindowParameters &windowParams);
    virtual ~Window();

    int32 getX() const;
    int32 getY() const;
    int32 getWidth() const;
    int32 getHeight() const;
    void setPosition(int32 x, int32 y);
    void resizeWindow(int32 width, int32 height);   // Destroys contents

    const Common::SharedPtr<Graphics::ManagedSurface> &getSurface() const;
    const Graphics::PixelFormat &getPixelFormat() const;

    const Common::SharedPtr<CursorGraphic> &getCursorGraphic() const;
    void setCursorGraphic(const Common::SharedPtr<CursorGraphic> &cursor);

    bool getMouseVisible() const;
    void setMouseVisible(bool visible);

    void setStrata(int strata);
    int getStrata() const;

    // Mouse transparency = ignores mouse events
    void setMouseTransparent(bool isTransparent);
    bool isMouseTransparent() const;

    void close();
    void detachFromRuntime();

    virtual void onMouseDown(int32 x, int32 y, int mouseButton);
    virtual void onMouseMove(int32 x, int32 y);
    virtual void onMouseUp(int32 x, int32 y, int mouseButton);
    virtual void onKeyboardEvent(const Common::EventType evtType, bool repeat, const Common::KeyState &keyEvt);
    virtual void onAction(Actions::Action action);

protected:
    int32 _x;
    int32 _y;
    Runtime *_runtime;
    int _strata;
    bool _isMouseTransparent;
    bool _isMouseVisible;

    Common::SharedPtr<Graphics::ManagedSurface> _surface;
    Common::SharedPtr<CursorGraphic> _cursor;
};

namespace Render {

uint32 resolveRGB(uint8 r, uint8 g, uint8 b, const Graphics::PixelFormat &fmt);
void renderProject(Runtime *runtime, Window *mainWindow, bool *outSkipped);
void renderSceneTransition(Runtime *runtime, Window *mainWindow, const SceneTransitionEffect &effect, uint32 startTime, uint32 endTime, uint32 currentTime, const Graphics::ManagedSurface &oldFrame, const Graphics::ManagedSurface &newFrame);

void convert32To16(Graphics::ManagedSurface &destSurface, const Graphics::ManagedSurface &srcSurface);
void convert16To32(Graphics::ManagedSurface &destSurface, const Graphics::ManagedSurface &srcSurface);

} // End of namespace Render

} // End of namespace MTropolis

#endif