path: root/src/extend/mesh.c

#include "mesh.h"

#define GENERATE_TANGNET
//#define GENERATE_NORMAL
//#define OPTIMIZE_MESH


#define LINE_SIZE 1024

#define darray_push(darray, value)                                          \
    do {                                                                    \
        (darray) = darray_hold((darray), 1, sizeof(*(darray)));             \
        (darray)[darray_size(darray) - 1] = (value);                        \
    } while (0)

#define DARRAY_RAW_DATA(darray) ((int*)(darray) - 2)
#define DARRAY_CAPACITY(darray) (DARRAY_RAW_DATA(darray)[0])
#define DARRAY_OCCUPIED(darray) (DARRAY_RAW_DATA(darray)[1])

int darray_size(void *darray) {
	return darray != NULL ? DARRAY_OCCUPIED(darray) : 0;
}

void darray_free(void *darray) {
	if (darray != NULL) {
		free(DARRAY_RAW_DATA(darray));
	}
}

#define UNUSED_VAR(x) ((void)(x))


void *darray_hold(void *darray, int count, int itemsize) {
	assert(count > 0 && itemsize > 0);
	if (darray == NULL) {
		int raw_size = sizeof(int) * 2 + itemsize * count;
		int *base = (int*)malloc(raw_size);
		base[0] = count;  /* capacity */
		base[1] = count;  /* occupied */
		return base + 2;
	}
	else if (DARRAY_OCCUPIED(darray) + count <= DARRAY_CAPACITY(darray)) {
		DARRAY_OCCUPIED(darray) += count;
		return darray;
	}
	else {
		int needed_size = DARRAY_OCCUPIED(darray) + count;
		int double_curr = DARRAY_CAPACITY(darray) * 2;
		int capacity = needed_size > double_curr ? needed_size : double_curr;
		int occupied = needed_size;
		int raw_size = sizeof(int) * 2 + itemsize * capacity;
		int *base = (int*)realloc(DARRAY_RAW_DATA(darray), raw_size);
		base[0] = capacity;
		base[1] = occupied;
		return base + 2;
	}
}

Vec3 internal_vec3_min(Vec3 a, Vec3 b) {
	float x = min(a.x, b.x);
	float y = min(a.y, b.y);
	float z = min(a.z, b.z);
	Vec3 r = { x, y, z };
	return r;
}

Vec3 internal_vec3_max(Vec3 a, Vec3 b) {
	float x = max(a.x, b.x);
	float y = max(a.y, b.y);
	float z = max(a.z, b.z);
	Vec3 r = { x, y, z };
	return r;
}

static Mesh *build_mesh(
	Vec3 *positions, Vec2 *texcoords, Vec3 *normals,
	Vec4 *tangents, Vec4 *joints, Vec4 *weights,
	int *position_indices, int *texcoord_indices, int *normal_indices) {
	Vec3 bbox_min = { +1e6, +1e6, +1e6 };
	Vec3 bbox_max = { -1e6, -1e6, -1e6 };
	int num_indices = darray_size(position_indices);
	int num_faces = num_indices / 3;
	Mesh *mesh;
	int i;

	assert(num_faces > 0 && num_faces * 3 == num_indices);
	assert(darray_size(position_indices) == num_indices);
	assert(darray_size(texcoord_indices) == num_indices);
	assert(darray_size(normal_indices) == num_indices);

	mesh = (Mesh*)malloc(sizeof(Mesh));
	mesh->triangles = ssrM_newvector(int, 3 * num_faces);
	int nvert = DARRAY_OCCUPIED(positions);
	Vert* vertices = ssrM_newvector(Vert, nvert);

	for (i = 0; i < num_indices; i++) {
		int position_index = position_indices[i];
		int texcoord_index = texcoord_indices[i];
		int normal_index = normal_indices[i];
		assert(position_index >= 0 && position_index < darray_size(positions));
		assert(texcoord_index >= 0 && texcoord_index < darray_size(texcoords));
		assert(normal_index >= 0 && normal_index < darray_size(normals));

		vertices[position_index].index = position_index;
		vertices[position_index].position = positions[position_index];
		vertices[position_index].texcoord = texcoords[texcoord_index];
		vertices[position_index].normal = normals[normal_index];

		if (tangents) {
			int tangent_index = position_index;
			ssr_assert(tangent_index >= 0 && tangent_index < darray_size(tangents));
			vertices[position_index].tangent = tangents[tangent_index];
		}

		mesh->triangles[i] = position_index;

		//bbox_min = internal_vec3_min(bbox_min, vertices[i].position);
		//bbox_max = internal_vec3_max(bbox_max, vertices[i].position);
	}

	mesh->tris_count = num_faces;
	mesh->vert_count = nvert;
	mesh->vertices = vertices;
	//mesh->center = internal_vec3_div(internal_vec3_add(bbox_min, bbox_max), 2);

	return mesh;
}

