model.h

Go to the documentation of this file.

/*
** Jo Sega Saturn Engine
** Copyright (c) 2012-2026, Johannes Fetz (johannesfetz@gmail.com)
** All rights reserved.
**
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are met:
**     * Redistributions of source code must retain the above copyright
**       notice, this list of conditions and the following disclaimer.
**     * Redistributions in binary form must reproduce the above copyright
**       notice, this list of conditions and the following disclaimer in the
**       documentation and/or other materials provided with the distribution.
**     * Neither the name of the Johannes Fetz nor the
**       names of its contributors may be used to endorse or promote products
**       derived from this software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
** DISCLAIMED. IN NO EVENT SHALL Johannes Fetz BE LIABLE FOR ANY
** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
 
#ifndef __JO_MODEL_H__
# define __JO_MODEL_H__
 
#ifdef JO_COMPILE_WITH_3D_SUPPORT

# define JO_3D_MODEL_VERSION                    (1)
 
/*
** Material flags (jo_3d_material.flags, low 16 bits: the engine, high 16 bits: free for the program, see jo_model.py)
*/
# define JO_3D_MATERIAL_DUAL_PLANE              (1 << 0)
# define JO_3D_MATERIAL_SORT_MIN                (1 << 1)
# define JO_3D_MATERIAL_SORT_MAX                (1 << 2)
# define JO_3D_MATERIAL_SORT_PREVIOUS           (JO_3D_MATERIAL_SORT_MIN | JO_3D_MATERIAL_SORT_MAX)
# define JO_3D_MATERIAL_GOURAUD                 (1 << 3)
# define JO_3D_MATERIAL_HALF_TRANSPARENT        (1 << 4)
# define JO_3D_MATERIAL_SCREEN_DOORS            (1 << 5)
# define JO_3D_MATERIAL_LIGHT                   (1 << 6)
# define JO_3D_MATERIAL_FLIP_H                  (1 << 7)
# define JO_3D_MATERIAL_FLIP_V                  (1 << 8)
# define JO_3D_MATERIAL_END_CODES               (1 << 9)
# define JO_3D_MATERIAL_MIPMAPS                 (1 << 10)
# define JO_3D_MATERIAL_SUBDIVISION             (1 << 11)
# define JO_3D_MATERIAL_SUBDIVISION_NEAR        (1 << 12)
# define JO_3D_MATERIAL_USER(N)                 (1 << (16 + (N)))

typedef struct
{
    char                                    name[16];       // MTL newmtl (truncated, ended by a zero)
    unsigned char                           r;              // Color (MTL Kd): the polygons without texture
    unsigned char                           g;
    unsigned char                           b;
    unsigned char                           shine;          // MTL Ns (0 to 255, for the program)
    short                                   texture;        // Index in the textures of the model, -1: no texture
    unsigned short                          subdivision_error; // MTL jo_subdivision_error (pixels, see
                                                            // jo_3d_set_texture_subdivision_error()), 0: the default
    unsigned int                            flags;          // JO_3D_MATERIAL_xxx
    unsigned int                            user;           // MTL jo_value (for the program)
}                                           jo_3d_material;

typedef struct
{
    char                                    name[16];
    unsigned short                          first_point;
    unsigned short                          point_count;    // The points used only by the group (from first_point)
    unsigned short                          first_polygon;
    unsigned short                          polygon_count;
}                                           jo_3d_model_group;

# define JO_3D_MAX_BONES                        (32)
# define JO_3D_BONE_NO_GROUP                    (0xFFFF)
# define JO_3D_ANIMATION_LOOP                   (1 << 0)
# define JO_3D_ANIMATION_TICKS_PER_SECOND       (60)

typedef struct
{
    char                                    name[16];
    unsigned short                          group;          // Group moved by the bone (JO_3D_BONE_NO_GROUP: none)
    short                                   parent;         // Index of the parent bone, -1: root
    jo_pos3D_fixed                          pivot;          // Joint (model space): the bone turns around it
}                                           jo_3d_bone;

typedef struct
{
    char                                    name[16];
    unsigned short                          key_count;
    unsigned short                          key_ticks;      // Time between 2 keys (1/60 s)
    unsigned short                          flags;          // JO_3D_ANIMATION_xxx
    unsigned short                          duplicate;      // 0 in the file. Set at the loading: 1 when an animation before
                                                            // has the same name (see jo_3d_model_is_animation())
    unsigned int                            offset;         // Keys: offset from the count of the "ANIM" chunk
}                                           jo_3d_animation;

