luboslenco
814 lines
24 KiB
C
814 lines
24 KiB
C
#include "iron_array.h"
|
|
#include "iron_obj.h"
|
|
#include "ufbx/ufbx.h"
|
|
#include <math.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#define MAT_SPLIT_MAX 64
|
|
#define MAX_UDIM_TILES 100
|
|
|
|
static bool has_next = false;
|
|
static int current_node = 0;
|
|
static float scale_pos = 1.0;
|
|
static ufbx_scene *active_base_scene = NULL;
|
|
static ufbx_scene *active_eval_scene = NULL;
|
|
static bool active_tex1 = false;
|
|
static raw_mesh_t **mat_split_meshes = NULL;
|
|
static int mat_split_count = 0;
|
|
static int mat_split_idx = 0;
|
|
extern int plugins_split_by;
|
|
|
|
static bool valid_mesh(ufbx_node *n) {
|
|
return n->mesh != NULL && n->mesh->num_triangles > 0;
|
|
}
|
|
|
|
static bool mixed_uvs(ufbx_scene *scene) {
|
|
bool found_tex = false;
|
|
bool found_no_tex = false;
|
|
for (int i = 0; i < (int)scene->nodes.count; ++i) {
|
|
ufbx_node *n = scene->nodes.data[i];
|
|
if (valid_mesh(n)) {
|
|
if (n->mesh->vertex_uv.exists) {
|
|
found_tex = true;
|
|
}
|
|
else {
|
|
found_no_tex = true;
|
|
}
|
|
}
|
|
}
|
|
return found_tex && found_no_tex;
|
|
}
|
|
|
|
static bool mixed_cols(ufbx_scene *scene) {
|
|
bool found_col = false;
|
|
bool found_no_col = false;
|
|
for (int i = 0; i < (int)scene->nodes.count; ++i) {
|
|
ufbx_node *n = scene->nodes.data[i];
|
|
if (valid_mesh(n)) {
|
|
if (n->mesh->vertex_color.exists) {
|
|
found_col = true;
|
|
}
|
|
else {
|
|
found_no_col = true;
|
|
}
|
|
}
|
|
}
|
|
return found_col && found_no_col;
|
|
}
|
|
|
|
typedef struct {
|
|
float *data;
|
|
int count;
|
|
int cap;
|
|
} fbuf_t;
|
|
|
|
static void fbuf_push(fbuf_t *b, float v) {
|
|
if (b->count >= b->cap) {
|
|
b->cap = b->cap ? b->cap * 2 : 256;
|
|
b->data = realloc(b->data, b->cap * sizeof(float));
|
|
}
|
|
b->data[b->count++] = v;
|
|
}
|
|
|
|
static raw_mesh_t *mat_build_raw(char *name, fbuf_t *pf, fbuf_t *nf, fbuf_t *tf) {
|
|
int vertex_count = pf->count / 3;
|
|
float sp = 0.0f;
|
|
for (int i = 0; i < pf->count; ++i) {
|
|
float f = fabsf(pf->data[i]);
|
|
if (f > sp)
|
|
sp = f;
|
|
}
|
|
if (sp == 0.0f)
|
|
sp = 1.0f;
|
|
float inv = 1.0f / sp;
|
|
|
|
short *posa = malloc(sizeof(short) * vertex_count * 4);
|
|
short *nora = malloc(sizeof(short) * vertex_count * 2);
|
|
for (int i = 0; i < vertex_count; ++i) {
|
|
posa[i * 4] = pf->data[i * 3] * 32767.0f * inv;
|
|
posa[i * 4 + 1] = pf->data[i * 3 + 1] * 32767.0f * inv;
|
|
posa[i * 4 + 2] = pf->data[i * 3 + 2] * 32767.0f * inv;
|
|
nora[i * 2] = nf->data[i * 3] * 32767.0f;
|
|
nora[i * 2 + 1] = nf->data[i * 3 + 1] * 32767.0f;
|
|
posa[i * 4 + 3] = nf->data[i * 3 + 2] * 32767.0f;
|
|
}
|
|
|
|
short *texa = NULL;
|
|
if (tf->count > 0) {
|
|
texa = malloc(sizeof(short) * vertex_count * 2);
|
|
for (int i = 0; i < vertex_count; ++i) {
|
|
texa[i * 2] = tf->data[i * 2] * 32767.0f;
|
|
texa[i * 2 + 1] = (1.0f - tf->data[i * 2 + 1]) * 32767.0f;
|
|
}
|
|
}
|
|
|
|
uint32_t *inda = malloc(sizeof(uint32_t) * vertex_count);
|
|
for (int i = 0; i < vertex_count; ++i)
|
|
inda[i] = i;
|
|
|
|
raw_mesh_t *raw = calloc(sizeof(raw_mesh_t), 1);
|
|
raw->name = malloc(strlen(name) + 1);
|
|
strcpy(raw->name, name);
|
|
|
|
raw->posa = malloc(sizeof(i16_array_t));
|
|
raw->posa->buffer = posa;
|
|
raw->posa->length = raw->posa->capacity = vertex_count * 4;
|
|
|
|
raw->nora = malloc(sizeof(i16_array_t));
|
|
raw->nora->buffer = nora;
|
|
raw->nora->length = raw->nora->capacity = vertex_count * 2;
|
|
|
|
if (texa) {
|
|
raw->texa = malloc(sizeof(i16_array_t));
|
|
raw->texa->buffer = texa;
|
|
raw->texa->length = raw->texa->capacity = vertex_count * 2;
|
|
}
|
|
|
|
raw->inda = malloc(sizeof(u32_array_t));
|
|
raw->inda->buffer = inda;
|
|
raw->inda->length = raw->inda->capacity = vertex_count;
|
|
|
|
raw->scale_pos = sp;
|
|
raw->scale_tex = 1.0f;
|
|
return raw;
|
|
}
|
|
|
|
static void build_material_split(ufbx_scene *scene) {
|
|
char *names[MAT_SPLIT_MAX] = {0};
|
|
fbuf_t pf[MAT_SPLIT_MAX] = {0};
|
|
fbuf_t nf[MAT_SPLIT_MAX] = {0};
|
|
fbuf_t tf[MAT_SPLIT_MAX] = {0};
|
|
int num_mats = 0;
|
|
|
|
uint32_t max_tris = 1;
|
|
for (size_t ni = 0; ni < scene->nodes.count; ++ni) {
|
|
ufbx_node *n = scene->nodes.data[ni];
|
|
if (n->mesh && n->mesh->max_face_triangles > max_tris)
|
|
max_tris = n->mesh->max_face_triangles;
|
|
}
|
|
uint32_t *indices = malloc(sizeof(uint32_t) * max_tris * 3);
|
|
|
|
for (size_t ni = 0; ni < scene->nodes.count; ++ni) {
|
|
ufbx_node *n = scene->nodes.data[ni];
|
|
if (!n->mesh)
|
|
continue;
|
|
ufbx_mesh *mesh = n->mesh;
|
|
ufbx_matrix normal_mat = ufbx_get_compatible_matrix_for_normals(n);
|
|
bool has_tex = mesh->vertex_uv.exists;
|
|
|
|
for (size_t fi = 0; fi < mesh->faces.count; ++fi) {
|
|
ufbx_face face = mesh->faces.data[fi];
|
|
|
|
uint32_t midx = (mesh->face_material.count > 0) ? mesh->face_material.data[fi] : 0;
|
|
const char *mat_name = (midx < n->materials.count && n->materials.data[midx]) ? n->materials.data[midx]->name.data : n->name.data;
|
|
|
|
int m = -1;
|
|
for (int k = 0; k < num_mats; ++k) {
|
|
if (strcmp(names[k], mat_name) == 0) {
|
|
m = k;
|
|
break;
|
|
}
|
|
}
|
|
if (m == -1) {
|
|
if (num_mats >= MAT_SPLIT_MAX)
|
|
continue;
|
|
m = num_mats++;
|
|
names[m] = malloc(strlen(mat_name) + 1);
|
|
strcpy(names[m], mat_name);
|
|
}
|
|
|
|
uint32_t num_triangles = ufbx_triangulate_face(indices, max_tris * 3, mesh, face);
|
|
for (uint32_t v_ix = 0; v_ix < num_triangles * 3; ++v_ix) {
|
|
uint32_t a = indices[v_ix];
|
|
ufbx_vec3 v = ufbx_transform_position(&n->geometry_to_world, ufbx_get_vertex_vec3(&mesh->vertex_position, a));
|
|
fbuf_push(&pf[m], v.x);
|
|
fbuf_push(&pf[m], -v.z);
|
|
fbuf_push(&pf[m], v.y);
|
|
ufbx_vec3 nv = ufbx_transform_direction(&normal_mat, ufbx_get_vertex_vec3(&mesh->vertex_normal, a));
|
|
fbuf_push(&nf[m], nv.x);
|
|
fbuf_push(&nf[m], -nv.z);
|
|
fbuf_push(&nf[m], nv.y);
|
|
if (has_tex) {
|
|
ufbx_vec2 uv = ufbx_get_vertex_vec2(&mesh->vertex_uv, a);
|
|
fbuf_push(&tf[m], uv.x);
|
|
fbuf_push(&tf[m], uv.y);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
free(indices);
|
|
|
|
mat_split_meshes = malloc(sizeof(raw_mesh_t *) * num_mats);
|
|
mat_split_count = num_mats;
|
|
for (int m = 0; m < num_mats; ++m) {
|
|
mat_split_meshes[m] = mat_build_raw(names[m], &pf[m], &nf[m], &tf[m]);
|
|
free(names[m]);
|
|
free(pf[m].data);
|
|
free(nf[m].data);
|
|
free(tf[m].data);
|
|
}
|
|
}
|
|
|
|
static void build_udim_split(ufbx_scene *scene) {
|
|
int tile_ids[MAX_UDIM_TILES] = {0};
|
|
fbuf_t pf[MAX_UDIM_TILES] = {0};
|
|
fbuf_t nf[MAX_UDIM_TILES] = {0};
|
|
fbuf_t tf[MAX_UDIM_TILES] = {0};
|
|
int num_tiles = 0;
|
|
|
|
const char *base_name = "Mesh";
|
|
for (size_t ni = 0; ni < scene->nodes.count; ++ni) {
|
|
ufbx_node *n = scene->nodes.data[ni];
|
|
if (n->mesh && n->name.length > 0) {
|
|
base_name = n->name.data;
|
|
break;
|
|
}
|
|
}
|
|
|
|
uint32_t max_tris = 1;
|
|
for (size_t ni = 0; ni < scene->nodes.count; ++ni) {
|
|
ufbx_node *n = scene->nodes.data[ni];
|
|
if (n->mesh && n->mesh->max_face_triangles > max_tris)
|
|
max_tris = n->mesh->max_face_triangles;
|
|
}
|
|
uint32_t *indices = malloc(sizeof(uint32_t) * max_tris * 3);
|
|
|
|
for (size_t ni = 0; ni < scene->nodes.count; ++ni) {
|
|
ufbx_node *n = scene->nodes.data[ni];
|
|
if (!n->mesh)
|
|
continue;
|
|
ufbx_mesh *mesh = n->mesh;
|
|
ufbx_matrix normal_mat = ufbx_get_compatible_matrix_for_normals(n);
|
|
bool has_tex = mesh->vertex_uv.exists;
|
|
|
|
for (size_t fi = 0; fi < mesh->faces.count; ++fi) {
|
|
ufbx_face face = mesh->faces.data[fi];
|
|
uint32_t num_triangles = ufbx_triangulate_face(indices, max_tris * 3, mesh, face);
|
|
|
|
for (uint32_t tri = 0; tri < num_triangles; ++tri) {
|
|
uint32_t a0 = indices[tri * 3];
|
|
uint32_t a1 = indices[tri * 3 + 1];
|
|
uint32_t a2 = indices[tri * 3 + 2];
|
|
|
|
int tile_u = 0, tile_v = 0;
|
|
if (has_tex) {
|
|
ufbx_vec2 uv0 = ufbx_get_vertex_vec2(&mesh->vertex_uv, a0);
|
|
ufbx_vec2 uv1 = ufbx_get_vertex_vec2(&mesh->vertex_uv, a1);
|
|
ufbx_vec2 uv2 = ufbx_get_vertex_vec2(&mesh->vertex_uv, a2);
|
|
tile_u = (int)((uv0.x + uv1.x + uv2.x) / 3.0);
|
|
tile_v = (int)((uv0.y + uv1.y + uv2.y) / 3.0);
|
|
}
|
|
int tile_id = 1000 + tile_v * 10 + tile_u + 1;
|
|
|
|
int t = -1;
|
|
for (int k = 0; k < num_tiles; ++k) {
|
|
if (tile_ids[k] == tile_id) {
|
|
t = k;
|
|
break;
|
|
}
|
|
}
|
|
if (t == -1) {
|
|
if (num_tiles >= MAX_UDIM_TILES)
|
|
continue;
|
|
t = num_tiles++;
|
|
tile_ids[t] = tile_id;
|
|
}
|
|
|
|
uint32_t verts[3] = {a0, a1, a2};
|
|
for (int vi = 0; vi < 3; ++vi) {
|
|
uint32_t a = verts[vi];
|
|
ufbx_vec3 v = ufbx_transform_position(&n->geometry_to_world, ufbx_get_vertex_vec3(&mesh->vertex_position, a));
|
|
fbuf_push(&pf[t], v.x);
|
|
fbuf_push(&pf[t], -v.z);
|
|
fbuf_push(&pf[t], v.y);
|
|
ufbx_vec3 nv = ufbx_transform_direction(&normal_mat, ufbx_get_vertex_vec3(&mesh->vertex_normal, a));
|
|
fbuf_push(&nf[t], nv.x);
|
|
fbuf_push(&nf[t], -nv.z);
|
|
fbuf_push(&nf[t], nv.y);
|
|
if (has_tex) {
|
|
ufbx_vec2 uv = ufbx_get_vertex_vec2(&mesh->vertex_uv, a);
|
|
fbuf_push(&tf[t], uv.x - tile_u);
|
|
fbuf_push(&tf[t], uv.y - tile_v);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
free(indices);
|
|
|
|
char tile_name[256];
|
|
mat_split_meshes = malloc(sizeof(raw_mesh_t *) * num_tiles);
|
|
mat_split_count = num_tiles;
|
|
for (int t = 0; t < num_tiles; ++t) {
|
|
snprintf(tile_name, sizeof(tile_name), "%s.%d", base_name, tile_ids[t]);
|
|
mat_split_meshes[t] = mat_build_raw(tile_name, &pf[t], &nf[t], &tf[t]);
|
|
free(pf[t].data);
|
|
free(nf[t].data);
|
|
free(tf[t].data);
|
|
}
|
|
}
|
|
|
|
void io_fbx_parse_mesh(raw_mesh_t *raw, ufbx_mesh *mesh, ufbx_matrix *to_world, ufbx_matrix *to_world_unscaled, bool force_tex, bool force_col) {
|
|
uint32_t indices_size = mesh->max_face_triangles * 3;
|
|
uint32_t *indices = (uint32_t *)malloc(sizeof(uint32_t) * indices_size);
|
|
|
|
bool has_tex = mesh->vertex_uv.exists;
|
|
bool has_tex1 = active_tex1 && mesh->uv_sets.count > 1;
|
|
bool has_col = mesh->vertex_color.exists;
|
|
|
|
int numtri = mesh->num_triangles;
|
|
float *posa32 = (float *)malloc(sizeof(float) * numtri * 3 * 3);
|
|
float *nora32 = (float *)malloc(sizeof(float) * numtri * 3 * 3);
|
|
float *texa32 = (has_tex || force_tex) ? (float *)malloc(sizeof(float) * numtri * 3 * 2) : NULL;
|
|
float *texa132 = has_tex1 ? (float *)malloc(sizeof(float) * numtri * 3 * 2) : NULL;
|
|
float *cola32 = (has_col || force_col) ? (float *)malloc(sizeof(float) * numtri * 3 * 4) : NULL;
|
|
int pi = 0;
|
|
int ni = 0;
|
|
int ti = 0;
|
|
int ti1 = 0;
|
|
int ci = 0;
|
|
|
|
for (int j = 0; j < (int)mesh->faces.count; ++j) {
|
|
ufbx_face face = mesh->faces.data[j];
|
|
uint32_t num_triangles = ufbx_triangulate_face(indices, indices_size, mesh, face);
|
|
for (uint32_t v_ix = 0; v_ix < num_triangles * 3; v_ix++) {
|
|
uint32_t a = indices[v_ix];
|
|
|
|
ufbx_vec3 v = ufbx_transform_position(to_world, ufbx_get_vertex_vec3(&mesh->vertex_position, a));
|
|
// posa32[pi++] = v.x;
|
|
// posa32[pi++] = v.y;
|
|
// posa32[pi++] = v.z;
|
|
posa32[pi++] = v.x;
|
|
posa32[pi++] = -v.z;
|
|
posa32[pi++] = v.y;
|
|
|
|
v = ufbx_transform_direction(to_world_unscaled, ufbx_get_vertex_vec3(&mesh->vertex_normal, a));
|
|
// nora32[ni++] = v.x;
|
|
// nora32[ni++] = v.y;
|
|
// nora32[ni++] = v.z;
|
|
nora32[ni++] = v.x;
|
|
nora32[ni++] = -v.z;
|
|
nora32[ni++] = v.y;
|
|
|
|
if (has_tex) {
|
|
texa32[ti++] = ufbx_get_vertex_vec2(&mesh->vertex_uv, a).x;
|
|
texa32[ti++] = ufbx_get_vertex_vec2(&mesh->vertex_uv, a).y;
|
|
}
|
|
else if (force_tex) {
|
|
texa32[ti++] = 0;
|
|
texa32[ti++] = 0;
|
|
}
|
|
|
|
if (has_tex1) {
|
|
texa132[ti1++] = ufbx_get_vertex_vec2(&mesh->uv_sets.data[1].vertex_uv, a).x;
|
|
texa132[ti1++] = ufbx_get_vertex_vec2(&mesh->uv_sets.data[1].vertex_uv, a).y;
|
|
}
|
|
|
|
if (has_col) {
|
|
cola32[ci++] = ufbx_get_vertex_vec4(&mesh->vertex_color, a).x;
|
|
cola32[ci++] = ufbx_get_vertex_vec4(&mesh->vertex_color, a).y;
|
|
cola32[ci++] = ufbx_get_vertex_vec4(&mesh->vertex_color, a).z;
|
|
cola32[ci++] = ufbx_get_vertex_vec4(&mesh->vertex_color, a).w;
|
|
}
|
|
else if (force_col) {
|
|
cola32[ci++] = 0;
|
|
cola32[ci++] = 0;
|
|
cola32[ci++] = 0;
|
|
cola32[ci++] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
free(indices);
|
|
|
|
int vertex_count = pi / 3;
|
|
int index_count = vertex_count;
|
|
|
|
uint32_t *inda = malloc(sizeof(uint32_t) * index_count);
|
|
for (int i = 0; i < index_count; ++i) {
|
|
inda[i] = i;
|
|
}
|
|
|
|
// Pack positions to (-1, 1) range
|
|
float hx = 0.0;
|
|
float hy = 0.0;
|
|
float hz = 0.0;
|
|
for (int i = 0; i < vertex_count; ++i) {
|
|
float f = fabsf(posa32[i * 3]);
|
|
if (hx < f)
|
|
hx = f;
|
|
f = fabsf(posa32[i * 3 + 1]);
|
|
if (hy < f)
|
|
hy = f;
|
|
f = fabsf(posa32[i * 3 + 2]);
|
|
if (hz < f)
|
|
hz = f;
|
|
}
|
|
float _scale_pos = fmax(hx, fmax(hy, hz));
|
|
if (_scale_pos > scale_pos)
|
|
scale_pos = _scale_pos;
|
|
float inv = 1 / scale_pos;
|
|
|
|
// Pack into 16bit
|
|
short *posa = malloc(sizeof(short) * vertex_count * 4);
|
|
for (int i = 0; i < vertex_count; ++i) {
|
|
posa[i * 4] = posa32[i * 3] * 32767 * inv;
|
|
posa[i * 4 + 1] = posa32[i * 3 + 1] * 32767 * inv;
|
|
posa[i * 4 + 2] = posa32[i * 3 + 2] * 32767 * inv;
|
|
}
|
|
|
|
short *nora = malloc(sizeof(short) * vertex_count * 2);
|
|
if (nora32 != NULL) {
|
|
for (int i = 0; i < vertex_count; ++i) {
|
|
nora[i * 2] = nora32[i * 3] * 32767;
|
|
nora[i * 2 + 1] = nora32[i * 3 + 1] * 32767;
|
|
posa[i * 4 + 3] = nora32[i * 3 + 2] * 32767;
|
|
}
|
|
free(nora32);
|
|
}
|
|
|
|
free(posa32);
|
|
|
|
short *texa = NULL;
|
|
if (texa32 != NULL) {
|
|
texa = malloc(sizeof(short) * vertex_count * 2);
|
|
for (int i = 0; i < vertex_count; ++i) {
|
|
texa[i * 2] = texa32[i * 2] * 32767;
|
|
texa[i * 2 + 1] = (1.0 - texa32[i * 2 + 1]) * 32767;
|
|
}
|
|
free(texa32);
|
|
}
|
|
|
|
short *texa1 = NULL;
|
|
if (texa132 != NULL) {
|
|
texa1 = malloc(sizeof(short) * vertex_count * 2);
|
|
for (int i = 0; i < vertex_count; ++i) {
|
|
texa1[i * 2] = texa132[i * 2] * 32767;
|
|
texa1[i * 2 + 1] = (1.0 - texa132[i * 2 + 1]) * 32767;
|
|
}
|
|
free(texa132);
|
|
}
|
|
|
|
short *cola = NULL;
|
|
if (cola32 != NULL) {
|
|
cola = malloc(sizeof(short) * vertex_count * 4);
|
|
for (int i = 0; i < vertex_count; ++i) {
|
|
cola[i * 4] = cola32[i * 4] * 32767;
|
|
cola[i * 4 + 1] = cola32[i * 4 + 1] * 32767;
|
|
cola[i * 4 + 2] = cola32[i * 4 + 2] * 32767;
|
|
cola[i * 4 + 3] = cola32[i * 4 + 3] * 32767;
|
|
}
|
|
free(cola32);
|
|
}
|
|
|
|
raw->posa = (i16_array_t *)malloc(sizeof(i16_array_t));
|
|
raw->posa->buffer = posa;
|
|
raw->posa->length = raw->posa->capacity = vertex_count * 4;
|
|
|
|
raw->nora = (i16_array_t *)malloc(sizeof(i16_array_t));
|
|
raw->nora->buffer = nora;
|
|
raw->nora->length = raw->nora->capacity = vertex_count * 2;
|
|
|
|
if (texa != NULL) {
|
|
raw->texa = (i16_array_t *)malloc(sizeof(i16_array_t));
|
|
raw->texa->buffer = texa;
|
|
raw->texa->length = raw->texa->capacity = vertex_count * 2;
|
|
}
|
|
|
|
if (texa1 != NULL) {
|
|
raw->texa1 = (i16_array_t *)malloc(sizeof(i16_array_t));
|
|
raw->texa1->buffer = texa1;
|
|
raw->texa1->length = raw->texa1->capacity = vertex_count * 2;
|
|
}
|
|
|
|
if (cola != NULL) {
|
|
raw->cola = (i16_array_t *)malloc(sizeof(i16_array_t));
|
|
raw->cola->buffer = cola;
|
|
raw->cola->length = raw->cola->capacity = vertex_count * 4;
|
|
}
|
|
|
|
raw->inda = (u32_array_t *)malloc(sizeof(u32_array_t));
|
|
raw->inda->buffer = inda;
|
|
raw->inda->length = raw->inda->capacity = index_count;
|
|
|
|
raw->scale_pos = scale_pos;
|
|
raw->scale_tex = 1.0;
|
|
}
|
|
|
|
void *io_fbx_parse(char *buf, size_t size) {
|
|
if (active_base_scene == NULL) {
|
|
ufbx_load_opts opts = {.generate_missing_normals = true};
|
|
active_base_scene = active_eval_scene = ufbx_load_memory(buf, size, &opts, NULL);
|
|
active_tex1 = true;
|
|
for (size_t i = 0; i < active_eval_scene->nodes.count; ++i) {
|
|
ufbx_node *n = active_eval_scene->nodes.data[i];
|
|
if (valid_mesh(n) && n->mesh->uv_sets.count < 2) {
|
|
active_tex1 = false;
|
|
break;
|
|
}
|
|
}
|
|
if (plugins_split_by == 1 /* SPLIT_TYPE_MATERIAL */) {
|
|
build_material_split(active_eval_scene);
|
|
mat_split_idx = 0;
|
|
}
|
|
else if (plugins_split_by == 2 /* SPLIT_TYPE_UDIM */) {
|
|
build_udim_split(active_eval_scene);
|
|
mat_split_idx = 0;
|
|
}
|
|
}
|
|
|
|
if (plugins_split_by == 1 /* SPLIT_TYPE_MATERIAL */ || plugins_split_by == 2 /* SPLIT_TYPE_UDIM */) {
|
|
raw_mesh_t *raw = mat_split_meshes[mat_split_idx++];
|
|
raw->has_next = (mat_split_idx < mat_split_count);
|
|
if (!raw->has_next) {
|
|
ufbx_free_scene(active_base_scene);
|
|
active_base_scene = NULL;
|
|
active_eval_scene = NULL;
|
|
current_node = 0;
|
|
active_tex1 = false;
|
|
free(mat_split_meshes);
|
|
mat_split_meshes = NULL;
|
|
mat_split_count = 0;
|
|
mat_split_idx = 0;
|
|
}
|
|
return raw;
|
|
}
|
|
|
|
raw_mesh_t *raw = (raw_mesh_t *)calloc(sizeof(raw_mesh_t), 1);
|
|
|
|
bool force_tex = mixed_uvs(active_eval_scene);
|
|
bool force_col = mixed_cols(active_eval_scene);
|
|
|
|
for (; current_node < (int)active_eval_scene->nodes.count; ++current_node) {
|
|
ufbx_node *n = active_eval_scene->nodes.data[current_node];
|
|
if (valid_mesh(n)) {
|
|
raw->name = malloc(strlen(n->name.data) + 1);
|
|
strcpy(raw->name, n->name.data);
|
|
ufbx_matrix normal_mat = ufbx_get_compatible_matrix_for_normals(n);
|
|
io_fbx_parse_mesh(raw, n->mesh, &n->geometry_to_world, &normal_mat, force_tex, force_col);
|
|
break;
|
|
}
|
|
}
|
|
current_node++;
|
|
|
|
has_next = false;
|
|
for (int i = current_node; i < (int)active_eval_scene->nodes.count; ++i) {
|
|
ufbx_node *n = active_eval_scene->nodes.data[i];
|
|
if (valid_mesh(n)) {
|
|
has_next = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!has_next) {
|
|
ufbx_free_scene(active_base_scene);
|
|
active_base_scene = NULL;
|
|
active_eval_scene = NULL;
|
|
current_node = 0;
|
|
active_tex1 = false;
|
|
}
|
|
|
|
raw->has_next = has_next;
|
|
return raw;
|
|
}
|
|
|
|
void *io_fbx_parse_skinned(char *buf, size_t size, int frame) {
|
|
if (active_base_scene == NULL) {
|
|
ufbx_load_opts load_opts = {.generate_missing_normals = true};
|
|
active_base_scene = ufbx_load_memory(buf, size, &load_opts, NULL);
|
|
if (active_base_scene == NULL)
|
|
return NULL;
|
|
|
|
double fps = active_base_scene->settings.frames_per_second > 0.0 ? active_base_scene->settings.frames_per_second : 30.0;
|
|
double time = (double)frame / fps;
|
|
if (active_base_scene->anim_stacks.count > 0) {
|
|
ufbx_evaluate_opts eval_opts = {.evaluate_skinning = true};
|
|
active_eval_scene = ufbx_evaluate_scene(active_base_scene, active_base_scene->anim_stacks.data[0]->anim, time, &eval_opts, NULL);
|
|
if (active_eval_scene == NULL) {
|
|
ufbx_free_scene(active_base_scene);
|
|
active_base_scene = NULL;
|
|
return NULL;
|
|
}
|
|
}
|
|
else {
|
|
active_eval_scene = active_base_scene;
|
|
}
|
|
|
|
// Pre-scan: disable tex1 if any mesh lacks a second uv set
|
|
active_tex1 = true;
|
|
for (size_t i = 0; i < active_eval_scene->nodes.count; ++i) {
|
|
ufbx_node *n = active_eval_scene->nodes.data[i];
|
|
if (valid_mesh(n) && n->mesh->uv_sets.count < 2) {
|
|
active_tex1 = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Find next mesh node
|
|
ufbx_node *mesh_node = NULL;
|
|
for (; current_node < (int)active_eval_scene->nodes.count; ++current_node) {
|
|
ufbx_node *n = active_eval_scene->nodes.data[current_node];
|
|
if (valid_mesh(n)) {
|
|
mesh_node = n;
|
|
break;
|
|
}
|
|
}
|
|
current_node++;
|
|
|
|
if (mesh_node == NULL) {
|
|
if (active_eval_scene != active_base_scene)
|
|
ufbx_free_scene(active_eval_scene);
|
|
ufbx_free_scene(active_base_scene);
|
|
active_base_scene = NULL;
|
|
active_eval_scene = NULL;
|
|
current_node = 0;
|
|
has_next = false;
|
|
active_tex1 = false;
|
|
return calloc(sizeof(raw_mesh_t), 1);
|
|
}
|
|
|
|
ufbx_mesh *mesh = mesh_node->mesh;
|
|
ufbx_matrix normal_to_world = ufbx_get_compatible_matrix_for_normals(mesh_node);
|
|
|
|
uint32_t indices_size = mesh->max_face_triangles * 3;
|
|
uint32_t *indices = (uint32_t *)malloc(sizeof(uint32_t) * indices_size);
|
|
|
|
bool force_tex = mixed_uvs(active_eval_scene);
|
|
bool has_tex = mesh->vertex_uv.exists;
|
|
bool has_tex1 = active_tex1 && mesh->uv_sets.count > 1;
|
|
int numtri = mesh->num_triangles;
|
|
float *posa32 = (float *)malloc(sizeof(float) * numtri * 3 * 3);
|
|
float *nora32 = (float *)malloc(sizeof(float) * numtri * 3 * 3);
|
|
float *texa32 = (has_tex || force_tex) ? (float *)malloc(sizeof(float) * numtri * 3 * 2) : NULL;
|
|
float *texa132 = has_tex1 ? (float *)malloc(sizeof(float) * numtri * 3 * 2) : NULL;
|
|
int pi = 0, ni = 0, ti = 0, ti1 = 0;
|
|
|
|
for (int j = 0; j < mesh->faces.count; ++j) {
|
|
ufbx_face face = mesh->faces.data[j];
|
|
uint32_t num_triangles = ufbx_triangulate_face(indices, indices_size, mesh, face);
|
|
for (uint32_t v_ix = 0; v_ix < num_triangles * 3; v_ix++) {
|
|
uint32_t a = indices[v_ix];
|
|
|
|
// skinned_position/normal are world-space when skinned_is_local == false
|
|
// (evaluated skinned mesh), or local-space when skinned_is_local == true
|
|
ufbx_vec3 v = ufbx_get_vertex_vec3(&mesh->skinned_position, a);
|
|
if (mesh->skinned_is_local)
|
|
v = ufbx_transform_position(&mesh_node->geometry_to_world, v);
|
|
posa32[pi++] = v.x;
|
|
posa32[pi++] = -v.z;
|
|
posa32[pi++] = v.y;
|
|
|
|
ufbx_vec3 n = ufbx_get_vertex_vec3(&mesh->skinned_normal, a);
|
|
if (mesh->skinned_is_local)
|
|
n = ufbx_transform_direction(&normal_to_world, n);
|
|
float nlen = sqrtf(n.x * n.x + n.y * n.y + n.z * n.z);
|
|
if (nlen > 1e-6f) {
|
|
n.x /= nlen;
|
|
n.y /= nlen;
|
|
n.z /= nlen;
|
|
}
|
|
nora32[ni++] = n.x;
|
|
nora32[ni++] = -n.z;
|
|
nora32[ni++] = n.y;
|
|
|
|
if (has_tex) {
|
|
texa32[ti++] = ufbx_get_vertex_vec2(&mesh->vertex_uv, a).x;
|
|
texa32[ti++] = ufbx_get_vertex_vec2(&mesh->vertex_uv, a).y;
|
|
}
|
|
else if (force_tex) {
|
|
texa32[ti++] = 0;
|
|
texa32[ti++] = 0;
|
|
}
|
|
|
|
if (has_tex1) {
|
|
texa132[ti1++] = ufbx_get_vertex_vec2(&mesh->uv_sets.data[1].vertex_uv, a).x;
|
|
texa132[ti1++] = ufbx_get_vertex_vec2(&mesh->uv_sets.data[1].vertex_uv, a).y;
|
|
}
|
|
}
|
|
}
|
|
|
|
free(indices);
|
|
|
|
int vertex_count = pi / 3;
|
|
int index_count = vertex_count;
|
|
|
|
uint32_t *inda = malloc(sizeof(uint32_t) * index_count);
|
|
for (int i = 0; i < index_count; ++i)
|
|
inda[i] = i;
|
|
|
|
// Pack positions to (-1, 1) range
|
|
float hx = 0.0, hy = 0.0, hz = 0.0;
|
|
for (int i = 0; i < vertex_count; ++i) {
|
|
float f = fabsf(posa32[i * 3]);
|
|
if (hx < f)
|
|
hx = f;
|
|
f = fabsf(posa32[i * 3 + 1]);
|
|
if (hy < f)
|
|
hy = f;
|
|
f = fabsf(posa32[i * 3 + 2]);
|
|
if (hz < f)
|
|
hz = f;
|
|
}
|
|
float _scale_pos = fmax(hx, fmax(hy, hz));
|
|
if (_scale_pos > scale_pos)
|
|
scale_pos = _scale_pos;
|
|
float inv = 1 / scale_pos;
|
|
|
|
// Pack into 16bit
|
|
short *posa = malloc(sizeof(short) * vertex_count * 4);
|
|
for (int i = 0; i < vertex_count; ++i) {
|
|
posa[i * 4] = posa32[i * 3] * 32767 * inv;
|
|
posa[i * 4 + 1] = posa32[i * 3 + 1] * 32767 * inv;
|
|
posa[i * 4 + 2] = posa32[i * 3 + 2] * 32767 * inv;
|
|
}
|
|
free(posa32);
|
|
|
|
short *nora = malloc(sizeof(short) * vertex_count * 2);
|
|
for (int i = 0; i < vertex_count; ++i) {
|
|
nora[i * 2] = nora32[i * 3] * 32767;
|
|
nora[i * 2 + 1] = nora32[i * 3 + 1] * 32767;
|
|
posa[i * 4 + 3] = nora32[i * 3 + 2] * 32767;
|
|
}
|
|
free(nora32);
|
|
|
|
short *texa = NULL;
|
|
if (texa32 != NULL) {
|
|
texa = malloc(sizeof(short) * vertex_count * 2);
|
|
for (int i = 0; i < vertex_count; ++i) {
|
|
texa[i * 2] = texa32[i * 2] * 32767;
|
|
texa[i * 2 + 1] = (1.0 - texa32[i * 2 + 1]) * 32767;
|
|
}
|
|
free(texa32);
|
|
}
|
|
|
|
short *texa1 = NULL;
|
|
if (texa132 != NULL) {
|
|
texa1 = malloc(sizeof(short) * vertex_count * 2);
|
|
for (int i = 0; i < vertex_count; ++i) {
|
|
texa1[i * 2] = texa132[i * 2] * 32767;
|
|
texa1[i * 2 + 1] = (1.0 - texa132[i * 2 + 1]) * 32767;
|
|
}
|
|
free(texa132);
|
|
}
|
|
|
|
raw_mesh_t *raw = (raw_mesh_t *)calloc(sizeof(raw_mesh_t), 1);
|
|
raw->name = malloc(strlen(mesh_node->name.data) + 1);
|
|
strcpy(raw->name, mesh_node->name.data);
|
|
|
|
raw->posa = (i16_array_t *)malloc(sizeof(i16_array_t));
|
|
raw->posa->buffer = posa;
|
|
raw->posa->length = raw->posa->capacity = vertex_count * 4;
|
|
|
|
raw->nora = (i16_array_t *)malloc(sizeof(i16_array_t));
|
|
raw->nora->buffer = nora;
|
|
raw->nora->length = raw->nora->capacity = vertex_count * 2;
|
|
|
|
if (texa != NULL) {
|
|
raw->texa = (i16_array_t *)malloc(sizeof(i16_array_t));
|
|
raw->texa->buffer = texa;
|
|
raw->texa->length = raw->texa->capacity = vertex_count * 2;
|
|
}
|
|
|
|
if (texa1 != NULL) {
|
|
raw->texa1 = (i16_array_t *)malloc(sizeof(i16_array_t));
|
|
raw->texa1->buffer = texa1;
|
|
raw->texa1->length = raw->texa1->capacity = vertex_count * 2;
|
|
}
|
|
|
|
raw->inda = (u32_array_t *)malloc(sizeof(u32_array_t));
|
|
raw->inda->buffer = inda;
|
|
raw->inda->length = raw->inda->capacity = index_count;
|
|
|
|
raw->scale_pos = scale_pos;
|
|
raw->scale_tex = 1.0;
|
|
|
|
// Check for more mesh nodes
|
|
has_next = false;
|
|
for (int i = current_node; i < (int)active_eval_scene->nodes.count; ++i) {
|
|
ufbx_node *n = active_eval_scene->nodes.data[i];
|
|
if (valid_mesh(n)) {
|
|
has_next = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!has_next) {
|
|
if (active_eval_scene != active_base_scene)
|
|
ufbx_free_scene(active_eval_scene);
|
|
ufbx_free_scene(active_base_scene);
|
|
active_base_scene = NULL;
|
|
active_eval_scene = NULL;
|
|
current_node = 0;
|
|
active_tex1 = false;
|
|
scale_pos = 1.0;
|
|
}
|
|
|
|
raw->has_next = has_next;
|
|
return raw;
|
|
}
|