static bool get_bool_val(t_sub val, bool *dst) { if (SUB_EQU(SUBC("true"), val)) *dst = true; else if (SUB_EQU(SUBC("false"), val)) *dst = false; else return (false); return (true); }
static bool parse_scenes(t_xml_parser *xml, t_vector *dst) { while (ft_xml_next(xml)) if (xml->token != XML_TOKEN_START) return (ASSERT(false)); else if (!ft_subequ(ft_xml_name(xml), SUBC("scene"))) return (ft_xml_error(xml, SUBC("Invalid markup"))); else if (!parse_scene(xml, ft_vpush(dst, NULL, 1))) return (false); return (BOOL_OF(xml->token != XML_TOKEN_ERROR)); }
static bool parse(t_json_parser *p, t_json_t_value const *t, void *data) { if (!ft_json_next(p)) return (ft_json_fail(p, SUBC("Empty file"))); if (!g_json_t_parse[t->type](p, t, data)) return (false); ft_json_next(p); if (p->token == JSON_EOF) return (true); ft_json_t_free(t, data); if (p->token == JSON_ERROR) return (false); return (ft_json_fail(p, SUBC("Expecting EOF"))); }
__inline void fpsub751(const digit_t* a, const digit_t* b, digit_t* c) { // Modular subtraction, c = a-b mod p751. // Inputs: a, b in [0, 2*p751-1] // Output: c in [0, 2*p751-1] #if (OS_TARGET == OS_WIN) unsigned int i, borrow = 0; digit_t mask; for (i = 0; i < NWORDS_FIELD; i++) { SUBC(borrow, a[i], b[i], borrow, c[i]); } mask = 0 - (digit_t)borrow; borrow = 0; for (i = 0; i < NWORDS_FIELD; i++) { ADDC(borrow, c[i], ((digit_t*)p751x2)[i] & mask, borrow, c[i]); } #elif (OS_TARGET == OS_LINUX) fpsub751_asm(a, b, c); #endif }
__inline void fpadd751(const digit_t* a, const digit_t* b, digit_t* c) { // Modular addition, c = a+b mod p751. // Inputs: a, b in [0, 2*p751-1] // Output: c in [0, 2*p751-1] #if (OS_TARGET == OS_WIN) unsigned int i, carry = 0; digit_t mask; for (i = 0; i < NWORDS_FIELD; i++) { ADDC(carry, a[i], b[i], carry, c[i]); } carry = 0; for (i = 0; i < NWORDS_FIELD; i++) { SUBC(carry, c[i], ((digit_t*)p751x2)[i], carry, c[i]); } mask = 0 - (digit_t)carry; carry = 0; for (i = 0; i < NWORDS_FIELD; i++) { ADDC(carry, c[i], ((digit_t*)p751x2)[i] & mask, carry, c[i]); } #elif (OS_TARGET == OS_LINUX) fpadd751_asm(a, b, c); #endif }
bool json_t_parse_int(t_json_parser *p, t_json_t_value const *t, void *data) { if (p->token != JSON_VALUE || p->value_type != JSON_VALUE_INT) return (ft_json_fail(p, SUBC("Expecting int"))); *(int32_t*)data = p->val_int; return (true); (void)t; }
__inline void fpneg751(digit_t* a) { // Modular negation, a = -a mod p751. // Input/output: a in [0, 2*p751-1] unsigned int i, borrow = 0; for (i = 0; i < NWORDS_FIELD; i++) { SUBC(borrow, ((digit_t*)p751x2)[i], a[i], borrow, a[i]); } }
static bool get_identifier(t_json_parser *p) { t_sub const val = JSON_VAL_STRING(p); t_json_value_t val_t; if (get_bool_val(val, &p->val_bool)) val_t = JSON_VALUE_BOOL; else if (SUB_EQU(SUBC("null"), val)) val_t = JSON_VALUE_NULL; else if (ft_subto_int(val, &p->val_int) == val.length) val_t = JSON_VALUE_INT; else if (ft_subto_float(val, &p->val_float) == val.length) val_t = JSON_VALUE_FLOAT; else return (ft_json_fail(p, SUBC("Invalid value"))); p->value_type = val_t; return (true); }
bool json_t_parse_bool(t_json_parser *p, t_json_t_value const *t, void *data) { if (p->token != JSON_VALUE || p->value_type != JSON_VALUE_BOOL) return (ft_json_fail(p, SUBC("Expecting bool"))); *(bool*)data = p->val_bool; return (true); (void)t; }
unsigned int mp_sub(const digit_t* a, const digit_t* b, digit_t* c, const unsigned int nwords) { // Multiprecision subtraction, c = a-b, where lng(a) = lng(b) = nwords. Returns the borrow bit. unsigned int i, borrow = 0; for (i = 0; i < nwords; i++) { SUBC(borrow, a[i], b[i], borrow, c[i]); } return borrow; }
bool json_t_parse_float(t_json_parser *p, t_json_t_value const *t, void *data) { if (p->token != JSON_VALUE || (p->value_type != JSON_VALUE_FLOAT && p->value_type != JSON_VALUE_INT)) return (ft_json_fail(p, SUBC("Expecting float"))); *(float*)data = JSON_VAL_NUMBER(p); return (true); (void)t; }
t_json_token json_parse_value(t_json_parser *p, t_json_p_token t) { if (t == JSON_P_BRACE_OPEN) return (JSON_BEGIN_DICT); if (t == JSON_P_SQUARE_OPEN) return (JSON_BEGIN_LIST); if (t == JSON_P_STRING) { p->value_type = JSON_VALUE_STRING; return (JSON_VALUE); } if (t == JSON_P_IDENTIFIER) return (get_identifier(p) ? JSON_VALUE : JSON_ERROR); if (t == JSON_P_ERROR) return (JSON_ERROR); if (t == JSON_P_EOF) return (ft_json_fail(p, SUBC("Unexpected EOF")), JSON_ERROR); ft_json_fail(p, SUBC("Syntax error: Expecting value")); return (JSON_ERROR); }
bool parse_opt_ui(t_parse_argv *argv) { t_sub val; if (!ARGV_HAS_VALUE(&argv->args)) argv->ui_type = UI_NCURSES; else { if (!ft_argv_arg(&argv->args, &val)) HARD_ASSERT(false); if (SUB_EQU(val, SUBC("ncurses"))) argv->ui_type = UI_NCURSES; else if (SUB_EQU(val, SUBC("debug"))) argv->ui_type = UI_DEBUG; else { PARSE_ARGV_ERR("Invalid ui mode '%ts'", val); return (false); } } return (true); }
bool parse_scene_camera(t_xml_parser *xml, t_parse_scene *scene) { t_camera *const camera = ft_vpush(&scene->cameras, NULL, 1); *camera = DEF_CAMERA; if (!ft_xml_next(xml) || (xml->token == XML_TOKEN_PARAM && !parse_xml_params(xml, &g_camera_params, camera))) return (false); if (xml->token == XML_TOKEN_START) return (ft_xml_error(xml, SUBC("Can't have child"))); camera->dir = ft_vec3norm(camera->dir); return (BOOL_OF(xml->token == XML_TOKEN_END)); }
int main(int argc, char **argv) { int i; t_main main; ft_logf_set_enabled(LOG_DEBUG, true); ft_logf_set_enabled(LOG_VERBOSE, true); main = (t_main){ NULL, NULL, {}, VECTOR(t_scene), -1, -1, false, }; if ((main.thread_pool = ft_thread_pool_create(THREAD_COUNT)) == NULL) return (ft_dprintf(2, "Failed to create threads"), 1); if ((main.mlx = mlx_init()) == NULL || !ft_mlx_open(&main.win, main.mlx, VEC2U(WIN_WIDTH, WIN_HEIGHT), SUBC(WIN_TITLE))) return (1); i = 0; while (++i < argc) { ft_logf(LOG_VERBOSE, "Loading scene file: %s", argv[i]); if (!load_scenes(argv[i], &main.scenes)) return (1); } if (main.scenes.length == 0) { ft_logf(LOG_ERROR, "No scene loaded"); return (1); } ft_logf(LOG_SUCCESS, "%d scene(s) loaded", main.scenes.length); mlx_loop_hook(main.mlx, &loop_hook, &main); mlx_key_hook(main.win.win_id, &key_hook, &main); mlx_expose_hook(main.win.win_id, &expose_hook, &main); render(&main, 0, 0); mlx_loop(main.mlx); ASSERT(false); main_destroy(&main); return (0); }
void fpcorrection751(digit_t* a) { // Modular correction to reduce field element a in [0, 2*p751-1] to [0, p751-1]. unsigned int i, borrow = 0; digit_t mask; for (i = 0; i < NWORDS_FIELD; i++) { SUBC(borrow, a[i], ((digit_t*)p751)[i], borrow, a[i]); } mask = 0 - (digit_t)borrow; borrow = 0; for (i = 0; i < NWORDS_FIELD; i++) { ADDC(borrow, a[i], ((digit_t*)p751)[i] & mask, borrow, a[i]); } }
bool json_t_parse_string(t_json_parser *p, t_json_t_value const *t, void *data) { t_sub val_string; t_sub *value; if (p->token != JSON_VALUE || p->value_type != JSON_VALUE_STRING) return (ft_json_fail(p, SUBC("Expecting string"))); val_string = JSON_VAL_STRING(p); value = MALLOC(sizeof(t_sub) + val_string.length); *value = SUB(ENDOF(value), val_string.length); memcpy(ENDOF(value), val_string.str, val_string.length); *(t_sub**)data = value; return (true); (void)t; }
bool parse_scene_light(t_xml_parser *xml, t_parse_scene *scene) { t_light *const light = ft_vpush(&scene->lights, NULL, 1); *light = DEF_LIGHT; if (!ft_xml_next(xml) || (xml->token == XML_TOKEN_PARAM && !parse_xml_params(xml, &g_light_params, light))) return (false); if (xml->token == XML_TOKEN_START) return (ft_xml_error(xml, SUBC("Can't have child"))); light->dir = ft_vec3norm(light->dir); light->cutoff = (1.f - light->cutoff) * 2.f - 1.f; light->color = VEC3_MUL1(light->color, light->brightness); return (BOOL_OF(xml->token == XML_TOKEN_END)); }
static bool parse_scene(t_xml_parser *xml, t_scene *dst) { t_parse_scene scene; scene = (t_parse_scene){DSTR0(), KDTREE_BUILDER(3), VECTOR(t_light), VECTOR(t_camera), DEF_SKY_COLOR}; if (!ft_xml_next(xml) || (xml->token == XML_TOKEN_PARAM && !parse_xml_params(xml, &g_scene_params, &scene))) return (false); while (true) { ASSERT(xml->token == XML_TOKEN_START); if (!parse_scene_child(xml, &scene)) { ft_dstrclear(&scene.name); ft_vclear(&scene.lights); ft_vclear(&scene.cameras); kdtree_builder_destroy(&scene.kdtree); return (false); } if (!ft_xml_next(xml)) break ; } if (xml->token != XML_TOKEN_END) return (ft_xml_error(xml, SUBC("Unexpected EOF"))); if (scene.cameras.length == 0) ft_vpush(&scene.cameras, &DEF_CAMERA, 1); *dst = (t_scene){ DSTR_SUB(scene.name), kdtree_build(&scene.kdtree), scene.lights, scene.cameras, scene.sky_color }; kdtree_builder_destroy(&scene.kdtree); print_kdtree(dst->objs.root, 1, '.'); ft_logf(LOG_VERBOSE, "Scene '%ts' loaded: %u object(s), %u light(s), " "%u camera(s)", dst->name, dst->objs.length, dst->lights.length, dst->cameras.length); return (true); }
#include "ft/ft_printf.h" #include "internal.h" #include "kd_tree_builder.h" #include "scene.h" #include <stddef.h> #include <stdlib.h> static t_vector const g_scene_params = VECTOR(t_param_def, PARAM("name", name, t_scene, name), PARAM("sky_color", color, t_scene, sky_color), ); static t_vector const g_scene_childs = VECTOR(t_scene_child, {SUBC("light"), &parse_scene_light}, {SUBC("camera"), &parse_scene_camera}, ); static void print_kdtree(t_kdtree_child const *node, uint32_t offset, char prefix) { if (node->type == KDTREE_SPLIT) { print_kdtree(node->v.split.left, offset + 4, '/'); ft_logf(LOG_DEBUG, "%*c %c|", offset, prefix, "xyz"[node->v.split.d]); print_kdtree(node->v.split.right, offset + 4, '\\'); return ; } ft_logf(LOG_DEBUG, "%*c= %d node(s)", offset, prefix, node->v.leaf.length); }