lg_mesh.h

/*
 *      LibGame - Copyright (C) Emmanuel Thomas-Maurin 2011-2025
 *      All rights reserved
 */
 
#ifndef LG_MESH_H
#define LG_MESH_H
 
#define LG_MESH_NAME_MAX_LEN    (64 - 1)
#define MAT_NAME_MAX_LEN        (64 - 1)
#define TEX_FILENAME_MAX_LEN    (128 - 1)               /* = LG_TEX_PATH_MAX_LEN */
#define N_MAX_MAT_PER_OBJ       64                      /* Or N_MAX_MAT_PER_MTL ? */
#define N_MAX_USEMTL_PER_OBJ    256                     /* 4096 ? */
 
#define BINARY_MESH_EXT         "bmesh"
#define LG_BMESH_HEADER_SIZE    65536                   /* 64 KiB - make sure it's < sizeof(LG_Mesh) */
 
#define LG_FLOAT_EPSILON        (1e-6)                  /* 1e-6 or 1e-8 ? */
#define MAX_U32BIT_VALUE        4294967296
 
#define CHECK_PATH(_z_)         INFO_OUT("DEBUG: [%s %d]: %s() -> %s\n", basename2(__FILE__), __LINE__, __func__, _z_)
 
/* Why 50 Mib ?
#define LG_OBJ_FILE_MAXSIZE     ((size_t)50 * (size_t)(1024 * 1024))*/
 
#define LG_MESH_IS_RH           1
#define LG_MESH_IS_LH           2
 
/* Mesh original format, ie from OBJ/FBX file or whatever */
typedef enum {
        LG_MESH_OBJ,
        LG_MESH_FBX,
        LG_MESH_TERRAIN,
        LG_MESH_OTHER
} lg_mesh_type;
 
typedef struct {
        char            name[MAT_NAME_MAX_LEN + 1];
        uint32_t        indice;                                 /* Material face indice in VBO (uint32_t with GL_OES_element_index_uint extension) */
        LG_Texture      *texture;
        char            tex_filename[TEX_FILENAME_MAX_LEN + 1]; /* Relative path to image file inside the TEXTURES folder (in assets) accessible with lg_tex(path) */
} LG_Material;
 
/* Axis-aligned bounding box */
typedef union {
        struct {
                float   min_x;
                float   max_x;
                float   min_y;
                float   max_y;
                float   min_z;
                float   max_z;
        };
        #if 0
        /* LG_BBox_v2 ? */
        struct {
                vec3_t  center;
                float   extents;
        };
        /* LG_BBox_v3 ? */
        struct {
                vec3_t  min;
                vec3_t  max;
        };
        #endif
} LG_BBox;
 
/*
 * === Triangle mesh ===
 *
 * We want the same type sizes in binary files on all suppored platforms
 * (ie Linux and Android so far) to avoid portability issues, so we now
 * use fixed-size types (uint32_t, int32_t, ...) a lot for vertices structs
 * and buffer objects.
 *
 * In OBJ file:
 *      - 'mtllib'      -> obj_file.mtl
 *      - 'usemtl'      -> material name
 *
 * In MTL file:
 *      - 'newmtl'      -> material name
 *      - 'map_K*'      -> texture path
 */
typedef struct {
        int32_t         type;                                   /* lg_mesh_type = mesh original format, ie from OBJ/FBX file or whatever */
        char            name[LG_MESH_NAME_MAX_LEN + 1];         /* Should be relative path of the MESH file (OBJ/FBX/BMESH) */
        zboolean        skinned;
        /* Generated VBO and IBO */
        union {
          Vertex_uv_n   *vbo_data;                              /* VBO (with interleaved vertex data) - sizeof(Vertex_uv_n) = 24 */
          Vertex_uvn_iw *vbo_data_iw;                           /* VBO (with interleaved vertex data) - sizeof(Vertex_uvn_iw) = 36 */
          //Vertex_rgba_n *vbo_data_rgba_n;                     /* -> TO ASSIGN COLORS TO ELEVATIONS - sizeof(Vertex_rgba_n) = 24 */
        };
        uint32_t        *ibo_data;                              /* IBO (indices start at 0) - sizeof(uint32_t) = 4 */
        uint32_t        vbo_size;                               /* previously size_t */
        uint32_t        ibo_size;                               /* previously size_t */
        /* Read from OBJ file */
        int32_t         n_v;                                    /* Num of coords vertices */
        int32_t         n_vt;                                   /* Num of texture coords */
        int32_t         n_vn;                                   /* Num of normals */
        int32_t         n_f;                                    /* Num of faces */
        /* Materials */
        char            mtl_file[LG_MESH_NAME_MAX_LEN + 1];     /* The MTL file path */
        int32_t         n_mat;                                  /* Num of materials (with textures) in MTL file */
        int32_t         n_usemtl;                               /* Num of usemtl tags in OBJ file */
        LG_Material     materials[N_MAX_USEMTL_PER_OBJ];        /* Materials referenced by usemtl tags */
        LG_BBox         bbox;
        LG_Cuboid       b_cuboid;                               /* Bounding cuboid */
        Lines3D_VB      b_cuboid_l3d_vb;                        /* Lines3D_VB from bounding box cuboid */
        zboolean        xyz_normalized;
        double          normalize_k;
        zboolean        horiz_centered;                         /* Horizontally centered -> x, z*/
        zboolean        vert_centered;                          /* Vertically centered -> y */
        zboolean        vert_bottom;                            /* Vertically at bottom -> y - set mesh origin at bottom, override do_vert_center */
} LG_Mesh;
 
