diff options
Diffstat (limited to 'libdimension/cone.c')
| -rw-r--r-- | libdimension/cone.c | 158 |
1 files changed, 158 insertions, 0 deletions
diff --git a/libdimension/cone.c b/libdimension/cone.c new file mode 100644 index 0000000..9f5340a --- /dev/null +++ b/libdimension/cone.c @@ -0,0 +1,158 @@ +/************************************************************************* + * Copyright (C) 2009-2010 Tavian Barnes <tavianator@gmail.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 + * Cones/cylinders. + */ + +#include "dimension.h" +#include <math.h> + +/** Cone payload type. */ +typedef struct dmnsn_cone_payload { + double r1, r2; + bool open; +} dmnsn_cone_payload; + +/** Intersection callback for a cone. */ +static bool +dmnsn_cone_intersection_fn(const dmnsn_object *cone, dmnsn_line l, + dmnsn_intersection *intersection) +{ + const dmnsn_cone_payload *payload = cone->ptr; + double r1 = payload->r1, r2 = payload->r2; + + /* Solve (x0 + nx*t)^2 + (z0 + nz*t)^2 + == (((r2 - r1)*(y0 + ny*t) + r1 + r2)/2)^2 */ + double poly[3], x[2]; + poly[2] = l.n.x*l.n.x + l.n.z*l.n.z - l.n.y*l.n.y*(r2 - r1)*(r2 - r1)/4.0; + poly[1] = 2.0*(l.n.x*l.x0.x + l.n.z*l.x0.z) + - l.n.y*(r2 - r1)*(l.x0.y*(r2 - r1) + r2 + r1)/2.0; + poly[0] = l.x0.x*l.x0.x + l.x0.z*l.x0.z + - (l.x0.y*(r2 - r1) + r2 + r1)*(l.x0.y*(r2 - r1) + r2 + r1)/4; + + size_t n = dmnsn_solve_polynomial(poly, 2, x); + + if (n > 0) { + double t = x[0]; + dmnsn_vector p; + if (n == 2) { + t = dmnsn_min(t, x[1]); + p = dmnsn_line_point(l, t); + + if (p.y <= -1.0 || p.y >= 1.0) { + t = dmnsn_max(x[0], x[1]); + p = dmnsn_line_point(l, t); + } + } else { + p = dmnsn_line_point(l, t); + } + + if (!payload->open && l.n.y) { + /* Test for cap intersections */ + double tcap1 = (-1.0 - l.x0.y)/l.n.y; + double tcap2 = (+1.0 - l.x0.y)/l.n.y; + + double tcap, r; + dmnsn_vector norm; + if (tcap1 < tcap2) { + tcap = tcap1; + r = r1; + norm = dmnsn_new_vector(0.0, -1.0, 0.0); + } else { + tcap = tcap2; + r = r2; + norm = dmnsn_new_vector(0.0, 1.0, 0.0); + } + dmnsn_vector pcap = dmnsn_line_point(l, tcap); + + if (tcap < 0.0 || pcap.x*pcap.x + pcap.z*pcap.z >= r*r) { + if (tcap2 <= tcap1) { + tcap = tcap1; + r = r1; + norm = dmnsn_new_vector(0.0, -1.0, 0.0); + } else { + tcap = tcap2; + r = r2; + norm = dmnsn_new_vector(0.0, 1.0, 0.0); + } + pcap = dmnsn_line_point(l, tcap); + } + + if (tcap >= 0.0 + && (tcap < t || p.y <= -1.0 || p.y >= 1.0) + && pcap.x*pcap.x + pcap.z*pcap.z < r*r) + { + intersection->ray = l; + intersection->t = tcap; + intersection->normal = norm; + intersection->texture = cone->texture; + intersection->interior = cone->interior; + return true; + } + } + + if (t >= 0.0 && p.y > -1.0 && p.y < 1.0) { + dmnsn_vector norm = dmnsn_vector_normalize( + dmnsn_new_vector(p.x, -(r2 - r1)*sqrt(p.x*p.x + p.z*p.z)/2.0, p.z) + ); + intersection->ray = l; + intersection->t = t; + intersection->normal = norm; + intersection->texture = cone->texture; + intersection->interior = cone->interior; + return true; + } + } + + return false; +} + +/** Inside callback for a cone. */ +static bool +dmnsn_cone_inside_fn(const dmnsn_object *cone, dmnsn_vector point) +{ + const dmnsn_cone_payload *payload = cone->ptr; + double r1 = payload->r1, r2 = payload->r2; + double r = (point.y*(r2 - r1) + r1 + r2)/2.0; + return point.x*point.x + point.z*point.z < r*r + && point.y > -1.0 && point.y < 1.0; +} + +/* Allocate a new cone object */ +dmnsn_object * +dmnsn_new_cone(double r1, double r2, bool open) +{ + dmnsn_object *cone = dmnsn_new_object(); + cone->intersection_fn = &dmnsn_cone_intersection_fn; + cone->inside_fn = &dmnsn_cone_inside_fn; + double rmax = dmnsn_max(r1, r2); + cone->bounding_box.min = dmnsn_new_vector(-rmax, -1.0, -rmax); + cone->bounding_box.max = dmnsn_new_vector(rmax, 1.0, rmax); + + dmnsn_cone_payload *payload = dmnsn_malloc(sizeof(dmnsn_cone_payload)); + payload->r1 = r1; + payload->r2 = r2; + payload->open = open; + cone->ptr = payload; + cone->free_fn = &dmnsn_free; + return cone; +} |