frameout.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 SCI_GRAPHICS_FRAMEOUT_H
#define SCI_GRAPHICS_FRAMEOUT_H

#include "common/system.h"               // for g_system
#include "engines/util.h"                // for initGraphics
#include "sci/event.h"
#include "sci/graphics/plane32.h"
#include "sci/graphics/screen_item32.h"

namespace Sci {
typedef Common::Array<DrawList> ScreenItemListList;
typedef Common::Array<RectList> EraseListList;

class GfxCursor32;
class GfxTransitions32;
struct PlaneShowStyle;

class GfxFrameout {
    friend class GfxTransitions32;

public:
    GfxFrameout(SegManager *segMan, GfxPalette32 *palette, GfxTransitions32 *transitions, GfxCursor32 *cursor);
    ~GfxFrameout();

    void clear();
    void run();

    inline bool isHiRes() const { return _isHiRes; }

    inline int16 getScriptWidth() const { return _scriptWidth; }

    inline int16 getScriptHeight() const { return _scriptHeight; }

    inline int16 getScreenWidth() const { return _currentBuffer.w; }

    inline int16 getScreenHeight() const { return _currentBuffer.h; }

private:
    GfxCursor32 *_cursor;
    GfxPalette32 *_palette;
    GfxTransitions32 *_transitions;
    SegManager *_segMan;

    bool _isHiRes;

    int16 _scriptWidth, _scriptHeight;

    bool detectHiRes() const;

#pragma mark -
#pragma mark Screen items
public:
    void addScreenItem(ScreenItem &screenItem) const;

    void updateScreenItem(ScreenItem &screenItem) const;

    void deleteScreenItem(ScreenItem &screenItem);

    void deleteScreenItem(ScreenItem &screenItem, Plane &plane);

    void deleteScreenItem(ScreenItem &screenItem, const reg_t plane);

    void kernelAddScreenItem(const reg_t object);
    void kernelUpdateScreenItem(const reg_t object);
    void kernelDeleteScreenItem(const reg_t object);
    bool kernelSetNowSeen(const reg_t screenItemObject) const;
    int16 kernelObjectIntersect(const reg_t object1, const reg_t object2) const;

private:
    void remapMarkRedraw();
    bool getNowSeenRect(const reg_t screenItemObject, Common::Rect &result) const;

#pragma mark -
#pragma mark Planes
public:
    void addPlane(Plane *plane);

    void deletePlane(Plane &plane);

    void deletePlanesForMacRestore();

    const PlaneList &getPlanes() const {
        return _planes;
    }
    const PlaneList &getVisiblePlanes() const {
        return _visiblePlanes;
    }
    void kernelAddPlane(const reg_t object);
    void kernelUpdatePlane(const reg_t object);
    void kernelDeletePlane(const reg_t object);
    void kernelMovePlaneItems(const reg_t object, const int16 deltaX, const int16 deltaY, const bool scrollPics);
    int16 kernelGetHighPlanePri();

private:
    PlaneList _planes;

    void updatePlane(Plane &plane);

#pragma mark -
#pragma mark Pics
public:
    void kernelAddPicAt(const reg_t planeObject, const GuiResourceId pictureId, const int16 pictureX, const int16 pictureY, const bool mirrorX, const bool deleteDuplicate);

#pragma mark -
#pragma mark Rendering
public:
    void updateScreen(const int delta = 0);

    bool setPixelFormat(const Graphics::PixelFormat *format) const {
        if (!format) {
            initGraphics(_currentBuffer.w, _currentBuffer.h, format);
            return !g_system->getScreenFormat().isCLUT8();
        } else {
            // Also try CLUT8 as a fallback to prevent error dialogs
            Common::List<Graphics::PixelFormat> formatList;
            formatList.push_back(*format);
            if (!format->isCLUT8())
                formatList.push_back(Graphics::PixelFormat::createFormatCLUT8());
            initGraphics(_currentBuffer.w, _currentBuffer.h, formatList);
            return g_system->getScreenFormat() == *format;
        }
    }

