data.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_DATA_H
#define MTROPOLIS_DATA_H
 
#include "common/array.h"
#include "common/data-io.h"
#include "common/endian.h"
#include "common/error.h"
#include "common/hashmap.h"
#include "common/hash-str.h"
#include "common/ptr.h"
#include "common/stream.h"
#include "common/rect.h"
#include "common/xpfloat.h"
 
#include "mtropolis/core.h"
 
// This contains defs related to parsing of mTropolis stored data into structured data objects.
// This is separated from asset construction for a number of reasons, mainly that data parsing has
// several quirky parses, and there are a lot of fields where, due to platform-specific byte
// swaps, we know the size of the value but don't know what it means.
 
namespace MTropolis {
 
class PlugIn;
 
namespace Data {
 
enum DataFormat {
    kDataFormatUnknown,
 
    kDataFormatMacintosh,
    kDataFormatWindows,
};
 
} // End of namespace Data
 
} // End of namespace MTropolis
 
namespace Common {
 
template<>
struct DataFormatTraits<MTropolis::Data::DataFormat> {
    static inline bool isLittleEndian(MTropolis::Data::DataFormat dataFormat) {
        return dataFormat != MTropolis::Data::kDataFormatMacintosh;
    }
};
 
template<>
struct DataIO<MTropolis::Data::DataFormat, Common::XPFloat> {
    static const uint kMaxSize = 10;
 
    static inline uint computeSize(MTropolis::Data::DataFormat dataFormat) {
        if (dataFormat == MTropolis::Data::kDataFormatMacintosh)
            return 10;
        else if (dataFormat == MTropolis::Data::kDataFormatWindows)
            return 8;
        else
            return 0;
    }
 
    static inline void encode(MTropolis::Data::DataFormat dataFormat, byte *data, const Common::XPFloat &value) {
        if (dataFormat == MTropolis::Data::kDataFormatMacintosh) {
            DataIO<MTropolis::Data::DataFormat, uint16>::encode(dataFormat, data + 0, value.signAndExponent);
            DataIO<MTropolis::Data::DataFormat, uint64>::encode(dataFormat, data + 2, value.mantissa);
        } else if (dataFormat == MTropolis::Data::kDataFormatWindows) {
            uint64 doubleBits = 0;
            bool overflowed = false;
            value.toDoubleBitsSafe(doubleBits, overflowed);
            DataIO<MTropolis::Data::DataFormat, uint64>::encode(dataFormat, data, doubleBits);
        }
    }
 
    static inline void decode(MTropolis::Data::DataFormat dataFormat, const byte *data, Common::XPFloat &value) {
        if (dataFormat == MTropolis::Data::kDataFormatMacintosh) {
            DataIO<MTropolis::Data::DataFormat, uint16>::decode(dataFormat, data + 0, value.signAndExponent);
            DataIO<MTropolis::Data::DataFormat, uint64>::decode(dataFormat, data + 2, value.mantissa);
        } else if (dataFormat == MTropolis::Data::kDataFormatWindows) {
            uint64 doubleBits = 0;
            DataIO<MTropolis::Data::DataFormat, uint64>::decode(dataFormat, data, doubleBits);
            value = value.fromDoubleBits(doubleBits);
        }
    }
};
 
} // End of namespace Common
 
 
namespace MTropolis {
 
class PlugIn;
 
namespace Data {
 
struct PlugInModifier;
struct PlugInModifierData;
 
// Project format and data format are 2 separate things.
//
// A cross-platform project can be booted in either Mac or Win mode and contains
// separate scene streams for Mac and Win.  Which one is loaded depends on what the
// game platform is loaded as.
//
// The following table describes the behavior:
//
// Project type          | ProjectFormat | Catalog and asset data format | Scene data format |
// ------------------------------------------------------------------------------------------|
// Mac                   | Macintosh     | Macintosh                     | Macintosh         |
// Win                   | Windows       | Windows                       | Windows           |
// Cross-Platform as Mac | Neutral       | Windows                       | Macintosh         |
// Cross-Platform as Win | Neutral       | Windows                       | Windows           |
 
enum ProjectFormat {
    kProjectFormatUnknown,
 
    kProjectFormatMacintosh,
    kProjectFormatWindows,
    kProjectFormatNeutral,
};
 
enum DataReadErrorCode {
    kDataReadErrorNone = 0,
 
    kDataReadErrorUnsupportedRevision,
    kDataReadErrorReadFailed,
    kDataReadErrorUnrecognized,
    kDataReadErrorPlugInNotFound,
};
 
enum ModifierFlags {
    kModifierFlagLast = 0x2,
};
 
enum TextAlignmentCode {
    kTextAlignmentCodeLeft = 0,
    kTextAlignmentCodeCenter = 1,
    kTextAlignmentCodeRight = 0xffff,
};
 
 
namespace DataObjectTypes {
 
enum DataObjectType : uint {
    kUnknown                                = 0,
 
    kProjectLabelMap                        = 0x22,
    kProjectCatalog                         = 0x3e8,
    kStreamHeader                           = 0x3e9,
    kProjectHeader                          = 0x3ea,
    kPresentationSettings                   = 0x3ec,
 
    kAssetCatalog                           = 0xd,
    kGlobalObjectInfo                       = 0x17,
    kUnknown19                              = 0x19,
    kUnknown2B                              = 0x2b,
 
    kProjectStructuralDef                   = 0x2,
    kSectionStructuralDef                   = 0x3,
    kSubsectionStructuralDef                = 0x21,
 
    kGraphicElement                         = 0x8,
    kMovieElement                           = 0x5,
    kMToonElement                           = 0x6,
    kImageElement                           = 0x7,
    kSoundElement                           = 0xa,
    kTextLabelElement                       = 0x15,
 
    kAVIMovieElement                        = 0x25,
    kAliasModifier                          = 0x27,
    kChangeSceneModifier                    = 0x136,
    kReturnModifier                         = 0x140,
    kSoundEffectModifier                    = 0x1a4,
    kSimpleMotionModifier                   = 0x1fe,
    kDragMotionModifier                     = 0x208,
    kPathMotionModifierV1                   = 0x21c,
    kPathMotionModifierV2                   = 0x21b,
    kVectorMotionModifier                   = 0x226,
    kSceneTransitionModifier                = 0x26c,
    kElementTransitionModifier              = 0x276,
    kSharedSceneModifier                    = 0x29a,
    kIfMessengerModifier                    = 0x2bc,
    kBehaviorModifier                       = 0x2c6,
    kMessengerModifier                      = 0x2da,
    kSetModifier                            = 0x2df,
    kTimerMessengerModifier                 = 0x2e4,
    kCollisionDetectionMessengerModifier    = 0x2ee,
    kBoundaryDetectionMessengerModifier     = 0x2f8,
    kKeyboardMessengerModifier              = 0x302,
    kTextStyleModifier                      = 0x32a,
    kGraphicModifier                        = 0x334,
    kImageEffectModifier                    = 0x384,
    kMiniscriptModifier                     = 0x3c0,
    kCursorModifierV1                       = 0x3ca,
    kGradientModifier                       = 0x4b0,    // NYI
    kColorTableModifier                     = 0x4c4,
    kSoundFadeModifier                      = 0x4ce,
    kSaveAndRestoreModifier                 = 0x4d8,
 
