diff options
Diffstat (limited to 'libdimension')
36 files changed, 585 insertions, 628 deletions
diff --git a/libdimension/Makefile.am b/libdimension/Makefile.am index 83e6f62..0f3dee5 100644 --- a/libdimension/Makefile.am +++ b/libdimension/Makefile.am @@ -74,15 +74,14 @@ libdimension_la_SOURCES = $(nobase_include_HEADERS) \ cube.c \ csg.c \ dictionary.c \ - diffuse.c \ dimension-impl.h \ error.c \ finish.c \ - finish_combination.c \ geometry.c \ gradient.c \ inline.c \ interior.c \ + lambertian.c \ light.c \ malloc.c \ map.c \ @@ -103,7 +102,7 @@ libdimension_la_SOURCES = $(nobase_include_HEADERS) \ prtree.c \ prtree.h \ raytrace.c \ - reflective.c \ + reflection.c \ scene.c \ sky_sphere.c \ solid_pigment.c \ diff --git a/libdimension/ambient.c b/libdimension/ambient.c index 180889b..5152f1d 100644 --- a/libdimension/ambient.c +++ b/libdimension/ambient.c @@ -29,26 +29,25 @@ /** Ambient finish callback. */ static dmnsn_color -dmnsn_ambient_finish_fn(const dmnsn_finish *finish, dmnsn_color pigment) +dmnsn_basic_ambient_fn(const dmnsn_ambient *ambient, dmnsn_color pigment) { - dmnsn_color *ambient = finish->ptr; - dmnsn_color ret = dmnsn_color_illuminate(*ambient, pigment); + dmnsn_color *light = ambient->ptr; + dmnsn_color ret = dmnsn_color_illuminate(*light, pigment); ret.trans = 0.0; ret.filter = 0.0; return ret; } -dmnsn_finish * -dmnsn_new_ambient_finish(dmnsn_color ambient) +dmnsn_ambient * +dmnsn_new_basic_ambient(dmnsn_color ambient) { - dmnsn_finish *finish = dmnsn_new_finish(); + dmnsn_ambient *basic = dmnsn_new_ambient(); dmnsn_color *param = dmnsn_malloc(sizeof(dmnsn_color)); *param = ambient; - finish->ptr = param; - finish->ambient_fn = dmnsn_ambient_finish_fn; - finish->free_fn = dmnsn_free; - - return finish; + basic->ambient_fn = dmnsn_basic_ambient_fn; + basic->free_fn = dmnsn_free; + basic->ptr = param; + return basic; } diff --git a/libdimension/bench/prtree.c b/libdimension/bench/prtree.c index b6f778a..05fc1ce 100644 --- a/libdimension/bench/prtree.c +++ b/libdimension/bench/prtree.c @@ -76,8 +76,12 @@ main(void) } dmnsn_array *objects = dmnsn_new_array(sizeof(dmnsn_object *)); + dmnsn_texture *texture = dmnsn_new_texture(); + texture->pigment = dmnsn_new_pigment(); for (size_t i = 0; i < nobjects; ++i) { dmnsn_object *object = dmnsn_new_fake_object(); + object->texture = texture; + DMNSN_INCREF(object->texture); dmnsn_initialize_object(object); dmnsn_array_push(objects, &object); } @@ -108,12 +112,10 @@ main(void) /* Cleanup */ dmnsn_delete_prtree(tree); - for (size_t i = 0; i < nobjects; ++i) { - dmnsn_object *object; - dmnsn_array_get(objects, i, &object); - dmnsn_delete_object(object); + DMNSN_ARRAY_FOREACH (dmnsn_object **, object, objects) { + dmnsn_delete_object(*object); } - + dmnsn_delete_texture(texture); dmnsn_delete_array(objects); return EXIT_SUCCESS; } diff --git a/libdimension/camera.c b/libdimension/camera.c index 935a129..5c8a2c6 100644 --- a/libdimension/camera.c +++ b/libdimension/camera.c @@ -33,7 +33,7 @@ dmnsn_new_camera(void) dmnsn_camera *camera = dmnsn_malloc(sizeof(dmnsn_camera)); camera->free_fn = NULL; camera->trans = dmnsn_identity_matrix(); - camera->refcount = 0; + camera->refcount = 1; return camera; } @@ -41,7 +41,7 @@ dmnsn_new_camera(void) void dmnsn_delete_camera(dmnsn_camera *camera) { - if (camera && DMNSN_DECREF(camera)) { + if (DMNSN_DECREF(camera)) { if (camera->free_fn) { camera->free_fn(camera->ptr); } diff --git a/libdimension/canvas.c b/libdimension/canvas.c index 6df5dd3..9eef4e7 100644 --- a/libdimension/canvas.c +++ b/libdimension/canvas.c @@ -36,7 +36,7 @@ dmnsn_new_canvas(size_t width, size_t height) canvas->height = height; canvas->optimizers = dmnsn_new_array(sizeof(dmnsn_canvas_optimizer)); canvas->pixels = dmnsn_malloc(sizeof(dmnsn_color)*width*height); - canvas->refcount = 0; + canvas->refcount = 1; return canvas; } @@ -45,7 +45,7 @@ dmnsn_new_canvas(size_t width, size_t height) void dmnsn_delete_canvas(dmnsn_canvas *canvas) { - if (canvas && DMNSN_DECREF(canvas)) { + if (DMNSN_DECREF(canvas)) { /* Free the optimizers */ DMNSN_ARRAY_FOREACH (dmnsn_canvas_optimizer *, i, canvas->optimizers) { if (i->free_fn) { diff --git a/libdimension/canvas_pigment.c b/libdimension/canvas_pigment.c index 002cea3..3ab9de4 100644 --- a/libdimension/canvas_pigment.c +++ b/libdimension/canvas_pigment.c @@ -29,8 +29,6 @@ static dmnsn_color dmnsn_canvas_pigment_fn(const dmnsn_pigment *pigment, dmnsn_vector v) { - v = dmnsn_transform_vector(pigment->trans_inv, v); - dmnsn_canvas *canvas = pigment->ptr; int x = (fmod(v.x, 1.0) + 1.0)*(canvas->width - 1) + 0.5; diff --git a/libdimension/color_map.c b/libdimension/color_map.c index e7a25a6..654fe97 100644 --- a/libdimension/color_map.c +++ b/libdimension/color_map.c @@ -75,8 +75,6 @@ static void dmnsn_color_map_initialize_fn(dmnsn_pigment *pigment) { dmnsn_color_map_payload *payload = pigment->ptr; - payload->pattern->trans = dmnsn_matrix_mul(pigment->trans, - payload->pattern->trans); dmnsn_initialize_pattern(payload->pattern); } diff --git a/libdimension/csg.c b/libdimension/csg.c index 0222b8b..1b2e36f 100644 --- a/libdimension/csg.c +++ b/libdimension/csg.c @@ -26,21 +26,6 @@ #include "dimension-impl.h" #include <stdlib.h> -/** Apply the properties of \p csg to its children. */ -static void -dmnsn_csg_cascade(const dmnsn_object *csg, dmnsn_object *object) -{ - if (!object->texture && csg->texture) { - object->texture = csg->texture; - } - - if (!object->interior && csg->interior) { - object->interior = csg->interior; - } - - object->trans = dmnsn_matrix_mul(csg->trans, object->trans); -} - /* * Unions */ @@ -67,10 +52,6 @@ dmnsn_csg_union_inside_fn(const dmnsn_object *csg, dmnsn_vector point) static void dmnsn_csg_union_initialize_fn(dmnsn_object *csg) { - DMNSN_ARRAY_FOREACH (dmnsn_object **, child, csg->children) { - dmnsn_csg_cascade(csg, *child); - dmnsn_initialize_object(*child); - } csg->trans = dmnsn_identity_matrix(); dmnsn_prtree *prtree = dmnsn_new_prtree(csg->children); @@ -92,10 +73,9 @@ dmnsn_new_csg_union(const dmnsn_array *objects) dmnsn_object *csg = dmnsn_new_object(); DMNSN_ARRAY_FOREACH (dmnsn_object **, object, objects) { - DMNSN_INCREF(*object); dmnsn_array_push(csg->children, object); } - + csg->split_children = true; csg->ptr = NULL; csg->intersection_fn = dmnsn_csg_union_intersection_fn; csg->inside_fn = dmnsn_csg_union_inside_fn; @@ -105,16 +85,6 @@ dmnsn_new_csg_union(const dmnsn_array *objects) return csg; } -/** Generic CSG destruction callback. */ -static void -dmnsn_csg_free_fn(void *ptr) -{ - dmnsn_object **params = ptr; - dmnsn_delete_object(params[1]); - dmnsn_delete_object(params[0]); - dmnsn_free(ptr); -} - /** * Generic CSG intersection callback. * @param[in] csg The CSG object. @@ -131,11 +101,12 @@ dmnsn_csg_intersection_fn(const dmnsn_object *csg, dmnsn_line line, dmnsn_intersection *intersection, bool inside1, bool inside2) { - const dmnsn_object **params = csg->ptr; + const dmnsn_object *A = *(dmnsn_object **)dmnsn_array_first(csg->children); + const dmnsn_object *B = *(dmnsn_object **)dmnsn_array_last(csg->children); dmnsn_intersection i1, i2; - bool is_i1 = dmnsn_object_intersection(params[0], line, &i1); - bool is_i2 = dmnsn_object_intersection(params[1], line, &i2); + bool is_i1 = dmnsn_object_intersection(A, line, &i1); + bool is_i2 = dmnsn_object_intersection(B, line, &i2); double oldt = 0.0; while (is_i1) { @@ -144,11 +115,11 @@ dmnsn_csg_intersection_fn(const dmnsn_object *csg, dmnsn_line line, oldt = i1.t + dmnsn_epsilon; dmnsn_vector point = dmnsn_line_point(i1.ray, i1.t); - if (inside2 ^ dmnsn_object_inside(params[1], point)) { + if (inside2 ^ dmnsn_object_inside(B, point)) { dmnsn_line newline = line; newline.x0 = dmnsn_line_point(line, i1.t); newline = dmnsn_line_add_epsilon(newline); - is_i1 = dmnsn_object_intersection(params[0], newline, &i1); + is_i1 = dmnsn_object_intersection(A, newline, &i1); } else { break; } @@ -161,11 +132,11 @@ dmnsn_csg_intersection_fn(const dmnsn_object *csg, dmnsn_line line, oldt = i2.t + dmnsn_epsilon; dmnsn_vector point = dmnsn_line_point(i2.ray, i2.t); - if (inside1 ^ dmnsn_object_inside(params[0], point)) { + if (inside1 ^ dmnsn_object_inside(A, point)) { dmnsn_line newline = line; newline.x0 = dmnsn_line_point(line, i2.t); newline = dmnsn_line_add_epsilon(newline); - is_i2 = dmnsn_object_intersection(params[1], newline, &i2); + is_i2 = dmnsn_object_intersection(B, newline, &i2); } else { break; } @@ -205,24 +176,17 @@ dmnsn_csg_intersection_intersection_fn(const dmnsn_object *csg, static bool dmnsn_csg_intersection_inside_fn(const dmnsn_object *csg, dmnsn_vector point) { - dmnsn_object **params = csg->ptr; - return dmnsn_object_inside(params[0], point) - && dmnsn_object_inside(params[1], point); + const dmnsn_object *A = *(dmnsn_object **)dmnsn_array_first(csg->children); + const dmnsn_object *B = *(dmnsn_object **)dmnsn_array_last(csg->children); + return dmnsn_object_inside(A, point) && dmnsn_object_inside(B, point); } /** CSG intersection initialization callback. */ static void dmnsn_csg_intersection_initialize_fn(dmnsn_object *csg) { - dmnsn_object **params = csg->ptr; - dmnsn_object *A = params[0]; - dmnsn_object *B = params[1]; - - dmnsn_csg_cascade(csg, A); - dmnsn_csg_cascade(csg, B); - - dmnsn_initialize_object(A); - dmnsn_initialize_object(B); + dmnsn_object *A = *(dmnsn_object **)dmnsn_array_first(csg->children); + dmnsn_object *B = *(dmnsn_object **)dmnsn_array_last(csg->children); csg->trans = dmnsn_identity_matrix(); csg->bounding_box.min @@ -236,17 +200,12 @@ dmnsn_new_csg_intersection(dmnsn_object *A, dmnsn_object *B) { dmnsn_object *csg = dmnsn_new_object(); - DMNSN_INCREF(A); - DMNSN_INCREF(B); - dmnsn_object **params = dmnsn_malloc(2*sizeof(dmnsn_object *)); - params[0] = A; - params[1] = B; + dmnsn_array_push(csg->children, &A); + dmnsn_array_push(csg->children, &B); - csg->ptr = params; csg->intersection_fn = dmnsn_csg_intersection_intersection_fn; csg->inside_fn = dmnsn_csg_intersection_inside_fn; csg->initialize_fn = dmnsn_csg_intersection_initialize_fn; - csg->free_fn = dmnsn_csg_free_fn; return csg; } @@ -268,24 +227,16 @@ dmnsn_csg_difference_intersection_fn(const dmnsn_object *csg, static bool dmnsn_csg_difference_inside_fn(const dmnsn_object *csg, dmnsn_vector point) { - dmnsn_object **params = csg->ptr; - return dmnsn_object_inside(params[0], point) - && !dmnsn_object_inside(params[1], point); + const dmnsn_object *A = *(dmnsn_object **)dmnsn_array_first(csg->children); + const dmnsn_object *B = *(dmnsn_object **)dmnsn_array_last(csg->children); + return dmnsn_object_inside(A, point) && !dmnsn_object_inside(B, point); } /** CSG difference initialization callback. */ static void dmnsn_csg_difference_initialize_fn(dmnsn_object *csg) { - dmnsn_object **params = csg->ptr; - dmnsn_object *A = params[0]; - dmnsn_object *B = params[1]; - - dmnsn_csg_cascade(csg, A); - dmnsn_csg_cascade(csg, B); - - dmnsn_initialize_object(A); - dmnsn_initialize_object(B); + dmnsn_object *A = *(dmnsn_object **)dmnsn_array_first(csg->children); csg->trans = dmnsn_identity_matrix(); csg->bounding_box = A->bounding_box; @@ -296,17 +247,12 @@ dmnsn_new_csg_difference(dmnsn_object *A, dmnsn_object *B) { dmnsn_object *csg = dmnsn_new_object(); - DMNSN_INCREF(A); - DMNSN_INCREF(B); - dmnsn_object **params = dmnsn_malloc(2*sizeof(dmnsn_object *)); - params[0] = A; - params[1] = B; + dmnsn_array_push(csg->children, &A); + dmnsn_array_push(csg->children, &B); - csg->ptr = params; csg->intersection_fn = dmnsn_csg_difference_intersection_fn; csg->inside_fn = dmnsn_csg_difference_inside_fn; csg->initialize_fn = dmnsn_csg_difference_initialize_fn; - csg->free_fn = dmnsn_csg_free_fn; return csg; } @@ -328,24 +274,17 @@ dmnsn_csg_merge_intersection_fn(const dmnsn_object *csg, static bool dmnsn_csg_merge_inside_fn(const dmnsn_object *csg, dmnsn_vector point) { - dmnsn_object **params = csg->ptr; - return dmnsn_object_inside(params[0], point) - || dmnsn_object_inside(params[1], point); + const dmnsn_object *A = *(dmnsn_object **)dmnsn_array_first(csg->children); + const dmnsn_object *B = *(dmnsn_object **)dmnsn_array_last(csg->children); + return dmnsn_object_inside(A, point) || dmnsn_object_inside(B, point); } /** CSG merge initialization callback. */ static void dmnsn_csg_merge_initialize_fn(dmnsn_object *csg) { - dmnsn_object **params = csg->ptr; - dmnsn_object *A = params[0]; - dmnsn_object *B = params[1]; - - dmnsn_csg_cascade(csg, A); - dmnsn_csg_cascade(csg, B); - - dmnsn_initialize_object(A); - dmnsn_initialize_object(B); + dmnsn_object *A = *(dmnsn_object **)dmnsn_array_first(csg->children); + dmnsn_object *B = *(dmnsn_object **)dmnsn_array_last(csg->children); csg->trans = dmnsn_identity_matrix(); csg->bounding_box.min @@ -359,17 +298,12 @@ dmnsn_new_csg_merge(dmnsn_object *A, dmnsn_object *B) { dmnsn_object *csg = dmnsn_new_object(); - DMNSN_INCREF(A); - DMNSN_INCREF(B); - dmnsn_object **params = dmnsn_malloc(2*sizeof(dmnsn_object *)); - params[0] = A; - params[1] = B; + dmnsn_array_push(csg->children, &A); + dmnsn_array_push(csg->children, &B); - csg->ptr = params; csg->intersection_fn = dmnsn_csg_merge_intersection_fn; csg->inside_fn = dmnsn_csg_merge_inside_fn; csg->initialize_fn = dmnsn_csg_merge_initialize_fn; - csg->free_fn = dmnsn_csg_free_fn; return csg; } diff --git a/libdimension/dimension/finish.h b/libdimension/dimension/finish.h index f2b1df7..a163496 100644 --- a/libdimension/dimension/finish.h +++ b/libdimension/dimension/finish.h @@ -23,76 +23,148 @@ * Object finishes. */ -/* Forward-declare dmnsn_finish */ -typedef struct dmnsn_finish dmnsn_finish; +/* Ambient component */ + +typedef struct dmnsn_ambient dmnsn_ambient; + +/** + * Ambient light callback. + * @param[in] ambient The ambient object itself. + * @param[in] pigment The pigment of the object. + * @return The ambient contribution to the object's color. + */ +typedef dmnsn_color dmnsn_ambient_fn(const dmnsn_ambient *ambient, + dmnsn_color pigment); + +struct dmnsn_ambient { + dmnsn_ambient_fn *ambient_fn; /**< Ambient callback. */ + dmnsn_free_fn *free_fn; /**< Destructor callback. */ + void *ptr; /**< Generic data pointer. */ + dmnsn_refcount refcount; /**< @internal Reference count. */ +}; + +/** Allocate a dummy ambient component. */ +dmnsn_ambient *dmnsn_new_ambient(void); +/** Delete an ambient component. */ +void dmnsn_delete_ambient(dmnsn_ambient *ambient); + +/* Diffuse component */ + +typedef struct dmnsn_diffuse dmnsn_diffuse; /** * Diffuse reflection callback. - * @param[in] finish The finish itself. - * @param[in] light The color of the light illuminating the object. - * @param[in] color The pigment of the object. - * @param[in] ray The direction of the light source. - * @param[in] normal The normal vector of the surface. + * @param[in] diffuse The diffuse object itself. + * @param[in] light The color of the light illuminating the object. + * @param[in] color The pigment of the object. + * @param[in] ray The direction of the light source. + * @param[in] normal The normal vector of the surface. * @return The diffuse reflection component of the object's color. */ -typedef dmnsn_color dmnsn_diffuse_fn(const dmnsn_finish *finish, +typedef dmnsn_color dmnsn_diffuse_fn(const dmnsn_diffuse *diffuse, dmnsn_color light, dmnsn_color color, dmnsn_vector ray, dmnsn_vector normal); + +/** Diffuse finish component. */ +struct dmnsn_diffuse { + dmnsn_diffuse_fn *diffuse_fn; /**< Diffuse callback. */ + dmnsn_free_fn *free_fn; /**< Destructor callback. */ + void *ptr; /**< Generic data pointer. */ + dmnsn_refcount refcount; /**< @internal Reference count. */ +}; + +/** Allocate a dummy diffuse component. */ +dmnsn_diffuse *dmnsn_new_diffuse(void); +/** Delete a diffuse component. */ +void dmnsn_delete_diffuse(dmnsn_diffuse *diffuse); + +/* Specular component */ + +typedef struct dmnsn_specular dmnsn_specular; + /** * Specular highlight callback. - * @param[in] finish The finish itself. - * @param[in] light The color of the light illuminating the object. - * @param[in] color The pigment of the object. - * @param[in] ray The direction of the light source. - * @param[in] normal The normal vector of the surface. - * @param[in] viewer The direction of the viewer. + * @param[in] specular The specular object itself. + * @param[in] light The color of the light illuminating the object. + * @param[in] color The pigment of the object. + * @param[in] ray The direction of the light source. + * @param[in] normal The normal vector of the surface. + * @param[in] viewer The direction of the viewer. * @return The specular reflection component of the object's color. */ -typedef dmnsn_color dmnsn_specular_fn(const dmnsn_finish *finish, +typedef dmnsn_color dmnsn_specular_fn(const dmnsn_specular *specular, dmnsn_color light, dmnsn_color color, dmnsn_vector ray, dmnsn_vector normal, dmnsn_vector viewer); -/** - * Ambient light callback. - * @param[in] finish The finish itself. - * @param[in] pigment The pigment of the object. - * @return The ambient contribution to the object's color. - */ -typedef dmnsn_color dmnsn_ambient_fn(const dmnsn_finish *finish, - dmnsn_color pigment); + +struct dmnsn_specular { + dmnsn_specular_fn *specular_fn; /**< Specular callback. */ + dmnsn_free_fn *free_fn; /**< Destructor callback. */ + void *ptr; /**< Generic data pointer. */ + dmnsn_refcount refcount; /**< @internal Reference count. */ +}; + +/** Allocate a dummy specular component. */ +dmnsn_specular *dmnsn_new_specular(void); +/** Delete a specular component. */ +void dmnsn_delete_specular(dmnsn_specular *specular); + +/* Reflection component */ + +typedef struct dmnsn_reflection dmnsn_reflection; + /** * Reflected light callback. - * @param[in] finish The finish itself. - * @param[in] reflect The color of the reflected ray. - * @param[in] color The pigment of the object. - * @param[in] ray The direction of the reflected ray. - * @param[in] normal The normal vector of the surface. + * @param[in] reflection The reflection object itself. + * @param[in] reflect The color of the reflected ray. + * @param[in] color The pigment of the object. + * @param[in] ray The direction of the reflected ray. + * @param[in] normal The normal vector of the surface. * @return The contribution of the reflected ray to the object's color. */ -typedef dmnsn_color dmnsn_reflection_fn(const dmnsn_finish *finish, +typedef dmnsn_color dmnsn_reflection_fn(const dmnsn_reflection *reflection, dmnsn_color reflect, dmnsn_color color, dmnsn_vector ray, dmnsn_vector normal); -/** A finish. */ -struct dmnsn_finish { - dmnsn_diffuse_fn *diffuse_fn; /**< The diffuse callback. */ - dmnsn_specular_fn *specular_fn; /**< The specular callback. */ - dmnsn_ambient_fn *ambient_fn; /**< The ambient callback. */ - dmnsn_reflection_fn *reflection_fn; /**< The reflection callback. */ - dmnsn_free_fn *free_fn; /**< The destruction callback. */ - - /** Generic pointer. */ - void *ptr; +/** The reflection component. */ +struct dmnsn_reflection { + dmnsn_reflection_fn *reflection_fn; /**< Reflection callback. */ + dmnsn_free_fn *free_fn; /**< Destructor callback. */ + void *ptr; /**< Generic data pointer. */ + dmnsn_refcount refcount; /**< @internal Reference count. */ }; +/** Allocate a dummy reflection component. */ +dmnsn_reflection *dmnsn_new_reflection(void); +/** Delete a reflection component. */ +void dmnsn_delete_reflection(dmnsn_reflection *reflection); + +/* Entire finishes */ + +/** A finish. */ +typedef struct dmnsn_finish { + dmnsn_ambient *ambient; /**< Ambient component. */ + dmnsn_diffuse *diffuse; /**< Diffuse component. */ + dmnsn_specular *specular; /**< Specular component. */ + dmnsn_reflection *reflection; /**< Reflection component. */ +} dmnsn_finish; + /** - * Allocate a new dummy finish. - * @return The allocated finish. + * Create a new blank finish. + * @return The new finish. */ -dmnsn_finish *dmnsn_new_finish(void); +dmnsn_finish dmnsn_new_finish(void); /** * Delete a finish. * @param[in,out] finish The finish to delete. */ -void dmnsn_delete_finish(dmnsn_finish *finish); +void dmnsn_delete_finish(dmnsn_finish finish); + +/** + * Fill missing finish properties from a default finish. + * @param[in] default_finish The default finish. + * @param[in,out] finish The finish to fill. + */ +void dmnsn_finish_cascade(const dmnsn_finish *default_finish, + dmnsn_finish *finish); diff --git a/libdimension/dimension/finishes.h b/libdimension/dimension/finishes.h index e3c308c..81b0ff6 100644 --- a/libdimension/dimension/finishes.h +++ b/libdimension/dimension/finishes.h @@ -24,41 +24,33 @@ */ /** - * Add two finishes together. - * @param[in,out] f1 The first finish. - * @param[in,out] f2 The second finish. - * @return A finish that adds the values of two finishes together. - */ -dmnsn_finish *dmnsn_new_finish_combination(dmnsn_finish *f1, dmnsn_finish *f2); - -/** * Ambient finish. * @param[in] ambient The color of the ambient light. - * @return A finish with ambient light. + * @return An ambient finish component. */ -dmnsn_finish *dmnsn_new_ambient_finish(dmnsn_color ambient); +dmnsn_ambient *dmnsn_new_basic_ambient(dmnsn_color ambient); /** - * Diffuse finish. + * Regular diffuse finish. * @param[in] diffuse The diffuse reflection coefficient. - * @return A finish with diffuse reflection. + * @return A diffuse finish component. */ -dmnsn_finish *dmnsn_new_diffuse_finish(double diffuse); +dmnsn_diffuse *dmnsn_new_lambertian(double diffuse); /** * A phong specular highlight. * @param[in] specular The specular reflection coefficient. * @param[in] exp The exponent (roughly the highlight size). - * @return A finish with phong specular highlight. + * @return A phong specular finish component. */ -dmnsn_finish *dmnsn_new_phong_finish(double specular, double exp); +dmnsn_specular *dmnsn_new_phong(double specular, double exp); /** * Specular (mirror) reflection. * @param[in] min Reflection at paralell angles. * @param[in] max Reflection at perpendicular angles (often == \p min). * @param[in] falloff Degree of exponential falloff (usually 1). - * @return A finish with specular reflection. + * @return A reflective finish component. */ -dmnsn_finish *dmnsn_new_reflective_finish(dmnsn_color min, dmnsn_color max, - double falloff); +dmnsn_reflection *dmnsn_new_basic_reflection(dmnsn_color min, dmnsn_color max, + double falloff); diff --git a/libdimension/dimension/interior.h b/libdimension/dimension/interior.h index 22a9091..a52c225 100644 --- a/libdimension/dimension/interior.h +++ b/libdimension/dimension/interior.h @@ -47,3 +47,11 @@ dmnsn_interior *dmnsn_new_interior(void); * @param[in,out] interior The interior to delete. */ void dmnsn_delete_interior(dmnsn_interior *interior); + +/** + * Fill missing interior properties from a default interior. + * @param[in] default_interior The default interior. + * @param[in,out] interiorp A pointer to the interior to fill. + */ +void dmnsn_interior_cascade(dmnsn_interior *default_interior, + dmnsn_interior **interiorp); diff --git a/libdimension/dimension/object.h b/libdimension/dimension/object.h index 02daaba..24e1bcb 100644 --- a/libdimension/dimension/object.h +++ b/libdimension/dimension/object.h @@ -71,7 +71,7 @@ typedef bool dmnsn_object_inside_fn(const dmnsn_object *object, /** An object. */ struct dmnsn_object { - dmnsn_texture *texture; /**< Surface properties. */ + dmnsn_texture *texture; /**< Surface properties. */ dmnsn_interior *interior; /**< Interior properties. */ dmnsn_matrix trans; /**< Transformation matrix. */ @@ -79,20 +79,18 @@ struct dmnsn_object { dmnsn_bounding_box bounding_box; /**< Object bounding box. */ - /** Child objects. This array lists objects that can be split into - sub-objects for bounding purposes (for unions and meshes, for example). */ - dmnsn_array *children; + dmnsn_array *children; /**< Child objects. */ + bool split_children; /**< Whether the child objects can be split. */ dmnsn_object_initialize_fn *initialize_fn; /**< Initialization callback. */ dmnsn_object_intersection_fn *intersection_fn; /**< Intersection callback. */ dmnsn_object_inside_fn *inside_fn; /**< Inside callback. */ dmnsn_free_fn *free_fn; /**< Destruction callback. */ - /** Generic pointer for object info. */ - void *ptr; + void *ptr; /**< Generic pointer for object info. */ - /** @internal Reference count. */ - dmnsn_refcount refcount; + dmnsn_refcount refcount; /**< @internal Reference count. */ + bool initialized; /**< @internal Whether the object is initialized yet. */ }; /** @@ -113,7 +111,6 @@ void dmnsn_delete_object(dmnsn_object *object); */ void dmnsn_initialize_object(dmnsn_object *object); - /** * Transform a surface normal vector. * @param[in] trans The transformation matrix. diff --git a/libdimension/dimension/pattern.h b/libdimension/dimension/pattern.h index beeb9f7..de37286 100644 --- a/libdimension/dimension/pattern.h +++ b/libdimension/dimension/pattern.h @@ -44,6 +44,8 @@ struct dmnsn_pattern { dmnsn_matrix trans_inv; /**< The inverse of the transformation matrix. */ void *ptr; /**< Generic pointer. */ + + dmnsn_refcount refcount; /**< @internal Reference count. */ }; /** diff --git a/libdimension/dimension/pigment.h b/libdimension/dimension/pigment.h index 896c0bc..8b3ce4b 100644 --- a/libdimension/dimension/pigment.h +++ b/libdimension/dimension/pigment.h @@ -55,6 +55,9 @@ struct dmnsn_pigment { /** Generic pointer. */ void *ptr; + + dmnsn_refcount refcount; /** @internal Reference count. */ + bool initialized; /** @internal Whether the pigment is initialized. */ }; /** @@ -76,3 +79,12 @@ void dmnsn_delete_pigment(dmnsn_pigment *pigment); * @param[in,out] pigment The pigment to initialize. */ void dmnsn_initialize_pigment(dmnsn_pigment *pigment); + +/** + * Evaluate the color of a pigment at a point. + * @param[in] pigment The pigment to evaluate. + * @param[in] v The point to color. + * @return The color at \p v. + */ +dmnsn_color dmnsn_evaluate_pigment(const dmnsn_pigment *pigment, + dmnsn_vector v); diff --git a/libdimension/dimension/refcount.h b/libdimension/dimension/refcount.h index 4431cbc..be437a8 100644 --- a/libdimension/dimension/refcount.h +++ b/libdimension/dimension/refcount.h @@ -32,7 +32,7 @@ typedef unsigned int dmnsn_refcount; * Increment a reference count. * @param[in,out] object The reference-counted object to acquire. */ -#define DMNSN_INCREF(obj) ((void)++(obj)->refcount) +#define DMNSN_INCREF(obj) ((void)((obj) && ++(obj)->refcount)) /** * @internal @@ -40,4 +40,5 @@ typedef unsigned int dmnsn_refcount; * @param[in,out] object The reference-counted object to release. * @return Whether the object is now garbage. */ -#define DMNSN_DECREF(obj) ((obj)->refcount == 0 || --(obj)->refcount == 0) +#define DMNSN_DECREF(obj) \ + ((obj) && ((obj)->refcount == 0 || --(obj)->refcount == 0)) diff --git a/libdimension/dimension/scene.h b/libdimension/dimension/scene.h index bb47ee9..969fa45 100644 --- a/libdimension/dimension/scene.h +++ b/libdimension/dimension/scene.h @@ -40,13 +40,10 @@ typedef unsigned int dmnsn_quality; /** An entire scene. */ typedef struct dmnsn_scene { /* World attributes */ - dmnsn_color background; /**< Background color. */ - dmnsn_color ambient; /**< Global ambient color. */ - dmnsn_sky_sphere *sky_sphere; /**< Sky sphere. */ - dmnsn_texture *default_texture; /**< Default object texture. */ - - /** Camera. */ - dmnsn_camera *camera; + dmnsn_color background; /**< Background color. */ + dmnsn_sky_sphere *sky_sphere; /**< Sky sphere. */ + dmnsn_texture *default_texture; /**< Default object texture. */ + dmnsn_interior *default_interior; /**< Default object interior. */ /** Canvas. */ dmnsn_canvas *canvas; @@ -57,6 +54,9 @@ typedef struct dmnsn_scene { /** Lights. */ dmnsn_array *lights; + /** Camera. */ + dmnsn_camera *camera; + /** Render quality. */ dmnsn_quality quality; @@ -72,6 +72,8 @@ typedef struct dmnsn_scene { /** Timers. */ dmnsn_timer *bounding_timer; dmnsn_timer *render_timer; + + bool initialized; /**< @internal Whether the scene is initialized. */ } dmnsn_scene; /** @@ -91,31 +93,3 @@ void dmnsn_delete_scene(dmnsn_scene *scene); * @param[in,out] scene The scene to initalize. */ void dmnsn_initialize_scene(dmnsn_scene *scene); - -/** - * Set the output canvas for a scene. - * @param[in,out] scene The scene for which to set the canvas. - * @param[in] canvas The canvas to set. - */ -void dmnsn_scene_set_canvas(dmnsn_scene *scene, dmnsn_canvas *canvas); - -/** - * Add a light to a scene. - * @param[in,out] scene The scene to which to add the light. - * @param[in] object The object to light. - */ -void dmnsn_scene_add_light(dmnsn_scene *scene, dmnsn_light *light); - -/** - * Set the camera for a scene. - * @param[in,out] scene The scene for which to set the canvas. - * @param[in] camera The camera to set. - */ -void dmnsn_scene_set_camera(dmnsn_scene *scene, dmnsn_camera *camera); - -/** - * Add an object to a scene. - * @param[in,out] scene The scene to which to add the object. - * @param[in] object The object to add. - */ -void dmnsn_scene_add_object(dmnsn_scene *scene, dmnsn_object *object); diff --git a/libdimension/dimension/sky_sphere.h b/libdimension/dimension/sky_sphere.h index 43ad57e..2d2c834 100644 --- a/libdimension/dimension/sky_sphere.h +++ b/libdimension/dimension/sky_sphere.h @@ -27,7 +27,10 @@ typedef struct dmnsn_sky_sphere { /** An array of pigments in inside-to-outside order. */ dmnsn_array *pigments; - dmnsn_matrix trans; + + dmnsn_matrix trans; /**< Transformation matrix. */ + + dmnsn_refcount refcount; /**< @internal Reference count. */ } dmnsn_sky_sphere; /** diff --git a/libdimension/dimension/texture.h b/libdimension/dimension/texture.h index 7edcabc..0c944a9 100644 --- a/libdimension/dimension/texture.h +++ b/libdimension/dimension/texture.h @@ -26,13 +26,13 @@ /** A complete texture. */ typedef struct { dmnsn_pigment *pigment; /**< Pigment. */ - dmnsn_finish *finish; /**< Finish. */ + dmnsn_finish finish; /**< Finish. */ dmnsn_matrix trans; /**< Transformation matrix. */ dmnsn_matrix trans_inv; /**< The inverse of the transformation matrix. */ dmnsn_refcount refcount; /**< @internal Reference count. */ - bool should_init; /**< @internal Whether to initialize the texture. */ + bool initialized; /**< @internal Whether the texture is initialized yet. */ } dmnsn_texture; /** @@ -54,3 +54,11 @@ void dmnsn_delete_texture(dmnsn_texture *texture); * @param[in,out] texture The texture to initialize. */ void dmnsn_initialize_texture(dmnsn_texture *texture); + +/** + * Fill missing texture properties from a default texture. + * @param[in] default_texture The default texture. + * @param[in,out] texturep A pointer to the texture to fill. + */ +void dmnsn_texture_cascade(dmnsn_texture *default_texture, + dmnsn_texture **texture); diff --git a/libdimension/finish.c b/libdimension/finish.c index e647152..d356676 100644 --- a/libdimension/finish.c +++ b/libdimension/finish.c @@ -25,27 +25,127 @@ #include "dimension.h" -/* Allocate a dummy finish */ -dmnsn_finish * +dmnsn_ambient * +dmnsn_new_ambient(void) +{ + dmnsn_ambient *ambient = dmnsn_malloc(sizeof(dmnsn_ambient)); + ambient->free_fn = NULL; + ambient->ptr = NULL; + ambient->refcount = 1; + return ambient; +} + +void +dmnsn_delete_ambient(dmnsn_ambient *ambient) +{ + if (DMNSN_DECREF(ambient)) { + if (ambient->free_fn) { + ambient->free_fn(ambient->ptr); + } + dmnsn_free(ambient); + } +} + +dmnsn_diffuse * +dmnsn_new_diffuse(void) +{ + dmnsn_diffuse *diffuse = dmnsn_malloc(sizeof(dmnsn_diffuse)); + diffuse->free_fn = NULL; + diffuse->ptr = NULL; + diffuse->refcount = 1; + return diffuse; +} + +void +dmnsn_delete_diffuse(dmnsn_diffuse *diffuse) +{ + if (DMNSN_DECREF(diffuse)) { + if (diffuse->free_fn) { + diffuse->free_fn(diffuse->ptr); + } + dmnsn_free(diffuse); + } +} + +dmnsn_specular * +dmnsn_new_specular(void) +{ + dmnsn_specular *specular = dmnsn_malloc(sizeof(dmnsn_specular)); + specular->free_fn = NULL; + specular->ptr = NULL; + specular->refcount = 1; + return specular; +} + +void +dmnsn_delete_specular(dmnsn_specular *specular) +{ + if (DMNSN_DECREF(specular)) { + if (specular->free_fn) { + specular->free_fn(specular->ptr); + } + dmnsn_free(specular); + } +} + +dmnsn_reflection * +dmnsn_new_reflection(void) +{ + dmnsn_reflection *reflection = dmnsn_malloc(sizeof(dmnsn_reflection)); + reflection->free_fn = NULL; + reflection->ptr = NULL; + reflection->refcount = 1; + return reflection; +} + +void +dmnsn_delete_reflection(dmnsn_reflection *reflection) +{ + if (DMNSN_DECREF(reflection)) { + if (reflection->free_fn) { + reflection->free_fn(reflection->ptr); + } + dmnsn_free(reflection); + } +} + +dmnsn_finish dmnsn_new_finish(void) { - dmnsn_finish *finish = dmnsn_malloc(sizeof(dmnsn_finish)); - finish->diffuse_fn = NULL; - finish->specular_fn = NULL; - finish->ambient_fn = NULL; - finish->reflection_fn = NULL; - finish->free_fn = NULL; + dmnsn_finish finish; + finish.ambient = NULL; + finish.diffuse = NULL; + finish.specular = NULL; + finish.reflection = NULL; return finish; } -/* Free a finish */ void -dmnsn_delete_finish(dmnsn_finish *finish) +dmnsn_delete_finish(dmnsn_finish finish) { - if (finish) { - if (finish->free_fn) { - finish->free_fn(finish->ptr); - } - dmnsn_free(finish); + dmnsn_delete_reflection(finish.reflection); + dmnsn_delete_specular(finish.specular); + dmnsn_delete_diffuse(finish.diffuse); + dmnsn_delete_ambient(finish.ambient); +} + +void +dmnsn_finish_cascade(const dmnsn_finish *default_finish, dmnsn_finish *finish) +{ + if (!finish->ambient) { + finish->ambient = default_finish->ambient; + DMNSN_INCREF(finish->ambient); + } + if (!finish->diffuse) { + finish->diffuse = default_finish->diffuse; + DMNSN_INCREF(finish->diffuse); + } + if (!finish->specular) { + finish->specular = default_finish->specular; + DMNSN_INCREF(finish->specular); + } + if (!finish->reflection) { + finish->reflection = default_finish->reflection; + DMNSN_INCREF(finish->reflection); } } diff --git a/libdimension/finish_combination.c b/libdimension/finish_combination.c deleted file mode 100644 index acdc719..0000000 --- a/libdimension/finish_combination.c +++ /dev/null @@ -1,150 +0,0 @@ -/************************************************************************* - * Copyright (C) 2010 Tavian Barnes <tavianator@tavianator.com> * - * * - * This file is part of The Dimension Library. * - * * - * The Dimension Library is free software; you can redistribute it and/ * - * or modify it under the terms of the GNU Lesser General Public License * - * as published by the Free Software Foundation; either version 3 of the * - * License, or (at your option) any later version. * - * * - * The Dimension Library is distributed in the hope that it will be * - * useful, but WITHOUT ANY WARRANTY; without even the implied warranty * - * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * - * Lesser General Public License for more details. * - * * - * You should have received a copy of the GNU Lesser General Public * - * License along with this program. If not, see * - * <http://www.gnu.org/licenses/>. * - *************************************************************************/ - -/** - * @file - * Finish combinations. - */ - -#include "dimension.h" -#include <math.h> -#include <stdlib.h> - -/** Diffuse combination callback. */ -static dmnsn_color -dmnsn_finish_combination_diffuse_fn(const dmnsn_finish *finish, - dmnsn_color light, dmnsn_color color, - dmnsn_vector ray, dmnsn_vector normal) -{ - dmnsn_finish **params = finish->ptr; - if (params[0]->diffuse_fn && params[1]->diffuse_fn) { - return dmnsn_color_add( - params[0]->diffuse_fn(params[0], light, color, ray, normal), - params[1]->diffuse_fn(params[1], light, color, ray, normal) - ); - } else if (params[0]->diffuse_fn) { - return params[0]->diffuse_fn(params[0], light, color, ray, normal); - } else if (params[1]->diffuse_fn) { - return params[1]->diffuse_fn(params[1], light, color, ray, normal); - } else { - return dmnsn_black; - } -} - -/** Specular combination callback. */ -static dmnsn_color -dmnsn_finish_combination_specular_fn(const dmnsn_finish *finish, - dmnsn_color light, dmnsn_color color, - dmnsn_vector ray, dmnsn_vector normal, - dmnsn_vector viewer) -{ - dmnsn_finish **params = finish->ptr; - if (params[0]->specular_fn && params[1]->specular_fn) { - return dmnsn_color_add( - params[0]->specular_fn(params[0], light, color, ray, normal, viewer), - params[1]->specular_fn(params[1], light, color, ray, normal, viewer) - ); - } else if (params[0]->specular_fn) { - return params[0]->specular_fn(params[0], light, color, ray, - normal, viewer); - } else if (params[1]->specular_fn) { - return params[1]->specular_fn(params[1], light, color, ray, - normal, viewer); - } else { - return dmnsn_black; - } -} - -/** Ambient combination callback. */ -static dmnsn_color -dmnsn_finish_combination_ambient_fn(const dmnsn_finish *finish, - dmnsn_color pigment) -{ - dmnsn_finish **params = finish->ptr; - if (params[0]->ambient_fn && params[1]->ambient_fn) { - return dmnsn_color_add(params[0]->ambient_fn(params[0], pigment), - params[1]->ambient_fn(params[1], pigment)); - } else if (params[0]->ambient_fn) { - return params[0]->ambient_fn(params[0], pigment); - } else if (params[1]->ambient_fn) { - return params[1]->ambient_fn(params[1], pigment); - } else { - return dmnsn_black; - } -} - -/** Reflection combination callback. */ -static dmnsn_color -dmnsn_finish_combination_reflection_fn(const dmnsn_finish *finish, - dmnsn_color reflect, dmnsn_color color, - dmnsn_vector ray, dmnsn_vector normal) -{ - dmnsn_finish **params = finish->ptr; - if (params[0]->reflection_fn && params[1]->reflection_fn) { - return dmnsn_color_add( - params[0]->reflection_fn(params[0], reflect, color, ray, normal), - params[1]->reflection_fn(params[1], reflect, color, ray, normal) - ); - } else if (params[0]->reflection_fn) { - return params[0]->reflection_fn(params[0], reflect, color, ray, normal); - } else if (params[1]->reflection_fn) { - return params[1]->reflection_fn(params[1], reflect, color, ray, normal); - } else { - return dmnsn_black; - } -} - -/** Finish combination destructor callback. */ -static void -dmnsn_finish_combination_free_fn(void *ptr) -{ - dmnsn_finish **params = ptr; - dmnsn_delete_finish(params[0]); - dmnsn_delete_finish(params[1]); - dmnsn_free(ptr); -} - -dmnsn_finish * -dmnsn_new_finish_combination(dmnsn_finish *f1, dmnsn_finish *f2) -{ - dmnsn_finish *finish = dmnsn_new_finish(); - - dmnsn_finish **params = dmnsn_malloc(2*sizeof(dmnsn_finish *)); - params[0] = f1; - params[1] = f2; - - finish->ptr = params; - - if (f1->diffuse_fn || f2->diffuse_fn) - finish->diffuse_fn = dmnsn_finish_combination_diffuse_fn; - - if (f1->specular_fn || f2->specular_fn) - finish->specular_fn = dmnsn_finish_combination_specular_fn; - - if (f1->ambient_fn || f2->ambient_fn) - finish->ambient_fn = dmnsn_finish_combination_ambient_fn; - - if (f1->reflection_fn || f2->reflection_fn) - finish->reflection_fn = dmnsn_finish_combination_reflection_fn; - - finish->free_fn = dmnsn_finish_combination_free_fn; - - return finish; -} diff --git a/libdimension/interior.c b/libdimension/interior.c index 0594e06..47ba19f 100644 --- a/libdimension/interior.c +++ b/libdimension/interior.c @@ -33,7 +33,7 @@ dmnsn_new_interior(void) dmnsn_interior *interior = dmnsn_malloc(sizeof(dmnsn_interior)); interior->ior = 1.0; interior->free_fn = NULL; - interior->refcount = 0; + interior->refcount = 1; return interior; } @@ -41,10 +41,21 @@ dmnsn_new_interior(void) void dmnsn_delete_interior(dmnsn_interior *interior) { - if (interior && DMNSN_DECREF(interior)) { + if (DMNSN_DECREF(interior)) { if (interior->free_fn) { interior->free_fn(interior->ptr); } dmnsn_free(interior); } } + +/* Cascade a interior */ +void +dmnsn_interior_cascade(dmnsn_interior *default_interior, + dmnsn_interior **interiorp) +{ + if (!*interiorp) { + *interiorp = default_interior; + DMNSN_INCREF(*interiorp); + } +} diff --git a/libdimension/diffuse.c b/libdimension/lambertian.c index fae8e74..089ce56 100644 --- a/libdimension/diffuse.c +++ b/libdimension/lambertian.c @@ -29,12 +29,12 @@ /** Diffuse finish callback. */ static dmnsn_color -dmnsn_diffuse_finish_fn(const dmnsn_finish *finish, - dmnsn_color light, dmnsn_color color, - dmnsn_vector ray, dmnsn_vector normal) +dmnsn_lambertian_diffuse_fn(const dmnsn_diffuse *diffuse, + dmnsn_color light, dmnsn_color color, + dmnsn_vector ray, dmnsn_vector normal) { - double *diffuse = finish->ptr; - double diffuse_factor = fabs((*diffuse)*dmnsn_vector_dot(ray, normal)); + double *coeff = diffuse->ptr; + double diffuse_factor = fabs((*coeff)*dmnsn_vector_dot(ray, normal)); dmnsn_color ret = dmnsn_color_mul(diffuse_factor, dmnsn_color_illuminate(light, color)); ret.filter = 0.0; @@ -42,17 +42,17 @@ dmnsn_diffuse_finish_fn(const dmnsn_finish *finish, return ret; } -dmnsn_finish * -dmnsn_new_diffuse_finish(double diffuse) +dmnsn_diffuse * +dmnsn_new_lambertian(double diffuse) { - dmnsn_finish *finish = dmnsn_new_finish(); + dmnsn_diffuse *lambertian = dmnsn_new_diffuse(); double *param = dmnsn_malloc(sizeof(double)); *param = diffuse; - finish->ptr = param; - finish->diffuse_fn = dmnsn_diffuse_finish_fn; - finish->free_fn = dmnsn_free; + lambertian->diffuse_fn = dmnsn_lambertian_diffuse_fn; + lambertian->free_fn = dmnsn_free; + lambertian->ptr = param; - return finish; + return lambertian; } diff --git a/libdimension/light.c b/libdimension/light.c index 1103727..2ff8820 100644 --- a/libdimension/light.c +++ b/libdimension/light.c @@ -36,7 +36,7 @@ dmnsn_new_light(void) light->shadow_fn = NULL; light->free_fn = NULL; light->ptr = NULL; - light->refcount = 0; + light->refcount = 1; return light; } @@ -44,7 +44,7 @@ dmnsn_new_light(void) void dmnsn_delete_light(dmnsn_light *light) { - if (light && DMNSN_DECREF(light)) { + if (DMNSN_DECREF(light)) { if (light->free_fn) { light->free_fn(light->ptr); } diff --git a/libdimension/object.c b/libdimension/object.c index fecfdbe..bb7773d 100644 --- a/libdimension/object.c +++ b/libdimension/object.c @@ -35,11 +35,13 @@ dmnsn_new_object(void) object->interior = NULL; object->trans = dmnsn_identity_matrix(); object->children = dmnsn_new_array(sizeof(dmnsn_object *)); + object->split_children = false; object->intersection_fn = NULL; object->inside_fn = NULL; object->initialize_fn = NULL; object->free_fn = NULL; - object->refcount = 0; + object->refcount = 1; + object->initialized = false; return object; } @@ -47,7 +49,7 @@ dmnsn_new_object(void) void dmnsn_delete_object(dmnsn_object *object) { - if (object && DMNSN_DECREF(object)) { + if (DMNSN_DECREF(object)) { DMNSN_ARRAY_FOREACH (dmnsn_object **, child, object->children) { dmnsn_delete_object(*child); } @@ -65,31 +67,31 @@ dmnsn_delete_object(dmnsn_object *object) void dmnsn_initialize_object(dmnsn_object *object) { - /* Don't double-init textures */ - bool should_init = false; - dmnsn_matrix old_trans = object->trans; - if (object->texture) { - DMNSN_INCREF(object->texture); - should_init = object->texture->should_init; - object->texture->should_init = false; + dmnsn_assert(!object->initialized, "Object double-initialized."); + object->initialized = true; + + /* Initialize the texture */ + if (!object->texture->initialized) { + object->texture->trans = dmnsn_matrix_mul(object->trans, + object->texture->trans); + dmnsn_initialize_texture(object->texture); } - if (object->interior) { - DMNSN_INCREF(object->interior); + /* Initialize the object's children */ + DMNSN_ARRAY_FOREACH (dmnsn_object **, child, object->children) { + (*child)->trans = dmnsn_matrix_mul(object->trans, (*child)->trans); + dmnsn_texture_cascade(object->texture, &(*child)->texture); + dmnsn_interior_cascade(object->interior, &(*child)->interior); + dmnsn_initialize_object(*child); } + /* Initialization callback */ if (object->initialize_fn) { object->initialize_fn(object); } + /* Precalculate object values */ object->bounding_box = dmnsn_transform_bounding_box(object->trans, object->bounding_box); object->trans_inv = dmnsn_matrix_inverse(object->trans); - - if (should_init) { - /* Transform the texture with the object */ - object->texture->trans - = dmnsn_matrix_mul(old_trans, object->texture->trans); - dmnsn_initialize_texture(object->texture); - } } diff --git a/libdimension/pattern.c b/libdimension/pattern.c index b266527..368755a 100644 --- a/libdimension/pattern.c +++ b/libdimension/pattern.c @@ -30,8 +30,9 @@ dmnsn_pattern * dmnsn_new_pattern(void) { dmnsn_pattern *pattern = dmnsn_malloc(sizeof(dmnsn_pattern)); - pattern->trans = dmnsn_identity_matrix(); - pattern->free_fn = NULL; + pattern->trans = dmnsn_identity_matrix(); + pattern->free_fn = NULL; + pattern->refcount = 1; return pattern; } @@ -39,10 +40,12 @@ dmnsn_new_pattern(void) void dmnsn_delete_pattern(dmnsn_pattern *pattern) { - if (pattern->free_fn) { - pattern->free_fn(pattern->ptr); + if (DMNSN_DECREF(pattern)) { + if (pattern->free_fn) { + pattern->free_fn(pattern->ptr); + } + dmnsn_free(pattern); } - dmnsn_free(pattern); } /* Precompute the transformation matrix inverse */ diff --git a/libdimension/phong.c b/libdimension/phong.c index 3fc154f..90bf505 100644 --- a/libdimension/phong.c +++ b/libdimension/phong.c @@ -28,15 +28,15 @@ /** Phong specular highlight callback. */ static dmnsn_color -dmnsn_phong_specular_fn(const dmnsn_finish *finish, +dmnsn_phong_specular_fn(const dmnsn_specular *specular, dmnsn_color light, dmnsn_color color, dmnsn_vector ray, dmnsn_vector normal, dmnsn_vector viewer) { - double *params = finish->ptr; + double *params = specular->ptr; - double specular = params[0]; - double exp = params[1]; + double coeff = params[0]; + double exp = params[1]; dmnsn_vector proj = dmnsn_vector_mul(2*dmnsn_vector_dot(ray, normal), normal); dmnsn_vector reflected = dmnsn_vector_sub(proj, ray); @@ -47,22 +47,22 @@ dmnsn_phong_specular_fn(const dmnsn_finish *finish, } specular_factor = pow(specular_factor, exp); - return dmnsn_color_mul(specular*specular_factor, light); + return dmnsn_color_mul(coeff*specular_factor, light); } /* A phong finish */ -dmnsn_finish * -dmnsn_new_phong_finish(double specular, double exp) +dmnsn_specular * +dmnsn_new_phong(double specular, double exp) { - dmnsn_finish *finish = dmnsn_new_finish(); + dmnsn_specular *phong = dmnsn_new_specular(); double *params = dmnsn_malloc(2*sizeof(double)); params[0] = specular; params[1] = exp; - finish->ptr = params; - finish->specular_fn = dmnsn_phong_specular_fn; - finish->free_fn = dmnsn_free; + phong->specular_fn = dmnsn_phong_specular_fn; + phong->free_fn = dmnsn_free; + phong->ptr = params; - return finish; + return phong; } diff --git a/libdimension/pigment.c b/libdimension/pigment.c index a1b4fb7..5522d71 100644 --- a/libdimension/pigment.c +++ b/libdimension/pigment.c @@ -35,6 +35,8 @@ dmnsn_new_pigment(void) pigment->free_fn = NULL; pigment->trans = dmnsn_identity_matrix(); pigment->quick_color = dmnsn_black; + pigment->refcount = 1; + pigment->initialized = false; return pigment; } @@ -42,7 +44,7 @@ dmnsn_new_pigment(void) void dmnsn_delete_pigment(dmnsn_pigment *pigment) { - if (pigment) { + if (DMNSN_DECREF(pigment)) { if (pigment->free_fn) { pigment->free_fn(pigment->ptr); } @@ -54,9 +56,20 @@ dmnsn_delete_pigment(dmnsn_pigment *pigment) void dmnsn_initialize_pigment(dmnsn_pigment *pigment) { + dmnsn_assert(!pigment->initialized, "Pigment double-initialized."); + pigment->initialized = true; + if (pigment->initialize_fn) { pigment->initialize_fn(pigment); } pigment->trans_inv = dmnsn_matrix_inverse(pigment->trans); } + +/* Evaluate a pigment */ +dmnsn_color +dmnsn_evaluate_pigment(const dmnsn_pigment *pigment, dmnsn_vector v) +{ + dmnsn_vector v_trans = dmnsn_transform_vector(pigment->trans_inv, v); + return pigment->pigment_fn(pigment, v_trans); +} diff --git a/libdimension/pigment_map.c b/libdimension/pigment_map.c index e97553f..cf49649 100644 --- a/libdimension/pigment_map.c +++ b/libdimension/pigment_map.c @@ -75,8 +75,8 @@ dmnsn_pigment_map_pigment_fn(const dmnsn_pigment *pigment, dmnsn_vector v) dmnsn_pigment *pigment1, *pigment2; dmnsn_evaluate_map(payload->map, dmnsn_pattern_value(payload->pattern, v), &n, &pigment1, &pigment2); - dmnsn_color color1 = pigment1->pigment_fn(pigment1, v); - dmnsn_color color2 = pigment2->pigment_fn(pigment2, v); + dmnsn_color color1 = dmnsn_evaluate_pigment(pigment1, v); + dmnsn_color color2 = dmnsn_evaluate_pigment(pigment2, v); if (payload->flags == DMNSN_PIGMENT_MAP_SRGB) { color1 = dmnsn_color_to_sRGB(color1); @@ -95,8 +95,6 @@ static void dmnsn_pigment_map_initialize_fn(dmnsn_pigment *pigment) { dmnsn_pigment_map_payload *payload = pigment->ptr; - payload->pattern->trans = dmnsn_matrix_mul(pigment->trans, - payload->pattern->trans); dmnsn_initialize_pattern(payload->pattern); dmnsn_map_apply(payload->map, dmnsn_initialize_mapped_pigment); } diff --git a/libdimension/prtree.c b/libdimension/prtree.c index 2d8acc4..06cecf9 100644 --- a/libdimension/prtree.c +++ b/libdimension/prtree.c @@ -349,12 +349,12 @@ dmnsn_make_prtree(const dmnsn_array *objects) static void dmnsn_split_add_object(dmnsn_array *objects, const dmnsn_object *object) { - if (dmnsn_array_size(object->children) == 0) { - dmnsn_array_push(objects, &object); - } else { + if (object->split_children) { DMNSN_ARRAY_FOREACH (const dmnsn_object **, child, object->children) { dmnsn_split_add_object(objects, *child); } + } else { + dmnsn_array_push(objects, &object); } } diff --git a/libdimension/raytrace.c b/libdimension/raytrace.c index e2fd61e..5d62738 100644 --- a/libdimension/raytrace.c +++ b/libdimension/raytrace.c @@ -113,9 +113,9 @@ typedef struct dmnsn_raytrace_state { unsigned int reclevel; dmnsn_vector r; - dmnsn_vector light; dmnsn_vector viewer; dmnsn_vector reflected; + dmnsn_vector light; dmnsn_color pigment; dmnsn_color diffuse; @@ -171,45 +171,6 @@ dmnsn_raytrace_scene_concurrent(void *ptr, unsigned int thread, return 0; } -/** Get the intersection texture. */ -#define ITEXTURE(state) (state->intersection->texture) -/** Get the default texture. */ -#define DTEXTURE(state) (state->scene->default_texture) - -/** Can a texture element be accessed? */ -#define CAN_ACCESS(texture, telem) \ - ((texture) && (texture)->telem) -/** Can a texture element callback be called? */ -#define CAN_CALL(texture, telem, fn) \ - (CAN_ACCESS(texture, telem) && (texture)->telem->fn) - -/** Determine whether a callback may be called. */ -#define TEXTURE_HAS_CALLBACK(state, telem, fn) \ - (CAN_CALL(ITEXTURE(state), telem, fn) \ - || CAN_CALL(DTEXTURE(state), telem, fn)) - -/** Call the appropriate overloaded texture callback. */ -#define TEXTURE_CALLBACK(state, telem, fn, def, ...) \ - (CAN_CALL(ITEXTURE(state), telem, fn) \ - ? ITEXTURE(state)->telem->fn(ITEXTURE(state)->telem, __VA_ARGS__) \ - : (CAN_CALL(DTEXTURE(state), telem, fn) \ - ? DTEXTURE(state)->telem->fn(DTEXTURE(state)->telem, __VA_ARGS__) \ - : def)); - -/** Get a property from a texture element. */ -#define TEXTURE_PROPERTY(state, telem, prop, def) \ - (CAN_ACCESS(ITEXTURE(state), telem) \ - ? ITEXTURE(state)->telem->prop \ - : (CAN_ACCESS(DTEXTURE(state), telem) \ - ? DTEXTURE(state)->telem->prop \ - : def)) - -/** Get the current index of refraction. */ -#define IOR(state) \ - ((state)->intersection->interior \ - ? (state)->intersection->interior->ior \ - : 1.0) - /** Calculate the background color. */ static dmnsn_color dmnsn_raytrace_background(dmnsn_raytrace_state *state, dmnsn_line ray) @@ -230,12 +191,13 @@ dmnsn_raytrace_background(dmnsn_raytrace_state *state, dmnsn_line ray) static void dmnsn_raytrace_pigment(dmnsn_raytrace_state *state) { + dmnsn_pigment *pigment = state->intersection->texture->pigment; if (state->scene->quality & DMNSN_RENDER_PIGMENT) { - state->pigment = TEXTURE_CALLBACK(state, pigment, pigment_fn, dmnsn_black, - state->r); + state->pigment = dmnsn_evaluate_pigment(pigment, state->r); } else { - state->pigment = TEXTURE_PROPERTY(state, pigment, quick_color, dmnsn_black); + state->pigment = pigment->quick_color; } + state->diffuse = state->pigment; } @@ -297,15 +259,12 @@ static void dmnsn_raytrace_lighting(dmnsn_raytrace_state *state) { /* The ambient color */ - state->diffuse = TEXTURE_CALLBACK(state, finish, ambient_fn, dmnsn_black, - state->pigment); - state->diffuse = dmnsn_color_illuminate(state->scene->ambient, - state->diffuse); + state->diffuse = dmnsn_black; - if (!TEXTURE_HAS_CALLBACK(state, finish, diffuse_fn) - && !TEXTURE_HAS_CALLBACK(state, finish, specular_fn)) - { - return; + const dmnsn_finish *finish = &state->intersection->texture->finish; + if (finish->ambient) { + state->diffuse + = finish->ambient->ambient_fn(finish->ambient, state->pigment); } /* Iterate over each light */ @@ -314,16 +273,22 @@ dmnsn_raytrace_lighting(dmnsn_raytrace_state *state) if (!dmnsn_color_is_black(light_color)) { if (state->scene->quality & DMNSN_RENDER_FINISH) { /* Get this light's color contribution to the object */ - dmnsn_color diffuse = TEXTURE_CALLBACK( - state, finish, diffuse_fn, dmnsn_black, - light_color, state->pigment, state->light, - state->intersection->normal - ); - dmnsn_color specular = TEXTURE_CALLBACK( - state, finish, specular_fn, dmnsn_black, - light_color, state->pigment, state->light, - state->intersection->normal, state->viewer - ); + dmnsn_color diffuse = dmnsn_black; + if (finish->diffuse) { + diffuse = finish->diffuse->diffuse_fn( + finish->diffuse, light_color, state->pigment, state->light, + state->intersection->normal + ); + } + + dmnsn_color specular = dmnsn_black; + if (finish->specular) { + specular = finish->specular->specular_fn( + finish->specular, light_color, state->pigment, state->light, + state->intersection->normal, state->viewer + ); + } + state->diffuse = dmnsn_color_add(diffuse, state->diffuse); state->additional = dmnsn_color_add(specular, state->additional); } else { @@ -341,20 +306,21 @@ dmnsn_raytrace_reflection(const dmnsn_raytrace_state *state) { dmnsn_color reflected = dmnsn_black; - if (TEXTURE_HAS_CALLBACK(state, finish, reflection_fn)) { + const dmnsn_finish *finish = &state->intersection->texture->finish; + if (finish->reflection) { dmnsn_line refl_ray = dmnsn_new_line(state->r, state->reflected); refl_ray = dmnsn_line_add_epsilon(refl_ray); dmnsn_raytrace_state recursive_state = *state; - recursive_state.adc_value = TEXTURE_CALLBACK( - state, finish, reflection_fn, dmnsn_black, - state->adc_value, state->pigment, state->reflected, + recursive_state.adc_value = finish->reflection->reflection_fn( + finish->reflection, state->adc_value, state->pigment, state->reflected, state->intersection->normal ); + dmnsn_color rec = dmnsn_raytrace_shoot(&recursive_state, refl_ray); - reflected = TEXTURE_CALLBACK( - state, finish, reflection_fn, dmnsn_black, - rec, state->pigment, state->reflected, state->intersection->normal + reflected = finish->reflection->reflection_fn( + finish->reflection, rec, state->pigment, state->reflected, + state->intersection->normal ); reflected.trans = 0.0; reflected.filter = 0.0; @@ -378,7 +344,7 @@ dmnsn_raytrace_translucency(dmnsn_raytrace_state *state) if (dmnsn_vector_dot(r, n) < 0.0) { /* We are entering an object */ - recursive_state.ior = IOR(state); + recursive_state.ior = state->intersection->interior->ior; recursive_state.parent = state; } else { /* We are leaving an object */ @@ -438,15 +404,15 @@ dmnsn_raytrace_shoot(dmnsn_raytrace_state *state, dmnsn_line ray) bool reset = state->reclevel == state->scene->reclimit - 1; if (dmnsn_prtree_intersection(state->prtree, ray, &intersection, reset)) { state->intersection = &intersection; - state->r = dmnsn_line_point(state->intersection->ray, - state->intersection->t); + + state->r = dmnsn_line_point(intersection.ray, intersection.t); state->viewer = dmnsn_vector_normalized( - dmnsn_vector_negate(state->intersection->ray.n) + dmnsn_vector_negate(intersection.ray.n) ); state->reflected = dmnsn_vector_sub( dmnsn_vector_mul( - 2*dmnsn_vector_dot(state->viewer, state->intersection->normal), - state->intersection->normal), + 2*dmnsn_vector_dot(state->viewer, intersection.normal), + intersection.normal), state->viewer ); diff --git a/libdimension/reflective.c b/libdimension/reflection.c index 32bec58..2417304 100644 --- a/libdimension/reflective.c +++ b/libdimension/reflection.c @@ -35,23 +35,23 @@ typedef struct dmnsn_reflection_params { /** Reflective finish callback. */ static dmnsn_color -dmnsn_reflective_finish_fn(const dmnsn_finish *finish, - dmnsn_color reflect, dmnsn_color color, - dmnsn_vector ray, dmnsn_vector normal) +dmnsn_basic_reflection_fn(const dmnsn_reflection *reflection, + dmnsn_color reflect, dmnsn_color color, + dmnsn_vector ray, dmnsn_vector normal) { - dmnsn_reflection_params *params = finish->ptr; - double reflection = pow(fabs(dmnsn_vector_dot(ray, normal)), params->falloff); + dmnsn_reflection_params *params = reflection->ptr; + double coeff = pow(fabs(dmnsn_vector_dot(ray, normal)), params->falloff); return dmnsn_color_illuminate( - dmnsn_color_gradient(params->min, params->max, reflection), + dmnsn_color_gradient(params->min, params->max, coeff), reflect ); } -dmnsn_finish * -dmnsn_new_reflective_finish(dmnsn_color min, dmnsn_color max, double falloff) +dmnsn_reflection * +dmnsn_new_basic_reflection(dmnsn_color min, dmnsn_color max, double falloff) { - dmnsn_finish *finish = dmnsn_new_finish(); + dmnsn_reflection *reflection = dmnsn_new_reflection(); dmnsn_reflection_params *params = dmnsn_malloc(sizeof(dmnsn_reflection_params)); @@ -59,9 +59,9 @@ dmnsn_new_reflective_finish(dmnsn_color min, dmnsn_color max, double falloff) params->max = max; params->falloff = falloff; - finish->ptr = params; - finish->reflection_fn = dmnsn_reflective_finish_fn; - finish->free_fn = dmnsn_free; + reflection->reflection_fn = dmnsn_basic_reflection_fn; + reflection->free_fn = dmnsn_free; + reflection->ptr = params; - return finish; + return reflection; } diff --git a/libdimension/scene.c b/libdimension/scene.c index 8462203..ef597ee 100644 --- a/libdimension/scene.c +++ b/libdimension/scene.c @@ -32,20 +32,21 @@ dmnsn_new_scene(void) { dmnsn_scene *scene = dmnsn_malloc(sizeof(dmnsn_scene)); - scene->background = dmnsn_black; - scene->ambient = dmnsn_white; - scene->sky_sphere = NULL; - scene->default_texture = dmnsn_new_texture(); - scene->camera = NULL; - scene->canvas = NULL; - scene->objects = dmnsn_new_array(sizeof(dmnsn_object *)); - scene->lights = dmnsn_new_array(sizeof(dmnsn_light *)); - scene->quality = DMNSN_RENDER_FULL; - scene->reclimit = 5; - scene->adc_bailout = 1.0/255.0; - scene->nthreads = dmnsn_ncpus(); - scene->bounding_timer = NULL; - scene->render_timer = NULL; + scene->background = dmnsn_black; + scene->sky_sphere = NULL; + scene->default_texture = dmnsn_new_texture(); + scene->default_interior = dmnsn_new_interior(); + scene->canvas = NULL; + scene->objects = dmnsn_new_array(sizeof(dmnsn_object *)); + scene->lights = dmnsn_new_array(sizeof(dmnsn_light *)); + scene->camera = NULL; + scene->quality = DMNSN_RENDER_FULL; + scene->reclimit = 5; + scene->adc_bailout = 1.0/255.0; + scene->nthreads = dmnsn_ncpus(); + scene->bounding_timer = NULL; + scene->render_timer = NULL; + scene->initialized = false; return scene; } @@ -69,6 +70,7 @@ dmnsn_delete_scene(dmnsn_scene *scene) dmnsn_delete_array(scene->objects); dmnsn_delete_canvas(scene->canvas); dmnsn_delete_camera(scene->camera); + dmnsn_delete_interior(scene->default_interior); dmnsn_delete_texture(scene->default_texture); dmnsn_delete_sky_sphere(scene->sky_sphere); dmnsn_free(scene); @@ -78,38 +80,18 @@ dmnsn_delete_scene(dmnsn_scene *scene) void dmnsn_initialize_scene(dmnsn_scene *scene) { + dmnsn_assert(!scene->initialized, "Texture double-initialized."); + scene->initialized = true; + + dmnsn_initialize_texture(scene->default_texture); + if (scene->sky_sphere) { dmnsn_initialize_sky_sphere(scene->sky_sphere); } -} - -void -dmnsn_scene_set_canvas(dmnsn_scene *scene, dmnsn_canvas *canvas) -{ - DMNSN_INCREF(canvas); - dmnsn_delete_canvas(scene->canvas); - scene->canvas = canvas; -} - -void -dmnsn_scene_add_light(dmnsn_scene *scene, dmnsn_light *light) -{ - DMNSN_INCREF(light); - dmnsn_array_push(scene->lights, &light); -} -void -dmnsn_scene_set_camera(dmnsn_scene *scene, dmnsn_camera *camera) -{ - DMNSN_INCREF(camera); - dmnsn_delete_camera(scene->camera); - scene->camera = camera; -} - -void -dmnsn_scene_add_object(dmnsn_scene *scene, dmnsn_object *object) -{ - DMNSN_INCREF(object); - dmnsn_initialize_object(object); - dmnsn_array_push(scene->objects, &object); + DMNSN_ARRAY_FOREACH (dmnsn_object **, object, scene->objects) { + dmnsn_texture_cascade(scene->default_texture, &(*object)->texture); + dmnsn_interior_cascade(scene->default_interior, &(*object)->interior); + dmnsn_initialize_object(*object); + } } diff --git a/libdimension/sky_sphere.c b/libdimension/sky_sphere.c index 0ea5fa3..2279881 100644 --- a/libdimension/sky_sphere.c +++ b/libdimension/sky_sphere.c @@ -30,14 +30,15 @@ dmnsn_new_sky_sphere(void) { dmnsn_sky_sphere *sky_sphere = dmnsn_malloc(sizeof(dmnsn_sky_sphere)); sky_sphere->pigments = dmnsn_new_array(sizeof(dmnsn_pigment *)); - sky_sphere->trans = dmnsn_identity_matrix(); + sky_sphere->trans = dmnsn_identity_matrix(); + sky_sphere->refcount = 1; return sky_sphere; } void dmnsn_delete_sky_sphere(dmnsn_sky_sphere *sky_sphere) { - if (sky_sphere) { + if (DMNSN_DECREF(sky_sphere)) { DMNSN_ARRAY_FOREACH (dmnsn_pigment **, pigment, sky_sphere->pigments) { dmnsn_delete_pigment(*pigment); } @@ -61,11 +62,8 @@ dmnsn_sky_sphere_color(const dmnsn_sky_sphere *sky_sphere, dmnsn_vector d) dmnsn_color color = dmnsn_clear; DMNSN_ARRAY_FOREACH (const dmnsn_pigment **, pigment, sky_sphere->pigments) { - dmnsn_pigment_fn *pigment_fn = (*pigment)->pigment_fn; - if (pigment_fn) { - dmnsn_color sky = pigment_fn(*pigment, d); - color = dmnsn_apply_filter(color, sky); - } + dmnsn_color sky = dmnsn_evaluate_pigment(*pigment, d); + color = dmnsn_apply_filter(color, sky); } return color; diff --git a/libdimension/tests/prtree.c b/libdimension/tests/prtree.c index 86aaa4e..5fb2f10 100644 --- a/libdimension/tests/prtree.c +++ b/libdimension/tests/prtree.c @@ -62,17 +62,17 @@ main(void) dmnsn_die_on_warnings(true); const size_t nobjects = 128; - dmnsn_scene *scene = dmnsn_new_scene(); + dmnsn_array *objects = dmnsn_new_array(sizeof(dmnsn_object *)); for (size_t i = 0; i < nobjects; ++i) { dmnsn_object *object = dmnsn_new_object(); dmnsn_randomize_bounding_box(object); object->intersection_fn = dmnsn_fake_intersection_fn; - dmnsn_initialize_object(object); - dmnsn_scene_add_object(scene, object); + object->trans_inv = dmnsn_identity_matrix(); + dmnsn_array_push(objects, &object); } - dmnsn_prtree *prtree = dmnsn_new_prtree(scene->objects); + dmnsn_prtree *prtree = dmnsn_new_prtree(objects); dmnsn_intersection intersection; dmnsn_line ray = dmnsn_new_line( @@ -93,6 +93,9 @@ main(void) } dmnsn_delete_prtree(prtree); - dmnsn_delete_scene(scene); + DMNSN_ARRAY_FOREACH (dmnsn_object **, object, objects) { + dmnsn_delete_object(*object); + } + dmnsn_delete_array(objects); return EXIT_SUCCESS; } diff --git a/libdimension/tests/render.c b/libdimension/tests/render.c index 85742d0..13a4b2c 100644 --- a/libdimension/tests/render.c +++ b/libdimension/tests/render.c @@ -23,7 +23,7 @@ #include <stdio.h> /* - * Test scene -- code version of tests/dimension/demo.pov + * Test scene */ static dmnsn_scene * dmnsn_new_test_scene(void) @@ -31,16 +31,20 @@ dmnsn_new_test_scene(void) /* Allocate a new scene */ dmnsn_scene *scene = dmnsn_new_scene(); - /* Default finish */ - scene->default_texture->finish = dmnsn_new_finish_combination( - dmnsn_new_ambient_finish( - dmnsn_color_mul(0.01, dmnsn_white) - ), - dmnsn_new_diffuse_finish(0.3) + /* Default texture */ + scene->default_texture->pigment = dmnsn_new_solid_pigment(dmnsn_black); + dmnsn_finish *default_finish = &scene->default_texture->finish; + default_finish->ambient = dmnsn_new_basic_ambient( + dmnsn_color_from_sRGB(dmnsn_color_mul(0.1, dmnsn_white)) + ); + default_finish->diffuse = dmnsn_new_lambertian( + dmnsn_color_intensity( + dmnsn_color_from_sRGB(dmnsn_color_mul(0.6, dmnsn_white)) + ) ); /* Allocate a canvas */ - dmnsn_scene_set_canvas(scene, dmnsn_new_canvas(768, 480)); + scene->canvas = dmnsn_new_canvas(768, 480); /* Set up the transformation matrix for the perspective camera */ dmnsn_matrix trans = dmnsn_scale_matrix( @@ -62,9 +66,8 @@ dmnsn_new_test_scene(void) ); /* Create a perspective camera */ - dmnsn_camera *camera = dmnsn_new_perspective_camera(); - camera->trans = trans; - dmnsn_scene_set_camera(scene, camera); + scene->camera = dmnsn_new_perspective_camera(); + scene->camera->trans = trans; /* Background color */ scene->background = dmnsn_clear; @@ -88,7 +91,7 @@ dmnsn_new_test_scene(void) dmnsn_new_vector(-15.0, 20.0, 10.0), dmnsn_white ); - dmnsn_scene_add_light(scene, light); + dmnsn_array_push(scene->lights, &light); /* Now make our objects */ @@ -96,15 +99,18 @@ dmnsn_new_test_scene(void) cube->trans = dmnsn_rotation_matrix( dmnsn_new_vector(dmnsn_radians(45.0), 0.0, 0.0) ); - cube->texture = dmnsn_new_texture(); dmnsn_color cube_color = dmnsn_blue; cube_color.trans = 0.75; cube_color.filter = 1.0/3.0; + cube->texture = dmnsn_new_texture(); cube->texture->pigment = dmnsn_new_solid_pigment(cube_color); - dmnsn_color reflect = dmnsn_color_mul(0.5, dmnsn_white); - cube->texture->finish = dmnsn_new_reflective_finish(reflect, reflect, 1.0); + dmnsn_color reflect = dmnsn_color_from_sRGB( + dmnsn_color_mul(0.5, dmnsn_white) + ); + cube->texture->finish.reflection + = dmnsn_new_basic_reflection(reflect, reflect, 1.0); cube->interior = dmnsn_new_interior(); cube->interior->ior = 1.1; @@ -112,11 +118,11 @@ dmnsn_new_test_scene(void) dmnsn_object *sphere = dmnsn_new_sphere(); sphere->texture = dmnsn_new_texture(); sphere->texture->pigment = dmnsn_new_solid_pigment(dmnsn_green); - sphere->texture->finish = dmnsn_new_phong_finish(0.2, 40.0); + sphere->texture->finish.specular = dmnsn_new_phong(0.2, 40.0); sphere->trans = dmnsn_scale_matrix(dmnsn_new_vector(1.25, 1.25, 1.25)); dmnsn_object *csg = dmnsn_new_csg_difference(cube, sphere); - dmnsn_scene_add_object(scene, csg); + dmnsn_array_push(scene->objects, &csg); dmnsn_array *arrow_array = dmnsn_new_array(sizeof(dmnsn_object *)); @@ -149,12 +155,13 @@ dmnsn_new_test_scene(void) arrow->texture->pigment = dmnsn_new_color_map_pigment(gradient, gradient_color_map, DMNSN_PIGMENT_MAP_SRGB); + arrow->texture->trans = dmnsn_matrix_mul( dmnsn_translation_matrix(dmnsn_new_vector(0.0, -1.25, 0.0)), dmnsn_scale_matrix(dmnsn_new_vector(1.0, 2.75, 1.0)) ); - dmnsn_scene_add_object(scene, arrow); + dmnsn_array_push(scene->objects, &arrow); dmnsn_delete_array(arrow_array); dmnsn_array *torus_array = dmnsn_new_array(sizeof(dmnsn_object *)); @@ -176,13 +183,13 @@ dmnsn_new_test_scene(void) ); torii->texture = dmnsn_new_texture(); torii->texture->pigment = dmnsn_new_solid_pigment(dmnsn_blue); - torii->texture->finish = dmnsn_new_ambient_finish(dmnsn_white); - dmnsn_scene_add_object(scene, torii); + torii->texture->finish.ambient + = dmnsn_new_basic_ambient(dmnsn_white); + dmnsn_array_push(scene->objects, &torii); dmnsn_delete_array(torus_array); dmnsn_object *plane = dmnsn_new_plane(dmnsn_new_vector(0.0, 1.0, 0.0)); plane->trans = dmnsn_translation_matrix(dmnsn_new_vector(0.0, -2.0, 0.0)); - plane->texture = dmnsn_new_texture(); dmnsn_pattern *checker1 = dmnsn_new_checker_pattern(); dmnsn_pattern *checker2 = dmnsn_new_checker_pattern(); dmnsn_map *checker_color_map = dmnsn_new_color_map(); @@ -197,13 +204,14 @@ dmnsn_new_test_scene(void) dmnsn_map *checker_pigment_map = dmnsn_new_pigment_map(); dmnsn_add_map_entry(checker_pigment_map, 0.0, &pigment1); dmnsn_add_map_entry(checker_pigment_map, 1.0, &pigment2); + plane->texture = dmnsn_new_texture(); plane->texture->pigment = dmnsn_new_pigment_map_pigment(checker2, checker_pigment_map, DMNSN_PIGMENT_MAP_REGULAR); plane->texture->pigment->quick_color = dmnsn_color_from_sRGB( dmnsn_new_color(1.0, 0.5, 0.75) ); - dmnsn_scene_add_object(scene, plane); + dmnsn_array_push(scene->objects, &plane); return scene; } diff --git a/libdimension/texture.c b/libdimension/texture.c index c65c913..6f52abe 100644 --- a/libdimension/texture.c +++ b/libdimension/texture.c @@ -31,10 +31,10 @@ dmnsn_new_texture(void) { dmnsn_texture *texture = dmnsn_malloc(sizeof(dmnsn_texture)); texture->pigment = NULL; - texture->finish = NULL; + texture->finish = dmnsn_new_finish(); texture->trans = dmnsn_identity_matrix(); - texture->refcount = 0; - texture->should_init = true; + texture->refcount = 1; + texture->initialized = false; return texture; } @@ -42,7 +42,7 @@ dmnsn_new_texture(void) void dmnsn_delete_texture(dmnsn_texture *texture) { - if (texture && DMNSN_DECREF(texture)) { + if (DMNSN_DECREF(texture)) { dmnsn_delete_finish(texture->finish); dmnsn_delete_pigment(texture->pigment); dmnsn_free(texture); @@ -53,10 +53,34 @@ dmnsn_delete_texture(dmnsn_texture *texture) void dmnsn_initialize_texture(dmnsn_texture *texture) { + dmnsn_assert(!texture->initialized, "Texture double-initialized."); + texture->initialized = true; + texture->trans_inv = dmnsn_matrix_inverse(texture->trans); - if (texture->pigment) { - texture->pigment->trans - = dmnsn_matrix_mul(texture->trans, texture->pigment->trans); + + if (!texture->pigment->initialized) { + texture->pigment->trans = dmnsn_matrix_mul(texture->trans, + texture->pigment->trans); dmnsn_initialize_pigment(texture->pigment); } } + +/* Cascade a texture */ +void +dmnsn_texture_cascade(dmnsn_texture *default_texture, + dmnsn_texture **texturep) +{ + if (!*texturep) { + *texturep = default_texture; + DMNSN_INCREF(*texturep); + } + + dmnsn_texture *texture = *texturep; + + if (!texture->pigment) { + texture->pigment = default_texture->pigment; + DMNSN_INCREF(texture->pigment); + } + + dmnsn_finish_cascade(&default_texture->finish, &texture->finish); +} |