/************************************************************************/
/* obj loader                                                           */
/************************************************************************/

#define SIMPLE_OBJ_LOADER 0

#if SIMPLE_OBJ_LOADER
Mesh* mesh_loadfromobj(const char *filename) {
	Vec3 *positions = NULL;
	Vec2 *texcoords = NULL;
	Vec3 *normals = NULL;
	Vec4 *tangents = NULL;
	Vec4 *joints = NULL;
	Vec4 *weights = NULL;
	int *position_indices = NULL;
	int *texcoord_indices = NULL;
	int *normal_indices = NULL;
	char line[LINE_SIZE];
	Mesh *mesh;
	FILE *file;

	file = fopen(filename, "rb");
	assert(file != NULL);
	while (1) {
		int items;
		if (fgets(line, LINE_SIZE, file) == NULL) {
			break;
		}
		else if (strncmp(line, "v ", 2) == 0) {               /* position */
			Vec3 position;
			items = sscanf(line, "v %f %f %f",
				&position.x, &position.y, &position.z);
			assert(items == 3);
			darray_push(positions, position);
		}
		else if (strncmp(line, "vt ", 3) == 0) {              /* texcoord */
			Vec2 texcoord;
			items = sscanf(line, "vt %f %f",
				&texcoord.x, &texcoord.y);
			assert(items == 2);
			darray_push(texcoords, texcoord);
		}
		else if (strncmp(line, "vn ", 3) == 0) {              /* normal */
			Vec3 normal;
			items = sscanf(line, "vn %f %f %f",
				&normal.x, &normal.y, &normal.z);
			assert(items == 3);
			darray_push(normals, normal);
		}
		else if (strncmp(line, "f ", 2) == 0) {               /* face */
			int i;
			int pos_indices[3], uv_indices[3], n_indices[3];
			items = sscanf(line, "f %d/%d/%d %d/%d/%d %d/%d/%d",
				&pos_indices[0], &uv_indices[0], &n_indices[0],
				&pos_indices[1], &uv_indices[1], &n_indices[1],
				&pos_indices[2], &uv_indices[2], &n_indices[2]);
			assert(items == 9);
			for (i = 0; i < 3; i++) {
				darray_push(position_indices, pos_indices[i] - 1);
				darray_push(texcoord_indices, uv_indices[i] - 1);
				darray_push(normal_indices, n_indices[i] - 1);
			}
		} else if (strncmp(line, "# ext.tangent ", 14) == 0) {  /* tangent */
			Vec4 tangent;
			items = sscanf(line, "# ext.tangent %f %f %f %f",
				&tangent.x, &tangent.y, &tangent.z, &tangent.w);
			assert(items == 4);
			darray_push(tangents, tangent);
		}
	}
	fclose(file);

	mesh = build_mesh(positions, texcoords, normals, tangents, joints, weights,
		position_indices, texcoord_indices, normal_indices);
	darray_free(positions);
	darray_free(texcoords);
	darray_free(normals);
	darray_free(tangents);
	darray_free(joints);
	darray_free(weights);
	darray_free(position_indices);
	darray_free(texcoord_indices);
	darray_free(normal_indices);

	printf("%s: %d verts, %d tris\n", filename, mesh->vert_count, mesh->tris_count);

	return mesh;
}

#else 

typedef struct {
	int normal_index; 
	int uv_index; 
	int index; 
} VertexInfo;

typedef struct {
	VertexInfo* vertices; // vertices list 
} VertexListElement; 

typedef struct {
	int posIndex, normalIndex, uvIndex;
} FaceVertex;

