gltf.h

/*
 * See Licensing and Copyright notice in naev.h
 */
#pragma once
 
/* We use this file in utils/model-view-c to debug things. */
#ifdef PACKAGE
#define HAVE_NAEV
#endif
 
#include <stddef.h>
 
#include "glad.h"
 
#include "mat4.h"
#include "vec3.h"
#ifdef HAVE_NAEV
#include "opengl_tex.h"
#endif /* HAVE_NAEV */
 
#define MAX_LIGHTS                                                             \
   7 
 
typedef struct Texture {
   GLuint  tex;      
   GLuint  texcoord; 
   GLfloat strength; 
#ifdef HAVE_NAEV
   glTexture *gtex; 
#endif              /* HAVE_NAEV */
} Texture;

typedef struct Material {
   char *name;         
   int   blend;        
   int   noshadows;    
   int   double_sided; 
   int   unlit;        
   /* pbr_metallic_roughness */
   Texture baseColour_tex; 
   Texture metallic_tex;   
   GLfloat metallicFactor; 
   GLfloat roughnessFactor; 
   GLfloat baseColour[4];   
   /* pbr_specular_glossiness */
   /* Sheen. */
   GLfloat sheen[3];
   GLfloat sheen_roughness;
   /* Clearcoat */
   /*GLuint clearcoat_tex;
   GLuint clearcoat_roughness_tex;
   GLuint clearcoat_normal_tex; */
   GLfloat clearcoat;
   GLfloat clearcoat_roughness;
   /* misc. */
   Texture normal_tex;
   Texture occlusion_tex;
   Texture emissive_tex;
   GLfloat emissiveFactor[3];
   /* Custom Naev. */
   // GLfloat waxiness;
} Material;

typedef struct MeshPrimitive {
   size_t nidx;     
   GLuint vbo_idx;  
   GLuint vbo_pos;  
   GLuint vbo_nor;  
   GLuint vbo_tex0; 
   GLuint vbo_tex1; 
   int    material; 
} MeshPrimitive;

typedef struct Mesh {
   MeshPrimitive *primitives;  
   int            nprimitives; 
} Mesh;
 
typedef struct NodeTransform {
   vec3 t; 
   quat r; 
   vec3 s; 
} NodeTransform;

typedef struct Node {
   char *name;  
   mat4  H;     
   mat4  Horig; 
   int   mesh;  
   // int parent;     /**< Parent node. */
   size_t *children;  
   size_t  nchildren; 
 
   GLfloat radius;   
   vec3    aabb_min; 
   vec3    aabb_max; 
 
   /* Animation data. */
   int           has_anim; 
   NodeTransform nt;       
   NodeTransform ntorig;   
} Node;
 
typedef enum AnimationInterpolation {
   ANIM_INTER_LINEAR,
   ANIM_INTER_STEP,
} AnimationInterpolation;
 
typedef enum AnimationType {
   ANIM_TYPE_ROTATION,
   ANIM_TYPE_TRANSLATION,
   ANIM_TYPE_SCALE,
} AnimationType;
 
typedef struct AnimationSampler {
   float                 *time;   
   GLfloat               *data;   
   AnimationInterpolation interp; 
   size_t                 n;      
   size_t                 l;      
   size_t                 cur;    
   GLfloat                max;    
} AnimationSampler;
 
typedef struct AnimationChannel {
   AnimationType     type;    
   Node             *target;  
   AnimationSampler *sampler; 
} AnimationChannel;
 
typedef struct Animation {
   char             *name;      
   AnimationSampler *samplers;  
   size_t            nsamplers; 
   AnimationChannel *channels;  
   size_t            nchannels; 
} Animation;

typedef struct Scene {
   char   *name;   
   size_t *nodes;  
   size_t  nnodes; 
} Scene;
 
typedef struct GltfTrail {
   char *generator; 
   vec3  pos;       
} GltfTrail;
 
typedef struct GltfMount {
   int id;   
   vec3 pos; 
} GltfMount;

typedef struct GltfObject {
   char      *path; 
   Mesh      *meshes;      
   size_t     nmeshes;     
   Node      *nodes;       
   size_t     nnodes;      
   Scene     *scenes;      
   size_t     nscenes;     
   Material  *materials;   
   size_t     nmaterials;  
   Animation *animations;  
   size_t     nanimations; 
   GLfloat    radius;      
   /* Some useful default scenes. */
   int scene_body;   
   int scene_engine; 
   /* Useful things used for special cases. */
   GltfTrail *trails; 
   GltfMount *mounts; 
   int        loaded; 
} GltfObject;

typedef struct Light {
   int sun; 
   /* left(-)/right(+), down(-)/up(+), forward(-)/back(+) */
   vec3
      pos; 
   double intensity; 
   vec3   colour;    
} Light;
 
typedef struct Lighting {
   double ambient_r, ambient_g, ambient_b; 
   Light  lights[MAX_LIGHTS];              
   int    nlights;   
   double intensity; 
} Lighting;
extern const Lighting
   L_default_const; 
extern const Lighting L_store_const; 
extern Lighting       L_default;     
 
/* Framework itself. */
int  gltf_init( void );
void gltf_exit( void );
 
/* Loading and freeing. */
GltfObject *gltf_loadFromFile( const char *filename );
void        gltf_free( GltfObject *obj );
 
/* Rendering and updating. */
void gltf_render( GLuint fb, GltfObject *obj, const mat4 *H, GLfloat time,
                  double size );
void gltf_renderScene( GLuint fb, GltfObject *obj, int scene, const mat4 *H,
                       GLfloat time, double size, const Lighting *L );
 
/* Lighting. */
void   gltf_lightReset( void );
int    gltf_lightSet( int idx, const Light *L );
void   gltf_lightAmbient( double r, double g, double b );
void   gltf_lightAmbientGet( double *r, double *g, double *b );
void   gltf_lightIntensity( double strength );
double gltf_lightIntensityGet( void );
void   gltf_lightTransform( Lighting *L, const mat4 *H );
 
/* Misc functions. */
GLuint gltf_shadowmap( int light );