view.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 MOHAWK_VIEW_H
#define MOHAWK_VIEW_H
 
#include "mohawk/mohawk.h"
#include "common/rect.h"
 
namespace Mohawk {
 
class GraphicsManager;
 
class Feature;
class View;
 
enum : uint {
    kFeatureObjectMask = 0xff, // both (sort of)
    kFeatureOldSortForeground = 0x1000, // old
    kFeatureOldDropSpot = 0x2000, // old
    kFeatureOldNoClip = 0x4000, // old
    kFeatureNewSortForeground = 0x4000, // new
    kFeatureSortBackground = 0x8000, // both
    kFeatureOldReset = 0x10000, // old
    kFeatureOldDisable = 0x20000, // old
    kFeatureOldAlternateScripts = 0x40000, // old
    kFeatureOldDisableOnReset = 0x80000, // old
    kFeatureDisableOnEnd = 0x100000, // both
    kFeatureNewDisable = 0x200000, // new
    kFeatureNewDisableOnReset = 0x400000, // new
    kFeatureOldAdjustByPos = 0x800000, // old
    kFeatureNewNoLoop = 0x800000, // new
    kFeatureOldDisabled = 0x1000000, // old
    kFeatureOldRandom = 0x2000000, // old
    kFeatureNewClip = 0x2000000, // new
    kFeatureSortStatic = 0x4000000, // both
    kFeatureInternalRegion = 0x8000000, // both
    kFeatureSortCheckRight = 0x10000000, // both
    kFeatureSortCheckTop = 0x20000000, // both
    kFeatureSortCheckLeft = 0x40000000, // both
    kFeatureNewInternalTiming = 0x80000000 // new
};
 
class Module {
public:
    Module();
    virtual ~Module();
 
    virtual void init() = 0;
    virtual void shutdown() = 0;
    virtual void update() = 0;
 
    typedef void (Module::*HotspotProc)(uint);
    typedef void (Module::*FeatureProc)(Feature *);
    typedef bool (Module::*BooleanProc)(Feature *);
    typedef void (Module::*PickupProc)(Feature *, Common::Point, uint32, Common::Rect *);
};
 
// This is memcpy()ed around, beware.
#define FEATURE_BITMAP_ITEMS 48 // this is 24 in old
struct FeatureData {
    uint16 bitmapIds[FEATURE_BITMAP_ITEMS];
    Common::Point bitmapPos[FEATURE_BITMAP_ITEMS];
 
    uint16 unknown192; // old?
 
    uint16 scrbIndex;
    uint16 compoundSHAPIndex;
    uint16 endFrame; // old?
    uint16 currFrame; // old?
    uint32 currOffset;
 
    Common::Rect bounds;
 
    Common::Point currentPos;
    Common::Point nextPos;
 
    uint16 unknown220; // old?
 
    uint16 syncChannel;
    uint16 enabled;
    byte paused; // new
    byte hidden; // new
 
    uint16 useClipRect;
    Common::Rect clipRect;
};
 
class Feature {
public:
    Feature(View *view);
    virtual ~Feature();
 
    virtual void resetFrame() = 0;
 
    virtual void setNodeDefaults(Feature *prev, Feature *next);
    virtual void resetFeatureScript(uint16 enabled, uint16 scrbId);
    virtual void resetFeature(bool notifyDone, Module::FeatureProc doneProc, uint16 scrbId);
 
    void hide(bool clip);
    void show();
 
    void moveAndUpdate(Common::Point newPos);
 
    void defaultDraw();
 
    Feature *_next, *_prev;
 
    Module::FeatureProc _drawProc;
    Module::FeatureProc _moveProc;
    Module::FeatureProc _doneProc;
    Module::FeatureProc _frameProc;
    Module::BooleanProc _timeProc;
 
    uint16 _region; // TODO
    uint16 _id;
    uint16 _scrbId;
    uint16 _storedScrbId; // old
    uint32 _flags;
    uint32 _nextTime;
    uint32 _delayTime;
    bool _dirty; // byte in old
    bool _needsReset;
    bool _justReset; // old
    bool _done; // new
 
    FeatureData _data;
 
protected:
    View *_view;
 
    virtual void resetScript() = 0;
    virtual void finishResetFeatureScript() = 0;
};
 
class OldFeature : public Feature {
public:
    OldFeature(View *view);
    ~OldFeature() override;
 
    void resetFrame() override;
    void resetFeatureScript(uint16 enabled, uint16 scrbId) override;
 
protected:
    void resetScript() override;
    void finishResetFeatureScript() override;
};
 
class NewFeature : public Feature {
public:
    NewFeature(View *view);
    ~NewFeature() override;
 
    void resetFrame() override;
    void resetFeatureScript(uint16 enabled, uint16 scrbId) override;
 
    uint32 _unknown168;
 
    // Drag/drop variables.
    Module::PickupProc _pickupProc;
    Module::FeatureProc _dropProc;
    Module::FeatureProc _dragMoveProc;
    Module::FeatureProc _oldMoveProc;
    uint32 _dragFlags;
    uint32 _oldFlags;
    Common::Point _oldPos;
    Common::Point _posDiff;
    Common::Point _currDragPos;
 
protected:
    void resetScript() override;
    void finishResetFeatureScript() override;
};
 
class View {
public:
    View(MohawkEngine *vm);
    virtual ~View();
 
    virtual void idleView();
 
    void setModule(Module *module);
    Module *getCurrentModule() { return _currentModule; }
    GraphicsManager *getGfx() { return _gfx; }
 
    Common::Array<uint16> getSHPL(uint16 id);
    void installBG(uint16 id);
    void setColors(Common::SeekableReadStream *tpalStream);
    void copyFadeColors(uint start, uint count);
 
    uint16 getCompoundSHAPId(uint16 shapIndex);
 
    void installGroupOfSCRBs(bool main, uint base, uint size, uint count = 0);
    virtual void freeScripts();
    void installFeatureShapes(bool regs, uint groupId, uint16 resourceBase);
    void freeFeatureShapes();
 
    uint16 getGroupFromBaseId(uint16 baseId);
    void getnthScriptSetGroup(uint16 &scrbIndex, uint16 &shapIndex, uint16 scrbId);
    Common::SeekableReadStream *getSCRB(uint16 index, uint16 id = 0xffff);
 
    Feature *getFeaturePtr(uint16 id);
    uint16 getNewFeatureId();
    void removeFeature(Feature *feature, bool free);
    void insertUnderCursor(Feature *feature);
    Feature *pointOnFeature(bool topdown, uint32 flags, Common::Point pos);
    void sortView();
 
    uint32 _lastIdleTime;
 
    virtual uint32 getTime() = 0;
 
    bool _needsUpdate;
 
protected:
    MohawkEngine *_vm;
    GraphicsManager *_gfx;
    void setGraphicsManager(GraphicsManager *gfx) { _gfx = gfx; } // TODO
    Module *_currentModule;
 
    uint16 _backgroundId;
 
    Feature *_rootNode, *_cursorNode;
 
    uint16 _numSCRBGroups;
    uint16 _SCRBGroupBases[14];
    uint16 _SCRBGroupSizes[14];
    Common::Array<uint16> _SCRBEntries;
    //uint16 _numCompoundSHAPGroups;
    uint16 _compoundSHAPGroups[14];
 
    Feature *sortOneList(Feature *root);
    Feature *mergeLists(Feature *root, Feature *mergeRoot);
 
    virtual void finishDraw() { }
};
 
} // End of namespace Mohawk
 
#endif