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, see above
    uint16_t bit0 : 1;      // path waypoint
    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;       // degrees
    uint32_t scale : 23;    // percent for an actor spawn, 0 for its default size
    uint32_t unk10_31 : 12; // this record's number in a path chain
    uint32_t unk10_19 : 12; // the next record's number in the chain
    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 Prop {
    uint8_t raw[12];
} Prop;

typedef struct CubeData {
    int32_t x;
    int32_t y;
    int32_t z;
    bool listedEmpty = false; // holds nothing, but the file still writes its node and prop blocks
    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]; // the point it looks from while the player is nearly underneath it
    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;   // nearest it comes to the player
    float farDistance;     // farthest it drops back
    float pitchYawRoll[3]; // the point it looks from while the player is nearly underneath it
    int32_t unknownFlag;   // unknown
} CameraNodeType3;

typedef struct CameraNodeType4 {
    int32_t unknownFlag; // the preset
} CameraNodeType4;

typedef struct CameraNode {
    int16_t index; // node index
    uint8_t type;  // 0=Empty, 1=Pivot, 2=Static, 3=Dolly, 4=ZoomPreset
    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;
};
 
// The setup as the ROM stores it once decompressed, which is also the decomp's .lvl_setup.bin.
std::shared_ptr<MapData> ReadMapRom(const std::vector<uint8_t>& bytes, const std::string& symbol);
std::vector<uint8_t> WriteMapRom(const MapData& map);
// A BKMap resource, as MapBinaryExporter writes it.
std::shared_ptr<MapData> ReadMapResource(const std::vector<uint8_t>& resource);
std::string MapToYaml(const MapData& map, const std::string& symbol);
bool MapFromYaml(const std::string& text, MapData& out, std::string& error);
 
class MapFactory : public BaseFactory {
  public:
    std::optional<std::shared_ptr<IParsedData>> parse(std::vector<uint8_t>& buffer, YAML::Node& data) override;
    std::optional<std::shared_ptr<IParsedData>> parse_modding(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;
    }
    bool SupportModdedAssets() override {
        return true;
    }
};
} // namespace BK64