2018-02-11 23:22:04 +00:00
|
|
|
#include "data/modelData.h"
|
2019-04-05 11:27:48 +00:00
|
|
|
#include "data/blob.h"
|
|
|
|
#include "data/textureData.h"
|
2019-06-02 07:20:10 +00:00
|
|
|
#include "core/ref.h"
|
|
|
|
#include <stdlib.h>
|
2018-12-19 03:57:52 +00:00
|
|
|
|
2019-01-27 22:29:06 +00:00
|
|
|
ModelData* lovrModelDataInit(ModelData* model, Blob* source) {
|
|
|
|
if (lovrModelDataInitGltf(model, source)) {
|
2019-01-23 19:15:01 +00:00
|
|
|
return model;
|
2019-01-27 22:29:06 +00:00
|
|
|
} else if (lovrModelDataInitObj(model, source)) {
|
2019-01-23 19:15:01 +00:00
|
|
|
return model;
|
2018-09-26 00:10:09 +00:00
|
|
|
}
|
2018-02-11 01:27:29 +00:00
|
|
|
|
2019-01-23 19:15:01 +00:00
|
|
|
lovrThrow("Unable to load model from '%s'", source->name);
|
|
|
|
return NULL;
|
2017-02-19 09:54:58 +00:00
|
|
|
}
|
2017-11-02 02:27:58 +00:00
|
|
|
|
2018-09-26 00:10:09 +00:00
|
|
|
void lovrModelDataDestroy(void* ref) {
|
2019-01-10 19:34:00 +00:00
|
|
|
ModelData* model = ref;
|
2019-05-21 03:35:07 +00:00
|
|
|
for (uint32_t i = 0; i < model->blobCount; i++) {
|
2019-04-05 10:41:03 +00:00
|
|
|
lovrRelease(Blob, model->blobs[i]);
|
2019-01-23 06:40:34 +00:00
|
|
|
}
|
2019-05-21 03:35:07 +00:00
|
|
|
for (uint32_t i = 0; i < model->textureCount; i++) {
|
2019-04-05 10:41:03 +00:00
|
|
|
lovrRelease(TextureData, model->textures[i]);
|
2019-01-23 06:40:34 +00:00
|
|
|
}
|
2019-01-10 19:34:00 +00:00
|
|
|
free(model->data);
|
2017-11-02 02:27:58 +00:00
|
|
|
}
|
2019-01-23 19:15:01 +00:00
|
|
|
|
|
|
|
// Note: this code is a scary optimization
|
|
|
|
void lovrModelDataAllocate(ModelData* model) {
|
|
|
|
size_t totalSize = 0;
|
2019-01-31 02:56:17 +00:00
|
|
|
size_t sizes[13];
|
2019-01-23 19:15:01 +00:00
|
|
|
totalSize += sizes[0] = model->blobCount * sizeof(Blob*);
|
2019-01-31 02:56:17 +00:00
|
|
|
totalSize += sizes[1] = model->bufferCount * sizeof(ModelBuffer);
|
|
|
|
totalSize += sizes[2] = model->textureCount * sizeof(TextureData*);
|
|
|
|
totalSize += sizes[3] = model->materialCount * sizeof(ModelMaterial);
|
|
|
|
totalSize += sizes[4] = model->attributeCount * sizeof(ModelAttribute);
|
|
|
|
totalSize += sizes[5] = model->primitiveCount * sizeof(ModelPrimitive);
|
|
|
|
totalSize += sizes[6] = model->animationCount * sizeof(ModelAnimation);
|
|
|
|
totalSize += sizes[7] = model->skinCount * sizeof(ModelSkin);
|
2019-01-23 19:15:01 +00:00
|
|
|
totalSize += sizes[8] = model->nodeCount * sizeof(ModelNode);
|
2019-01-31 02:56:17 +00:00
|
|
|
totalSize += sizes[9] = model->channelCount * sizeof(ModelAnimationChannel);
|
|
|
|
totalSize += sizes[10] = model->childCount * sizeof(uint32_t);
|
|
|
|
totalSize += sizes[11] = model->jointCount * sizeof(uint32_t);
|
|
|
|
totalSize += sizes[12] = model->charCount * sizeof(char);
|
2019-01-23 19:15:01 +00:00
|
|
|
|
|
|
|
size_t offset = 0;
|
|
|
|
char* p = model->data = calloc(1, totalSize);
|
|
|
|
lovrAssert(model->data, "Out of memory");
|
|
|
|
model->blobs = (Blob**) (p + offset), offset += sizes[0];
|
2019-01-31 02:56:17 +00:00
|
|
|
model->buffers = (ModelBuffer*) (p + offset), offset += sizes[1];
|
|
|
|
model->textures = (TextureData**) (p + offset), offset += sizes[2];
|
|
|
|
model->materials = (ModelMaterial*) (p + offset), offset += sizes[3];
|
|
|
|
model->attributes = (ModelAttribute*) (p + offset), offset += sizes[4];
|
|
|
|
model->primitives = (ModelPrimitive*) (p + offset), offset += sizes[5];
|
|
|
|
model->animations = (ModelAnimation*) (p + offset), offset += sizes[6];
|
|
|
|
model->skins = (ModelSkin*) (p + offset), offset += sizes[7];
|
2019-01-23 19:15:01 +00:00
|
|
|
model->nodes = (ModelNode*) (p + offset), offset += sizes[8];
|
2019-01-31 02:56:17 +00:00
|
|
|
model->channels = (ModelAnimationChannel*) (p + offset), offset += sizes[9];
|
|
|
|
model->children = (uint32_t*) (p + offset), offset += sizes[10];
|
|
|
|
model->joints = (uint32_t*) (p + offset), offset += sizes[11];
|
|
|
|
model->chars = (char*) (p + offset), offset += sizes[12];
|
2019-01-23 19:15:01 +00:00
|
|
|
}
|