    kCompoundVariableModifier               = 0x2c7,
    kBooleanVariableModifier                = 0x321,
    kIntegerVariableModifier                = 0x322,
    kIntegerRangeVariableModifier           = 0x324,
    kVectorVariableModifier                 = 0x327,
    kPointVariableModifier                  = 0x326,
    kFloatingPointVariableModifier          = 0x328,
    kStringVariableModifier                 = 0x329,
    kObjectReferenceVariableModifierV1      = 0x33e,
    kDebris                                 = 0xfffffffe,   // Deleted modifier in alias list
    kPlugInModifier                         = 0xffffffff,
 
    kMovieAsset                             = 0x10,
    kAudioAsset                             = 0x11,
    kColorTableAsset                        = 0x1e,
    kImageAsset                             = 0xe,
    kMToonAsset                             = 0xf,
    kTextAsset                              = 0x1f,
    kAVIMovieAsset                          = 0x24,
 
    kAssetDataChunk                         = 0xffff,
};
 
bool isValidSceneRootElement(DataObjectType type);
bool isVisualElement(DataObjectType type);
bool isNonVisualElement(DataObjectType type);
bool isStructural(DataObjectType type);
bool isElement(DataObjectType type);
bool isModifier(DataObjectType type);
bool isAsset(DataObjectType type);
 
} // End of namespace DataObjectTypes
 
namespace StructuralFlags {
    enum StructuralFlags {
        kHasModifiers = 0x1,
        kHasChildren = 0x4,
        kNoMoreSiblings = 0x8,
    };
} // End of namespace StructuralFlags
 
 
class DataReader {
public:
    DataReader(int64 globalPosition, Common::SeekableReadStream &stream, DataFormat dataFormat, RuntimeVersion runtimeVersion, bool autoDetectVersion);
 
    bool readU8(uint8 &value);
    bool readU16(uint16 &value);
    bool readU32(uint32 &value);
    bool readU64(uint64 &value);
    bool readS8(int8 &value);
    bool readS16(int16 &value);
    bool readS32(int32 &value);
    bool readS64(int64 &value);
    bool readF32(float &value);
    bool readF64(double &value);
    bool readPlatformFloat(Common::XPFloat &value);
 
    template<class... T>
    bool readMultiple(T &...values);
 
    bool read(void *dest, size_t size);
 
    // Reads a terminated string where "length" is the number of characters including a null terminator
    bool readTerminatedStr(Common::String &value, size_t length);
 
    bool readNonTerminatedStr(Common::String &value, size_t length);
 
    template<size_t TSize>
    bool readChars(char (&arr)[TSize]);
 
    template<size_t TSize>
    bool readBytes(uint8 (&arr)[TSize]);
 
    bool seek(int64 pos);
    bool skip(size_t count);
 
    int64 tell() const;
    inline int64 tellGlobal() const { return _globalPosition + tell(); }
 
    DataFormat getDataFormat() const;
 
    void setPermitDamagedStrings(bool permit);
 
    bool isVersionAutoDetect() const;
    RuntimeVersion getRuntimeVersion() const;
    void setRuntimeVersion(RuntimeVersion runtimeVersion);
 
private:
    bool checkErrorAndReset();
 
    Common::SeekableReadStream &_stream;
    DataFormat _dataFormat;
    int64 _globalPosition;
 
    bool _permitDamagedStrings;
 
    RuntimeVersion _runtimeVersion; // NOTE: May change during parsing if auto-detecting
    bool _autoDetect;
};
 
template<class... T>
bool DataReader::readMultiple(T &...values) {
    byte buffer[Common::DataMultipleIO<DataFormat, T...>::kMaxSize];
    const uint actualSize = Common::DataMultipleIO<DataFormat, T...>::computeSize(_dataFormat);
 
    if (!read(buffer, actualSize))
        return false;
 
    Common::DataMultipleIO<DataFormat, T...>::decode(_dataFormat, buffer, values...);
    return true;
}
 
struct Rect {
    Rect();
 
    bool load(DataReader &reader);
 
    bool toScummVMRect(Common::Rect &outRect) const;
    bool toScummVMRectUnchecked(Common::Rect &outRect) const;
 
    int16 top;
    int16 left;
    int16 bottom;
    int16 right;
};
 
struct Point {
    Point();
 
    bool load(DataReader &reader);
    bool toScummVMPoint(Common::Point &outPoint) const;
 
    int16 x;
    int16 y;
};
 
struct Event {
    Event();
 
    bool load(DataReader &reader);
 
    uint32 eventID;
    uint32 eventInfo;
};
 
struct ColorRGB16 {
    ColorRGB16();
 
    bool load(DataReader &reader);
 
    uint16 red;
    uint16 green;
    uint16 blue;
};
 
struct IntRange {
    IntRange();
 
    bool load(DataReader &reader);
 
    int32 min;
    int32 max;
};
 
struct XPFloatVector {
    bool load(DataReader &reader);
 
    Common::XPFloat angleRadians;
    Common::XPFloat magnitude;
};
 
struct XPFloatPOD {
    uint16 signAndExponent;
    uint64 mantissa;
 
    bool load(DataReader &reader);
    Common::XPFloat toXPFloat() const;
};
 
struct Label {
    bool load(DataReader &reader);
 
    uint32 superGroupID;
    uint32 labelID;
};
 
struct UniversalTime {
    bool load(DataReader &reader);
 
    int32 value;
    int32 scale;
    int32 base;
};
 
 
// mTropolis uses two separate type-tagged value formats.
//
// InternalTypeTaggedValue is used by internal modifiers for messenger payloads and set modifiers
// and seems to match Miniscript ops too.
// InternalTypeTaggedValue is always 46 bytes in size and stores string data elsewhere in the containing structure.
//
// PlugInTypeTaggedValue is used by plug-ins and is fully self-contained.
//
// If you change something here, remember to update DynamicValue::load
struct InternalTypeTaggedValue {
    enum TypeCode {
        kNull = 0x00,
        kInteger = 0x01,
        kString = 0x0d, // String data is stored externally from the value
        kPoint = 0x10,
        kIntegerRange = 0x11,
        kFloat = 0x15,
        kBool = 0x1a,
        kIncomingData = 0x1b,
        kVariableReference = 0x1c,
        kLabel = 0x1d,
    };
 
    struct VariableReference {
        uint32 unknown;
        uint32 guid;
    };
 
    union ValueUnion {
        ValueUnion();
 
        uint8 asBool;
        XPFloatPOD asFloat;
        int32 asInteger;
        IntRange asIntegerRange;
        VariableReference asVariableReference;
        Label asLabel;
        Point asPoint;
 
        template<class T>
        void constructField(T ValueUnion::*fieldPtr);
    };
 
