metaforce/DataSpec/DNAMP1/FRME.hpp

#pragma once

#include "DataSpec/DNACommon/DNACommon.hpp"
#include "DNAMP1.hpp"
#include <athena/FileWriter.hpp>
#include "athena/DNAOp.hpp"

namespace DataSpec::DNAMP1
{
struct FRME : BigDNA
{
    AT_DECL_EXPLICIT_DNA
    Value<atUint32> version;
    Value<atUint32> unk1;
    Value<atUint32> modelCount; // Matches MODL widgets
    Value<atUint32> unk3;
    Value<atUint32> widgetCount;

    struct Widget : BigDNA
    {
        AT_DECL_EXPLICIT_DNA
        FRME* owner;
        DNAFourCC type;
        struct WidgetHeader : BigDNA
        {
            AT_DECL_DNA
            String<-1> name;
            String<-1> parent;
            Value<bool> useAnimController;
            Value<bool> defaultVisible;
            Value<bool> defaultActive;
            Value<bool> cullFaces;
            Value<atVec4f> color;
            Value<atUint32> modelDrawFlags;
        } header;

        struct IWidgetInfo : BigDNAV
        {
            Delete _dBase;
            virtual FourCC fourcc() const=0;
        };

        std::unique_ptr<IWidgetInfo> widgetInfo;
        Value<bool> isWorker;
        Value<atUint16> workerId = 0;
        Value<atVec3f> origin;
        Value<atVec3f> basis[3];
        Value<atVec3f> rotationCenter;
        Value<atInt32> unk1;
        Value<atInt16> unk2;

        struct BWIGInfo : IWidgetInfo
        {
            AT_DECL_DNA
            const char* DNATypeV() const { return "FRME::BWIG"; }
            FourCC fourcc() const { return FOURCC('BWIG'); }
        };

        struct HWIGInfo : IWidgetInfo
        {
            AT_DECL_DNA
            const char* DNATypeV() const { return "FRME::HWIG"; }
            FourCC fourcc() const { return FOURCC('HWIG'); }
        };

        struct CAMRInfo : IWidgetInfo
        {
            AT_DECL_EXPLICIT_DNA
            const char* DNATypeV() const { return "FRME::CAMR"; }
            enum class ProjectionType
            {
                Perspective,
                Orthographic
            };

            Value<ProjectionType> projectionType;
            struct IProjection : BigDNAV
            {
                Delete _d;
                const ProjectionType type;
                IProjection(ProjectionType t) : type(t) {}
            };

            struct PerspectiveProjection : IProjection
            {
                AT_DECL_DNA
                AT_DECL_DNAV
                PerspectiveProjection() : IProjection(ProjectionType::Perspective) {}
                Value<float> fov;
                Value<float> aspect;
                Value<float> znear;
                Value<float> zfar;
            };

            struct OrthographicProjection : IProjection
            {
                AT_DECL_DNA
                AT_DECL_DNAV
                OrthographicProjection() : IProjection(ProjectionType::Orthographic) {}
                Value<float> left;
                Value<float> right;
                Value<float> top;
                Value<float> bottom;
                Value<float> znear;
                Value<float> zfar;
            };
            std::unique_ptr<IProjection> projection;

            FourCC fourcc() const { return FOURCC('CAMR'); }
        };

        struct MODLInfo : IWidgetInfo
        {
            AT_DECL_DNA
            const char* DNATypeV() const { return "FRME::MODL"; }
            UniqueID32 model;
            enum class BlendMode
            {
                Unknown0,
                Unknown1,
                Unknown2,
                Additive
            };

            Value<atUint32> blendMode;
            Value<atUint32> lightMask;

            FourCC fourcc() const { return FOURCC('MODL'); }
        };

        struct LITEInfo : IWidgetInfo
        {
            AT_DECL_EXPLICIT_DNA
            const char* DNATypeV() const { return "FRME::LITE"; }
            enum class ELightType : atUint32
            {
                Spot = 0,
                Point = 1,
                Directional = 2,
                LocalAmbient = 3,
                Custom = 4,
            };

            Value<ELightType> type;
            Value<float> distC;
            Value<float> distL;
            Value<float> distQ;
            Value<float> angC;
            Value<float> angL;
            Value<float> angQ;
            Value<atUint32> loadedIdx;
            Value<float> cutoff; /* Spot only */

            FourCC fourcc() const { return FOURCC('LITE'); }
        };

        struct ENRGInfo : IWidgetInfo
        {
            AT_DECL_DNA
            const char* DNATypeV() const { return "FRME::ENRG"; }
            UniqueID32 texture;

