lib3ddevil1/src/devil1geo.c

#include "devil1geo.h"
#include <stdio.h>

void printgheader(struct Header *gh) {
    if (gh != NULL) {
        printf("pointer %x\n", gh);
        printf("number of meshes %x\n", gh -> numMesh);
        printf("unknown number B %x\n", gh -> unknownNumberB);
        printf("unknown number C %x\n", gh -> unknownNumberC);
        printf("unknown number D %x\n", gh -> unknownNumberD);
        printf("padding %x\n", gh -> padding);
        printf("unknown offset %x\n", gh -> unknownOffset);
    }
}

void printmeshheader(struct MeshHeader *mh) {
    if (mh == NULL) {
        return;
    }
    printf("number of batches %x\n", mh -> numBatch);
    printf("number of vertices %x\n", mh -> numVertex);
    printf("unknown %x\n", mh -> u);
    printf("batch offset %x\n", mh -> offsetBatches);
    printf("flags %x\n\n", mh -> flags);
}

void printmeshbatch(struct Batch *b) {
    if (b == NULL) {
        return;
    }
    printf("number of vertices %x\n", b -> numVertex);
    printf("unknown byte %x\n", b -> uB);
    printf("padding %x\n", b -> padding);
    printf("offsetPositions %x\n", b -> offsetPositions);
    printf("offsetNormals %x\n", b -> offsetNormals);
    printf("offsetUVs %x\n", b -> offsetUVs);
    printf("offsetBoneIndexes %x\n", b -> offsetBoneIndexes);
    printf("offsetBoneWeights %x\n", b -> offsetBoneWeights);
    printf("offsets %x\n\n", b -> offsets[0]);
}

void printpositions(struct Positions *p, unsigned int count) {
    if (p == NULL) {
        return;
    }
    unsigned int i;
    for (i = 0; i < count; i++) {
        printf("(%f, %f, %f)\n", (p[i]).x, (p[i]).y, (p[i]).z);
    }
}

void printnormals(struct Normals *n, unsigned int count) {
    if (n == NULL) {
        return;
    }
    unsigned int i;
    for (i = 0; i < count; i++) {
        printf("(%f, %f, %f)\n", (n[i]).x, (n[i]).y, (n[i]).z);
    }
}

bool getmeshheader(struct MeshHeader **hs,
                   unsigned int i,
                   const char * const filedata) {
    bool done = false;
    if (hs == NULL || filedata == NULL) {
        return done;
    }
    struct Header *h = (struct Header*)filedata;
    if (h -> numMesh < i) {
        return done;
    }
    unsigned int pos = sizeof(struct MeshHeader) * i + sizeof(struct Header);
    (*hs)   = (struct MeshHeader*)(filedata + pos);
    done = true;
    return done;
}

bool getmeshbatch(struct Batch **b, 
                  struct MeshHeader *h, 
                  const char * const filedata) {
    bool done = false;
    if (b == NULL || h == NULL || filedata == NULL) {
        return done;
    }
    unsigned int offset = h -> offsetBatches;
    *b = (struct Batch*)(filedata + offset);
    (*b) -> p  = (struct Positions*)(filedata   + ((*b) -> offsetPositions));
    (*b) -> n  = (struct Normals*)(filedata     + ((*b) -> offsetNormals));
    (*b) -> u  = (struct UVs*)(filedata         + ((*b) -> offsetUVs));
    (*b) -> bi = (struct BoneIndexes*)(filedata + ((*b) -> offsetBoneIndexes));
    (*b) -> bw = (struct BoneWeights*)(filedata + ((*b) -> offsetBoneWeights));
    done = true;
    return done;
}