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 */