typedef struct
{
    jo_pos3D_fixed                          root;           // Offset of the whole model
    jo_angle                                angles[JO_3D_MAX_BONES][3];  // Around X, Y, Z (0x10000 = 360 degrees)
}                                           jo_3d_pose;

typedef void                                (*jo_3d_bone_callback)(const int bone, void * const param, const jo_fixed (* const matrix)[3]);

typedef struct
{
    jo_3d_mesh                              *mesh;              // Drawn with jo_3d_mesh_draw()
    jo_pos3D_fixed                          center;             // Bounding sphere (see jo_3d_is_sphere_visible())
    jo_fixed                                radius;
    unsigned int                            material_count;
    jo_3d_material                          *materials;
    unsigned short                          *polygon_materials; // Material of each polygon
    unsigned int                            texture_count;
    int                                     *textures;          // Sprite ids
    unsigned int                            normal_count;       // 0: no normals
    jo_pos3D_fixed                          *normals;
    unsigned short                          *corner_normals;    // 4 per polygon: index in normals (JO_NULL: none)
    jo_pos3D_fixed                          *vertex_colors;     // r, g, b per point, 1.0 = JO_FIXED_1 (JO_NULL: none)
    unsigned short                          gouraud_tables;     // First gouraud table (polygon k: + k), 0: none
    unsigned int                            group_count;
    jo_3d_model_group                       *groups;
    unsigned int                            bone_count;         // 0: no skeleton
    jo_3d_bone                              *bones;
    signed char                             *bone_children;     // First child of each bone, then the next sibling of
                                                                // each bone (-1: none)
    unsigned int                            animation_count;
    jo_3d_animation                         *animations;
    const unsigned char                     *animation_data;    // The "ANIM" chunk from its count
    void                                    *file;              // Data of the file (jo_3d_load_model(): the points, the
                                                                // polygons, etc are in it), JO_NULL: copies
    bool                                    file_not_owned;     // The data of the file belong to the caller
                                                                // (jo_3d_create_model_in_place()): not freed with the model
    bool                                    single_block;       // The model, its mesh, the attributes and the texture ids
                                                                // in one memory block (jo_3d_create_model_in_place())
}                                           jo_3d_model;

jo_3d_model                                 *jo_3d_create_model_from_memory(const unsigned char * const data, const unsigned int size);

jo_3d_model                                 *jo_3d_create_model_in_place(const unsigned char * const data, const unsigned int size);
 
#ifdef JO_COMPILE_WITH_FS_SUPPORT

jo_3d_model                                 *jo_3d_load_model(const char * const filename);

jo_3d_model                                 *__jo_3d_load_model_for_lights(const char * const filename);

int                                         jo_3d_model_texture(const char * const filename);

int                                         jo_3d_model_loaded_texture(const char * const name);
 
#endif

void                                        jo_3d_free_model(jo_3d_model * const model);

void                                        jo_3d_model_free_textures_from(const int sprite_id);

const jo_3d_model_group                     *jo_3d_model_find_group(const jo_3d_model * const model, const char * const name);

int                                         jo_3d_model_find_bone(const jo_3d_model * const model, const char * const name);

int                                         jo_3d_model_find_animation(const jo_3d_model * const model, const char * const name);

bool                                        jo_3d_model_is_animation(const jo_3d_model * const model, const int animation, const char * const name);

int                                         jo_3d_model_animation_duration(const jo_3d_model * const model, const int animation);

void                                        jo_3d_model_get_pose(const jo_3d_model * const model, const int animation, int time,
                                                                 jo_3d_pose * const pose);

void                                        jo_3d_pose_blend(const jo_3d_model * const model, jo_3d_pose * const pose,
                                                             const jo_3d_pose * const other, const int weight);

void                                        jo_3d_model_draw_pose(const jo_3d_model * const model, const jo_3d_pose * const pose,
                                                                  const jo_3d_bone_callback callback, void * const param);

void                                        jo_3d_model_set_hidden_bones(const unsigned int mask);

static  __jo_force_inline void              jo_3d_model_draw(const jo_3d_model * const model)
{
    if (model->bone_count > 0)
        jo_3d_model_draw_pose(model, JO_NULL, JO_NULL, JO_NULL);
    else
        jo_3d_mesh_draw(model->mesh);
}
 
#endif /* !JO_COMPILE_WITH_3D_SUPPORT */
 
#endif /* !__JO_MODEL_H__ */
 
/*
** END OF FILE
*/