MapFactory.h

#pragma once
 
#include <factories/BaseFactory.h>
#include <vector>
 
namespace BK64 {

typedef struct NodeProp {
    int16_t position[3];    // X, Y, Z world position (s16)
    uint16_t radius : 9;    // selector_or_radius: trigger/volume radius
    uint16_t bit6 : 6;      // category (6=actor, 7=warp, 9=trigger, 0xA=event)
    uint16_t bit0 : 1;      // active/enabled
    uint16_t unk8;          // actorId — meaning depends on category
    uint8_t unkA;           // markerId: index into the ActorMarker lookup table
    uint8_t padB;           // padding
    uint32_t yaw : 9;       // spawn Y rotation; *2 for degrees (0-511 → 0-1022°)
    uint32_t scale : 23;    // spawn scale, fixed point (/1000.0 for the real value)
    uint32_t unk10_31 : 12; // secondary ID or overlay-specific param
    uint32_t unk10_19 : 12; // more params (animation phase, variant, ...)
    uint32_t pad10_7 : 1;   // padding
    uint32_t unk10_6 : 1;   // "initialized" flag, set at runtime
    uint32_t pad10_5 : 4;   // padding
    uint32_t unk10_0 : 2;   // param passed to func_803303B8
} NodeProp;

typedef struct ModelProp {
    uint16_t unk0;       // modelId:12, pad0_19:4
    uint8_t yaw;         // Y-axis rotation
    uint8_t roll;        // roll
    int16_t position[3]; // X, Y, Z world position
    uint8_t scale;       // scale
    uint8_t flags;       // discriminator (isModelProp=1, isActorProp=0)
} ModelProp;

typedef struct SpriteProp {
    uint32_t word0;
    int16_t unk4[3];
    uint16_t wordA;
} SpriteProp;

typedef struct ActorProp {
    uint32_t marker;     // ActorMarker* — runtime only
    int16_t position[3]; // X, Y, Z position cache
    uint16_t flags;      // discriminator (isActorProp=1)
} ActorProp;

typedef union Prop {
    ModelProp model;
    SpriteProp sprite;
    ActorProp actor;
    struct {
        uint32_t pad0;
        int16_t unk4[3];
        uint16_t padA_15 : 10;
        uint16_t unkA_5 : 1;
        uint16_t unkA_4 : 1;
        uint16_t unkA_3 : 1;
        uint16_t unkA_2 : 1;
        uint16_t is_3d : 1;
        uint16_t is_actor : 1;
    };
    uint8_t raw[12];
} Prop;

typedef struct CubeData {
    int32_t x : 5;
    int32_t y : 5;
    int32_t z : 5;
    uint32_t prop1Cnt : 6;
    uint32_t prop2Cnt : 6;
    uint32_t unk0_4 : 5; // split point: [0..unk0_4)=spawns, [unk0_4..prop1Cnt)=events
    std::vector<NodeProp> nodeProps;
    std::vector<Prop> props;
} CubeData;

typedef struct CameraNodeType1 {
    float position[3];     // camera position
    float horizontalSpeed; // horizontal speed
    float verticalSpeed;   // vertical speed
    float rotation;        // rotation speed
    float accelaration;    // acceleration
    float pitchYawRoll[3]; // orientation (pitch, yaw, roll)
    int32_t unknownFlag;   // unknown; tested against 1, 2, 4
} CameraNodeType1;

typedef struct CameraNodeType2 {
    float position[3];     // camera position
    float pitchYawRoll[3]; // orientation (pitch, yaw, roll)
} CameraNodeType2;

typedef struct CameraNodeType3 {
    float position[3];     // camera position
    float horizontalSpeed; // horizontal speed
    float verticalSpeed;   // vertical speed
    float rotation;        // rotation speed
    float accelaration;    // acceleration
    float closeDistance;   // near clip distance
    float farDistance;     // far clip distance
    float pitchYawRoll[3]; // orientation (pitch, yaw, roll)
    int32_t unknownFlag;   // unknown
} CameraNodeType3;

typedef struct CameraNodeType4 {
    int32_t unknownFlag; // unknown
} CameraNodeType4;

typedef struct CameraNode {
    int16_t index; // node index
    uint8_t type;  // 1=Scripted, 2=Dynamic, 3=Static, 4=Random
    union {
        CameraNodeType1 type1;
        CameraNodeType2 type2;
        CameraNodeType3 type3;
        CameraNodeType4 type4;
    } data;
} CameraNode;

typedef struct LightingVector {
    float position[3];  // X, Y, Z light position
    float fadeRadii[2]; // inner/outer fade distances
    int32_t rgb[3];     // R, G, B
} LightingVector;
 
class MapData : public IParsedData {
  public:
    // Cube data section (chunk type 0x01)
    int32_t mCubeMin[3]; // grid min bounds
    int32_t mCubeMax[3]; // grid max bounds
    std::vector<CubeData> mCubes;
 
    // Camera nodes section (chunk type 0x03)
    std::vector<CameraNode> mCameraNodes;
 
    // Lighting section (chunk type 0x04)
    std::vector<LightingVector> mLightingVectors;
 
    MapData() {
        mCubeMin[0] = mCubeMin[1] = mCubeMin[2] = 0;
        mCubeMax[0] = mCubeMax[1] = mCubeMax[2] = 0;
    }
};
 
class MapHeaderExporter : public BaseExporter {
    ExportResult Export(std::ostream& write, std::shared_ptr<IParsedData> data, std::string& entryName,
                        YAML::Node& node, std::string* replacement) override;
};
 
class MapBinaryExporter : public BaseExporter {
    ExportResult Export(std::ostream& write, std::shared_ptr<IParsedData> data, std::string& entryName,
                        YAML::Node& node, std::string* replacement) override;
};
 
class MapCodeExporter : public BaseExporter {
    ExportResult Export(std::ostream& write, std::shared_ptr<IParsedData> data, std::string& entryName,
                        YAML::Node& node, std::string* replacement) override;
};
 
class MapModdingExporter : public BaseExporter {
    ExportResult Export(std::ostream& write, std::shared_ptr<IParsedData> data, std::string& entryName,
                        YAML::Node& node, std::string* replacement) override;
};
 
class MapFactory : public BaseFactory {
  public:
    std::optional<std::shared_ptr<IParsedData>> parse(std::vector<uint8_t>& buffer, YAML::Node& data) override;
    inline std::unordered_map<ExportType, std::shared_ptr<BaseExporter>> GetExporters() override {
        return { REGISTER(Code, MapCodeExporter) REGISTER(Header, MapHeaderExporter) REGISTER(Binary, MapBinaryExporter)
                     REGISTER(Modding, MapModdingExporter) };
    }
 
    bool HasModdedDependencies() override {
        return true;
    }
};
} // namespace BK64