models.h

Go to the documentation of this file.

/* This file is part of LibT2FS.
 *
 * LibT2FS is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * LibT2FS is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef H_T2FS_MODELS
#define H_T2FS_MODELS
 
#include <stdint.h>
 
#include "t2fs.h"
#include "array.h"
#include "models/common.h"
 
// Usefull links:
// https://ultra64.ca/files/documentation/online-manuals/man/header/gbi.htm
 
#define T2FS_VERTEX_CACHE_SIZE   32
#define T2FS_VERTEX_GLOBAL_UNSET (uint32_t)-1
 
#define T2FS_MODEL_BONE_SYMBOL_LEG      0b001 // else arm also depends on T2FS_MODEL_BONE_SYMBOL_NOT_HEAD
#define T2FS_MODEL_BONE_SYMBOL_NOT_HEAD 0b010
#define T2FS_MODEL_BONE_SYMBOL_RIGHT    0b100 // else left
 
#define T2FS_MATERIAL_FLAG_UNK_0        0b0000000000000001
#define T2FS_MATERIAL_FLAG_UNK_1        0b0000000000000010
#define T2FS_MATERIAL_FLAG_CULBF        0b0000000000000100
#define T2FS_MATERIAL_FLAG_UNK_3        0b0000000000001000
#define T2FS_MATERIAL_FLAG_UNK_4        0b0000000000010000
#define T2FS_MATERIAL_FLAG_UNK_5        0b0000000000100000
#define T2FS_MATERIAL_FLAG_UNK_6        0b0000000001000000
#define T2FS_MATERIAL_FLAG_UNK_7        0b0000000010000000
#define T2FS_MATERIAL_FLAG_TRANSPARENCY 0b0000000100000000
#define T2FS_MATERIAL_FLAG_UNK_9        0b0000001000000000
#define T2FS_MATERIAL_FLAG_UNK_10       0b0000010000000000
#define T2FS_MATERIAL_FLAG_UNK_11       0b0000100000000000
#define T2FS_MATERIAL_FLAG_UNK_12       0b0001000000000000
#define T2FS_MATERIAL_FLAG_UNK_13       0b0010000000000000
#define T2FS_MATERIAL_FLAG_UNK_14       0b0100000000000000
#define T2FS_MATERIAL_FLAG_UNK_15       0b1000000000000000
 
// ********************************************************************
// Structs as in file (possible after decompression and/or deinterleaving)
// ********************************************************************
 

typedef struct __attribute__((__packed__)) s_T2FSDataModelInfo {
  T2FSDataCoordF32 min;
  T2FSDataCoordF32 max;
  int8_t headTrackStartBone;
  int8_t headTrackEndBone;
  int8_t headTrackFactor;
  int8_t unk1;
  uint16_t unk2;
  int16_t unk3;
} T2FSDataModelInfo;
 
SASSERT_SIZE(T2FSDataModelInfo, 32)
T2FS_CREATE_SWAP_STRUCT(T2FSDataModelInfo, (4,4,4,4,4,4,1,1,1,1,2,2));
 

typedef struct __attribute__((__packed__)) s_T2FSDataModelInfoDino {
  T2FSDataCoordF32 min;
  T2FSDataCoordF32 max;
} T2FSDataModelInfoDino;
 
SASSERT_SIZE(T2FSDataModelInfoDino, 24)
T2FS_CREATE_SWAP_STRUCT(T2FSDataModelInfoDino, (4,4,4,4,4,4));
 

typedef struct __attribute__((__packed__)) s_T2FSDataBone {
  /* The bouding box order:
 
         7-----6     Z axis
        / |   /|     |
       /  |  / |     |
      3-----2  |     |
      |   4-|--5     |      Y axis
      |  /  | /      |     /
      | /   |/       |    /
      0-----1        |   /
                     |  /
    X axis ---------
 
  Are these always rectangular prisms or any cuboid?
 
  */
  T2FSDataCoordF32 bbox[8];
  float maxBounds;
  int8_t parentIndex;
  uint8_t symbol;
  uint8_t materialType;
  uint8_t pad;
  float damageScaler;
  uint32_t flags;
} T2FSDataBone;
 
SASSERT_SIZE(T2FSDataBone, 112)
T2FS_CREATE_SWAP_STRUCT(T2FSDataBone, (4,4,4,4,4,4,4,4,
                                       4,4,4,4,4,4,4,4,
                                       4,4,4,4,4,4,4,4,
                                       4,1,1,1,1,4,4));

typedef struct __attribute__((__packed__)) s_T2FSDataBoneOrientation {
  T2FSDataCoordF32 pos;
  int16_t rotx; 
  int16_t roty; 
  int16_t rotz; 
  int16_t rotw; 
} T2FSDataBoneOrientation;
 
SASSERT_SIZE(T2FSDataBoneOrientation, 20)
T2FS_CREATE_SWAP_STRUCT(T2FSDataBoneOrientation, (4,4,4,2,2,2,2));
 