typedef struct {
	FaceVertex vertices[3];
} FaceInfo;

Mesh* mesh_loadfromobj(const char* path) {
	Vec3* position_list = NULL;
	Vec3* normal_list = NULL; 
	Vec2* uv_list = NULL;
	VertexListElement* vertex_list = NULL; 
	FaceInfo* face_list = NULL;
	FILE *file;
	file = fopen(path, "rb");
	assert(file != NULL);
	char line[LINE_SIZE];

	while (1) {
		int items;
		if (fgets(line, LINE_SIZE, file) == NULL) {
			break;
		}
		else if (strncmp(line, "v ", 2) == 0) { /* position */
			Vec3 position;
			items = sscanf(line, "v %f %f %f",
				&position.x, &position.y, &position.z);
			assert(items == 3);
			darray_push(position_list, position);
			// init vertex_list
			VertexListElement element = { 0 };
			darray_push(vertex_list, element);
		}
		else if (strncmp(line, "vt ", 3) == 0) { /* texcoord */
			Vec2 texcoord;
			items = sscanf(line, "vt %f %f",
				&texcoord.x, &texcoord.y);
			assert(items == 2);
			darray_push(uv_list, texcoord);
		}
		else if (strncmp(line, "vn ", 3) == 0) { /* normal */
			Vec3 normal;
			items = sscanf(line, "vn %f %f %f",
				&normal.x, &normal.y, &normal.z);
			assert(items == 3);
			darray_push(normal_list, normal);
		}
		else if (strncmp(line, "f ", 2) == 0) { /* face */
			FaceInfo face;
			items = sscanf(line, "f %d/%d/%d %d/%d/%d %d/%d/%d", // only support triangle
				&face.vertices[0].posIndex, &face.vertices[0].uvIndex, &face.vertices[0].normalIndex,
				&face.vertices[1].posIndex, &face.vertices[1].uvIndex, &face.vertices[1].normalIndex,
				&face.vertices[2].posIndex, &face.vertices[2].uvIndex, &face.vertices[2].normalIndex);
			assert(items == 9);
			darray_push(face_list, face);
		}
		else
		{
			// skip
		}
	}

	int vert_counts = darray_size(vertex_list);
	int faceCount = darray_size(face_list);
	int normalCount = darray_size(normal_list);
	int uvCount = darray_size(uv_list);

	int vert_count = 0;

	Mesh temp_mesh = {0};

	for (int i = 0; i < darray_size(face_list); ++i)
	{
		FaceInfo* face = &face_list[i];
		for (int j = 0; j < 3; ++j)
		{
			FaceVertex face_vert = face->vertices[j];
			int pos_index = face_vert.posIndex - 1;
			int normal_index = face_vert.normalIndex - 1;
			int uv_index = face_vert.uvIndex - 1;
			VertexListElement* vertex = &vertex_list[pos_index];
			if (vertex->vertices)
			{
				for (int j = 0; j < darray_size(vertex->vertices); ++j)
				{
					VertexInfo* vert = &vertex->vertices[j];
					if (vert->normal_index == normal_index && vert->uv_index == uv_index)
					{
						darray_push(temp_mesh.triangles, vert->index);
						goto next;
					}
				}
			}

			// create seam

			VertexInfo new_vert;
			new_vert.normal_index = normal_index;
			new_vert.uv_index = uv_index; 
			new_vert.index = vert_count;

			darray_push(vertex->vertices, new_vert);

			Vert vert; 
			vert.position = position_list[pos_index];
			vert.normal = normal_list[normal_index];
			vert.texcoord = uv_list[uv_index];
			vert.index = vert_count;
			darray_push(temp_mesh.vertices, vert);

			darray_push(temp_mesh.triangles, vert_count);

			++temp_mesh.vert_count;

			++vert_count;

		next: continue;
		}

		++temp_mesh.tris_count;
	}

	Mesh* mesh = malloc(sizeof(Mesh));
	mesh->triangles = temp_mesh.triangles; 
	mesh->vertices = temp_mesh.vertices;
	mesh->tris_count = temp_mesh.tris_count;
	mesh->vert_count = temp_mesh.vert_count;

	return mesh;
}

#endif