t2fs.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_TUROK2_FILESYSTEM
#define H_T2FS_TUROK2_FILESYSTEM
 
#include <stdint.h>
#include <stdio.h>
 
#include "config.h"
#include "schema.h"
#include "rnc.h"

 
#define T2FS_NODE_SANE_MAX_COUNT 65000
#define T2FS_NODE_SANE_MIN_OFFSET 0x10
 
#define T2FS_PRINT_ERROR_NODE(node, ...) t2fs_print_error_node(T2FS_PRINT_FLAG_ERROR, __func__, node, __VA_ARGS__)
#define T2FS_PRINT_WARN_NODE(node, ...) t2fs_print_error_node(T2FS_PRINT_FLAG_WARNING, __func__, node, __VA_ARGS__)
#define T2FS_PRINT_DEBUG_NODE(node, ...) t2fs_print_error_node(T2FS_PRINT_FLAG_DEBUG, __func__, node, __VA_ARGS__)
 

typedef enum e_t2fsReadSize {
  T2FS_READ_16 = 2,
  T2FS_READ_32 = 4
} t2fsReadSize;
 
 
typedef struct s_t2fs t_t2fs;
typedef struct s_t2fsInput t2fsInput;
typedef size_t (t2fs_read_callback)(t2fsInput *input, void *dest, size_t size);
typedef size_t (t2fs_read_value_callback)(t2fsInput *input, void *dest, t2fsReadSize size);
typedef int (t2fs_seek_callback)(t2fsInput *input, long offset, int whence);

typedef struct s_t2fsInput {
  FILE *fp;

  long fileSize;
 
  // Some node(s) are compressed with RNC, we need to
  // decompress the data read from file first before we can process it.
  // buf is the decompressed buffer.
  uint8_t *buf;
  uint32_t bufSize;
  uint32_t bufOffset;

  t2fs_read_callback *read;

  t2fs_seek_callback *seek;

  t2fs_read_value_callback *readValue;
} t2fsInput;
 
 
/**********************************************************************
 **********************************************************************
 **********************************************************************/
 
 
typedef struct s_t2fs t_t2fs;
typedef struct s_t2fsNode t2fsNode;

typedef struct s_t2fsNode {
  t2fsSchemaNode *schema;

  uint32_t id;

  uint32_t offset;

  uint32_t size;

  uint8_t *data;

  t2fsInput *input;

  t2fsNode *parent;
 
  // when this is a branch node
  uint32_t childCount;

  t2fsNode *childNodes;

  uint8_t isCompressed;

  uint8_t hasBeenRead;

  t_t2fs *lib;
} t2fsNode;
 

void t2fs_node_init(t2fsNode *node);
 

void
t2fs_node_free_childeren(t2fsNode *node);
 

int
t2fs_node_read_data(t2fsNode *node);
 

int
t2fs_node_read_branch(t_t2fs *lib, t2fsNode *node);
 

int
t2fs_node_read_recurse(t_t2fs *lib, t2fsNode *node, uint8_t loadData);
 

uint8_t
t2fs_node_has_index(const t2fsNode *const node, uint32_t index);
 

t2fsNode *
t2fs_node_find_by_name(t2fsNode *start, const char *name, uint32_t level, uint32_t maxLevel);
 
 
void
t2fs_node_print_recursive(const t2fsNode *const node, uint32_t indent);
 
int
t2fs_node_guess_read_recursive(t_t2fs *lib, t2fsNode *node, uint8_t loadData, uint8_t decompress);
 
 
#define NODE_MAX_LEVEL 64
#define NODE_PATH_END  (uint32_t)-1
typedef struct s_t2fsNodePath {
  uint32_t segs[NODE_MAX_LEVEL];
  uint32_t count;
} t2fsNodePath;
 
void
t2fs_node_path_init(t2fsNodePath *np);
 
void
t2fs_node_path_parse(t2fsNodePath *np, t2fsNode *node);
 
void
t2fs_node_path_print(const t_t2fs *const lib, const t2fsNodePath *const np);
 
int
t2fs_node_path_to_string(const t2fsNodePath *const np, char *buf, size_t bufsize);
 
void
t2fs_print_error_node(int printType, const char *const func, t2fsNode *node, const char *const fmt, ...);
 
 
/**********************************************************************
 **********************************************************************
 **********************************************************************/
 
 
typedef enum {
  T2FS_OK    = 0,
  T2FS_ERROR = 1
} t2fsStatus;
 

typedef struct s_t2fs {
  T2FSFileConfig config;

  t2fsInput input;

  t2fsNode root;

  t_rnc rnc;
 
  // for convenience
  t2fsNode *models;
  t2fsNode *textures;
  t2fsNode *levels;
  t2fsNode *spawnpoints;
  t2fsNode *scenes;
} t_t2fs;
 

void
t2fs_init(t_t2fs *lib);

t2fsStatus
t2fs_open(t_t2fs *lib,
          const char *const filepath,
          const char *const schemaPath,
          uint8_t searchSchema);
 

void
t2fs_close(t_t2fs *lib);
 
#endif