typedef struct __attribute__((__packed__)) s_T2FSDataBoneOrientationE3 {
  T2FSDataCoordF32 pos;
  float rotx;
  float roty;
  float rotz;
  float rotw;
} T2FSDataBoneOrientationE3;
 
SASSERT_SIZE(T2FSDataBoneOrientationE3, 28)
T2FS_CREATE_SWAP_STRUCT(T2FSDataBoneOrientationE3, (4,4,4,4,4,4,4));
 

typedef struct __attribute__((__packed__)) s_T2FSDataAnimationBoneIndices {
  int16_t rotationIndex; 
  int16_t positionIndex; 
} T2FSDataAnimationBoneIndices;
 
SASSERT_SIZE(T2FSDataAnimationBoneIndices, 4)
T2FS_CREATE_SWAP_STRUCT(T2FSDataAnimationBoneIndices, (2, 2));
 

typedef struct __attribute__((__packed__)) s_T2FSDataAnimationHeader {
  uint16_t unk_u16_00;
  uint16_t unk_u16_01;

  uint16_t unk_u16_02;
  uint16_t unk_u16_03;
 
  uint16_t unk_u16_04;
  uint16_t unk_u16_05;
 
  //uint16_t unk_u16_06;
  //uint16_t unk_u16_07;
  float scale; 

  uint16_t positionBoneCount;
  uint16_t unk_u16_09;
 
  uint16_t rotationBoneCount; 
  uint16_t unk_u16_11;
 
  uint16_t unk_u16_12; 
  uint16_t unk_u16_13; 
  uint16_t unk_u16_14; 
  uint16_t unk_u16_15; 
} T2FSDataAnimationHeader;
 
SASSERT_SIZE(T2FSDataAnimationHeader, 32)
T2FS_CREATE_SWAP_STRUCT(T2FSDataAnimationHeader, (2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 2));
 

typedef struct __attribute__((__packed__)) s_T2FSDataUnk2_x_4 {
  int16_t boneId;     
  int16_t unk_s16_00; 
  int16_t unk_s16_01; 
 
  // possible vector
  float unk_f32_00;
  float unk_f32_01;
  float unk_f32_02;
 
  int16_t unk_s16_04;
  int16_t unk_s16_05;
 
  // possible bounds
  int8_t unk_s8_00;
  int8_t unk_s8_01;
  int8_t unk_s8_02;
  int8_t unk_s8_03;
  int8_t unk_s8_04;
  int8_t unk_s8_05;
} T2FSDataUnk2_x_4;
 
SASSERT_SIZE(T2FSDataUnk2_x_4, 28)
T2FS_CREATE_SWAP_STRUCT(T2FSDataUnk2_x_4, (2, 2, 2, 4, 4, 4, 2, 2, 1, 1, 1, 1, 1, 1));
 

typedef struct __attribute__((__packed__)) s_T2FSDataHotpoint {
  T2FSDataCoordF32 pos;
  uint32_t flags;
  uint16_t boneId;
  uint16_t unk;
} T2FSDataHotpoint;
 
SASSERT_SIZE(T2FSDataHotpoint, 20)
T2FS_CREATE_SWAP_STRUCT(T2FSDataHotpoint, (4, 4, 4, 4, 2, 2));
 

typedef struct __attribute__((__packed__)) s_T2FSDataColorRGBA8 {
  uint8_t r, g, b, a;
} T2FSDataColorRGBA8;
 

typedef struct __attribute__((__packed__)) s_T2FSDataMaterial {
  uint32_t textureId; // 0xFFFFFFFF means no texture
  uint32_t unk_u32_1;
  uint32_t flags;
 
  // fgColor looks good on South Park model 652
  T2FSDataColorRGBA8 fgColor; // most set to 0x******FF
  T2FSDataColorRGBA8 bgColor; // most set to 0xFFFFFF**

  uint16_t sc, tc;
} T2FSDataMaterial;
 
SASSERT_SIZE(T2FSDataMaterial, 24)
T2FS_CREATE_SWAP_STRUCT(T2FSDataMaterial, (4, 4, 4, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2));
 
 
typedef struct __attribute__((__packed__)) s_T2FSDataVertexNormal {
  int8_t x, y, z;
} T2FSDataVertexNormal;
 
typedef struct __attribute__((__packed__)) s_T2FSDataVertexColor {
  uint8_t red, green, blue;
} T2FSDataVertexColor;
 
 
typedef union u_T2FSDataVertexAttr {
  T2FSDataVertexNormal normals;
  T2FSDataVertexColor colors;
} T2FSDataVertexAttr;
 

typedef struct __attribute__((__packed__)) s_T2FSDataVertex {
  int16_t x, y, z;
  uint16_t flags; //<! n64 docs say unused, but some models do set this
  float s, t;
  T2FSDataVertexAttr attr;
  uint8_t alpha;
} T2FSDataVertex;
 
