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_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
 
// ********************************************************************
// Structs as in file (possible after decompression and/or deinterleaving)
// ********************************************************************
 

typedef struct __attribute__((__packed__)) s_t2fsDataModelInfo {
  t2fsDataCoordF32 min;
  t2fsDataCoordF32 max;
  int8_t headTrackStartNode;
  int8_t headTrackEndNode;
  int8_t headTrackFactor;
  int8_t pad;
  uint16_t variationCount;
  int16_t scale;
} t2fsDataModelInfo;
 
SASSERT_SIZE(t2fsDataModelInfo, 32)
 
 

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)
 
 

typedef struct __attribute__((__packed__)) s_t2fsDataBoneOrientation {
  t2fsDataCoordF32 pos;
  int16_t rotx, roty, rotz, rotw;
} t2fsDataBoneOrientation;
 
SASSERT_SIZE(t2fsDataBoneOrientation, 20)
 
 
 

typedef struct __attribute__((__packed__)) s_t2fsDataAnimationBoneIndices {
  int16_t rotationIndex; 
  int16_t positionIndex; 
} t2fsDataAnimationBoneIndices;
 
SASSERT_SIZE(t2fsDataAnimationBoneIndices, 4)
 
 

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)
 
 

typedef struct __attribute__((__packed__)) s_t2fsDataHotpoint {
  t2fsDataCoordF32 pos;
  uint32_t flags;
  uint16_t boneId;
  uint16_t unk;
} t2fsDataHotpoint;
 
SASSERT_SIZE(t2fsDataHotpoint, 20)
 
 

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 unk_u32_2; // 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)
 
 

typedef struct __attribute__((__packed__)) s_t2fsDataVertex {
  int16_t x, y, z;
  uint16_t flags; //<! n64 docs say unused, but some models do set this
  int16_t s, t; 
  int8_t nx, ny, nz;
  uint8_t unk;
  t2fsDataColorRGBA8 color;
} t2fsDataVertex;
 
SASSERT_SIZE(t2fsDataVertex, 20)
 
 
 
// ********************************************************************
// Our structs
// ********************************************************************
 
 
typedef struct s_t2fsModelSurface {
  t2fsDataMaterial *material;
  uint8_t *triangleData;
  uint32_t triangleDataSize;
  t2fsArray *vertexBuffer; // for convenience
} t2fsModelSurface;
 
 
typedef struct s_t2fsModelMesh {
  uint32_t id;
  uint32_t surfaceCount;
  uint32_t hotpointCount;
  t2fsArray vertexBuffer; // needs deinterleaving
  t2fsDataHotpoint *hotpoints;
  t2fsNode *nodeSurfaces;
} t2fsModelMesh;
 
 
typedef struct s_t2fsModel {
  t2fsNode *node;
  t2fsNode *nodeMeshes;       // 1/
  t2fsNode *nodeVertBuffers;  // 1/0/
  t2fsNode *nodeSurfaces;     // 1/2/
  t2fsNode *nodeBones;        // 1/3/
  t2fsNode *nodeHotpoints;    // 1/4/
  t2fsNode *nodeOrientations; // 2/
  uint8_t isValid;
 
  t2fsDataModelInfo *info;
  uint32_t boneCount;
  uint32_t poseCount;
  uint32_t meshCount;
} t2fsModel;
 
 
typedef struct s_t2fsTCoord {
  float u, v;
} t2fsTCoord;
 
 
typedef struct s_t2fsVertex {
  t2fsDataCoordF32 position;
  t2fsDataCoordF32 normal;
  t2fsDataColorRGBA8 color;
  t2fsTCoord tcoord;
  int8_t boneId;
} t2fsVertex;
 
 
typedef struct s_t2fsIndices {
  uint32_t a, b, c;
 
  // for debugging, remove later FIXME
  uint8_t boneId;
  uint8_t blockType;
  uint32_t blockOffset;
  uint32_t vertCount; // for this block
  uint32_t la, lb, lc; // local inside block
  uint32_t ra, rb, rc; // real
} t2fsIndices;
 
 
typedef struct s_t2fsTriangles {
  uint32_t vertCount;
  uint32_t indiceCount;
  t2fsVertex *verts;
  t2fsIndices *indices;
 
  uint32_t vertOffset;
} t2fsTriangles;
 

 
 
void
t2fs_triangles_init(t2fsTriangles *tri);
 
void
t2fs_triangles_free(t2fsTriangles *tri);
 
void
t2fs_model_clear(t2fsModel *model);
 
uint32_t
t2fs_model_count(t_t2fs *lib);
 
int
t2fs_model_load(t_t2fs *lib, t2fsModel *model, uint32_t id);
 
void
t2fs_model_unload(t2fsModel *model);
 
t2fsDataBone *
t2fs_model_get_bone(t2fsModel *model, uint32_t boneId);
 
int
t2fs_model_get_bone_orientations(t2fsModel *model, t2fsArray *orientations, uint32_t poseId);
 
void
t2fs_model_mesh_init(t2fsModelMesh *mesh);
 
int
t2fs_model_get_mesh(t2fsModel *model, t2fsModelMesh *dest, uint32_t meshId);
 
void
t2fs_model_mesh_surface_clear(t2fsModelSurface *surface);
 
int
t2fs_model_mesh_get_surface(t2fsModelMesh *mesh, t2fsModelSurface *dest, uint32_t surfaceId);
 
int
t2fs_model_surface_get_triangles(t2fsModelSurface *surface, t2fsTriangles *dest, uint32_t vertOffset);
 
 
#endif