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_T2FSContext T2FSContext;
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_T2FSContext T2FSContext;
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;

  T2FSContext *ctx;
} T2FSNode;
 

void t2fs_node_init(T2FSNode *node);
 

void
t2fs_node_free_childeren(T2FSNode *node);
 

int
t2fs_node_read_data(T2FSContext *ctx, T2FSNode *node);
 

int
t2fs_node_read_branch(T2FSContext *ctx, T2FSNode *node);
 

int
t2fs_node_read_recurse(T2FSContext *ctx, 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(T2FSContext *ctx, 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 T2FSContext *const ctx, 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_T2FSContext {
  T2FSFileConfig config;

  T2FSInput input;

  T2FSNode root;

  t_rnc rnc;
 
  // for convenience
  T2FSNode *models;
  T2FSNode *textures;
  T2FSNode *levels;
  T2FSNode *spawnpoints;
  T2FSNode *scenes;
} T2FSContext;
 

void
t2fs_init(T2FSContext *ctx);

T2FSStatus
t2fs_open(T2FSContext *ctx,
          const char *const filepath,
          const char *const schemaPath,
          uint8_t searchSchema);
 

void
t2fs_close(T2FSContext *ctx);
 
#endif