plane32.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_PLANE32_H
#define SCI_GRAPHICS_PLANE32_H

#include "common/array.h"
#include "common/rect.h"
#include "sci/engine/features.h"
#include "sci/engine/vm_types.h"
#include "sci/graphics/helpers.h"
#include "sci/graphics/lists32.h"
#include "sci/graphics/screen_item32.h"

namespace Sci {
enum PlaneType {
    kPlaneTypeColored            = 0,
    kPlaneTypePicture            = 1,
    kPlaneTypeTransparent        = 2,
    kPlaneTypeOpaque             = 3,
    kPlaneTypeTransparentPicture = 4
};

enum PlanePictureCodes {
    // Any value at or below 65531 means the plane is a kPlaneTypePicture
    kPlanePic                   = 65531,
    kPlanePicTransparentPicture = 65532,
    kPlanePicOpaque             = 65533,
    kPlanePicTransparent        = 65534,
    kPlanePicColored            = 65535
};

#pragma mark -
#pragma mark RectList

typedef StablePointerArray<Common::Rect, 200> RectListBase;
class RectList : public RectListBase {
public:
    void add(const Common::Rect &rect) {
        RectListBase::add(new Common::Rect(rect));
    }
};

#pragma mark -
#pragma mark DrawList

struct DrawItem {
    ScreenItem *screenItem;

    Common::Rect rect;

    inline bool operator<(const DrawItem &other) const {
        return *screenItem < *other.screenItem;
    }
};

typedef StablePointerDynamicArray<DrawItem, 250> DrawListBase;
class DrawList : public DrawListBase {
private:
    inline static bool sortHelper(const DrawItem *a, const DrawItem *b) {
        return *a < *b;
    }
public:
    void add(ScreenItem *screenItem, const Common::Rect &rect);
    inline void sort() {
        pack();
        Common::sort(begin(), end(), sortHelper);
    }
};

class PlaneList;

#pragma mark -
#pragma mark Plane

class Plane {
private:
    static uint16 _nextObjectId;

    static uint32 _nextCreationId;

    uint32 _creationId;

    GuiResourceId _pictureId;

    bool _mirrored;

    bool _pictureChanged;

    void convertGameRectToPlaneRect();

    void setType();

public:
    PlaneType _type;

    byte _back;

    int _priorityChanged;

    reg_t _object;

    int16 _priority;

    int _redrawAllCount;

    int _created, _updated, _deleted, _moved;

    Common::Point _vanishingPoint;

    Common::Rect _planeRect;

    Common::Rect _gameRect;

    Common::Rect _screenRect;

    ScreenItemList _screenItemList;

public:
    static void init();

    // In SSCI this constructor signature did not accept a picture ID, but some
    // calls to construct planes with this signature immediately set the picture
    // ID and then called setType again, so it made more sense to just make the
    // picture ID a parameter instead.
    Plane(const Common::Rect &gameRect, PlanePictureCodes pictureId = kPlanePicColored);

    Plane(const reg_t object);

    Plane(const Plane &other);

    void operator=(const Plane &other);

    inline bool operator<(const Plane &other) const {
        if (_priority < other._priority) {
            return true;
        }

        if (_priority == other._priority) {
            // This is different than SSCI; see ScreenItem::operator< for an
            // explanation
            return _creationId < other._creationId;
        }

        return false;
    }

    inline void clipScreenRect(const Common::Rect &screenRect) {
        // LSL6 hires creates planes with invalid rects; SSCI does not care
        // about this, but `Common::Rect::clip` does, so we need to check
        // whether or not the rect is actually valid before clipping and only
        // clip valid rects
        if (_screenRect.isValidRect() && _screenRect.intersects(screenRect)) {
            _screenRect.clip(screenRect);
        } else {
            _screenRect.left = 0;
            _screenRect.top = 0;
            _screenRect.right = 0;
            _screenRect.bottom = 0;
        }
    }

    void printDebugInfo(Console *con) const;

    void sync(const Plane *other, const Common::Rect &screenRect);

    void update(const reg_t object);

    void scrollScreenItems(const int16 deltaX, const int16 deltaY, const bool scrollPics);

    inline bool isDefaultPlane() {
        return _object.isNumber() && _object.getOffset() == (uint32)g_sci->_features->detectPlaneIdBase();
    }

#pragma mark -
#pragma mark Plane - Pic
private:
    inline void addPicInternal(const GuiResourceId pictureId, const Common::Point *position, const bool mirrorX);

    void deletePic(const GuiResourceId pictureId);

    void deleteAllPics();

public:
    GuiResourceId addPic(const GuiResourceId pictureId, const Common::Point &position, const bool mirrorX, const bool deleteDuplicate = true);

    void changePic();

    void deletePic(const GuiResourceId oldPictureId, const GuiResourceId newPictureId);

#pragma mark -
#pragma mark Plane - Rendering
private:
    void breakDrawListByPlanes(DrawList &drawList, const PlaneList &planeList) const;

    void breakEraseListByPlanes(RectList &eraseList, const PlaneList &planeList) const;

    void mergeToDrawList(const DrawList::size_type index, const Common::Rect &rect, DrawList &drawList) const;

    void mergeToRectList(const Common::Rect &rect, RectList &eraseList) const;

public:
    void calcLists(Plane &visiblePlane, const PlaneList &planeList, DrawList &drawList, RectList &eraseList);

    void decrementScreenItemArrayCounts(Plane *visiblePlane, const bool forceUpdate);

    void filterDownEraseRects(DrawList &drawList, RectList &eraseList, RectList &higherEraseList) const;

    void filterUpEraseRects(DrawList &drawList, const RectList &lowerEraseList) const;

    void filterUpDrawRects(DrawList &drawList, const DrawList &lowerDrawList) const;

    void redrawAll(Plane *visiblePlane, const PlaneList &planeList, DrawList &drawList, RectList &eraseList);

    void remapMarkRedraw();
};

#pragma mark -
#pragma mark PlaneList

typedef Common::Array<Plane *> PlaneListBase;
class PlaneList : public PlaneListBase {
private:
    inline static bool sortHelper(const Plane *a, const Plane *b) {
        return *a < *b;
    }

    using PlaneListBase::push_back;

public:
    // A method for finding the index of a plane inside a PlaneList is used
    // because entries in the main plane list and visible plane list of
    // GfxFrameout are synchronised by index
    int findIndexByObject(const reg_t object) const;
    Plane *findByObject(const reg_t object) const;

    int16 getTopPlanePriority() const;

    int16 getTopSciPlanePriority() const;

    void add(Plane *plane);
    void clear();
    iterator erase(iterator it);
    void erase(Plane *plane);
    inline void sort() {
        Common::sort(begin(), end(), sortHelper);
    }
    void remove_at(size_type index);
};

} // End of namespace Sci

#endif // SCI_GRAPHICS_PLANE32_H