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);
}
