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