summaryrefslogtreecommitdiffstats
path: root/dimension/realize.c
diff options
context:
space:
mode:
authorTavian Barnes <tavianator@gmail.com>2011-05-15 16:10:51 -0600
committerTavian Barnes <tavianator@gmail.com>2011-05-15 16:10:51 -0600
commite5e88afdbf158e6df8f8c3328f308512819d9cf3 (patch)
tree2a011762c07c0087defcdc1f1022ffe32d532f49 /dimension/realize.c
parenta5a6b94c038e01ebf1e2de0a0774a69b02fb8e1e (diff)
downloaddimension-e5e88afdbf158e6df8f8c3328f308512819d9cf3.tar.xz
Rip out old client.
Diffstat (limited to 'dimension/realize.c')
-rw-r--r--dimension/realize.c1450
1 files changed, 0 insertions, 1450 deletions
diff --git a/dimension/realize.c b/dimension/realize.c
deleted file mode 100644
index c9a507d..0000000
--- a/dimension/realize.c
+++ /dev/null
@@ -1,1450 +0,0 @@
-/*************************************************************************
- * Copyright (C) 2009-2011 Tavian Barnes <tavianator@tavianator.com> *
- * *
- * This file is part of Dimension. *
- * *
- * Dimension is free software; you can redistribute it and/or modify it *
- * under the terms of the GNU General Public License as published by the *
- * Free Software Foundation; either version 3 of the License, or (at *
- * your option) any later version. *
- * *
- * Dimension 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 *
- * General Public License for more details. *
- * *
- * You should have received a copy of the GNU General Public License *
- * along with this program. If not, see <http://www.gnu.org/licenses/>. *
- *************************************************************************/
-
-#include "realize.h"
-#include "parse.h"
-#include "utility.h"
-#include <math.h>
-#include <fenv.h>
-#include <stdio.h>
-#include <stdbool.h>
-
-static long
-dmnsn_realize_integer(dmnsn_astnode astnode)
-{
- switch (astnode.type) {
- case DMNSN_AST_INTEGER:
- return *(long *)astnode.ptr;
- case DMNSN_AST_FLOAT:
- {
- feclearexcept(FE_ALL_EXCEPT);
- long ret = lrint(*(double *)astnode.ptr);
- if (fetestexcept(FE_INVALID | FE_DIVBYZERO | FE_OVERFLOW | FE_UNDERFLOW))
- dmnsn_error("Float out of range of integer.");
- return ret;
- }
-
- default:
- dmnsn_assert(false, "Invalid integer.");
- return 0; /* Silence compiler warning */
- }
-}
-
-static double
-dmnsn_realize_float(dmnsn_astnode astnode)
-{
- switch (astnode.type) {
- case DMNSN_AST_FLOAT:
- return *(double *)astnode.ptr;
- case DMNSN_AST_INTEGER:
- return *(long *)astnode.ptr;
-
- default:
- dmnsn_assert(false, "Invalid float.");
- return 0; /* Silence compiler warning */
- }
-}
-
-/* dmnsn_realize_string is an API function, so call this dmnsn_realize_str */
-static const char*
-dmnsn_realize_str(dmnsn_astnode astnode)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_STRING, "Expected a string.");
- return astnode.ptr;
-}
-
-static dmnsn_vector
-dmnsn_realize_vector(dmnsn_astnode astnode)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_VECTOR, "Expected a vector.");
-
- dmnsn_astnode xnode, ynode, znode;
- dmnsn_array_get(astnode.children, 0, &xnode);
- dmnsn_array_get(astnode.children, 1, &ynode);
- dmnsn_array_get(astnode.children, 2, &znode);
-
- double x = dmnsn_realize_float(xnode),
- y = dmnsn_realize_float(ynode),
- z = dmnsn_realize_float(znode);
-
- return dmnsn_new_vector(x, y, z);
-}
-
-static dmnsn_color
-dmnsn_realize_color(dmnsn_astnode astnode)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_VECTOR, "Expected a vector.");
-
- dmnsn_astnode rnode, gnode, bnode, fnode, tnode;
- dmnsn_array_get(astnode.children, 0, &rnode);
- dmnsn_array_get(astnode.children, 1, &gnode);
- dmnsn_array_get(astnode.children, 2, &bnode);
- dmnsn_array_get(astnode.children, 3, &fnode);
- dmnsn_array_get(astnode.children, 4, &tnode);
-
- return dmnsn_new_color5(dmnsn_realize_float(rnode),
- dmnsn_realize_float(gnode),
- dmnsn_realize_float(bnode),
- dmnsn_realize_float(fnode),
- dmnsn_realize_float(tnode));
-}
-
-static dmnsn_matrix
-dmnsn_realize_translation(dmnsn_astnode astnode)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_TRANSLATION,
- "Expected a translation.");
-
- dmnsn_astnode trans_node;
- dmnsn_array_get(astnode.children, 0, &trans_node);
- dmnsn_vector trans = dmnsn_realize_vector(trans_node);
-
- return dmnsn_translation_matrix(trans);
-}
-
-static dmnsn_matrix
-dmnsn_realize_scale(dmnsn_astnode astnode)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_SCALE, "Expected a scale.");
-
- dmnsn_astnode scale_node;
- dmnsn_array_get(astnode.children, 0, &scale_node);
- dmnsn_vector scale = dmnsn_realize_vector(scale_node);
-
- return dmnsn_scale_matrix(scale);
-}
-
-static dmnsn_matrix
-dmnsn_realize_rotation(dmnsn_astnode astnode)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_ROTATION, "Expected a rotation.");
-
- dmnsn_astnode angle_node;
- dmnsn_array_get(astnode.children, 0, &angle_node);
-
- dmnsn_vector angle = dmnsn_vector_mul(
- dmnsn_radians(1.0),
- dmnsn_realize_vector(angle_node)
- );
-
- dmnsn_matrix trans = dmnsn_rotation_matrix(
- dmnsn_new_vector(angle.x, 0.0, 0.0)
- );
- trans = dmnsn_matrix_mul(
- dmnsn_rotation_matrix(dmnsn_new_vector(0.0, angle.y, 0.0)),
- trans
- );
- trans = dmnsn_matrix_mul(
- dmnsn_rotation_matrix(dmnsn_new_vector(0.0, 0.0, angle.z)),
- trans
- );
-
- return trans;
-}
-
-static dmnsn_matrix
-dmnsn_realize_matrix(dmnsn_astnode astnode)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_MATRIX, "Expected a matrix.");
-
- dmnsn_astnode *children = dmnsn_array_first(astnode.children);
- dmnsn_matrix trans;
-
- trans.n[0][0] = dmnsn_realize_float(children[0]);
- trans.n[0][1] = dmnsn_realize_float(children[1]);
- trans.n[0][2] = dmnsn_realize_float(children[2]);
- trans.n[0][3] = dmnsn_realize_float(children[9]);
-
- trans.n[1][0] = dmnsn_realize_float(children[3]);
- trans.n[1][1] = dmnsn_realize_float(children[4]);
- trans.n[1][2] = dmnsn_realize_float(children[5]);
- trans.n[1][3] = dmnsn_realize_float(children[10]);
-
- trans.n[2][0] = dmnsn_realize_float(children[6]);
- trans.n[2][1] = dmnsn_realize_float(children[7]);
- trans.n[2][2] = dmnsn_realize_float(children[8]);
- trans.n[2][3] = dmnsn_realize_float(children[11]);
-
- return trans;
-}
-
-static dmnsn_matrix
-dmnsn_realize_transformation(dmnsn_astnode astnode)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_TRANSFORMATION,
- "Expected a transformation.");
-
- dmnsn_matrix trans = dmnsn_identity_matrix();
-
- DMNSN_ARRAY_FOREACH (dmnsn_astnode *, child, astnode.children) {
- switch (child->type) {
- case DMNSN_AST_TRANSLATION:
- trans = dmnsn_matrix_mul(trans, dmnsn_realize_translation(*child));
- break;
- case DMNSN_AST_SCALE:
- trans = dmnsn_matrix_mul(trans, dmnsn_realize_scale(*child));
- break;
- case DMNSN_AST_ROTATION:
- trans = dmnsn_matrix_mul(trans, dmnsn_realize_rotation(*child));
- break;
- case DMNSN_AST_MATRIX:
- trans = dmnsn_matrix_mul(trans, dmnsn_realize_matrix(*child));
- break;
- case DMNSN_AST_INVERSE:
- trans = dmnsn_matrix_inverse(trans);
- break;
- case DMNSN_AST_TRANSFORMATION:
- trans = dmnsn_matrix_mul(trans, dmnsn_realize_transformation(*child));
- break;
-
- default:
- dmnsn_assert(false, "Invalid transformation type.");
- break;
- }
- }
-
- return trans;
-}
-
-static void
-dmnsn_realize_global_settings(dmnsn_astnode astnode, dmnsn_scene *scene)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_GLOBAL_SETTINGS,
- "Expected global settings.");
-
- DMNSN_ARRAY_FOREACH (dmnsn_astnode *, item, astnode.children) {
- dmnsn_astnode child;
-
- switch (item->type) {
- case DMNSN_AST_ADC_BAILOUT:
- dmnsn_array_get(item->children, 0, &child);
- scene->adc_bailout = dmnsn_realize_float(child);
- break;
-
- case DMNSN_AST_AMBIENT:
- dmnsn_array_get(item->children, 0, &child);
- scene->ambient = dmnsn_realize_color(child);
- scene->ambient.filter = 0.0;
- scene->ambient.trans = 0.0;
- break;
-
- case DMNSN_AST_MAX_TRACE_LEVEL:
- dmnsn_array_get(item->children, 0, &child);
- scene->reclimit = dmnsn_realize_integer(child);
- break;
-
- case DMNSN_AST_ASSUMED_GAMMA:
- case DMNSN_AST_CHARSET:
- case DMNSN_AST_MAX_INTERSECTIONS:
- /* Ignored settings */
- break;
-
- default:
- dmnsn_assert(false, "Invalid global settings item.");
- }
- }
-}
-
-static dmnsn_pigment *dmnsn_realize_pigment(dmnsn_astnode astnode);
-
-static dmnsn_sky_sphere *
-dmnsn_realize_sky_sphere(dmnsn_astnode astnode)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_SKY_SPHERE, "Expected a sky sphere.");
-
- dmnsn_sky_sphere *sky_sphere = dmnsn_new_sky_sphere();
-
- DMNSN_ARRAY_FOREACH (dmnsn_astnode *, item, astnode.children) {
- switch (item->type) {
- case DMNSN_AST_PIGMENT:
- {
- dmnsn_pigment *pigment = dmnsn_realize_pigment(*item);
- dmnsn_array_push(sky_sphere->pigments, &pigment);
- break;
- }
-
- case DMNSN_AST_TRANSFORMATION:
- sky_sphere->trans = dmnsn_matrix_mul(
- dmnsn_realize_transformation(*item),
- sky_sphere->trans
- );
- break;
-
- default:
- dmnsn_assert(false, "Invalid sky sphere item.");
- }
- }
-
- return sky_sphere;
-}
-
-static dmnsn_camera *
-dmnsn_realize_camera(dmnsn_astnode astnode)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_CAMERA, "Expected a camera.");
-
- dmnsn_astnode_type camera_type = DMNSN_AST_PERSPECTIVE;
- dmnsn_vector location = dmnsn_new_vector(0.0, 0.0, 0.0);
- dmnsn_vector direction = dmnsn_new_vector(0.0, 0.0, 1.0);
- dmnsn_vector right = dmnsn_new_vector(4.0/3.0, 0.0, 0.0);
- dmnsn_vector up = dmnsn_new_vector(0.0, 1.0, 0.0);
- dmnsn_vector sky = dmnsn_new_vector(0.0, 1.0, 0.0);
- dmnsn_matrix trans = dmnsn_identity_matrix();
-
- dmnsn_camera *camera = NULL;
-
- DMNSN_ARRAY_FOREACH (dmnsn_astnode *, item, astnode.children) {
- dmnsn_astnode child;
-
- switch (item->type) {
- /* Camera types */
- case DMNSN_AST_PERSPECTIVE:
- camera_type = item->type;
- break;
-
- /* Camera vectors */
- case DMNSN_AST_LOCATION:
- dmnsn_array_get(item->children, 0, &child);
- location = dmnsn_realize_vector(child);
- break;
- case DMNSN_AST_RIGHT:
- dmnsn_array_get(item->children, 0, &child);
- right = dmnsn_realize_vector(child);
- break;
- case DMNSN_AST_UP:
- dmnsn_array_get(item->children, 0, &child);
- right = dmnsn_realize_vector(child);
- break;
- case DMNSN_AST_SKY:
- dmnsn_array_get(item->children, 0, &child);
- sky = dmnsn_realize_vector(child);
- break;
- case DMNSN_AST_DIRECTION:
- dmnsn_array_get(item->children, 0, &child);
- direction = dmnsn_realize_vector(child);
- break;
-
- /* Camera modifiers */
-
- case DMNSN_AST_LOOK_AT:
- {
- dmnsn_array_get(item->children, 0, &child);
- dmnsn_vector look_at = dmnsn_realize_vector(child);
-
- /* Line the camera up with the sky */
-
- dmnsn_matrix sky1 = dmnsn_rotation_matrix(
- dmnsn_vector_mul(
- dmnsn_vector_axis_angle(up, sky, direction),
- dmnsn_vector_normalize(direction)
- )
- );
- up = dmnsn_transform_vector(sky1, up);
- right = dmnsn_transform_vector(sky1, right);
-
- dmnsn_matrix sky2 = dmnsn_rotation_matrix(
- dmnsn_vector_mul(
- dmnsn_vector_axis_angle(up, sky, right),
- dmnsn_vector_normalize(right)
- )
- );
- up = dmnsn_transform_vector(sky2, up);
- direction = dmnsn_transform_vector(sky2, direction);
-
- /* Line up the camera with the look_at */
-
- look_at = dmnsn_vector_sub(look_at, location);
- dmnsn_matrix look_at1 = dmnsn_rotation_matrix(
- dmnsn_vector_mul(
- dmnsn_vector_axis_angle(direction, look_at, up),
- dmnsn_vector_normalize(up)
- )
- );
- right = dmnsn_transform_vector(look_at1, right);
- direction = dmnsn_transform_vector(look_at1, direction);
-
- dmnsn_matrix look_at2 = dmnsn_rotation_matrix(
- dmnsn_vector_mul(
- dmnsn_vector_axis_angle(direction, look_at, right),
- dmnsn_vector_normalize(right)
- )
- );
- up = dmnsn_transform_vector(look_at2, up);
- direction = dmnsn_transform_vector(look_at2, direction);
-
- break;
- }
-
- case DMNSN_AST_ANGLE:
- {
- dmnsn_array_get(item->children, 0, &child);
- double angle = dmnsn_radians(dmnsn_realize_float(child));
- direction = dmnsn_vector_mul(
- 0.5*dmnsn_vector_norm(right)/tan(angle/2.0),
- dmnsn_vector_normalize(direction)
- );
- break;
- }
-
- /* Transformations */
- case DMNSN_AST_TRANSFORMATION:
- trans = dmnsn_matrix_mul(dmnsn_realize_transformation(*item), trans);
- break;
-
- default:
- dmnsn_assert(false, "Invalid camera item.");
- break;
- }
- }
-
- switch (camera_type) {
- case DMNSN_AST_PERSPECTIVE:
- {
- /* These multiplications are in right-to-left order so that user
- transformations happen after camera alignment */
-
- trans = dmnsn_matrix_mul(trans, dmnsn_translation_matrix(location));
-
- /* Align y with `up' */
-
- dmnsn_matrix align = dmnsn_rotation_matrix(
- dmnsn_vector_mul(
- dmnsn_vector_axis_angle(dmnsn_y, up, dmnsn_z),
- dmnsn_z
- )
- );
-
- dmnsn_vector x = dmnsn_transform_vector(align, dmnsn_x);
- dmnsn_vector y = dmnsn_transform_vector(align, dmnsn_y);
-
- align = dmnsn_matrix_mul(
- dmnsn_rotation_matrix(
- dmnsn_vector_mul(
- dmnsn_vector_axis_angle(y, up, x),
- x
- )
- ),
- align
- );
-
- /* Align x with `right' */
-
- align = dmnsn_matrix_mul(
- dmnsn_rotation_matrix(
- dmnsn_vector_mul(
- dmnsn_vector_axis_angle(x, right, up),
- dmnsn_vector_normalize(up)
- )
- ),
- align
- );
-
- trans = dmnsn_matrix_mul(trans, align);
-
- /* Scale the camera with `up', `right', and `direction' */
- trans = dmnsn_matrix_mul(
- trans,
- dmnsn_scale_matrix(
- dmnsn_new_vector(
- dmnsn_vector_norm(right),
- dmnsn_vector_norm(up),
- dmnsn_vector_norm(direction)
- )
- )
- );
-
- camera = dmnsn_new_perspective_camera();
- break;
- }
-
- default:
- dmnsn_assert(false, "Unsupported camera type.");
- }
-
- camera->trans = trans;
- return camera;
-}
-
-static dmnsn_pattern *
-dmnsn_realize_pattern(dmnsn_astnode astnode)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_PATTERN, "Expected a pattern.");
-
- dmnsn_astnode type;
- dmnsn_array_get(astnode.children, 0, &type);
-
- dmnsn_pattern *pattern = NULL;
-
- switch (type.type) {
- case DMNSN_AST_CHECKER:
- pattern = dmnsn_new_checker_pattern();
- break;
- case DMNSN_AST_GRADIENT:
- {
- dmnsn_astnode orientation;
- dmnsn_array_get(type.children, 0, &orientation);
- dmnsn_vector v = dmnsn_realize_vector(orientation);
- pattern = dmnsn_new_gradient_pattern(v);
- break;
- }
-
- default:
- dmnsn_assert(false, "Unexpected pattern type.");
- }
-
- return pattern;
-}
-
-static dmnsn_map *
-dmnsn_realize_color_list(dmnsn_astnode astnode)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_COLOR_LIST, "Expected a color list.");
-
- dmnsn_map *color_map = dmnsn_new_color_map();
-
- double n = 0.0, i = 1.0/(dmnsn_array_size(astnode.children) - 1);
- DMNSN_ARRAY_FOREACH (dmnsn_astnode *, entry, astnode.children) {
- dmnsn_color color = dmnsn_realize_color(*entry);
- dmnsn_add_map_entry(color_map, n, &color);
- n += i;
- }
-
- return color_map;
-}
-
-static dmnsn_map *
-dmnsn_realize_color_map(dmnsn_astnode astnode)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_COLOR_MAP, "Expected a color_map.");
-
- dmnsn_map *color_map = dmnsn_new_color_map();
-
- DMNSN_ARRAY_FOREACH (dmnsn_astnode *, entry, astnode.children) {
- dmnsn_assert(entry->type == DMNSN_AST_COLOR_MAP_ENTRY,
- "Expected a color_map entry.");
-
- dmnsn_astnode n_node, color_node;
- dmnsn_array_get(entry->children, 0, &n_node);
- dmnsn_array_get(entry->children, 1, &color_node);
-
- double n = dmnsn_realize_float(n_node);
- dmnsn_color color = dmnsn_realize_color(color_node);
-
- dmnsn_add_map_entry(color_map, n, &color);
- }
-
- return color_map;
-}
-
-static dmnsn_map *
-dmnsn_realize_pigment_list(dmnsn_astnode astnode)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_PIGMENT_LIST,
- "Expected a pigment list.");
-
- dmnsn_map *pigment_map = dmnsn_new_pigment_map();
-
- double n = 0.0, i = 1.0/(dmnsn_array_size(astnode.children) - 1);
- DMNSN_ARRAY_FOREACH (dmnsn_astnode *, entry, astnode.children) {
- dmnsn_pigment *pigment = dmnsn_realize_pigment(*entry);
- dmnsn_add_map_entry(pigment_map, n, &pigment);
- n += i;
- }
-
- return pigment_map;
-}
-
-static dmnsn_map *
-dmnsn_realize_pigment_map(dmnsn_astnode astnode)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_PIGMENT_MAP,
- "Expected a pigment_map.");
-
- dmnsn_map *pigment_map = dmnsn_new_pigment_map();
-
- DMNSN_ARRAY_FOREACH (dmnsn_astnode *, entry, astnode.children) {
- dmnsn_assert(entry->type == DMNSN_AST_PIGMENT_MAP_ENTRY,
- "Expected a pigment_map entry.");
-
- dmnsn_astnode n_node, pigment_node;
- dmnsn_array_get(entry->children, 0, &n_node);
- dmnsn_array_get(entry->children, 1, &pigment_node);
-
- double n = dmnsn_realize_float(n_node);
- dmnsn_pigment *pigment = dmnsn_realize_pigment(pigment_node);
-
- dmnsn_add_map_entry(pigment_map, n, &pigment);
- }
-
- return pigment_map;
-}
-
-static dmnsn_pigment *
-dmnsn_realize_pattern_pigment(dmnsn_astnode type, dmnsn_astnode modifiers)
-{
- dmnsn_assert(modifiers.type == DMNSN_AST_PIGMENT_MODIFIERS,
- "Expected pigment modifiers");
-
- dmnsn_pattern *pattern = dmnsn_realize_pattern(type);
- dmnsn_map *color_map = NULL, *pigment_map = NULL;
-
- /* Set up the map */
- DMNSN_ARRAY_FOREACH_REVERSE (dmnsn_astnode *, modifier, modifiers.children) {
- switch (modifier->type) {
- case DMNSN_AST_COLOR_LIST:
- color_map = dmnsn_realize_color_list(*modifier);
- break;
- case DMNSN_AST_COLOR_MAP:
- color_map = dmnsn_realize_color_map(*modifier);
- break;
-
- case DMNSN_AST_PIGMENT_LIST:
- pigment_map = dmnsn_realize_pigment_list(*modifier);
- break;
- case DMNSN_AST_PIGMENT_MAP:
- pigment_map = dmnsn_realize_pigment_map(*modifier);
- break;
-
- default:
- break;
- }
-
- if (color_map || pigment_map)
- break;
- }
-
- /* Now add the default values */
-
- dmnsn_astnode pattern_type;
- dmnsn_array_get(type.children, 0, &pattern_type);
-
- switch (pattern_type.type) {
- case DMNSN_AST_CHECKER:
- /* Default checker pattern is blue and green */
- if (!color_map && !pigment_map) {
- color_map = dmnsn_new_color_map();
- if (dmnsn_map_size(color_map) < 1)
- dmnsn_add_map_entry(color_map, 0.0, &dmnsn_blue);
- if (dmnsn_map_size(color_map) < 2)
- dmnsn_add_map_entry(color_map, 1.0, &dmnsn_green);
- }
- break;
-
- default:
- /* Default map is grayscale */
- if (!color_map && !pigment_map) {
- color_map = dmnsn_new_color_map();
- dmnsn_add_map_entry(color_map, 0.0, &dmnsn_black);
- dmnsn_add_map_entry(color_map, 1.0, &dmnsn_white);
- }
- break;
- }
-
- dmnsn_pigment *pigment = NULL;
- if (color_map) {
- pigment = dmnsn_new_color_map_pigment(pattern, color_map);
- } else if (pigment_map) {
- pigment = dmnsn_new_pigment_map_pigment(pattern, pigment_map);
- } else {
- dmnsn_assert(false, "No appropriate map constructed.");
- }
- return pigment;
-}
-
-static void
-dmnsn_realize_pigment_modifiers(dmnsn_astnode astnode, dmnsn_pigment *pigment)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_PIGMENT_MODIFIERS,
- "Expected pigment modifiers.");
-
- DMNSN_ARRAY_FOREACH (dmnsn_astnode *, modifier, astnode.children) {
- switch (modifier->type) {
- case DMNSN_AST_TRANSFORMATION:
- pigment->trans = dmnsn_matrix_mul(
- dmnsn_realize_transformation(*modifier),
- pigment->trans
- );
- break;
-
- case DMNSN_AST_QUICK_COLOR:
- {
- dmnsn_astnode quick_color;
- dmnsn_array_get(modifier->children, 0, &quick_color);
- pigment->quick_color = dmnsn_realize_color(quick_color);
- break;
- }
-
- case DMNSN_AST_COLOR_LIST:
- case DMNSN_AST_COLOR_MAP:
- case DMNSN_AST_PIGMENT_LIST:
- case DMNSN_AST_PIGMENT_MAP:
- /* Already handled by dmnsn_realize_pattern_pigment() */
- break;
-
- default:
- dmnsn_assert(false, "Invalid pigment modifier.");
- }
- }
-}
-
-static dmnsn_pigment *
-dmnsn_realize_pigment(dmnsn_astnode astnode)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_PIGMENT, "Expected a pigment.");
-
- dmnsn_pigment *pigment = NULL;
-
- dmnsn_astnode type_node, modifiers;
- dmnsn_array_get(astnode.children, 0, &type_node);
- dmnsn_array_get(astnode.children, 1, &modifiers);
-
- switch (type_node.type) {
- case DMNSN_AST_NONE:
- break;
-
- case DMNSN_AST_VECTOR:
- {
- dmnsn_color color = dmnsn_realize_color(type_node);
- pigment = dmnsn_new_solid_pigment(color);
- break;
- }
-
- case DMNSN_AST_PATTERN:
- {
- pigment = dmnsn_realize_pattern_pigment(type_node, modifiers);
- break;
- }
-
- case DMNSN_AST_IMAGE_MAP:
- {
- dmnsn_astnode filetype, strnode;
- dmnsn_array_get(type_node.children, 0, &filetype);
- dmnsn_array_get(type_node.children, 1, &strnode);
-
- const char *path = dmnsn_realize_str(strnode);
- FILE *file = fopen(path, "rb");
- if (!file) {
- dmnsn_error("Couldn't open image file.");
- }
-
- dmnsn_canvas *canvas;
- switch (filetype.type) {
- case DMNSN_AST_PNG:
- canvas = dmnsn_png_read_canvas(file);
- if (!canvas) {
- dmnsn_error("Invalid PNG file.");
- }
- pigment = dmnsn_new_canvas_pigment(canvas);
- break;
-
- default:
- dmnsn_assert(false, "Invalid image_map type.");
- break;
- }
- break;
- }
-
- default:
- dmnsn_assert(false, "Invalid pigment type.");
- }
-
- dmnsn_realize_pigment_modifiers(modifiers, pigment);
-
- return pigment;
-}
-
-static dmnsn_finish *
-dmnsn_realize_reflection(dmnsn_astnode astnode)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_REFLECTION, "Expected a reflection.");
-
- dmnsn_astnode min_node, max_node;
- dmnsn_array_get(astnode.children, 0, &min_node);
- dmnsn_array_get(astnode.children, 1, &max_node);
-
- dmnsn_color min = dmnsn_realize_color(min_node);
- dmnsn_color max = dmnsn_realize_color(max_node);
-
- double falloff = 1.0;
-
- dmnsn_astnode items;
- dmnsn_array_get(astnode.children, 2, &items);
-
- DMNSN_ARRAY_FOREACH (dmnsn_astnode *, item, items.children) {
- dmnsn_astnode child;
-
- switch (item->type) {
- case DMNSN_AST_FALLOFF:
- dmnsn_array_get(item->children, 0, &child);
- falloff = dmnsn_realize_float(child);
- break;
-
- default:
- dmnsn_assert(false, "Invalid reflection item.");
- }
- }
-
- dmnsn_finish *reflection = dmnsn_new_reflective_finish(min, max, falloff);
-
- return reflection;
-}
-
-static dmnsn_finish *
-dmnsn_realize_finish(dmnsn_astnode astnode)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_FINISH, "Expected a finish.");
-
- dmnsn_finish *finish = dmnsn_new_finish();
-
- dmnsn_color ambient = dmnsn_black;
- bool ambient_set = false;
-
- double diffuse = 0.0;
- bool diffuse_set = false;
-
- double phong = 0.0;
- double phong_size = 40.0;
-
- dmnsn_finish *reflection = NULL;
-
- DMNSN_ARRAY_FOREACH (dmnsn_astnode *, item, astnode.children) {
- dmnsn_astnode child;
-
- switch (item->type) {
- case DMNSN_AST_AMBIENT:
- dmnsn_array_get(item->children, 0, &child);
- ambient = dmnsn_realize_color(child);
- ambient_set = true;
- break;
-
- case DMNSN_AST_DIFFUSE:
- dmnsn_array_get(item->children, 0, &child);
- diffuse = dmnsn_realize_float(child);
- diffuse_set = true;
- break;
-
- case DMNSN_AST_PHONG:
- dmnsn_array_get(item->children, 0, &child);
- phong = dmnsn_realize_float(child);
- break;
- case DMNSN_AST_PHONG_SIZE:
- dmnsn_array_get(item->children, 0, &child);
- phong_size = dmnsn_realize_float(child);
- break;
-
- case DMNSN_AST_REFLECTION:
- dmnsn_delete_finish(reflection);
- reflection = dmnsn_realize_reflection(*item);
- break;
-
- default:
- dmnsn_assert(false, "Invalid finish item.");
- }
- }
-
- if (ambient_set) {
- finish = dmnsn_new_finish_combination(
- dmnsn_new_ambient_finish(ambient),
- finish
- );
- }
-
- if (diffuse_set) {
- finish = dmnsn_new_finish_combination(
- dmnsn_new_diffuse_finish(diffuse),
- finish
- );
- }
-
- if (phong) {
- finish = dmnsn_new_finish_combination(
- dmnsn_new_phong_finish(phong, phong_size),
- finish
- );
- }
-
- if (reflection) {
- finish = dmnsn_new_finish_combination(reflection, finish);
- }
-
- return finish;
-}
-
-static dmnsn_texture *
-dmnsn_realize_texture(dmnsn_astnode astnode)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_TEXTURE, "Expected a texture.");
-
- dmnsn_texture *texture = dmnsn_new_texture();
-
- DMNSN_ARRAY_FOREACH (dmnsn_astnode *, item, astnode.children) {
- switch (item->type) {
- case DMNSN_AST_PIGMENT:
- dmnsn_delete_pigment(texture->pigment);
- texture->pigment = dmnsn_realize_pigment(*item);
- break;
-
- case DMNSN_AST_FINISH:
- dmnsn_delete_finish(texture->finish);
- texture->finish = dmnsn_realize_finish(*item);
- break;
-
- case DMNSN_AST_TRANSFORMATION:
- texture->trans = dmnsn_matrix_mul(
- dmnsn_realize_transformation(*item),
- texture->trans
- );
- break;
-
- default:
- dmnsn_assert(false, "Invalid texture item.");
- }
- }
-
- return texture;
-}
-
-static dmnsn_interior *
-dmnsn_realize_interior(dmnsn_astnode astnode)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_INTERIOR, "Expected a texture.");
-
- dmnsn_interior *interior = dmnsn_new_interior();
-
- DMNSN_ARRAY_FOREACH (dmnsn_astnode *, item, astnode.children) {
- dmnsn_astnode child;
-
- switch (item->type) {
- case DMNSN_AST_IOR:
- dmnsn_array_get(item->children, 0, &child);
- interior->ior = dmnsn_realize_float(child);
- break;
-
- default:
- dmnsn_assert(false, "Invalid interior item.");
- }
- }
-
- return interior;
-}
-
-static void
-dmnsn_realize_object_modifiers(dmnsn_astnode astnode, dmnsn_object *object)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_OBJECT_MODIFIERS,
- "Expected object modifiers.");
-
- /* Save the pre-existing transformations */
- dmnsn_matrix existing_trans = dmnsn_matrix_inverse(object->trans);
-
- DMNSN_ARRAY_FOREACH (dmnsn_astnode *, modifier, astnode.children) {
- switch (modifier->type) {
- case DMNSN_AST_TRANSFORMATION:
- object->trans = dmnsn_matrix_mul(
- dmnsn_realize_transformation(*modifier),
- object->trans
- );
- break;
-
- case DMNSN_AST_TEXTURE:
- dmnsn_delete_texture(object->texture);
- object->texture = dmnsn_realize_texture(*modifier);
- break;
- case DMNSN_AST_PIGMENT:
- if (!object->texture)
- object->texture = dmnsn_new_texture();
- dmnsn_delete_pigment(object->texture->pigment);
- object->texture->pigment = dmnsn_realize_pigment(*modifier);
- break;
- case DMNSN_AST_FINISH:
- if (!object->texture)
- object->texture = dmnsn_new_texture();
- dmnsn_delete_finish(object->texture->finish);
- object->texture->finish = dmnsn_realize_finish(*modifier);
- break;
-
- case DMNSN_AST_INTERIOR:
- dmnsn_delete_interior(object->interior);
- object->interior = dmnsn_realize_interior(*modifier);
- break;
-
- case DMNSN_AST_STURM:
- /* Ignored */
- break;
-
- default:
- dmnsn_assert(false, "Invalid object modifier.");
- }
- }
-
- if (object->texture) {
- /* Right-multiply to counteract any pre-existing transformations -- this
- means, for example, that the transformation that makes a sphere have
- radius 2 doesn't scale the texture by a factor of 2 */
- object->texture->trans = dmnsn_matrix_mul(
- object->texture->trans,
- existing_trans
- );
- }
-}
-
-static void
-dmnsn_realize_light_source_modifiers(dmnsn_astnode astnode, dmnsn_light *light)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_OBJECT_MODIFIERS,
- "Expected object modifiers.");
-
- DMNSN_ARRAY_FOREACH (dmnsn_astnode *, modifier, astnode.children) {
- switch (modifier->type) {
- case DMNSN_AST_TRANSFORMATION:
- light->x0 = dmnsn_transform_vector(
- dmnsn_realize_transformation(*modifier),
- light->x0
- );
- break;
-
- case DMNSN_AST_TEXTURE:
- case DMNSN_AST_PIGMENT:
- case DMNSN_AST_FINISH:
- case DMNSN_AST_INTERIOR:
- /* Ignore other object modifiers */
- break;
-
- default:
- dmnsn_assert(false, "Invalid object modifier.");
- }
- }
-}
-
-static dmnsn_light *
-dmnsn_realize_light_source(dmnsn_astnode astnode)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_LIGHT_SOURCE,
- "Expected a light source.");
-
- dmnsn_astnode point, color_node;
- dmnsn_array_get(astnode.children, 0, &point);
- dmnsn_array_get(astnode.children, 1, &color_node);
-
- dmnsn_vector x0 = dmnsn_realize_vector(point);
- dmnsn_color color = dmnsn_realize_color(color_node);
-
- dmnsn_light *light = dmnsn_new_point_light(x0, color);
-
- dmnsn_astnode modifiers;
- dmnsn_array_get(astnode.children, 2, &modifiers);
- dmnsn_realize_light_source_modifiers(modifiers, light);
-
- return light;
-}
-
-static dmnsn_object *dmnsn_realize_object(dmnsn_astnode astnode,
- dmnsn_array *lights);
-
-static dmnsn_object *
-dmnsn_realize_box(dmnsn_astnode astnode)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_BOX, "Expected a box.");
-
- dmnsn_astnode corner1, corner2;
- dmnsn_array_get(astnode.children, 0, &corner1);
- dmnsn_array_get(astnode.children, 1, &corner2);
-
- dmnsn_vector x1 = dmnsn_realize_vector(corner1),
- x2 = dmnsn_realize_vector(corner2);
-
- dmnsn_object *box = dmnsn_new_cube();
-
- box->trans = dmnsn_scale_matrix(
- dmnsn_new_vector(fabs(x2.x - x1.x)/2.0,
- fabs(x2.y - x1.y)/2.0,
- fabs(x2.z - x1.z)/2.0)
- );
- box->trans = dmnsn_matrix_mul(
- dmnsn_translation_matrix(dmnsn_new_vector((x2.x + x1.x)/2.0,
- (x2.y + x1.y)/2.0,
- (x2.z + x1.z)/2.0)),
- box->trans
- );
-
- return box;
-}
-
-static dmnsn_object *
-dmnsn_realize_cone(dmnsn_astnode astnode)
-{
- dmnsn_astnode pnode1, rnode1, pnode2, rnode2, open;
-
- if (astnode.type == DMNSN_AST_CONE) {
- dmnsn_array_get(astnode.children, 0, &pnode1);
- dmnsn_array_get(astnode.children, 1, &rnode1);
- dmnsn_array_get(astnode.children, 2, &pnode2);
- dmnsn_array_get(astnode.children, 3, &rnode2);
- dmnsn_array_get(astnode.children, 4, &open);
- } else if (astnode.type == DMNSN_AST_CYLINDER) {
- dmnsn_array_get(astnode.children, 0, &pnode1);
- dmnsn_array_get(astnode.children, 1, &pnode2);
- dmnsn_array_get(astnode.children, 2, &rnode1);
- dmnsn_array_get(astnode.children, 2, &rnode2);
- dmnsn_array_get(astnode.children, 3, &open);
- } else {
- dmnsn_assert(false, "Expected a cone or cylinder.");
- }
-
- dmnsn_vector p1 = dmnsn_realize_vector(pnode1);
- dmnsn_vector p2 = dmnsn_realize_vector(pnode2);
- double r1 = dmnsn_realize_float(rnode1);
- double r2 = dmnsn_realize_float(rnode2);
-
- dmnsn_vector dir = dmnsn_vector_sub(p2, p1);
- double l = dmnsn_vector_norm(dir);
-
- double theta1 = dmnsn_vector_axis_angle(dmnsn_y, dir, dmnsn_x);
- double theta2 = dmnsn_vector_axis_angle(dmnsn_y, dir, dmnsn_z);
-
- dmnsn_object *cone = dmnsn_new_cone(r1, r2, dmnsn_realize_integer(open));
- /* Transformations: lift the cone to start at the origin, scale, rotate,
- and translate properly */
- cone->trans = dmnsn_translation_matrix(dmnsn_new_vector(0.0, 1.0, 0.0));
- cone->trans = dmnsn_matrix_mul(
- dmnsn_scale_matrix(dmnsn_new_vector(1.0, l/2.0, 1.0)),
- cone->trans
- );
- cone->trans = dmnsn_matrix_mul(
- dmnsn_rotation_matrix(dmnsn_new_vector(theta1, 0.0, 0.0)),
- cone->trans
- );
- cone->trans = dmnsn_matrix_mul(
- dmnsn_rotation_matrix(dmnsn_new_vector(0.0, 0.0, theta2)),
- cone->trans
- );
- cone->trans = dmnsn_matrix_mul(
- dmnsn_translation_matrix(p1),
- cone->trans
- );
- return cone;
-}
-
-static dmnsn_object *
-dmnsn_realize_sphere(dmnsn_astnode astnode)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_SPHERE, "Expected a sphere.");
-
- dmnsn_astnode center, radius;
- dmnsn_array_get(astnode.children, 0, &center);
- dmnsn_array_get(astnode.children, 1, &radius);
-
- dmnsn_vector x0 = dmnsn_realize_vector(center);
- double r = dmnsn_realize_float(radius);
-
- dmnsn_object *sphere = dmnsn_new_sphere();
- sphere->trans = dmnsn_scale_matrix(dmnsn_new_vector(r, r, r));
- sphere->trans = dmnsn_matrix_mul(dmnsn_translation_matrix(x0), sphere->trans);
- return sphere;
-}
-
-static dmnsn_object *
-dmnsn_realize_torus(dmnsn_astnode astnode)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_TORUS, "Expected a torus.");
-
- dmnsn_astnode major, minor;
- dmnsn_array_get(astnode.children, 0, &major);
- dmnsn_array_get(astnode.children, 1, &minor);
-
- double R = dmnsn_realize_float(major);
- double r = dmnsn_realize_float(minor);
-
- dmnsn_object *torus = dmnsn_new_torus(R, r);
- return torus;
-}
-
-static dmnsn_object *
-dmnsn_realize_plane(dmnsn_astnode astnode)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_PLANE, "Expected a plane.");
-
- dmnsn_astnode normal, distance;
- dmnsn_array_get(astnode.children, 0, &normal);
- dmnsn_array_get(astnode.children, 1, &distance);
-
- dmnsn_vector n = dmnsn_vector_normalize(dmnsn_realize_vector(normal));
- double d = dmnsn_realize_float(distance);
-
- dmnsn_object *plane = dmnsn_new_plane(n);
- plane->trans = dmnsn_translation_matrix(dmnsn_vector_mul(d, n));
- return plane;
-}
-
-/* Bulk-load a union */
-static dmnsn_object *
-dmnsn_realize_union(dmnsn_astnode astnode, dmnsn_astnode modifiers,
- dmnsn_array *lights)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_UNION, "Expected a union.");
-
- dmnsn_array *children = dmnsn_new_array(sizeof(dmnsn_object *));
- DMNSN_ARRAY_FOREACH (dmnsn_astnode *, onode, astnode.children) {
- if (onode->type == DMNSN_AST_LIGHT_SOURCE) {
- dmnsn_light *light = dmnsn_realize_light_source(*onode);
- dmnsn_realize_light_source_modifiers(modifiers, light);
- dmnsn_array_push(lights, &light);
- } else {
- dmnsn_object *object = dmnsn_realize_object(*onode, lights);
- if (object)
- dmnsn_array_push(children, &object);
- }
- }
-
- dmnsn_object *csg = NULL;
- if (dmnsn_array_size(children) > 0)
- csg = dmnsn_new_csg_union(children);
- dmnsn_delete_array(children);
- return csg;
-}
-
-typedef dmnsn_object *dmnsn_csg_object_fn(dmnsn_object *a, dmnsn_object *b);
-
-/* Generalized CSG realizer */
-static dmnsn_object *
-dmnsn_realize_csg(dmnsn_astnode astnode, dmnsn_astnode modifiers,
- dmnsn_array *lights, dmnsn_csg_object_fn *csg_object_fn)
-{
- dmnsn_object *csg = NULL;
- dmnsn_astnode *onode;
- for (onode = dmnsn_array_first(astnode.children);
- onode <= (dmnsn_astnode *)dmnsn_array_last(astnode.children);
- ++onode)
- {
- if (onode->type == DMNSN_AST_LIGHT_SOURCE) {
- dmnsn_light *light = dmnsn_realize_light_source(*onode);
- dmnsn_realize_light_source_modifiers(modifiers, light);
- dmnsn_array_push(lights, &light);
- } else {
- csg = dmnsn_realize_object(*onode, lights);
- break;
- }
- }
-
- for (++onode;
- onode <= (dmnsn_astnode *)dmnsn_array_last(astnode.children);
- ++onode)
- {
- if (onode->type == DMNSN_AST_LIGHT_SOURCE) {
- dmnsn_light *light = dmnsn_realize_light_source(*onode);
- dmnsn_realize_light_source_modifiers(modifiers, light);
- dmnsn_array_push(lights, &light);
- } else {
- dmnsn_object *object = dmnsn_realize_object(*onode, lights);
- csg = csg_object_fn(csg, object);
- }
- }
-
- return csg;
-}
-
-static dmnsn_object *
-dmnsn_realize_intersection(dmnsn_astnode astnode, dmnsn_astnode modifiers,
- dmnsn_array *lights)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_INTERSECTION,
- "Expected an intersection.");
- return dmnsn_realize_csg(astnode, modifiers, lights,
- dmnsn_new_csg_intersection);
-}
-
-static dmnsn_object *
-dmnsn_realize_difference(dmnsn_astnode astnode, dmnsn_astnode modifiers,
- dmnsn_array *lights)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_DIFFERENCE, "Expected a difference.");
- return dmnsn_realize_csg(astnode, modifiers, lights,
- dmnsn_new_csg_difference);
-}
-
-static dmnsn_object *
-dmnsn_realize_merge(dmnsn_astnode astnode, dmnsn_astnode modifiers,
- dmnsn_array *lights)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_MERGE, "Expected a merge.");
- return dmnsn_realize_csg(astnode, modifiers, lights, dmnsn_new_csg_merge);
-}
-
-/* Realize an object, or maybe a light */
-static dmnsn_object *
-dmnsn_realize_object(dmnsn_astnode astnode, dmnsn_array *lights)
-{
- dmnsn_assert(astnode.type == DMNSN_AST_OBJECT
- || astnode.type == DMNSN_AST_LIGHT_SOURCE,
- "Expected an object.");
-
- dmnsn_astnode onode, modifiers;
- dmnsn_array_get(astnode.children, 0, &onode);
- dmnsn_array_get(astnode.children, 1, &modifiers);
-
- dmnsn_object *object = NULL;
-
- switch (onode.type) {
- case DMNSN_AST_BOX:
- object = dmnsn_realize_box(onode);
- break;
- case DMNSN_AST_CONE:
- case DMNSN_AST_CYLINDER:
- object = dmnsn_realize_cone(onode);
- break;
- case DMNSN_AST_DIFFERENCE:
- object = dmnsn_realize_difference(onode, modifiers, lights);
- break;
- case DMNSN_AST_INTERSECTION:
- object = dmnsn_realize_intersection(onode, modifiers, lights);
- break;
- case DMNSN_AST_MERGE:
- object = dmnsn_realize_merge(onode, modifiers, lights);
- break;
- case DMNSN_AST_PLANE:
- object = dmnsn_realize_plane(onode);
- break;
- case DMNSN_AST_SPHERE:
- object = dmnsn_realize_sphere(onode);
- break;
- case DMNSN_AST_TORUS:
- object = dmnsn_realize_torus(onode);
- break;
- case DMNSN_AST_UNION:
- object = dmnsn_realize_union(onode, modifiers, lights);
- break;
-
- case DMNSN_AST_LIGHT_SOURCE:
- {
- dmnsn_light *light = dmnsn_realize_light_source(astnode);
- dmnsn_array_push(lights, &light);
- return NULL;
- }
-
- default:
- dmnsn_assert(false, "Expected an object type.");
- }
-
- if (object) {
- dmnsn_realize_object_modifiers(modifiers, object);
- }
- return object;
-}
-
-static dmnsn_scene *
-dmnsn_realize_astree(const dmnsn_astree *astree)
-{
- dmnsn_scene *scene = dmnsn_new_scene();
-
- /* Default finish */
- scene->default_texture->finish = dmnsn_new_finish_combination(
- dmnsn_new_ambient_finish(
- dmnsn_color_mul(0.1, dmnsn_white)
- ),
- dmnsn_new_diffuse_finish(0.6)
- );
-
- /* Background color */
- scene->background = dmnsn_black;
-
- /* Create the default perspective camera */
- scene->camera = dmnsn_new_perspective_camera();
-
- /*
- * Now parse the abstract syntax tree
- */
-
- DMNSN_ARRAY_FOREACH (dmnsn_astnode *, astnode, astree) {
- dmnsn_astnode child;
- dmnsn_light *light;
- dmnsn_object *object;
-
- switch (astnode->type) {
- case DMNSN_AST_GLOBAL_SETTINGS:
- dmnsn_realize_global_settings(*astnode, scene);
- break;
-
- case DMNSN_AST_BACKGROUND:
- dmnsn_array_get(astnode->children, 0, &child);
- scene->background = dmnsn_realize_color(child);
- break;
- case DMNSN_AST_SKY_SPHERE:
- dmnsn_delete_sky_sphere(scene->sky_sphere);
- scene->sky_sphere = dmnsn_realize_sky_sphere(*astnode);
- break;
-
- case DMNSN_AST_CAMERA:
- dmnsn_delete_camera(scene->camera);
- scene->camera = dmnsn_realize_camera(*astnode);
- break;
-
- case DMNSN_AST_OBJECT:
- object = dmnsn_realize_object(*astnode, scene->lights);
- if (object)
- dmnsn_array_push(scene->objects, &object);
- break;
-
- case DMNSN_AST_LIGHT_SOURCE:
- light = dmnsn_realize_light_source(*astnode);
- dmnsn_array_push(scene->lights, &light);
- break;
-
- default:
- dmnsn_assert(false, "Unrecognised syntax element.");
- }
- }
-
- return scene;
-}
-
-dmnsn_scene *
-dmnsn_realize(FILE *file, dmnsn_symbol_table *symtable)
-{
- if (!symtable) {
- symtable = dmnsn_new_symbol_table();
- }
-
- dmnsn_astree *astree = dmnsn_parse(file, symtable);
- if (!astree) {
- return NULL;
- }
-
- dmnsn_scene *scene = dmnsn_realize_astree(astree);
-
- dmnsn_delete_astree(astree);
- return scene;
-}
-
-dmnsn_scene *
-dmnsn_realize_string(const char *str, dmnsn_symbol_table *symtable)
-{
- if (!symtable) {
- symtable = dmnsn_new_symbol_table();
- }
-
- dmnsn_astree *astree = dmnsn_parse_string(str, symtable);
- if (!astree) {
- return NULL;
- }
-
- dmnsn_scene *scene = dmnsn_realize_astree(astree);
-
- dmnsn_delete_astree(astree);
- return scene;
-}