SASSERT_SIZE(T2FSDataVertex, 20)
T2FS_CREATE_SWAP_STRUCT(T2FSDataVertex, (2, 2, 2, 2, 4, 4, 1, 1, 1, 1));
 
 
typedef struct __attribute__((__packed__)) s_T2FSDataVertexN64 {
  int16_t x, y, z;
  uint16_t flags; //<! n64 docs say unused, but some models do set this
  int16_t s, t;
  T2FSDataVertexAttr attr;
  uint8_t alpha;
} T2FSDataVertexN64;
 
SASSERT_SIZE(T2FSDataVertexN64, 16)
T2FS_CREATE_SWAP_STRUCT(T2FSDataVertexN64, (2, 2, 2, 2, 2, 2, 1, 1, 1, 1));
 
 
 
// ********************************************************************
// Our structs
// ********************************************************************
 
 
typedef struct s_T2FSAnimationFrame {
  float posx, posy, posz;
  float rotx, roty, rotz, rotw;
} T2FSAnimationFrame;
 
 
typedef struct s_T2FSAnimation {
  uint32_t boneCount; // count of bones that have changes
  uint8_t *boneIds;   // bone id's of those that have changes
  uint32_t frameCount;
  T2FSAnimationFrame *frames;
} T2FSAnimation;
 
 
typedef struct s_T2FSPolygon {
  uint32_t a, b, c;
  uint32_t realA, realB, realC; 
} T2FSPolygon;
 
 
typedef struct s_T2FSVertexBonePair {
  uint32_t vertexIndex; 
  int32_t boneId;       
} T2FSVertexBonePair;
 
 
typedef struct s_T2FSSurface {
  T2FSDataMaterial material;
  uint32_t vertexCount;
  T2FSVertexBonePair *vertices; 
  uint32_t polygonCount;
  T2FSPolygon *polygons;
} T2FSSurface;
 
 
typedef enum e_T2FSModelType {
  T2FS_MDL_TYPE_STATIC,
  T2FS_MDL_TYPE_ANIMATED
} T2FSModelType;
 
 
typedef struct s_T2FSModel {
  uint32_t id;                 
  uint32_t var;                
 
  T2FSModelType type;          
  T2FSDataCoordF32 min;        
  T2FSDataCoordF32 max;        
  int8_t headTrackStartBone;   
  int8_t headTrackEndBone;     
  int8_t headTrackFactor;      
  float scale;                 
 
  uint32_t vertexCount;        
  T2FSDataVertex *vertices;    
 
  uint8_t boneCount;           
  T2FSDataBone *bones;         

  uint32_t poseCount;
  T2FSDataBoneOrientation **poses;
 
  uint32_t animationCount;     
  T2FSAnimation *animations;   
 
  uint32_t surfaceCount;
  T2FSSurface *surfaces;
 
  uint32_t hotpointCount;      
  T2FSDataHotpoint *hotpoints; 
} T2FSModel;
 
 
typedef struct s_T2FSVtxCache {
  uint32_t buf[T2FS_VERTEX_CACHE_SIZE]; 
  int8_t bones[T2FS_VERTEX_CACHE_SIZE]; 
  uint32_t globalOffset; 

  uint32_t localOffset;

  uint32_t curVertCount;
} T2FSVtxCache;
 

typedef struct s_T2FSSurfaceVertices {
  T2FSVertexBonePair *indices;
  uint32_t count;
  uint32_t size;
} T2FSSurfaceVertices;
 
 
typedef struct s_T2FSPolygonBuffer {
  T2FSVtxCache cache;
  T2FSPolygon *polygons; 
  uint32_t polygonCount; 
  uint32_t polygonSize;  
 
  T2FSSurfaceVertices vertices;
} T2FSPolygonBuffer;
 

typedef struct s_T2FSModelContext {
  // main functions
  uint32_t (*getVarCount)(T2FSNode *mdlNode);
  int (*make)(T2FSContext *ctx, T2FSNode *mdlNode, uint32_t varId, T2FSModel *dest);
  // helper functions for make
 
  // for convenience
  T2FSContext *ctx;
} T2FSModelContext;
 

uint32_t
t2fs_model_count(T2FSContext *ctx);
 

void
t2fs_model_context_init(T2FSContext *ctx, T2FSModelContext *mdlCtx);
 

int
t2fs_model_load_data_node(T2FSModelContext *mdlCtx, uint32_t mdlId, T2FSNode **dest);
 

void
t2fs_model_unload_data_node(T2FSNode *modelNode);
 

uint32_t
t2fs_model_get_variation_count(T2FSModelContext *mdlCtx, T2FSNode *mdlNode);

void
t2fs_model_init(T2FSModel *mdl);
 

int
t2fs_model_make(T2FSModelContext *mdlCtx, T2FSNode *mdlNode, uint32_t varId, T2FSModel *dest);

void
t2fs_model_free(T2FSModel *mdl);
 
#endif