oot/tools/vtxdis.c

#include <stdlib.h>
#include <stdint.h>
#include <getopt.h>
#include <stdio.h>
#include <string.h>
#include <inttypes.h>
#include <sys/stat.h>
#include <errno.h>

#define VTXDIS_VER "0.2"

#define SWAP16(x) (((x & 0xFF00) >> 8) | ((x & 0x00FF) << 8))

typedef struct {
    int16_t pos[3];     /* 0x00 */
    int16_t flag;       /* 0x06 */
    int16_t tpos[2];    /* 0x08 */
    uint8_t cn[4];      /* 0x0C */
} Vtx;                  /* 0x10 */

static char *filename = NULL;
static char *data = NULL;
static int32_t offset = 0;
static int32_t data_len = 0;
static int16_t count = 0;

static const struct option cmdline_opts[] = {
    { "offset", required_argument, NULL, 'o', },
    { "length", required_argument, NULL, 'l', },
    { "file" , required_argument, NULL, 'f', },
    { "version", no_argument, NULL, '~', },
    { "help", no_argument, NULL, '?', },
    { "count", required_argument, NULL, 'c', },
    { 0, 0, 0, 0 },
};

static uint32_t parse_int(const char *num){
    uint32_t ret;
    char outnum[21];
    
    if(strlen(num) > 2 && num[0] == '0' && (num[1] == 'x' || num[1] == 'X')) {
        strncpy(outnum, &num[2], 20);
        sscanf(outnum, "%"SCNx32, &ret);
    } else if(strlen(num) == 0){
        ret =  -1;
    } else {
        strncpy(outnum, num, 20);
        sscanf(outnum, "%"SCNu32, &ret);
    }
    return ret;

}

static inline void print_usage(void)
{
    puts("vtxdis version " VTXDIS_VER "\n"
    "Usage:\n"
    "  vtxdis -f/--file FILE [options]\n"
    "  vtxdis -?/--help\n"
    "  vtxdis --version\n"
    "Options:\n"
    "  -f, --file       The file path to extract vertex data from.\n"
    "  -c, --count      The number of vertices to extract.\n"
    "  -l, --length     The amount of data to extract vertices from.\n"
    "  -o, --offset     The offset into file to start reading vertex data.\n"
    "  -?, --help       Prints this help message\n"
    "  --version        Prints the current version\n"
    );
}

static inline void print_version(void){
    puts("Version: " VTXDIS_VER);
}

static void print_vtx_data(Vtx *vtx, int vtx_cnt)
{
    puts("{");
    for(int i = 0; i < vtx_cnt; i++)
    {
        Vtx *v = &vtx[i];
        printf("    VTX(%d, %d, %d, %d, %d, %d, %d, %d, %d),\n", v->pos[0], v->pos[1], v->pos[2], v->tpos[0], v->tpos[1], v->cn[0], v->cn[1], v->cn[2], v->cn[3]);

    }
    puts("}");
}

static void parse_file(void)
{
    unsigned int alloc_size = 0;
    struct stat sbuffer;
    stat(filename, &sbuffer);
    if(errno != 0){
        perror("Count not stat file.");
        exit(1);
    }

    /* sanity checks */
    if(count > 0)
    {
        alloc_size = sizeof(Vtx) * count;
        if((offset > 0 && (offset + alloc_size) > sbuffer.st_size) || alloc_size > sbuffer.st_size)
        {
            puts("Requested data is beyond file boundaries.");
            exit(1);
        }
    }
    else if(data_len > 0)
    {
        alloc_size = data_len;

        if((offset > 0 && (offset + alloc_size) > sbuffer.st_size) || alloc_size > sbuffer.st_size)
        {
            puts("Requested data is beyond file boundaries.");
            exit(1);
        }
    }
    else
    {
        if (offset > 0)
        {
            alloc_size = sbuffer.st_size - offset;
        }
        else
        {
            alloc_size = sbuffer.st_size;
        }
    }

    if(alloc_size % sizeof(Vtx) != 0)
    {
        printf("Requested data size is not a multiple of sizeof(Vtx).  Requested size is %8x", alloc_size);
        exit(1);
    }

    FILE *file = fopen(filename, "rb");
    if(!file){
        perror("Could not open file");
        exit(1);
    }

    if(offset > 0){
        if(fseek(file, offset, SEEK_SET)){
            perror("Could not seek file");
            fclose(file);
            exit(1);
        }
    }

    Vtx *data = malloc(alloc_size);
    if(!data){
        fclose(file);
        perror("Could not allocate vtx data");
        exit(1);
    }

    if(!fread(data, alloc_size, 1, file)){
        perror("Could not read from file");
        fclose(file);
        free(data);
        exit(1);
    }

    fclose(file);

    unsigned int vtx_cnt = alloc_size / sizeof(Vtx);
    for(unsigned int i = 0; i < vtx_cnt; i++){
        Vtx *v = &data[i];

        v->pos[0] = SWAP16(v->pos[0]);
        v->pos[1] = SWAP16(v->pos[1]);
        v->pos[2] = SWAP16(v->pos[2]);
        v->flag = SWAP16(v->flag);
        v->tpos[0] = SWAP16(v->tpos[0]);
        v->tpos[1] = SWAP16(v->tpos[1]);
    }

    print_vtx_data(data, vtx_cnt);
    free(data);
}

int main(int argc, char **argv)
{
    int opt;

    while(1){
        opt = getopt_long(argc, argv, "o:l:f:c:v?", cmdline_opts, NULL);
        if(opt == -1){
            break;
        }
        switch(opt){
            case 'd':
                data = optarg;
                break;
            case '~':
                print_version();
                return 0;
            case '?':
                print_usage();
                return 0;
            case 'l':
                data_len = parse_int(optarg);
                break;
            case 'o':
                offset = parse_int(optarg);
                break;
            case 'f':
                filename = optarg;
                break;
            case 'c':
                count = parse_int(optarg);
                break;
        }
    }

    if (filename == NULL && data == NULL)
    {
        puts("Must specify -f or -d");
        print_usage();
        exit(1);
    }

    if(data_len < 0)
    {
        puts("Invalid -l/--length parameter passed.");
        print_usage();
        exit(1);
    }

    if(offset < 0)
    {
        puts("Invalid -o/--offset parameter passed.");
        print_usage();
        exit(1);
    }

    if(count < 0)
    {
        puts("Invalid -c/--count parameter passed.");
        print_usage();
        exit(1);
    }

    if(count > 0 && data_len > 0)
    {
        puts("Cannot specify both -c/--count and -l/--length.");
        print_usage();
        exit(1);
    }

    if(filename != NULL)
    {
        parse_file();
    }

    return 0;
}