gfxfile.h

Go to the documentation of this file.

/* xoreos - A reimplementation of BioWare's Aurora engine
 *
 * xoreos is the legal property of its developers, whose names
 * can be found in the AUTHORS file distributed with this source
 * distribution.
 *
 * xoreos 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.
 *
 * xoreos 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 xoreos. If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef AURORA_GFXFILE_H
#define AURORA_GFXFILE_H

#include <boost/variant.hpp>
#include <boost/optional.hpp>

#include "glm/glm.hpp"

#include "src/common/scopedptr.h"
#include "src/common/ustring.h"
#include "src/common/readstream.h"
#include "src/common/rect.h"
#include "src/common/bitstream.h"

#include "src/aurora/actionscript/asbuffer.h"

namespace Aurora {

// Forward declaration.
class GFXControl;

class GFXCharacter {
public:
    enum CharacterType {
        kSprite,
        kShape,
        kEditText,
        kFont,
        kExternalImage
    };

    struct GradientRecord {
        byte ratio;
        glm::u8vec4 color;
    };

    struct Fill {
        glm::u8vec4 color;
    };

    struct Gradient {
        glm::mat3x2 matrix;
        uint8 spreadMode;
        uint8 interpolationMode;
        std::vector<GradientRecord> records;
    };

    struct Bitmap {
        uint16 id;
        glm::mat3x2 matrix;
    };

    struct FillStyle {
        byte type;
        boost::variant<Fill, Gradient, Bitmap> value;

        FillStyle() {
            type = 0xFF;
        }
    };

    struct LineStyle {
        uint16 width;
        glm::u8vec4 color;

        LineStyle() {
            width = 0;
        }
    };

    struct ShapeRecord {
        struct {
            FillStyle fillStyle0, fillStyle1;
            LineStyle lineStyle;
        } style;
        struct {
            int32 deltaX, deltaY;
        } move;
        struct {
            int32 deltaX, deltaY;
        } straightEdge;
        struct {
            int32 controlDeltaX, controlDeltaY;
            int32 anchorDeltaX, anchorDeltaY;
        } curvedEdge;

        ShapeRecord() {
            move.deltaX = 0;
            move.deltaY = 0;
            straightEdge.deltaX = 0;
            straightEdge.deltaY = 0;
            curvedEdge.controlDeltaX = 0;
            curvedEdge.controlDeltaY = 0;
            curvedEdge.anchorDeltaX = 0;
            curvedEdge.anchorDeltaY = 0;
        }
    };

    struct Glyph {
        uint16 code;
        Common::Rect bounds;
        std::vector<ShapeRecord> shapeRecords;
    };

    struct KerningCode {
        uint16 code1, code2;
        int16 adjustment;
    };

    enum TextAlignment {
        kLeft = 0,
        kRight = 1,
        kCenter = 2,
        kJustify = 3
    };

    struct Sprite {
        uint16 frameCount;
        std::vector<GFXControl> controls;
    };

    struct Shape {
        Common::Rect bounds;
        std::vector<ShapeRecord> shapeRecords;
    };

    struct EditTextLayout {
        TextAlignment alignment;
        uint16 leftMargin;
        uint16 rightMargin;
        uint16 indent;
        uint16 leading;
    };

    struct EditText {
        Common::Rect bounds;
        bool wordWrap;
        bool multiLine;
        bool password;
        bool readOnly;
        bool autosize;
        bool noSelect;
        bool html;
        boost::optional<uint16> fontId;
        boost::optional<uint16> fontHeight;
        boost::optional<glm::u8vec4> textColor;
        boost::optional<uint16> maxLength;
        boost::optional<Common::UString> initialText;
        boost::optional<EditTextLayout> layout;
    };

    struct Font {
        Common::UString name;
        std::vector<Glyph> glyphs;
        std::vector<KerningCode> kerningCodes;
        boost::optional<uint16> fontAscent;
        boost::optional<uint16> fontDescent;
        boost::optional<int16> fontLeading;
    };

    struct ExternalImage {
        Common::UString name;
        uint16 width, height;
        uint16 bitmapFormat;
    };

    static GFXCharacter createSprite(uint16 id, Sprite sprite);
    static GFXCharacter createShape(uint16 id, Shape shape);
    static GFXCharacter createEditText(uint16 id, EditText editText);
    static GFXCharacter createFont(uint16 id, Font font);
    static GFXCharacter createExternalImage(uint16 id, ExternalImage externalImage);

    CharacterType getType() const;
    uint16 getId() const;

    void getSprite(Sprite &sprite) const;
    void getShape(Shape &shape) const;
    void getFont(Font &font) const;
    void getEditText(EditText &editText) const;
    void getExternalImage(ExternalImage &externalImage) const;

private:
    boost::variant<
        Sprite,
        Shape,
        EditText,
        Font,
        ExternalImage
    > _value;

    uint16 _id;
    CharacterType _type;

    GFXCharacter(uint16 id, CharacterType type);
};

class GFXControl {
public:
    enum ControlType {
        kShowFrame,
        kPlaceObject,
        kDoAction
    };

    struct ColorTransform {
        bool mulTransform, addTransform;
        int mulR, mulG, mulB, mulA;
        int addR, addG, addB, addA;

        ColorTransform() {
            mulR = mulG = mulB = mulA = 0;
            addR = addG = addB = addA = 0;
            mulTransform = false;
            addTransform = false;
        }
    };

    struct PlaceObject {
        bool hasMove;

        uint16 depth;
        boost::optional<uint16> characterId;
        boost::optional<Common::UString> name;
        boost::optional<glm::mat3x2> matrix;
        boost::optional<ColorTransform> colorTransform;
        boost::optional<uint8> blendMode;
    };

    struct DoAction {
        Aurora::ActionScript::ASBuffer *asBuffer;
    };

    static GFXControl createPlaceObject(PlaceObject);
    static GFXControl createDoAction(DoAction);
    static GFXControl createShowFrame();

    ControlType getType() const { return _type; };

    void getPlaceObject(PlaceObject &placeObject) const;
    void getDoAction(DoAction &doAction) const;

private:
    boost::variant<PlaceObject, DoAction> _value;

    ControlType _type;

    explicit GFXControl(ControlType type);
};

class GFXFile {
public:
    GFXFile(const Common::UString &resref, Aurora::ActionScript::AVM &avm);

    float getFrameRate() { return _frameRate; };

    uint16 getExportedAssetId(const Common::UString &id);
    GFXCharacter getCharacter(uint16 id);

    std::vector<GFXControl> getControls() { return _controlTags; };

private:
    struct RecordHeader {
        uint16 tagType;
        uint32 tagLength;
    };

    std::map<Common::UString, uint16> _exportTable;
    std::map<uint16, GFXCharacter> _characters;
    std::vector<GFXControl> _controlTags;

    Common::ScopedPtr<Common::SeekableReadStream> _gfx;

    Common::Rect _frameSize;
    float _frameRate;
    unsigned short _frameCount;

    void load(Common::SeekableReadStream *gfx, Aurora::ActionScript::AVM &avm);

    void readHeader();

    void readDefineShape(byte version);
    void readBackgroundColor();
    void readExportAssets();
    void readImportAssets(ActionScript::AVM &avm);
    void readFileAttributes();
    void readDefineSprite();
    GFXControl readPlaceObject(byte version = 1);
    void readDefineFont();
    void readDefineEditText();
    void readInitAction(ActionScript::AVM &avm);
    Aurora::ActionScript::ASBuffer *readAction();

    // .--- Scaleform specific tags based on https://github.com/jindrapetrik/jpexs-decompiler.

    void readGFXExporterInfo(RecordHeader header);
    void readGFXDefineExternalImage(RecordHeader header, byte version = 0);

    // '---

    // .--- Utility types inside gfx files

    RecordHeader readRecordHeader();
    Common::Rect readRectangle();
    glm::mat3x2 readMatrix();
    glm::u8vec3 readRGB();
    glm::u8vec4 readRGBA();
    std::vector<GFXCharacter::FillStyle> readFillStyleArray(byte version);
    GFXCharacter::FillStyle readFillStyle(byte version);
    std::vector<GFXCharacter::LineStyle> readLineStyleArray(byte version);
    GFXCharacter::LineStyle readLineStyle(byte version);
    GFXControl::ColorTransform readColorTransform();
    void readFocalGradient(byte version);
    GFXCharacter::GradientRecord readGradientRecord(byte version);
    std::vector<GFXCharacter::ShapeRecord> readShape(byte version, bool withStyle);

    // '---

    // .--- GFx utility methods

    Common::UString readNullTerminatedString();
    Common::UString readLengthPrefixedString();
    int32 read2ComplementValue(Common::BitStream &bitStream, size_t n);

    // '---
};

} // End of namespace Aurora

#endif // AURORA_GFXFILE_H