            FourCC fourcc() const { return FOURCC('ENRG'); }
        };

        struct METRInfo : IWidgetInfo
        {
            AT_DECL_DNA
            const char* DNATypeV() const { return "FRME::METR"; }
            Value<bool> unk1;
            Value<bool> noRoundUp;
            Value<atUint32> maxCapacity;
            Value<atUint32> workerCount;

            FourCC fourcc() const { return FOURCC('METR'); }
        };

        struct GRUPInfo : IWidgetInfo
        {
            AT_DECL_DNA
            const char* DNATypeV() const { return "FRME::GRUP"; }
            Value<atInt16> defaultWorker;
            Value<bool> unk3;

            FourCC fourcc() const { return FOURCC('GRUP'); }
        };

        struct TBGPInfo : IWidgetInfo
        {
            AT_DECL_DNA
            const char* DNATypeV() const { return "FRME::TBGP"; }
            Value<atUint16> elementCount;
            Value<atUint16> unk2;
            Value<atUint32> unkEnum;
            Value<atUint16> defaultSelection;
            Value<atUint16> un4;
            Value<bool>  selectWraparound;
            Value<bool>  unk6;
            Value<float> unkFloat1;
            Value<float> unkFloat2;
            Value<bool> unk7;
            Value<float> unkFloat3;
            Value<atUint16> unk8;
            Value<atUint16> unk9;
            Value<atUint16> unk10;
            Value<atUint16> unk11;

            FourCC fourcc() const { return FOURCC('TBGP'); }
        };

        struct SLGPInfo : IWidgetInfo
        {
            AT_DECL_DNA
            const char* DNATypeV() const { return "FRME::SLGP"; }
            Value<float> min;
            Value<float> max;
            Value<float> cur;
            Value<float> increment;

            FourCC fourcc() const { return FOURCC('SLGP'); }
        };

        struct PANEInfo : IWidgetInfo
        {
            AT_DECL_DNA
            const char* DNATypeV() const { return "FRME::PANE"; }
            Value<float> xDim;
            Value<float> zDim;
            Value<atVec3f> scaleCenter;

            FourCC fourcc() const { return FOURCC('PANE'); }
        };

        struct TXPNInfo : IWidgetInfo
        {
            const char* DNATypeV() const { return "FRME::TXPN"; }
            enum class Justification : atUint32
            {
                Left = 0,
                Center,
                Right,
                Full,
                NLeft,
                NCenter,
                NRight,
                LeftMono,
                CenterMono,
                RightMono
            };

            enum class VerticalJustification : atUint32
            {
                Top = 0,
                Center,
                Bottom,
                Full,
                NTop,
                NCenter,
                NBottom,
                LeftMono,
                CenterMono,
                RightMono
            };

            AT_DECL_EXPLICIT_DNA

            atUint32 version = 0;
            TXPNInfo() {}
            TXPNInfo(atUint32 version)
                : version(version)
            {}
            Value<float> xDim;
            Value<float> zDim;
            Value<atVec3f> scaleCenter;
            UniqueID32 font;
            Value<bool> wordWrap;
            Value<bool> horizontal;
            Value<Justification> justification;
            Value<VerticalJustification> verticalJustification;
            Value<atVec4f> fillColor;
            Value<atVec4f> outlineColor;
            Value<atVec2f> blockExtent; /* In points; converted to int by loader */
            /* The following is only found in V1 */
            UniqueID32 jpnFont;
            Value<atInt32> jpnPointScale[2] = {};

            FourCC fourcc() const { return FOURCC('TXPN'); }
        };

        struct IMGPInfo : IWidgetInfo
        {
            AT_DECL_DNA
            const char* DNATypeV() const { return "FRME::IMGP"; }
            UniqueID32 texture;
            Value<atUint32> unk1;
            Value<atUint32> unk2;
            Value<atUint32> quadCoordCount;
            Vector<atVec3f, AT_DNA_COUNT(quadCoordCount)> quadCoords;
            Value<atUint32> uvCoordCount;
            Vector<atVec2f, AT_DNA_COUNT(uvCoordCount)>  uvCoords;

            FourCC fourcc() const { return FOURCC('IMGP'); }
        };
    };

    Vector<Widget, AT_DNA_COUNT(widgetCount)> widgets;
    static bool Extract(const SpecBase& dataSpec,
                        PAKEntryReadStream& rs,
                        const hecl::ProjectPath& outPath,
                        PAKRouter<PAKBridge>& pakRouter,
                        const PAK::Entry& entry,
                        bool force,
                        hecl::blender::Token& btok,
                        std::function<void(const hecl::SystemChar*)> fileChanged);
};

}