1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
|
/**
* @file obj.c
* @brief Wavefront OBJ loader.
* @copyright Copyright (c) 2024
*/
#include <ctype.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "core.h"
#include "darray.h"
#include "file.h"
#include "log.h"
#include "maths.h"
#include "mem.h"
#include "platform.h"
#include "render.h"
#include "render_types.h"
#include "str.h"
extern Core g_core;
struct face {
u32 vertex_indices[3];
u32 normal_indices[3];
u32 uv_indices[3];
};
typedef struct face face;
KITC_DECL_TYPED_ARRAY(Vec3)
KITC_DECL_TYPED_ARRAY(Vec2)
KITC_DECL_TYPED_ARRAY(face)
// Forward declarations
// void create_submesh(mesh_darray *meshes, Vec3_darray *tmp_positions, Vec3_darray *tmp_normals,
// Vec2_darray *tmp_uvs, face_darray *tmp_faces, material_darray *materials,
// bool material_loaded, char current_material_name[256]);
// bool load_material_lib(const char *path, str8 relative_path, material_darray *materials);
// bool model_load_obj_str(const char *file_string, str8 relative_path, Model *out_model,
// bool invert_textures_y);
ModelHandle model_load_obj(Core* core, const char* path, bool invert_textures_y) {
size_t arena_size = 1024;
arena scratch = arena_create(malloc(arena_size), arena_size);
TRACE("Loading model at Path %s\n", path);
path_opt relative_path = path_parent(&scratch, path);
if (!relative_path.has_value) {
WARN("Couldnt get a relative path for the path to use for loading materials & textures later");
}
const char* file_string = string_from_file(path);
ModelHandle handle;
// model *model = model_pool_alloc(&g_core.models, &handle);
// model->name = str8_cstr_view(path);
// model->meshes = mesh_darray_new(1);
// bool success = model_load_obj_str(file_string, relative_path.path, &model, invert_textures_y);
// if (!success) {
// FATAL("Couldnt load OBJ file at path %s", path);
// ERROR_EXIT("Load fails are considered crash-worthy right now. This will change later.\n");
// }
// arena_free_all(&scratch);
// arena_free_storage(&scratch);
return handle;
}
bool model_load_obj_str(const char* file_string, Str8 relative_path, Model* out_model,
bool invert_textures_y) {
TRACE("Load OBJ from string");
// // Setup temps
// vec3_darray *tmp_positions = vec3_darray_new(1000);
// vec3_darray *tmp_normals = vec3_darray_new(1000);
// vec2_darray *tmp_uvs = vec2_darray_new(1000);
// face_darray *tmp_faces = face_darray_new(1000);
// // TODO: In the future I'd like these temporary arrays to be allocated from an arena provided
// // by the function one level up, model_load_obj. That way we can just `return false;` anywhere
// in
// // this code to indicate an error, and be sure that all that memory will be cleaned up without
// // having to call vec3_darray_free in every single error case before returning.
// // Other state
// bool object_set = false;
// bool material_loaded = false;
// char current_material_name[64];
// char *pch;
// char *rest = file_string;
// pch = strtok_r((char *)file_string, "\n", &rest);
// int line_num = 0;
// char last_char_type = 'a';
// while (pch != NULL) {
// line_num++;
// char line_header[128];
// int offset = 0;
// // skip whitespace
// char *p = pch;
// skip_space(pch);
// if (*p == '\0') {
// /* the string is empty */
// } else {
// // read the first word of the line
// int res = sscanf(pch, "%s %n", line_header, &offset);
// /* printf("header: %s, offset : %d res: %d\n",line_header, offset, res); */
// if (res != 1) {
// break;
// }
// if (strcmp(line_header, "o") == 0 || strcmp(line_header, "g") == 0) {
// // if we're currently parsing one
// if (!object_set) {
// object_set = true;
// } else {
// create_submesh(out_model->meshes, tmp_positions, tmp_normals, tmp_uvs, tmp_faces,
// NULL, // out_model->materials,
// material_loaded, current_material_name);
// object_set = false;
// }
// } else if (strcmp(line_header, "v") == 0) {
// // special logic: if we went from faces back to vertices trigger a mesh output.
// // PS: I hate OBJ
// if (last_char_type == 'f') {
// create_submesh(out_model->meshes, tmp_positions, tmp_normals, tmp_uvs, tmp_faces,
// NULL, // FIXME: out_model->materials,
// material_loaded, current_material_name);
// object_set = false;
// }
// last_char_type = 'v';
// vec3 vertex;
// sscanf(pch + offset, "%f %f %f", &vertex.x, &vertex.y, &vertex.z);
// vec3_darray_push(tmp_positions, vertex);
// } else if (strcmp(line_header, "vt") == 0) {
// last_char_type = 't';
// vec2 uv;
// char copy[1024];
// memcpy(copy, pch + offset, strlen(pch + offset) + 1);
// char *p = pch + offset;
// while (isspace((unsigned char)*p)) ++p;
// // I can't remember what is going on here
// memset(copy, 0, 1024);
// memcpy(copy, pch + offset, strlen(pch + offset) + 1);
// int res = sscanf(copy, "%f %f", &uv.x, &uv.y);
// memset(copy, 0, 1024);
// memcpy(copy, pch + offset, strlen(pch + offset) + 1);
// if (res != 1) {
// // da frick? some .obj files have 3 uvs instead of 2
// f32 dummy;
// int res2 = sscanf(copy, "%f %f %f", &uv.x, &uv.y, &dummy);
// }
// if (invert_textures_y) {
// uv.y = -uv.y; // flip Y axis to be consistent with how other PNGs are being handled
// // `texture_load` will flip it again
// }
// vec2_darray_push(tmp_uvs, uv);
// } else if (strcmp(line_header, "vn") == 0) {
// last_char_type = 'n';
// vec3 normal;
// sscanf(pch + offset, "%f %f %f", &normal.x, &normal.y, &normal.z);
// vec3_darray_push(tmp_normals, normal);
// } else if (strcmp(line_header, "f") == 0) {
// last_char_type = 'f';
// struct face f;
// sscanf(pch + offset, "%d/%d/%d %d/%d/%d %d/%d/%d", &f.vertex_indices[0],
// &f.uv_indices[0],
// &f.normal_indices[0], &f.vertex_indices[1], &f.uv_indices[1],
// &f.normal_indices[1], &f.vertex_indices[2], &f.uv_indices[2],
// &f.normal_indices[2]);
// // printf("f %d/%d/%d %d/%d/%d %d/%d/%d\n", f.vertex_indices[0], f.uv_indices[0],
// // f.normal_indices[0],
// // f.vertex_indices[1], f.uv_indices[1], f.normal_indices[1],
// // f.vertex_indices[2], f.uv_indices[2], f.normal_indices[2]);
// face_darray_push(tmp_faces, f);
// } else if (strcmp(line_header, "mtllib") == 0) {
// char filename[1024];
// sscanf(pch + offset, "%s", filename);
// char mtllib_path[1024];
// snprintf(mtllib_path, sizeof(mtllib_path), "%s/%s", relative_path.buf, filename);
// if (!load_material_lib(mtllib_path, relative_path, out_model->materials)) {
// ERROR("couldnt load material lib");
// return false;
// }
// } else if (strcmp(line_header, "usemtl") == 0) {
// material_loaded = true;
// sscanf(pch + offset, "%s", current_material_name);
// }
// }
// pch = strtok_r(NULL, "\n", &rest);
// }
// // last mesh or if one wasnt created with 'o' directive
// if (face_darray_len(tmp_faces) > 0) {
// TRACE("Last leftover mesh");
// create_submesh(out_model->meshes, tmp_positions, tmp_normals, tmp_uvs, tmp_faces,
// NULL, // TODO: out_model->materials,
// material_loaded, current_material_name);
// }
// // Free data
// free((char *)file_string);
// vec3_darray_free(tmp_positions);
// vec3_darray_free(tmp_normals);
// vec2_darray_free(tmp_uvs);
// face_darray_free(tmp_faces);
// TRACE("Freed temporary OBJ loading data");
// if (mesh_darray_len(out_model->meshes) > 256) {
// printf("num meshes: %ld\n", mesh_darray_len(out_model->meshes));
// }
// // TODO: bounding box calculation for each mesh
// // TODO: bounding box calculation for model
// TODO: copy from mesh_darray to malloc'd mesh* array
return true;
}
// /**
// * @brief Takes the current positions, normals, uvs arrays and constructs the vertex array
// * from those indices.
// */
// void create_submesh(mesh_darray *meshes, vec3_darray *tmp_positions, vec3_darray *tmp_normals,
// vec2_darray *tmp_uvs, face_darray *tmp_faces, material_darray *materials,
// bool material_loaded, char current_material_name[256]) {
// // size_t num_verts = face_darray_len(tmp_faces) * 3;
// // vertex_darray *out_vertices = vertex_darray_new(num_verts);
// // face_darray_iter face_iter = face_darray_iter_new(tmp_faces);
// // struct face *f;
// // while ((f = face_darray_iter_next(&face_iter))) {
// // for (int j = 0; j < 3; j++) {
// // vertex vert = { 0 };
// // vert.position = tmp_positions->data[f->vertex_indices[j] - 1];
// // if (vec3_darray_len(tmp_normals) == 0) {
// // vert.normal = vec3_create(0.0, 0.0, 0.0);
// // } else {
// // vert.normal = tmp_normals->data[f->normal_indices[j] - 1];
// // }
// // vert.uv = tmp_uvs->data[f->uv_indices[j] - 1];
// // vertex_darray_push(out_vertices, vert);
// // }
// // }
// // DEBUG("Loaded submesh\n vertices: %zu\n uvs: %zu\n normals: %zu\n faces: %zu",
// // vec3_darray_len(tmp_positions), vec2_darray_len(tmp_uvs),
// vec3_darray_len(tmp_normals),
// // face_darray_len(tmp_faces));
// // // Clear current object faces
// // face_darray_clear(tmp_faces);
// // mesh m = { .vertices = out_vertices };
// // if (material_loaded) {
// // // linear scan to find material
// // bool found = false;
// // DEBUG("Num of materials : %ld", material_darray_len(materials));
// // material_darray_iter mat_iter = material_darray_iter_new(materials);
// // blinn_phong_material *cur_material;
// // while ((cur_material = material_darray_iter_next(&mat_iter))) {
// // if (strcmp(cur_material->name, current_material_name) == 0) {
// // DEBUG("Found match");
// // m.material_index = mat_iter.current_idx - 1;
// // found = true;
// // break;
// // }
// // }
// // if (!found) {
// // // TODO: default material
// // m.material_index = 0;
// // DEBUG("Set default material");
// // }
// // }
// // mesh_darray_push(meshes, m);
// }
// bool load_material_lib(const char *path, str8 relative_path, material_darray *materials) {
// TRACE("BEGIN load material lib at %s", path);
// // const char *file_string = string_from_file(path);
// // if (file_string == NULL) {
// // ERROR("couldnt load %s", path);
// // return false;
// // }
// // char *pch;
// // char *saveptr;
// // pch = strtok_r((char *)file_string, "\n", &saveptr);
// // material current_material = DEFAULT_MATERIAL;
// // bool material_set = false;
// // while (pch != NULL) {
// // char line_header[128];
// // int offset = 0;
// // // read the first word of the line
// // int res = sscanf(pch, "%s %n", line_header, &offset);
// // if (res != 1) {
// // break;
// // }
// // // When we see "newmtl", start a new material, or flush the previous one
// // if (strcmp(line_header, "newmtl") == 0) {
// // if (material_set) {
// // // a material was being parsed, so flush that one and start a new one
// // material_darray_push(materials, current_material);
// // DEBUG("pushed material with name %s", current_material.name);
// // WARN("Reset current material");
// // current_material = DEFAULT_MATERIAL;
// // } else {
// // material_set = true;
// // }
// // // scan the new material name
// // char material_name[64];
// // sscanf(pch + offset, "%s", current_material.name);
// // DEBUG("material name %s\n", current_material.name);
// // // current_material.name = material_name;
// // } else if (strcmp(line_header, "Ka") == 0) {
// // // ambient
// // sscanf(pch + offset, "%f %f %f", ¤t_material.ambient_colour.x,
// // ¤t_material.ambient_colour.y, ¤t_material.ambient_colour.z);
// // } else if (strcmp(line_header, "Kd") == 0) {
// // // diffuse
// // sscanf(pch + offset, "%f %f %f", ¤t_material.diffuse.x,
// ¤t_material.diffuse.y,
// // ¤t_material.diffuse.z);
// // } else if (strcmp(line_header, "Ks") == 0) {
// // // specular
// // sscanf(pch + offset, "%f %f %f", ¤t_material.specular.x,
// // ¤t_material.specular.y,
// // ¤t_material.specular.z);
// // } else if (strcmp(line_header, "Ns") == 0) {
// // // specular exponent
// // sscanf(pch + offset, "%f", ¤t_material.spec_exponent);
// // } else if (strcmp(line_header, "map_Kd") == 0) {
// // char diffuse_map_filename[1024];
// // sscanf(pch + offset, "%s", diffuse_map_filename);
// // char diffuse_map_path[1024];
// // snprintf(diffuse_map_path, sizeof(diffuse_map_path), "%s/%s", relative_path.buf,
// // diffuse_map_filename);
// // printf("load from %s\n", diffuse_map_path);
// // // --------------
// // texture diffuse_texture = texture_data_load(diffuse_map_path, true);
// // current_material.diffuse_texture = diffuse_texture;
// // strcpy(current_material.diffuse_tex_path, diffuse_map_path);
// // texture_data_upload(¤t_material.diffuse_texture);
// // // --------------
// // } else if (strcmp(line_header, "map_Ks") == 0) {
// // // char specular_map_path[1024] = "assets/";
// // // sscanf(pch + offset, "%s", specular_map_path + 7);
// // char specular_map_filename[1024];
// // sscanf(pch + offset, "%s", specular_map_filename);
// // char specular_map_path[1024];
// // snprintf(specular_map_path, sizeof(specular_map_path), "%s/%s", relative_path.buf,
// // specular_map_filename);
// // printf("load from %s\n", specular_map_path);
// // // --------------
// // texture specular_texture = texture_data_load(specular_map_path, true);
// // current_material.specular_texture = specular_texture;
// // strcpy(current_material.specular_tex_path, specular_map_path);
// // texture_data_upload(¤t_material.specular_texture);
// // // --------------
// // } else if (strcmp(line_header, "map_Bump") == 0) {
// // // TODO
// // }
// // pch = strtok_r(NULL, "\n", &saveptr);
// // }
// // TRACE("end load material lib");
// // // last mesh or if one wasnt created with 'o' directive
// // // TRACE("Last leftover material");
// // material_darray_push(materials, current_material);
// // INFO("Loaded %ld materials", material_darray_len(materials));
// TRACE("END load material lib");
// return true;
// }
|