    bool _throttleKernelFrameOut;

    bool _palMorphIsOn;

    inline const Buffer &getCurrentBuffer() const {
        return _currentBuffer;
    }

    void kernelFrameOut(const bool showBits);

    void throttle();

    void frameOut(const bool shouldShowBits, const Common::Rect &eraseRect = Common::Rect());

    void palMorphFrameOut(const int8 *styleRanges, PlaneShowStyle *showStyle);

    void directFrameOut(const Common::Rect &showRect);

    void redrawGameScreen(const Common::Rect &skipRect) const;

    void resetHardware();

    void alterVmap(const Palette &palette1, const Palette &palette2, const int8 style, const int8 *const styleRanges);

    // This function is used within ScreenItem subsystem and assigned to various
    // booleanish fields that seem to represent the state of the screen item
    // (created, updated, deleted). In GK1/DOS, Phant1/m68k, SQ6/DOS, SQ6/Win,
    // and Phant2/Win, this function simply returns 1. If you know of any
    // game/environment where this function returns some value other than 1, or
    // if you used to work at Sierra and can explain why this is a thing (and if
    // anyone needs to care about it), please open a ticket!!
    inline int getScreenCount() const {
        return 1;
    };

    void shakeScreen(const int16 numShakes, const ShakeDirection direction);

    Plane *getTopVisiblePlane();

private:
    uint32 _lastScreenUpdateTick;

    uint8 _throttleState;

    Buffer _currentBuffer;

    bool _remapOccurred;

    RectList _showList;

    ScreenItemListList _screenItemLists;

    int _overdrawThreshold;

    PlaneList _visiblePlanes;

    void calcLists(ScreenItemListList &drawLists, EraseListList &eraseLists, const Common::Rect &eraseRect = Common::Rect());

    void drawEraseList(const RectList &eraseList, const Plane &plane);

    void drawScreenItemList(const DrawList &screenItemList);

    void mergeToShowList(const Common::Rect &drawRect, RectList &showList, const int overdrawThreshold);

    void showBits();

    inline bool validZeroStyle(const uint8 style, const int i) const {
        if (style != 0) {
            return false;
        }

        // TODO: Cannot check Shivers or MGDX until those executables can be
        // unwrapped
        switch (g_sci->getGameId()) {
        case GID_KQ7:
        case GID_PHANTASMAGORIA:
        case GID_SQ6:
            return (i > 71 && i < 104);
            break;
        default:
            return true;
        }
    }

#pragma mark -
#pragma mark Mouse cursor
public:
    reg_t kernelIsOnMe(const reg_t object, const Common::Point &position, const bool checkPixel) const;

private:
    void updateMousePositionForRendering() const {
        // In SSCI, mouse events were received via hardware interrupt, so the
        // mouse cursor would always get updated immediately when the user moved
        // the mouse. ScummVM must poll for mouse events from the backend
        // instead, so we poll just before rendering so that the latest mouse
        // position is rendered instead of whatever position it was at the last
        // time kGetEvent was called. Without this, the mouse appears stuck
        // during loops that do not make calls to kGetEvent, like transitions.
        g_sci->getEventManager()->getSciEvent(kSciEventPeek);
    }

    bool isOnMe(const ScreenItem &screenItem, const Plane &plane, const Common::Point &position, const bool checkPixel) const;

#pragma mark -
#pragma mark Debugging
public:
    void printPlaneList(Console *con) const;
    void printVisiblePlaneList(Console *con) const;
    void printPlaneListInternal(Console *con, const PlaneList &planeList) const;
    void printPlaneItemList(Console *con, const reg_t planeObject) const;
    void printVisiblePlaneItemList(Console *con, const reg_t planeObject) const;
    void printPlaneItemListInternal(Console *con, const ScreenItemList &screenItemList) const;
};

} // End of namespace Sci

#endif // SCI_GRAPHICS_FRAMEOUT_H