    InternalTypeTaggedValue();
    ~InternalTypeTaggedValue();
 
    uint16 type;
    ValueUnion value;
 
    bool load(DataReader &reader);
};
 
struct PlugInTypeTaggedValue : public Common::NonCopyable {
    enum TypeCode {
        kNull = 0x00,
        kInteger = 0x01,
        kUniversalTime = 0x09,
        kPoint = 0xa,
        kIntegerRange = 0xb,
        kFloat = 0xf,
        kBoolean = 0x14,
        kEvent = 0x17,
        kLabel = 0x64,
        kString = 0x66,
        kRGBColor = 0x6c,
        kIncomingData = 0x6e,
        kVariableReference = 0x73,  // Has extra data
    };
 
    union ValueUnion {
        ValueUnion();
        ~ValueUnion();
 
        int32 asInt;
        Point asPoint;
        UniversalTime asUniversalTime;
        ColorRGB16 asColor;
        IntRange asIntRange;
        XPFloatPOD asFloat;
        uint16 asBoolean;
        Event asEvent;
        Label asLabel;
        uint32 asVarRefGUID;
        Common::String asString;
 
        template<class T>
        void constructField(T ValueUnion::*fieldPtr);
 
        template<class T>
        void destructField(T ValueUnion::*fieldPtr);
    };
 
    PlugInTypeTaggedValue();
    ~PlugInTypeTaggedValue();
 
    uint16 type;
    ValueUnion value;
 
    Common::Array<uint8> extraData;
 
    bool load(DataReader &reader);
};
 
class DataObject : public Common::NonCopyable {
 
public:
    DataObject();
    virtual ~DataObject();
    DataReadErrorCode load(DataObjectTypes::DataObjectType type, uint16 revision, DataReader &reader);
 
    uint16 getRevision() const;
    DataObjectTypes::DataObjectType getType() const;
 
protected:
    virtual DataReadErrorCode load(DataReader &reader) = 0;
 
    DataObjectTypes::DataObjectType _type;
    uint16 _revision;
};
 
struct ProjectHeader : public DataObject {
    ProjectHeader();
 
