Surface_Z

Chum World SURFACE
ImZouna Surface_Z

Wikipedia Bézier surface

The surface_z_visualizer.py script is able to visualize Surface_Z data using Matplotlib.

SurfaceRelated.cpp

Collection of quadratic 3D Bezier patches

This has an associated Data Class.

struct Surface_Z : Object_Z {
    PascalArray<Vec3f> vertices;
    PascalArray<Vec4f> vec4fs;
    PascalArray<struct Unknown2 {
        std::uint8_t data[32];
    }> unknown2s;
    PascalArray<struct Unknown3 {
        std::uint8_t data[32];
    }> unknown3s;
    PascalArray<struct Patch_Z {
        std::uint16_t flag;
        std::uint16_t indexInUnkShortDA;
        std::uint16_t edgeIndices[4];
        std::uint32_t materialAnimIndex;
        float data[12];
        Mat4f mat;
        std::uint16_t vec4fsIndices[4];
        std::uint16_t unknown3s[17];
        std::uint16_t surfaceIndicesIndex;
        std::uint32_t materialAnimCRC32;
    }> patches;
    PascalArray<struct Edge_Z {
        std::uint16_t P[2];
        std::uint16_t T[2];
    }> edges;
    PascalArray<Vec3f> normals;
    PascalArray<Vec3f> vertex9s;
    PascalArray<Vec2f> vertex10s;
    PascalArray<struct shouldDrawBitfield { // 16 bits
        std::uint8_t indexInDrawInfoArray : 3;
        std::uint8_t shiftAmountForBit : 5;
        std::uint8_t other;
    }> shouldDrawRelateds;
    PascalArray<struct Unknown12 {
        std::uint8_t data[32];
    }> unknown12s;
    Optional<struct SeadIndex_Z {
        PascalArray<struct SeadVoxel_Z {
            std::uint16_t elementEntry;
            std::uint16_t numElement;
        }> seadVoxels;
        PascalArray<std::uint16_t> elements;
        struct Unknown15 {
            float data[48];
           std::uint32_t unknown0s[4];
        } unknown15;
        std::uint32_t repeatedPatchCount;
    }> seadIndex;
};

//------------------------------------------------
//--- 010 Editor v11.0.1 Binary Template
//------------------------------------------------

struct Surface_Z
{
    uint32 vertexCount;
    float vertices[vertexCount * 3];
    uint32 quatCount;
    float quats[quatCount * 4];
    uint32 unknown2Count;
    struct Unknown2
    {
        byte data[32];
    } unknown2s[unknown2Count];
    uint32 unknown3Count;
    struct Unknown3
    {
        byte data[32];
    } unknown3s[unknown3Count];
    uint32 patchCount;
    struct Patch_Z
    {
        uint16 flag;
        uint16 indexInUnkShortDA;
        uint16 edgeIndices[4];
        uint32 materialAnimIndex;
        float data[12];
        float mat[16];
        uint16 quatsIndices[4];
        uint16 unknown3s[17];
        uint16 surfaceIndicesIndex;
        uint32 materialAnimCRC32;
    } patches[patchCount];
    uint32 edgeCount;
    struct Edge_Z
    {
        uint16 P[2];
        uint16 T[2];
    } edges[edgeCount];
    uint32 normalCount;
    struct Normal
    {
        float x;
        float y;
        float z;
    } normals[normalCount];
    uint32 unknown9Count;
    struct Unknown9
    {
        float unknown0;
        float unknown1;
        float unknown2;
    } unknown9s[unknown9Count];
    uint32 unknown10Count;
    struct Unknown10
    {
        float unknown0;
        float unknown1;
    } unknown10s[unknown10Count];
    uint32 shouldDrawRelatedCount;
    struct shouldDrawBitfield { // 16 bits
        byte indexInDrawInfoArray : 3;
        byte shiftAmountForBit : 5;
        byte other;
    } shouldDrawRelateds[shouldDrawRelatedCount];
    uint32 unknown12Count;
    struct Unknown12
    {
        byte data[32];
    } unknown12s[unknown12Count];
    byte isSead;
    if (isSead)
    {
        struct SeadIndex_Z
        {
            uint32 seadVoxelCount;
            struct SeadVoxel_Z
            {
                uint16 elementEntry;
                uint16 numElement;
            } seadVoxels[seadVoxelCount];
            uint32 elementCount;
            uint16 elements[elementCount];
            struct Unknown15
            {
                float data[52];
            } unknown15;
            uint32 repeatedPatchCount;
        } seadIndex;
    }
} surface;