/* Mesh loading flags */
typedef struct {
        zboolean        save_to_assets;         /* Save to assets as BMESH, otherwise to cache - on Android, should always be set to FALSE as you can't write to assets */
        zboolean        invert_z;               /* Invert z spatial coord - should be set to TRUE if mesh uses RH coords sys, FALSE if mesh uses LH coords sys */
        zboolean        normalize_xyz;
        zboolean        horiz_center;
        zboolean        vert_center;            /* Center mesh vertically, if vert_bottom is not set */
        zboolean        vert_bottom;            /* Set mesh origin vertically at bottom, override vert_center */
} LG_LoadMesh_Flags;
 
/* Helper #define's */
#define SAVE_TO_ASSETS  TRUE
#define INVERT_Z        TRUE
#define NORMALIZE_XYZ   TRUE
#define HORIZ_CENTER    TRUE
#define VERT_CENTER     TRUE
#define VERT_BOTTOM     TRUE
 
/*
 *      BINARY MESH (.bmesh) file format
 *      ================================
 *      - Header = Serializable_LG_Mesh
 *              -> header_size = lg_align_up_to_next_4_bytes_boundary((void *)sizeof(Serializable_LG_Mesh))
 *      - VBO data block - aligned to 4 bytes boundaries
 *              -> starting at header_size
 *      - IBO data block - aligned to 4 bytes boundaries
 *              -> starting at header_size + lg_align_up_to_next_4_bytes_boundary((void *)(uint64_t)mesh->vbo_size)
 */
 
/*
 * === Structs for serialization ===
 * We convert pointers to two uint32_t values:
 *      Vertex_uv_n     *vbo_data
 *      ->
 *      uint32_t        vbo_data_big;
 *      uint32_t        vbo_data_little;
 *
 */
 
typedef struct {
        char            name[MAT_NAME_MAX_LEN + 1];
        uint32_t        indice;
        uint32_t        texture_big;                            /* Pointer value as 2 uint32_t */
        uint32_t        texture_little;
        char            tex_filename[TEX_FILENAME_MAX_LEN + 1];
} Serializable_LG_Material;
 
typedef struct {
        int32_t                         type;
        char                            name[LG_MESH_NAME_MAX_LEN + 1];
        zboolean                        skinned;
        uint32_t                        vbo_data_big;           /* Pointer value as 2 uint32_t */
        uint32_t                        vbo_data_little;
        uint32_t                        ibo_data_big;           /* Pointer value as 2 uint32_t */
        uint32_t                        ibo_data_little;
        uint32_t                        vbo_size;
        uint32_t                        ibo_size;
        int32_t                         n_v;
        int32_t                         n_vt;
        int32_t                         n_vn;
        int32_t                         n_f;
        char                            mtl_file[LG_MESH_NAME_MAX_LEN + 1];
        int32_t                         n_mat;
        int32_t                         n_usemtl;
        Serializable_LG_Material        materials[N_MAX_USEMTL_PER_OBJ];
        LG_BBox                         bbox;
        LG_Cuboid                       b_cuboid;
        Lines3D_VB                      b_cuboid_l3d_vb;
        zboolean                        xyz_normalized;
        double                          normalize_k;
        zboolean                        horiz_centered;
        zboolean                        vert_centered;
        zboolean                        vert_bottom;
} Serializable_LG_Mesh;
 
LG_Mesh                 *lg_mesh_load(const char *, LG_LoadMesh_Flags);
 
LG_Mesh                 *lg_mesh_load_easy(const char *, zboolean, LG_LoadMesh_Flags);
 
LG_Mesh                 *lg_mesh_new_from_objfile(const char *, zboolean, zboolean, zboolean, zboolean, zboolean);
 
LG_Mesh                 *lg_mesh_new_from_fbxfile(const char *, zboolean, zboolean, zboolean, zboolean, zboolean);
 
void                    lg_mesh_free(LG_Mesh *);
 
int                     lg_bmesh_save_to_file(const char *, LG_Mesh *);
 
int                     lg_bmesh_load_from_file(const char *, LG_Mesh **);
 
int                     lg_mesh_reload_mats(LG_Mesh *);
 
void                    lg_serialize_LG_Material_64_to_32(Serializable_LG_Material *, LG_Material *);
 
void                    lg_unserialize_LG_Material_32_to_64(LG_Material *, Serializable_LG_Material *);
 
void                    lg_serialize_LG_Mesh_64_to_32(Serializable_LG_Mesh *, LG_Mesh *);
 
void                    lg_unserialize_LG_Mesh_32_to_64(LG_Mesh *, Serializable_LG_Mesh *);
 
LG_LoadMesh_Flags       lg_loadmesh_flags(zboolean, zboolean, zboolean, zboolean, zboolean, zboolean);
 
void                    lg_mesh_info(LG_Mesh *);
 
char                    *lg_replace_file_extension(const char *, const char *);
 
#endif /* LG_MESH_H */