    uint32 persistFlags;
    uint32 sizeIncludingTag;
    uint16 unknown1;
    uint32 catalogFilePosition;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct ProjectLabelMap : public DataObject {
    ProjectLabelMap();
    ~ProjectLabelMap();
 
    struct LabelTree {
        LabelTree();
        ~LabelTree();
 
        enum : uint {
            kExpandedInEditor = 0x80000000,
        };
 
        uint32 nameLength;
        uint32 isGroup;
        uint32 id;
        uint32 unknown1;
        uint32 flags;
 
        Common::String name;
 
        uint32 numChildren;
        LabelTree *children;
    };
 
    struct SuperGroup {
        SuperGroup();
        ~SuperGroup();
 
        uint32 nameLength;
        uint32 id;
        uint32 unknown2;
        Common::String name;
 
        uint32 numChildren;
        LabelTree *tree;
    };
 
    uint32 persistFlags;
    uint32 unknown1; // Always 0x16
    uint32 numSuperGroups;
    uint32 nextAvailableID;
 
    SuperGroup *superGroups;
 
private:
    static DataReadErrorCode loadSuperGroup(SuperGroup &sg, DataReader &reader);
    static DataReadErrorCode loadLabelTree(LabelTree &lt, DataReader &reader);
 
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct PresentationSettings : public DataObject {
    PresentationSettings();
 
    uint32 persistFlags;
    uint32 sizeIncludingTag;
    uint8 unknown1[2];
    Point dimensions;
    uint16 bitsPerPixel;
    uint16 unknown4;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct AssetCatalog : public DataObject {
    enum {
        kFlag1Deleted = 1,
        kFlag1LimitOnePerSegment = 2,
    };
 
    struct AssetInfoRev4Fields {
        AssetInfoRev4Fields();
 
        uint32 assetType;
        uint32 flags2;
    };
 
    struct AssetInfo {
        AssetInfo();
 
        uint32 flags1;
        uint16 nameLength;
        uint16 alwaysZero;
        uint32 streamID;
        uint32 filePosition; // Contains a static value in Obsidian
 
        AssetInfoRev4Fields rev4Fields;
 
        Common::String name;
    };
 
    AssetCatalog();
 
    uint32 persistFlags;
    uint32 totalNameSizePlus22;
    uint8 unknown1[4];
    uint32 numAssets;
    bool haveRev4Fields;
 
    Common::Array<AssetInfo> assets;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct Unknown19 : public DataObject {
    Unknown19();
 
    uint32 persistFlags;
    uint32 sizeIncludingTag;
    uint8 unknown1[2];
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct Unknown2B : public DataObject {
    Unknown2B();
 
    uint32 persistFlags;
    uint32 sizeIncludingTag;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct StructuralDef : public DataObject {
    StructuralDef();
 
    uint32 structuralFlags;
};
 
struct ProjectStructuralDef : public DataObject {
    ProjectStructuralDef();
 
    uint32 unknown1; // Seems to always be 0x16 or 0x9
    uint32 sizeIncludingTag;
    uint32 guid;
    uint32 otherFlags;
    uint16 lengthOfName;
 
    Common::String name;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct SectionStructuralDef : public StructuralDef {
    SectionStructuralDef();
 
    uint32 sizeIncludingTag;
    uint32 guid;
    uint16 lengthOfName;
    uint32 otherFlags;
    uint16 unknown4;
    uint16 sectionID;
    uint32 segmentID;
 
    Common::String name;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct SubsectionStructuralDef : public StructuralDef {
    SubsectionStructuralDef();
 
    uint32 structuralFlags;
    uint32 sizeIncludingTag;
    uint32 guid;
    uint16 lengthOfName;
    uint32 otherFlags;
    uint16 sectionID;
 
    Common::String name;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
namespace ElementFlags {
 
enum ElementFlags {
    kNotDirectToScreen  = 0x00001000,
    kHidden             = 0x00008000,
    kPaused             = 0x00010000,
    kExpandedInEditor   = 0x00800000,
    kCacheBitmap        = 0x02000000,
    kSelectedInEditor   = 0x10000000,
};
 
} // End of namespace ElementFlags
 
namespace AnimationFlags {
 
enum AnimationFlags {
    kAlternate          = 0x10000000,
    kLoop               = 0x08000000,
    kPlayEveryFrame     = 0x02000000,
};
 
} // End of namespace AnimationFlags
 
namespace SceneTransitionTypes {
 
enum SceneTransitionType {
    kNone = 0,
    kPatternDissolve = 0x0406,
    kRandomDissolve = 0x0410, // No steps
    kFade = 0x041a,
    kSlide = 0x03e8, // Directional
    kPush = 0x03f2,  // Directional
    kZoom = 0x03fc,
    kWipe = 0x0424, // Directional
};
 
} // End of namespace SceneTransitionTypes
 
namespace SceneTransitionDirections {
 
enum SceneTransitionDirection {
    kUp = 0x384,
    kDown = 0x385,
    kLeft = 0x386,
    kRight = 0x387,
};
 
} // End of namespace SceneTransitionDirections
 
struct GraphicElement : public StructuralDef {
    GraphicElement();
 
    // Possible element flags: NotDirectToScreen, CacheBitmap, Hidden
    uint32 sizeIncludingTag;
    uint32 guid;
    uint16 lengthOfName;
    uint32 elementFlags;
    uint16 layer;
    uint16 sectionID;
    Rect rect1;
    Rect rect2;
    uint32 streamLocator; // 1-based index, sometimes observed with 0x10000000 flag set, not sure of the meaning
    uint8 unknown11[4];
 
    Common::String name;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct ImageElement : public StructuralDef {
    ImageElement();
 
    // Possible element flags: NotDirectToScreen, CacheBitmap, Hidden
    uint32 sizeIncludingTag;
    uint32 guid;
    uint16 lengthOfName;
    uint32 elementFlags;
    uint16 layer;
    uint16 sectionID;
    Rect rect1;
    Rect rect2;
    uint32 imageAssetID;
    uint32 streamLocator;
    uint8 unknown7[4];
 
    Common::String name;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct TextLabelElement : public StructuralDef {
    TextLabelElement();
 
    // Possible element flags: NotDirectToScreen, CacheBitmap, Hidden
    uint32 sizeIncludingTag;
    uint32 guid;
    uint16 lengthOfName;
    uint32 elementFlags;
    uint16 layer;
    uint16 sectionID;
    Rect rect1;
    Rect rect2;
    uint32 assetID;
 
    struct MacPart {
        uint8 unknown2[30];
    };
 
    struct WinPart {
        uint8 unknown3[2];
        uint8 unknown4[8];
    };
 
    union PlatformPart {
        MacPart mac;
        WinPart win;
    };
 
    bool haveMacPart;
    bool haveWinPart;
    PlatformPart platform;
 
    Common::String name;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct SoundElement : public StructuralDef {
    enum SoundFlags : uint {
        kPaused = 0x40000000,
        kLoop = 0x80000000,
    };
 
    SoundElement();
 
    // Possible element flags: Loop, Paused
    uint32 sizeIncludingTag;
    uint32 guid;
    uint16 lengthOfName;
    uint32 elementFlags;
    uint32 soundFlags;
    uint16 unknown2;
    uint8 unknown3[2];
    uint16 rightVolume;
    uint16 leftVolume;
    int16 balance;
    uint32 assetID;
    uint8 unknown5[8];
 
    Common::String name;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct MovieElement : public StructuralDef {
    explicit MovieElement(bool avi);
 
    // Possible flags: NotDirectToScreen, CacheBitmap, Hidden, Loop, Loop + Alternate, Paused
    uint32 sizeIncludingTag;
    uint32 guid;
    uint16 lengthOfName;
    uint32 elementFlags;
    uint16 layer;
    uint8 unknown3[44];
    uint16 sectionID;
    uint8 unknown5[2];
    Rect rect1;
    Rect rect2;
    uint32 assetID;
    uint32 unknown7;
    uint16 volume;
    uint32 animationFlags;
    uint8 unknown10[4];
    uint8 unknown11[4];
    uint32 streamLocator;
    uint8 unknown13[4];
 
    Common::String name;
 
    bool isAVI;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct MToonElement : public StructuralDef {
    MToonElement();
 
    // Possible flags: NotDirectToScreen, CacheBitmap, Hidden, Loop, Paused, PlayEveryFrame (inverted as "Maintain Rate")
    uint32 sizeIncludingTag;
    uint32 guid;
    uint16 lengthOfName;
    uint32 elementFlags;
    uint16 layer;
    uint32 animationFlags;
    uint8 unknown4[4];
    uint16 sectionID;
    Rect rect1;
    Rect rect2;
    uint32 assetID;
    uint32 rateTimes100000;
    uint32 streamLocator;
    uint32 unknown6;
 
    Common::String name;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct GlobalObjectInfo : public DataObject {
    GlobalObjectInfo();
 
    uint32 persistFlags;
    uint32 sizeIncludingTag;
    uint16 numGlobalModifiers;
    uint8 unknown1[4];
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
class ProjectCatalog : public DataObject {
public:
    struct StreamDesc {
        StreamDesc();
 
        char streamType[25];
        uint16 segmentIndexPlusOne;
        uint32 winSize;
        uint32 winPos;
        uint32 macSize;
        uint32 macPos;
    };
 
    struct SegmentDesc {
        SegmentDesc();
 
        uint32 segmentID;
        Common::String label;
        Common::String exportedPath;
    };
 
    ProjectCatalog();
 
    uint32 persistFlags;
    uint32 sizeOfStreamAndSegmentDescs;
    uint16 unknown1;
    uint16 unknown2;
    uint32 unknown3;
 
    Common::Array<SegmentDesc> segments;
    Common::Array<StreamDesc> streams;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct StreamHeader : public DataObject {
    StreamHeader();
 
    uint32 marker;
    uint32 sizeIncludingTag;
    char name[17];
    uint8 projectID[2];
    uint8 unknown1[4]; // Seems to be consistent across builds
    uint16 unknown2;   // 0
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct BehaviorModifier : public DataObject {
    enum BehaviorFlags {
        kBehaviorFlagSwitchable = 1,
    };
 
    BehaviorModifier();
 
    uint32 modifierFlags;
    uint32 sizeIncludingTag;
    uint8 unknown2[2];
    uint32 guid;
    uint32 unknown4;
    uint16 unknown5;
    uint32 unknown6;
    uint32 unknown8; // revision 2 only.
    Point editorLayoutPosition;
    uint16 lengthOfName;
    uint16 numChildren;
    uint32 behaviorFlags;
    Event enableWhen;
    Event disableWhen;
    uint8 unknown7[2];
 
    Common::String name;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct MiniscriptProgram {
    struct LocalRef {
        LocalRef();
 
        uint32 guid;
        uint8 lengthOfName;
        uint8 unknown2;
 
        Common::String name;
    };
 
    struct Attribute {
        Attribute();
 
        uint8 lengthOfName;
        uint8 unknown3;
 
        Common::String name;
    };
 
    MiniscriptProgram();
 
    uint32 unknown1;
    uint32 sizeOfInstructions;
    uint32 numOfInstructions;
    uint32 numLocalRefs;
    uint32 numAttributes;
 
    Common::Array<uint8> bytecode;
    Common::Array<LocalRef> localRefs;
    Common::Array<Attribute> attributes;
 
    DataFormat dataFormat;
 
    bool load(DataReader &reader);
};
 
// Header used for most modifiers, but not all
struct TypicalModifierHeader {
    TypicalModifierHeader();
 
    uint32 modifierFlags;
    uint32 sizeIncludingTag;
    uint32 guid;
    uint8 unknown3[6];
    uint32 unknown4;
    uint32 unknown5;  // V2 header only
    Point editorLayoutPosition;
    uint16 lengthOfName;
 
    Common::String name;
 
    bool load(DataReader &reader, bool isV2);
};
 
struct MiniscriptModifier : public DataObject {
    MiniscriptModifier();
 
    TypicalModifierHeader modHeader;
    Event enableWhen;
    uint8 unknown6[11];
    uint8 unknown7;
 
    MiniscriptProgram program;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct ColorTableModifier : public DataObject {
    ColorTableModifier();
 
    TypicalModifierHeader modHeader;
    Event applyWhen;
    uint32 unknown1;
    uint8 unknown2[4];
    uint32 assetID;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct SoundFadeModifier : public DataObject {
    SoundFadeModifier();
 
    TypicalModifierHeader modHeader;
    uint8 unknown1[4];
    Event enableWhen;
    Event disableWhen;
    uint16 fadeToVolume;
    uint8 codedDuration[4];
    uint8 unknown2[18];
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct SaveAndRestoreModifier : public DataObject {
    SaveAndRestoreModifier();
 
    TypicalModifierHeader modHeader;
    uint8 unknown1[4];
    Event saveWhen;
    Event restoreWhen;
    InternalTypeTaggedValue saveOrRestoreValue;
 
    uint8 unknown5[8];
 
    uint8 lengthOfFilePath;
    uint8 lengthOfFileName;
    uint8 lengthOfVariableName;
    uint8 lengthOfVariableString;
 
    Common::String varName;
    Common::String varString;
    Common::String filePath;
    Common::String fileName;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
enum MessageFlags : uint {
    kMessageFlagNoRelay = 0x20000000,
    kMessageFlagNoCascade = 0x40000000,
    kMessageFlagNoImmediate = 0x80000000,
};
 
 
struct MessengerModifier : public DataObject {
    MessengerModifier();
 
    TypicalModifierHeader modHeader;
 
    uint32 messageFlags;
    Event send;
    Event when;
    uint16 unknown14;
    uint32 destination;
    uint8 unknown11[10];
    InternalTypeTaggedValue with;
    uint8 withSourceLength;
    uint8 withStringLength;
 
    Common::String withSource;
    Common::String withString;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct SetModifier : public DataObject {
    SetModifier();
 
    TypicalModifierHeader modHeader;
 
    uint8 unknown1[4];
    Event executeWhen;
    InternalTypeTaggedValue source;
    InternalTypeTaggedValue target;
    uint8 unknown3;
    uint8 sourceNameLength;
    uint8 targetNameLength;
    uint8 sourceStringLength;
    uint8 targetStringLength;
    uint8 unknown4;
 
    Common::String sourceName;
    Common::String targetName;
    Common::String sourceString;
    Common::String targetString;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct AliasModifier : public DataObject {
    AliasModifier();
 
    uint32 modifierFlags;
    uint32 sizeIncludingTag;
    uint16 aliasIndexPlusOne;
    uint32 unknown1;
    uint32 unknown2;
    uint32 unknown3;
    uint32 lengthOfName;
    uint32 guid;
    Point editorLayoutPosition;
 
    Common::String name;
 
    bool haveGUID;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct ChangeSceneModifier : public DataObject {
    enum ChangeSceneFlags : uint {
        kChangeSceneFlagNextScene           = 0x80000000,
        kChangeSceneFlagPrevScene           = 0x40000000,
        kChangeSceneFlagSpecificScene       = 0x20000000,
        kChangeSceneFlagAddToReturnList     = 0x10000000,
        kChangeSceneFlagAddToDestList       = 0x08000000,
        kChangeSceneFlagWrapAround          = 0x04000000,
    };
 
    ChangeSceneModifier();
 
    TypicalModifierHeader modHeader;
    uint32 changeSceneFlags;
    Event executeWhen;
    uint32 targetSectionGUID;
    uint32 targetSubsectionGUID;
    uint32 targetSceneGUID;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct SoundEffectModifier : public DataObject {
    SoundEffectModifier();
 
    static const uint32 kSpecialAssetIDSystemBeep = 0xffffffffu;
 
    TypicalModifierHeader modHeader;
    uint8 unknown1[4];
    Event executeWhen;
    Event terminateWhen;
    uint32 unknown2;
    uint8 unknown3[4];
    uint32 assetID;
    uint8 unknown5[4];
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct PathMotionModifier : public DataObject {
    struct PointDefMessageSpec {
        PointDefMessageSpec();
 
        uint32 messageFlags;
        Event send;
        uint16 unknown11;
        uint32 destination;
        uint8 unknown13[10];
        InternalTypeTaggedValue with;
        uint8 withSourceLength;
        uint8 withStringLength;
 
        Common::String withSource;
        Common::String withString;
 
        bool load(DataReader &reader);
    };
 
    struct PointDef {
        PointDef();
 
        enum FrameFlags {
            kFrameFlagPlaySequentially = 1,
        };
 
        Point point;
        uint32 frame;
        uint32 frameFlags;
 
        PointDefMessageSpec messageSpec;
 
        bool load(DataReader &reader, bool haveMessageSpec);
    };
 
    enum Flags {
        kFlagReverse = 0x00100000,
        kFlagLoop = 0x10000000,
        kFlagAlternate = 0x02000000,
        kFlagStartAtBeginning = 0x08000000,
    };
 
    explicit PathMotionModifier(uint version);
 
    TypicalModifierHeader modHeader;
    uint32 flags;
 
    Event executeWhen;
    Event terminateWhen;
 
    uint8 unknown2[2];
    uint16 numPoints;
    uint8 unknown3[4];
    uint32 frameDurationTimes10Million;
    uint8 unknown5[4];
    uint32 unknown6;
 
    bool havePointDefMessageSpecs;
 
    Common::Array<PointDef> points;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct SimpleMotionModifier : public DataObject {
    SimpleMotionModifier();
 
    TypicalModifierHeader modHeader;
 
    Event executeWhen;
    Event terminateWhen;
    uint16 motionType;
    uint16 directionFlags;
    uint16 steps;
    uint32 delayMSecTimes4800;
    uint8 unknown1[4];
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct DragMotionModifier : public DataObject {
    DragMotionModifier();
 
    TypicalModifierHeader modHeader;
 
    Event enableWhen;
    Event disableWhen;
 
    struct WinPart {
        uint8 unknown2;
        uint8 constrainHorizontal;
        uint8 constrainVertical;
        uint8 constrainToParent;
    };
 
    struct MacPart {
        uint8 flags;
        uint8 unknown3;
 
        enum Flags {
            kConstrainToParent = 0x10,
            kConstrainVertical = 0x20,
            kConstrainHorizontal = 0x40,
        };
    };
 
    union PlatformPart {
        WinPart win;
        MacPart mac;
    };
 
    PlatformPart platform;
 
    bool haveMacPart;
    bool haveWinPart;
    Rect constraintMargin;
    uint16 unknown1;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct VectorMotionModifier : public DataObject {
    VectorMotionModifier();
 
    TypicalModifierHeader modHeader;
 
    Event enableWhen;
    Event disableWhen;
    InternalTypeTaggedValue vec;
    uint16 unknown1;
    uint8 vecSourceLength;
    uint8 vecStringLength;
 
    Common::String vecSource;
    Common::String vecString;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct SceneTransitionModifier : public DataObject {
    SceneTransitionModifier();
 
    TypicalModifierHeader modHeader;
 
    Event enableWhen;
    Event disableWhen;
    uint16 transitionType;
    uint16 direction;
    uint16 unknown3;
    uint16 steps;
    uint32 duration;
    uint8 unknown5[2];
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct ElementTransitionModifier : public DataObject {
    ElementTransitionModifier();
 
    enum TransitionType {
        kTransitionTypeRectangularIris = 0x03e8,
        kTransitionTypeOvalIris = 0x03f2,
        kTransitionTypeZoom = 0x044c,
        kTransitionTypeFade = 0x2328,
    };
 
    enum RevealType {
        kRevealTypeReveal = 0,
        kRevealTypeConceal = 1,
    };
 
    TypicalModifierHeader modHeader;
 
    Event enableWhen;
    Event disableWhen;
    uint16 revealType;
    uint16 transitionType;
    uint16 unknown3;
    uint16 unknown4;
    uint16 steps;
    uint16 rate;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct SharedSceneModifier : public DataObject {
    SharedSceneModifier();
 
    TypicalModifierHeader modHeader;
 
    uint8 unknown1[4];
    Event executeWhen;
    uint32 sectionGUID;
    uint32 subsectionGUID;
    uint32 sceneGUID;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct IfMessengerModifier : public DataObject {
    IfMessengerModifier();
 
    TypicalModifierHeader modHeader;
 
    uint32 messageFlags;
    Event send;
    Event when;
    uint16 unknown6;
    uint32 destination;
    uint8 unknown7[10];
    InternalTypeTaggedValue with;
    uint8 unknown9[10];
    uint8 withSourceLength;
    uint8 withStringLength;
    MiniscriptProgram program;
 
    Common::String withSource;
    Common::String withString;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct TimerMessengerModifier : public DataObject {
    TimerMessengerModifier();
 
    TypicalModifierHeader modHeader;
 
    enum TimerFlags {
        kTimerFlagLooping = 0x10000000,
    };
 
    uint32 messageAndTimerFlags;
    Event executeWhen;
    Event send;
    Event terminateWhen;
    uint16 unknown2;
    uint32 destination;
    uint8 unknown4[10];
    InternalTypeTaggedValue with;
    uint8 unknown5;
    uint8 minutes;
    uint8 seconds;
    uint8 hundredthsOfSeconds;
    uint32 unknown6;
    uint32 unknown7;
    uint8 unknown8[10];
    uint8 withSourceLength;
    uint8 withStringLength;
 
    Common::String withSource;
    Common::String withString;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct BoundaryDetectionMessengerModifier : public DataObject {
    BoundaryDetectionMessengerModifier();
 
    enum Flags {
        kDetectTopEdge = 0x1000,
        kDetectBottomEdge = 0x0800,
        kDetectLeftEdge = 0x0400,
        kDetectRightEdge = 0x0200,
        kDetectExiting = 0x0100, // Off = once exited
        kWhileDetected = 0x0080, // Off = on first detected
    };
 
    TypicalModifierHeader modHeader;
    uint16 messageFlagsHigh;
    Event enableWhen;
    Event disableWhen;
    Event send;
    uint16 unknown2;
    uint32 destination;
    uint8 unknown3[10];
    InternalTypeTaggedValue with;
    uint8 withSourceLength;
    uint8 withStringLength;
 
    Common::String withSource;
    Common::String withString;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct CollisionDetectionMessengerModifier : public DataObject {
    CollisionDetectionMessengerModifier();
 
    enum ModifierFlags {
        kDetectLayerInFront = 0x10000000,
        kDetectLayerBehind = 0x08000000,
        kSendToCollidingElement = 0x02000000,
        kSendToOnlyFirstCollidingElement = 0x00200000,
 
        kDetectionModeMask = 0x01c00000,
        kDetectionModeFirstContact = 0x01400000,
        kDetectionModeWhileInContact = 0x01000000,
        kDetectionModeExiting = 0x00800000,
 
        kNoCollideWithParent = 0x00100000,
    };
 
    TypicalModifierHeader modHeader;
    uint32 messageAndModifierFlags;
    Event enableWhen;
    Event disableWhen;
    Event send;
    uint16 unknown2;
    uint32 destination;
    uint8 unknown3[10];
    InternalTypeTaggedValue with;
    uint8 withSourceLength;
    uint8 withStringLength;
 
    Common::String withSource;
    Common::String withString;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct KeyboardMessengerModifier : public DataObject {
    enum KeyStateFlags {
        kOnDown = 0x10000000,
        kOnUp = 0x4000000,
        kOnRepeat = 0x8000000,
 
        kKeyStateMask = (kOnDown | kOnUp | kOnRepeat),
    };
 
    enum KeyModifiers {
        kControl = 0x1000,
        kCommand = 0x0100,
        kOption = 0x0800,
    };
 
    enum KeyCodes {
        kAny = 0x00,
        kHome = 0x01,
        kEnter = 0x03,
        kEnd = 0x04,
        kHelp = 0x05,
        kBackspace = 0x08,
        kTab = 0x09,
        kPageUp = 0x0b,
        kPageDown = 0x0c,
        kReturn = 0x0d,
        kEscape = 0x1b,
        kArrowLeft = 0x1c,
        kArrowRight = 0x1d,
        kArrowUp = 0x1e,
        kArrowDown = 0x1f,
        kDelete = 0x7f,
    };
 
    KeyboardMessengerModifier();
 
    TypicalModifierHeader modHeader;
    uint32 messageFlagsAndKeyStates;
    uint16 unknown2;
    uint16 keyModifiers;
    uint8 keycode;
    uint8 unknown4[7];
    Event message;
    uint16 unknown7;
    uint32 destination;
    uint8 unknown9[10];
    InternalTypeTaggedValue with;
    uint8 withSourceLength;
    uint8 withStringLength;
 
    Common::String withSource;
    Common::String withString;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct TextStyleModifier : public DataObject {
    TextStyleModifier();
 
    TypicalModifierHeader modHeader;
 
    uint8 unknown1[4];
    uint16 macFontID;
    uint8 flags;
    uint8 unknown2;
    uint16 size;
    ColorRGB16 textColor;       // Appears to not actually be used
    ColorRGB16 backgroundColor; // Appears to not actually be used
    uint16 alignment;
    uint16 unknown3;
    Event applyWhen;
    Event removeWhen;
    uint16 lengthOfFontFamilyName;
 
    Common::String fontFamilyName;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct GraphicModifier : public DataObject {
    GraphicModifier();
 
    TypicalModifierHeader modHeader;
 
    uint16 unknown1;
    Event applyWhen;
    Event removeWhen;
    uint8 unknown2[2];
    uint16 inkMode;
    uint16 shape;
 
    struct MacPart {
        uint8 unknown4_1[6];
        uint8 unknown4_2[26];
    };
 
    struct WinPart {
        uint8 unknown5_1[4];
        uint8 unknown5_2[22];
    };
 
    union PlatformPart {
        MacPart mac;
        WinPart win;
    };
 
    bool haveMacPart;
    bool haveWinPart;
    PlatformPart platform;
 
    ColorRGB16 foreColor;
    ColorRGB16 backColor;
    uint16 borderSize;
    ColorRGB16 borderColor;
    uint16 shadowSize;
    ColorRGB16 shadowColor;
 
    uint16 numPolygonPoints;
    uint8 unknown6[8];
 
    Common::Array<Point> polyPoints;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct ImageEffectModifier : public DataObject {
    ImageEffectModifier();
 
    enum Types {
        kTypeInvert = 1,
        kTypeSelectedBevels = 2,
        kTypeDeselectedBevels = 3,
        kTypeToneDown = 4,
        kTypeToneUp = 5,
    };
 
    TypicalModifierHeader modHeader;
 
    uint32 flags;
    uint16 type;
    Event applyWhen;
    Event removeWhen;
    uint16 bevelWidth;
    uint16 toneAmount;
    uint8 unknown2[2];
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct ReturnModifier : public DataObject {
    ReturnModifier();
 
    TypicalModifierHeader modHeader;
 
    Event executeWhen;
    uint16 unknown1;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct CursorModifierV1 : public DataObject {
    CursorModifierV1();
 
    struct MacOnlyPart {
        MacOnlyPart();
 
        Event applyWhen;
        uint32 unknown1;
        uint16 unknown2;
        uint32 cursorIndex;
    };
 
    TypicalModifierHeader modHeader;
 
    bool hasMacOnlyPart;
    MacOnlyPart macOnlyPart;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct CompoundVariableModifier : public DataObject {
    CompoundVariableModifier();
 
    // This doesn't follow the usual modifier header layout
    uint32 modifierFlags;
    uint32 sizeIncludingTag;
    uint8 unknown1[2];  // Extra field
    uint32 guid;
    uint8 unknown4[6];
    uint32 unknown5;
    Point editorLayoutPosition;
    uint16 lengthOfName;
    uint16 numChildren;
    uint8 unknown7[4];
 
    Common::String name;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct BooleanVariableModifier : public DataObject {
    BooleanVariableModifier();
 
    TypicalModifierHeader modHeader;
    uint8 value;
    uint8 unknown5;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct IntegerVariableModifier : public DataObject {
    IntegerVariableModifier();
 
    TypicalModifierHeader modHeader;
    uint8 unknown1[4];
    int32 value;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct IntegerRangeVariableModifier : public DataObject {
    IntegerRangeVariableModifier();
 
    TypicalModifierHeader modHeader;
    uint8 unknown1[4];
    IntRange range;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct VectorVariableModifier : public DataObject {
    VectorVariableModifier();
 
    TypicalModifierHeader modHeader;
    uint8 unknown1[4];
    XPFloatVector vector;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct PointVariableModifier : public DataObject {
    PointVariableModifier();
 
    TypicalModifierHeader modHeader;
 
    uint8 unknown5[4];
    Point value;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct FloatingPointVariableModifier : public DataObject {
    FloatingPointVariableModifier();
 
    TypicalModifierHeader modHeader;
    uint8 unknown1[4];
    Common::XPFloat value;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct StringVariableModifier : public DataObject {
    StringVariableModifier();
 
    TypicalModifierHeader modHeader;
    uint32 lengthOfString;
    uint8 unknown1[4];
    Common::String value;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct ObjectReferenceVariableModifierV1 : public DataObject {
    ObjectReferenceVariableModifierV1();
 
    TypicalModifierHeader modHeader;
    uint32 unknown1;
    Event setToSourcesParentWhen;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct PlugInModifierData {
    virtual ~PlugInModifierData();
    virtual DataReadErrorCode load(PlugIn &plugIn, const PlugInModifier &prefix, DataReader &reader) = 0;
};
 
struct PlugInModifier : public DataObject {
    PlugInModifier();
 
    uint32 modifierFlags;
    uint32 codedSize;   // Total size on Mac but (size + (name length * 255)) on Windows for some reason
    char modifierName[17];
    uint32 guid;
    uint8 unknown2[6];
    uint16 plugInRevision;
    uint32 unknown4;
    Point editorLayoutPosition;
    uint16 lengthOfName;
 
    Common::String name;
 
    uint32 subObjectSize;
 
    Common::SharedPtr<PlugInModifierData> plugInData;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct Debris : public DataObject {
    Debris();
 
    uint32 persistFlags;
    uint32 sizeIncludingTag;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct ColorTableAsset : public DataObject {
    ColorTableAsset();
 
    uint32 persistFlags;
    uint32 sizeIncludingTag;
    uint8 unknown1[4];
    uint32 assetID;
    uint32 unknown2; // Usually zero-fill but sometimes contains 0xb
 
    ColorRGB16 colors[256];
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct MovieAsset : public DataObject {
    struct MacPart {
        uint8 unknown5_1[66];
        uint8 unknown6[12];
        uint8 unknown8[4];
    };
 
    struct WinPart {
        uint8 unknown3_1[32];
        uint8 unknown4[12];
        uint8 unknown7[12];
    };
 
    union PlatformPart {
        MacPart mac;
        WinPart win;
    };
 
    MovieAsset();
 
    uint32 persistFlags;
    uint32 assetAndDataCombinedSize;
    uint8 unknown1[4];
    uint32 assetID;
    uint8 unknown1_1[4];
    uint16 extFileNameLength;
 
    uint32 movieDataPos;
    uint32 moovAtomPos;
    uint32 movieDataSize;
 
    bool haveMacPart;
    bool haveWinPart;
    PlatformPart platform;
 
    Common::String extFileName;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct AVIMovieAsset : public DataObject {
    AVIMovieAsset();
 
    uint8 unknown1[12];
    uint32 assetID;
    uint8 unknown2[4];
    uint16 extFileNameLength;
    uint8 unknown3[60];
 
    Common::String extFileName;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct AudioAsset : public DataObject {
    struct MacPart {
        uint8 unknown4[4];
        uint8 unknown5[5];
        uint8 unknown6[3];
        uint8 unknown8[20];
    };
 
    struct WinPart {
        uint8 unknown9[3];
        uint8 unknown10[3];
        uint8 unknown11[18];
        uint8 unknown12_1[2];
    };
 
    union PlatformPart {
        MacPart mac;
        WinPart win;
    };
 
    struct CuePoint {
        uint8 unknown13[2];
        uint32 unknown14;
        uint32 position;
        uint32 cuePointID;
    };
 
    AudioAsset();
 
    uint32 persistFlags;
    uint32 assetAndDataCombinedSize;
    uint8 unknown2[4];
    uint32 assetID;
    uint8 unknown3[20];
    uint16 sampleRate1;
    uint8 bitsPerSample;
    uint8 encoding1;
    uint8 channels;
    uint8 codedDuration[4];
    uint16 sampleRate2;
    uint32 cuePointDataSize;
    uint16 numCuePoints;
    uint8 unknown14[4];
    uint32 filePosition;
    uint32 size;
 
    Common::Array<CuePoint> cuePoints;
 
    bool haveMacPart;
    bool haveWinPart;
    bool isBigEndian;
    PlatformPart platform;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct ImageAsset : public DataObject {
    struct MacPart {
        uint8 unknown7[44];
    };
 
    struct WinPart {
        uint8 unknown8[10];
    };
 
    union PlatformPart {
        WinPart win;
        MacPart mac;
    };
 
    ImageAsset();
 
    uint32 persistFlags;
    uint32 unknown1;
    uint8 unknown2[4];
    uint32 assetID;
    uint32 unknown3;
 
    Rect rect1;
    uint32 hdpiFixed;
    uint32 vdpiFixed;
    uint16 bitsPerPixel;
    uint8 unknown4[2];
    uint8 unknown5[4];
    uint8 unknown6[8];
    Rect rect2;
    uint32 filePosition;
    uint32 size;
 
    bool haveMacPart;
    bool haveWinPart;
    PlatformPart platform;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct MToonAsset : public DataObject {
    struct MacPart {
        uint8 unknown10[88];
    };
 
    struct WinPart {
        uint8 unknown11[54];
    };
 
    union PlatformUnion {
        MacPart mac;
        WinPart win;
    };
 
    struct FrameDef {
        struct MacPart {
            uint8 unknown17[4];
        };
 
        struct WinPart {
            uint8 unknown18[2];
        };
 
        union PlatformUnion {
            MacPart mac;
            WinPart win;
        };
 
        FrameDef();
 
        uint8 unknown12[4];
        Rect rect1;
        uint32 dataOffset;
        uint8 unknown13[2];
        uint32 compressedSize;
        uint8 unknown14;
        uint8 keyframeFlag;
        uint8 platformBit;
        uint8 unknown15;
        Rect rect2;
        uint32 hdpiFixed;
        uint32 vdpiFixed;
        uint16 bitsPerPixel;
        uint32 unknown16;
        uint16 decompressedBytesPerRow;
        uint32 decompressedSize;
 
        PlatformUnion platform;
    };
 
    struct FrameRangeDef {
        FrameRangeDef();
 
        uint32 startFrame;
        uint32 endFrame;
        uint8 lengthOfName;
        uint8 unknown14;
 
        Common::String name; // Null terminated
    };
 
    enum {
        kEncodingFlag_TemporalCompression = 0x80,
        kEncodingFlag_HasRanges = 0x20000000,
        kEncodingFlag_Trimming = 0x08,
    };
 
    struct FrameRangePart {
        FrameRangePart();
 
        uint32 tag;
        uint32 sizeIncludingTag;
 
        uint32 numFrameRanges;
        Common::Array<FrameRangeDef> frameRanges;
    };
 
    MToonAsset();
 
    uint32 marker;
    uint8 unknown1[8];
    uint32 assetID;
 
    bool haveMacPart;
    bool haveWinPart;
    PlatformUnion platform;
 
    uint32 frameDataPosition;
    uint32 sizeOfFrameData;
 
    // mToon data
    uint32 mtoonHeader[2];
    uint16 version;
    uint8 unknown2[4];
    uint32 encodingFlags;
    Rect rect;
 
    uint16 numFrames;
    uint8 unknown3[14];
    uint16 bitsPerPixel;
    uint32 codecID;
    uint8 unknown4_1[8];
    uint32 codecDataSize;
    Point registrationPoint;
 
    Common::Array<FrameDef> frames;
 
    // Codec data appears to be a 16-byte header followed by a QuickTime sample description
    // Note that the sample description is partly useless because frames can have different sizes
    // and the sample desc is only for the last frame!
    //
    // The 16-byte header is:
    // uint32be size of codec data
    // char[4] codec ID
    // byte[8] unknown (all 0?)
    Common::Array<uint8> codecData;
 
    FrameRangePart frameRangesPart;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct TextAsset : public DataObject {
    struct MacFormattingSpan {
        uint8 unknown9[2];
        uint16 spanStart;
        uint8 unknown10[4];
        uint16 fontID;
        uint8 fontFlags;
        uint8 unknown11[1];
        uint16 size;
        uint8 unknown12[6];
    };
 
    struct MacPart {
        uint8 unknown3[44];
    };
 
    struct WinPart {
        uint8 unknown4[10];
    };
 
    union PlatformPart {
        MacPart mac;
        WinPart win;
    };
 
    TextAsset();
 
    uint32 persistFlags;
    uint32 sizeIncludingTag;
    uint32 unknown1;
    uint32 assetID;
    uint32 unknown2;
    Rect bitmapRect;
    uint32 hdpi;
    uint32 vdpi;
    uint16 unknown5;
    uint8 pitchBigEndian[2];
    uint32 unknown6;
 
    uint32 bitmapSize;
    uint8 unknown7[20];
    uint32 textSize;
    uint8 unknown8[8];
    uint16 alignment;
    uint16 isBitmap;
 
    bool haveMacPart;
    bool haveWinPart;
    PlatformPart platform;
 
    Common::String text;
    Common::Array<uint8> bitmapData;
 
    bool isBottomUp;
 
    Common::Array<MacFormattingSpan> macFormattingSpans;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct AssetDataChunk : public DataObject {
    AssetDataChunk();
 
    uint32 unknown1;
    uint32 sizeIncludingTag;
    int64 filePosition;
 
protected:
    DataReadErrorCode load(DataReader &reader) override;
};
 
struct IPlugInModifierDataFactory : public IInterfaceBase {
    virtual Common::SharedPtr<Data::PlugInModifierData> createModifierData() const = 0;
    virtual PlugIn &getPlugIn() const = 0;
};
 
class PlugInModifierRegistry {
public:
    const IPlugInModifierDataFactory *findLoader(const char *modifierName) const;
    void registerLoader(const char *modifierName, const IPlugInModifierDataFactory *loader);
 
private:
    Common::HashMap<Common::String, const IPlugInModifierDataFactory *> _loaders;
};
 
DataReadErrorCode loadDataObject(const PlugInModifierRegistry &registry, DataReader &reader, Common::SharedPtr<DataObject> &outObject);
 
template<size_t TSize>
inline bool DataReader::readBytes(uint8(&arr)[TSize]) {
    return this->read(arr, TSize);
}
 
template<size_t TSize>
inline bool DataReader::readChars(char (&arr)[TSize]) {
    return this->read(arr, TSize);
}
 
} // End of namespace Data
 
} // End of namespace MTropolis
 
#endif /* MTROPOLIS_DATA_H */