lg_mesh.h

/*
 *      LibGame - Copyright (C) Emmanuel Thomas-Maurin 2011-2026
 *      All rights reserved
 */
 
#ifndef LG_MESH_H
#define LG_MESH_H
 
#define LG_MESH_NAME_MAX_LEN            (512 - 1)
#define LG_MESH_FULLPATH_MAX_LEN        (512 - 1)
#define MAT_NAME_MAX_LEN                (64 - 1)
#define TEX_FILENAME_MAX_LEN            (512 - 1)               /* = LG_TEX_PATH_MAX_LEN */
 
#define N_NEWMTL_USEMTL_TAGS_MAX        4096
 
#define BINARY_MESH_EXT                 "bmesh"
 
#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_)
 
#define LG_MESH_IS_RH                   1
#define LG_MESH_IS_LH                   2
 
/*
 * If GL ES version < 3.0, need GL_OES_element_index_uint extension for UNSIGNED_INT (uint32_t) IBO indices
 */
 
/* 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;
 
/* Actually name and texture - misleading */
typedef struct {
        char            name[MAT_NAME_MAX_LEN + 1];
        LG_Texture      *texture;
        char            tex_full_path[TEX_FILENAME_MAX_LEN + 1];        /* Full path to image file */
} 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                    full_path[LG_MESH_FULLPATH_MAX_LEN + 1];        /* Full path of 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 */
        char                    mtl_file[LG_MESH_FULLPATH_MAX_LEN + 1];         /* The MTL file path */
        int32_t                 n_usemtl;                                       /* Num of 'usemtl' tags in OBJ file */
        /* Read from MTL file */
        int32_t                 n_mat;                                          /* Num of 'newmtl'/'map_K' tags (materials with referenced textures) in MTL file */
        LG_Material             materials[N_NEWMTL_USEMTL_TAGS_MAX];            /* Material's 'lib' (LG_Material = name and texture) */
        uint32_t                i_mat_in_vbo[N_NEWMTL_USEMTL_TAGS_MAX];         /* Material face indice in VBO, referenced by 'usemtl' tags */
        uint32_t                i_mat_in_lib[N_NEWMTL_USEMTL_TAGS_MAX];         /* Texture indice in materials[N_NEWMTL_USEMTL_TAGS_MAX] */
        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        texture_big;                            /* Pointer value as 2 uint32_t */
        uint32_t        texture_little;
        char            tex_full_path[TEX_FILENAME_MAX_LEN + 1];
} Serializable_LG_Material;
 
typedef struct {
        int32_t                         type;
        char                            full_path[LG_MESH_FULLPATH_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_FULLPATH_MAX_LEN + 1];
        int32_t                         n_usemtl;
        int32_t                         n_mat;
        Serializable_LG_Material        materials[N_NEWMTL_USEMTL_TAGS_MAX];
        uint32_t                        i_mat_in_vbo[N_NEWMTL_USEMTL_TAGS_MAX];
        uint32_t                        i_mat_in_lib[N_NEWMTL_USEMTL_TAGS_MAX];
        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_new_from_obj(const char *, zboolean, zboolean, zboolean, zboolean, zboolean);
 
LG_Mesh                 *lg_mesh_new_from_obj_relpath(const char *, zboolean, zboolean, zboolean, zboolean, zboolean);
 
LG_Mesh                 *lg_mesh_new_from_fbx(const char *, zboolean, zboolean, zboolean, zboolean, zboolean);
 
LG_Mesh                 *lg_mesh_new_from_fbx_relpath(const char *, zboolean, zboolean, zboolean, zboolean, zboolean);
 
void                    lg_mesh_free(LG_Mesh *);
 
void                    lg_mesh_free_v2(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 *, int);
 
char                    *lg_replace_file_extension(const char *, const char *);
 
#endif /* LG_MESH_H */