object: Get rid of void *ptr field.

Instead, allow dmnsn_object to be embedded in a larger struct.

This gives a consistent 1% speed boost.

7 files changed, 191 insertions, 156 deletions

diff --git a/libdimension/cone.c b/libdimension/cone.c
index a2d2d55..fe01e85 100644
--- a/libdimension/cone.c
+++ b/libdimension/cone.c
@@ -26,18 +26,19 @@
 #include "dimension.h"
 #include <math.h>
 
-/** Cone payload type. */
-typedef struct dmnsn_cone_payload {
+/** Cone type. */
+typedef struct dmnsn_cone {
+  dmnsn_object object;
   double r1, r2;
-} dmnsn_cone_payload;
+} dmnsn_cone;
 
 /** Intersection callback for a cone. */
 static bool
-dmnsn_cone_intersection_fn(const dmnsn_object *cone, dmnsn_line l,
+dmnsn_cone_intersection_fn(const dmnsn_object *object, dmnsn_line l,
                            dmnsn_intersection *intersection)
 {
-  const dmnsn_cone_payload *payload = cone->ptr;
-  double r1 = payload->r1, r2 = payload->r2;
+  const dmnsn_cone *cone = (const dmnsn_cone *)object;
+  double r1 = cone->r1, r2 = cone->r2;
 
   /* Solve (x0 + nx*t)^2 + (z0 + nz*t)^2
            == (((r2 - r1)*(y0 + ny*t) + r1 + r2)/2)^2 */
@@ -79,22 +80,29 @@ dmnsn_cone_intersection_fn(const dmnsn_object *cone, dmnsn_line l,
 
 /** Inside callback for a cone. */
 static bool
-dmnsn_cone_inside_fn(const dmnsn_object *cone, dmnsn_vector point)
+dmnsn_cone_inside_fn(const dmnsn_object *object, dmnsn_vector point)
 {
-  const dmnsn_cone_payload *payload = cone->ptr;
-  double r1 = payload->r1, r2 = payload->r2;
+  const dmnsn_cone *cone = (const dmnsn_cone *)cone;
+  double r1 = cone->r1, r2 = cone->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;
 }
 
+/** Cone cap type. */
+typedef struct dmnsn_cone_cap {
+  dmnsn_object object;
+  double r;
+} dmnsn_cone_cap;
+
 /** Cone cap intersection function. */
 static bool
-dmnsn_cone_cap_intersection_fn(const dmnsn_object *cap, dmnsn_line l,
+dmnsn_cone_cap_intersection_fn(const dmnsn_object *object, dmnsn_line l,
                                dmnsn_intersection *intersection)
 {
   if (l.n.y != 0.0) {
-    double *rptr = cap->ptr, r = *rptr;
+    const dmnsn_cone_cap *cap = (const dmnsn_cone_cap *)object;
+    double r = cap->r;
     double t = -l.x0.y/l.n.y;
     dmnsn_vector p = dmnsn_line_point(l, t);
     if (t >= 0.0 && p.x*p.x + p.z*p.z <= r*r) {
@@ -109,7 +117,7 @@ dmnsn_cone_cap_intersection_fn(const dmnsn_object *cap, dmnsn_line l,
 
 /** Inside callback for a cone cap. */
 static bool
-dmnsn_cone_cap_inside_fn(const dmnsn_object *cone, dmnsn_vector point)
+dmnsn_cone_cap_inside_fn(const dmnsn_object *object, dmnsn_vector point)
 {
   return false;
 }
@@ -118,57 +126,52 @@ dmnsn_cone_cap_inside_fn(const dmnsn_object *cone, dmnsn_vector point)
 dmnsn_object *
 dmnsn_new_cone_cap(double r)
 {
-  dmnsn_object *cap = dmnsn_new_object();
-  cap->intersection_fn  = dmnsn_cone_cap_intersection_fn;
-  cap->inside_fn        = dmnsn_cone_cap_inside_fn;
-  cap->bounding_box.min = dmnsn_new_vector(-r, 0.0, -r);
-  cap->bounding_box.max = dmnsn_new_vector(+r, 0.0, +r);
-
-  double *payload = DMNSN_MALLOC(double);
-  *payload = r;
-  cap->ptr     = payload;
-  cap->free_fn = dmnsn_free;
-
-  return cap;
+  dmnsn_cone_cap *cap = DMNSN_MALLOC(dmnsn_cone_cap);
+  dmnsn_init_object(&cap->object);
+  cap->object.intersection_fn  = dmnsn_cone_cap_intersection_fn;
+  cap->object.inside_fn = dmnsn_cone_cap_inside_fn;
+  cap->object.bounding_box.min = dmnsn_new_vector(-r, 0.0, -r);
+  cap->object.bounding_box.max = dmnsn_new_vector(+r, 0.0, +r);
+  cap->r = r;
+  return &cap->object;
 }
 
 /* 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;
+  dmnsn_cone *cone = DMNSN_MALLOC(dmnsn_cone);
+  dmnsn_init_object(&cone->object);
+  cone->object.intersection_fn  = dmnsn_cone_intersection_fn;
+  cone->object.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(dmnsn_cone_payload);
-  payload->r1 = r1;
-  payload->r2 = r2;
-  cone->ptr     = payload;
-  cone->free_fn = dmnsn_free;
+  cone->object.bounding_box.min = dmnsn_new_vector(-rmax, -1.0, -rmax);
+  cone->object.bounding_box.max = dmnsn_new_vector(rmax, 1.0, rmax);
+  cone->r1 = r1;
+  cone->r2 = r2;
 
-  /* Implement closed cones as a union with the caps */
-  if (!open) {
-    dmnsn_object *cap1 = dmnsn_new_cone_cap(r1);
-    dmnsn_object *cap2 = dmnsn_new_cone_cap(r2);
-    cap1->intrinsic_trans  = dmnsn_translation_matrix(
-      dmnsn_new_vector(0.0, -1.0, 0.0)
-    );
-    cap2->intrinsic_trans  = dmnsn_translation_matrix(
-      dmnsn_new_vector(0.0, +1.0, 0.0)
-    );
-    /* Flip the normal around for the top cap */
-    cap2->intrinsic_trans.n[1][1] = -1.0;
-
-    dmnsn_array *withcaps = dmnsn_new_array(sizeof(dmnsn_object *));
-    dmnsn_array_push(withcaps, &cone);
-    dmnsn_array_push(withcaps, &cap1);
-    dmnsn_array_push(withcaps, &cap2);
-    cone = dmnsn_new_csg_union(withcaps);
-    dmnsn_delete_array(withcaps);
+  if (open) {
+    return &cone->object;
   }
 
-  return cone;
+  /* Implement closed cones as a union with the caps */
+  dmnsn_object *cap1 = dmnsn_new_cone_cap(r1);
+  dmnsn_object *cap2 = dmnsn_new_cone_cap(r2);
+  cap1->intrinsic_trans  = dmnsn_translation_matrix(
+    dmnsn_new_vector(0.0, -1.0, 0.0)
+  );
+  cap2->intrinsic_trans  = dmnsn_translation_matrix(
+    dmnsn_new_vector(0.0, +1.0, 0.0)
+  );
+  /* Flip the normal around for the top cap */
+  cap2->intrinsic_trans.n[1][1] = -1.0;
+
+  dmnsn_array *withcaps = dmnsn_new_array(sizeof(dmnsn_object *));
+  dmnsn_array_push(withcaps, &cone);
+  dmnsn_array_push(withcaps, &cap1);
+  dmnsn_array_push(withcaps, &cap2);
+  dmnsn_object *cone_cap_union = dmnsn_new_csg_union(withcaps);
+  dmnsn_delete_array(withcaps);
+
+  return cone_cap_union;
 }
diff --git a/libdimension/csg.c b/libdimension/csg.c
index 2595f7d..b364e27 100644
--- a/libdimension/csg.c
+++ b/libdimension/csg.c
@@ -1,5 +1,5 @@
 /*************************************************************************
- * Copyright (C) 2010-2012 Tavian Barnes <tavianator@tavianator.com>     *
+ * Copyright (C) 2010-2014 Tavian Barnes <tavianator@tavianator.com>     *
  *                                                                       *
  * This file is part of The Dimension Library.                           *
  *                                                                       *
@@ -30,59 +30,68 @@
  * Unions
  */
 
+typedef struct {
+  dmnsn_object object;
+  dmnsn_bvh *bvh;
+} dmnsn_csg_union;
+
 /** CSG union intersection callback. */
 static bool
-dmnsn_csg_union_intersection_fn(const dmnsn_object *csg,
+dmnsn_csg_union_intersection_fn(const dmnsn_object *object,
                                 dmnsn_line line,
                                 dmnsn_intersection *intersection)
 {
-  dmnsn_bvh *bvh = csg->ptr;
+  dmnsn_bvh *bvh = ((const dmnsn_csg_union *)object)->bvh;
   return dmnsn_bvh_intersection(bvh, line, intersection, true);
 }
 
 /** CSG union inside callback. */
 static bool
-dmnsn_csg_union_inside_fn(const dmnsn_object *csg, dmnsn_vector point)
+dmnsn_csg_union_inside_fn(const dmnsn_object *object, dmnsn_vector point)
 {
-  dmnsn_bvh *bvh = csg->ptr;
+  dmnsn_bvh *bvh = ((const dmnsn_csg_union *)object)->bvh;
   return dmnsn_bvh_inside(bvh, point);
 }
 
 /** CSG union initialization callback. */
 static void
-dmnsn_csg_union_initialize_fn(dmnsn_object *csg)
+dmnsn_csg_union_initialize_fn(dmnsn_object *object)
 {
-  csg->trans = dmnsn_identity_matrix();
+  dmnsn_csg_union *csg = (dmnsn_csg_union *)object;
+  csg->object.trans = dmnsn_identity_matrix();
 
-  dmnsn_bvh *bvh = dmnsn_new_bvh(csg->children, DMNSN_BVH_PRTREE);
-  csg->ptr = bvh;
-  csg->bounding_box = dmnsn_bvh_bounding_box(bvh);
+  dmnsn_bvh *bvh = dmnsn_new_bvh(csg->object.children, DMNSN_BVH_PRTREE);
+  csg->bvh = bvh;
+  csg->object.bounding_box = dmnsn_bvh_bounding_box(bvh);
 }
 
 /** CSG union destruction callback. */
 static void
-dmnsn_csg_union_free_fn(void *ptr)
+dmnsn_csg_union_free_fn(dmnsn_object *object)
 {
-  dmnsn_delete_bvh(ptr);
+  dmnsn_csg_union *csg = (dmnsn_csg_union *)object;
+  dmnsn_delete_bvh(csg->bvh);
+  dmnsn_free(csg);
 }
 
 /* Bulk-load a union */
 dmnsn_object *
 dmnsn_new_csg_union(const dmnsn_array *objects)
 {
-  dmnsn_object *csg = dmnsn_new_object();
+  dmnsn_csg_union *csg = DMNSN_MALLOC(dmnsn_csg_union);
+  dmnsn_init_object(&csg->object);
 
   DMNSN_ARRAY_FOREACH (dmnsn_object **, object, objects) {
-    dmnsn_array_push(csg->children, object);
+    dmnsn_array_push(csg->object.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;
-  csg->initialize_fn   = dmnsn_csg_union_initialize_fn;
-  csg->free_fn         = dmnsn_csg_union_free_fn;
-
-  return csg;
+  csg->object.split_children  = true;
+  csg->object.intersection_fn = dmnsn_csg_union_intersection_fn;
+  csg->object.inside_fn       = dmnsn_csg_union_inside_fn;
+  csg->object.initialize_fn   = dmnsn_csg_union_initialize_fn;
+  csg->object.free_fn         = dmnsn_csg_union_free_fn;
+  csg->bvh = NULL;
+
+  return &csg->object;
 }
 
 /**
diff --git a/libdimension/dimension/object.h b/libdimension/dimension/object.h
index 28cc266..4d75582 100644
--- a/libdimension/dimension/object.h
+++ b/libdimension/dimension/object.h
@@ -1,5 +1,5 @@
 /*************************************************************************
- * Copyright (C) 2009-2011 Tavian Barnes <tavianator@tavianator.com>     *
+ * Copyright (C) 2009-2014 Tavian Barnes <tavianator@tavianator.com>     *
  *                                                                       *
  * This file is part of The Dimension Library.                           *
  *                                                                       *
@@ -67,6 +67,12 @@ typedef bool dmnsn_object_intersection_fn(const dmnsn_object *object,
 typedef bool dmnsn_object_inside_fn(const dmnsn_object *object,
                                     dmnsn_vector point);
 
+/**
+ * Object destruction callback.
+ * @param[in] object  The object to delete.
+ */
+typedef void dmnsn_object_free_fn(dmnsn_object *object);
+
 /** An object. */
 struct dmnsn_object {
   dmnsn_texture  *texture;  /**< Surface properties. */
@@ -85,9 +91,7 @@ struct dmnsn_object {
   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. */
-
-  void *ptr; /**< Generic pointer for object info. */
+  dmnsn_object_free_fn         *free_fn; /**< Destruction callback. */
 
   DMNSN_REFCOUNT; /**< Reference count. */
   bool initialized; /**< @internal Whether the object is initialized yet. */
@@ -100,6 +104,12 @@ struct dmnsn_object {
 dmnsn_object *dmnsn_new_object(void);
 
 /**
+ * Initialize a dmnsn_object field.
+ * @param[in,out] object  The object to initialize.
+ */
+void dmnsn_init_object(dmnsn_object *object);
+
+/**
  * Free an object
  * @param[in,out] object  The object to destroy.
  */
diff --git a/libdimension/object.c b/libdimension/object.c
index b085cff..52b9558 100644
--- a/libdimension/object.c
+++ b/libdimension/object.c
@@ -26,11 +26,25 @@
 #include "dimension-internal.h"
 #include <stdlib.h>
 
+static void
+dmnsn_default_object_free_fn(dmnsn_object *object)
+{
+  dmnsn_free(object);
+}
+
 /* Allocate a dummy object */
 dmnsn_object *
 dmnsn_new_object(void)
 {
   dmnsn_object *object = DMNSN_MALLOC(dmnsn_object);
+  dmnsn_init_object(object);
+  return object;
+}
+
+/* Initialize a dmnsn_object field */
+void
+dmnsn_init_object(dmnsn_object *object)
+{
   object->texture         = NULL;
   object->interior        = NULL;
   object->trans           = dmnsn_identity_matrix();
@@ -40,13 +54,12 @@ dmnsn_new_object(void)
   object->intersection_fn = NULL;
   object->inside_fn       = NULL;
   object->initialize_fn   = NULL;
-  object->free_fn         = NULL;
+  object->free_fn         = dmnsn_default_object_free_fn;
   object->initialized     = false;
   DMNSN_REFCOUNT_INIT(object);
-  return object;
 }
 
-/* Free a dummy object */
+/* Free a dmnsn_object */
 void
 dmnsn_delete_object(dmnsn_object *object)
 {
@@ -57,10 +70,7 @@ dmnsn_delete_object(dmnsn_object *object)
     dmnsn_delete_array(object->children);
     dmnsn_delete_interior(object->interior);
     dmnsn_delete_texture(object->texture);
-    if (object->free_fn) {
-      object->free_fn(object->ptr);
-    }
-    dmnsn_free(object);
+    object->free_fn(object);
   }
 }
 
diff --git a/libdimension/plane.c b/libdimension/plane.c
index 33d2737..dc7fc1a 100644
--- a/libdimension/plane.c
+++ b/libdimension/plane.c
@@ -27,6 +27,12 @@
 #include <math.h>
 #include <stdlib.h>
 
+/** Plane type. */
+typedef struct {
+  dmnsn_object object;
+  dmnsn_vector normal;
+} dmnsn_plane;
+
 /* Plane object callbacks */
 
 static bool dmnsn_plane_intersection_fn(const dmnsn_object *plane,
@@ -39,32 +45,30 @@ static bool dmnsn_plane_inside_fn(const dmnsn_object *plane,
 dmnsn_object *
 dmnsn_new_plane(dmnsn_vector normal)
 {
-  dmnsn_object *plane = dmnsn_new_object();
-
-  dmnsn_vector *param = DMNSN_MALLOC(dmnsn_vector);
-  *param = normal;
+  dmnsn_plane *plane = DMNSN_MALLOC(dmnsn_plane);
+  dmnsn_init_object(&plane->object);
 
-  plane->intersection_fn  = dmnsn_plane_intersection_fn;
-  plane->inside_fn        = dmnsn_plane_inside_fn;
-  plane->free_fn          = dmnsn_free;
-  plane->bounding_box     = dmnsn_infinite_bounding_box();
-  plane->ptr              = param;
-  return plane;
+  plane->object.intersection_fn = dmnsn_plane_intersection_fn;
+  plane->object.inside_fn = dmnsn_plane_inside_fn;
+  plane->object.bounding_box = dmnsn_infinite_bounding_box();
+  plane->normal = normal;
+  return &plane->object;
 }
 
 /* Returns the closest intersection of `line' with `plane' */
 static bool
-dmnsn_plane_intersection_fn(const dmnsn_object *plane, dmnsn_line line,
+dmnsn_plane_intersection_fn(const dmnsn_object *object, dmnsn_line line,
                             dmnsn_intersection *intersection)
 {
-  dmnsn_vector *normal = plane->ptr;
+  const dmnsn_plane *plane = (const dmnsn_plane *)object;
+  dmnsn_vector normal = plane->normal;
 
-  double den = dmnsn_vector_dot(line.n, *normal);
+  double den = dmnsn_vector_dot(line.n, normal);
   if (den != 0.0) {
-    double t = -dmnsn_vector_dot(line.x0, *normal)/den;
+    double t = -dmnsn_vector_dot(line.x0, normal)/den;
     if (t >= 0.0) {
       intersection->t      = t;
-      intersection->normal = *normal;
+      intersection->normal = normal;
       return true;
     }
   }
@@ -73,8 +77,8 @@ dmnsn_plane_intersection_fn(const dmnsn_object *plane, dmnsn_line line,
 
 /* Return whether a point is inside a plane */
 static bool
-dmnsn_plane_inside_fn(const dmnsn_object *plane, dmnsn_vector point)
+dmnsn_plane_inside_fn(const dmnsn_object *object, dmnsn_vector point)
 {
-  dmnsn_vector *normal = plane->ptr;
-  return dmnsn_vector_dot(point, *normal) < 0.0;
+  const dmnsn_plane *plane = (const dmnsn_plane *)object;
+  return dmnsn_vector_dot(point, plane->normal) < 0.0;
 }
diff --git a/libdimension/torus.c b/libdimension/torus.c
index 67bed0f..53e8fcb 100644
--- a/libdimension/torus.c
+++ b/libdimension/torus.c
@@ -25,16 +25,17 @@
 
 #include "dimension.h"
 
-/** Torus payload type. */
-typedef struct dmnsn_torus_payload {
+/** Torus type. */
+typedef struct {
+  dmnsn_object object;
   double major, minor;
-} dmnsn_torus_payload;
+} dmnsn_torus;
 
 /** Bound the torus in a cylindrical shell. */
 static inline bool
-dmnsn_torus_bound_intersection(const dmnsn_torus_payload *payload, dmnsn_line l)
+dmnsn_torus_bound_intersection(const dmnsn_torus *torus, dmnsn_line l)
 {
-  double R = payload->major, r = payload->minor;
+  double R = torus->major, r = torus->minor;
   double rmax = R + r, rmin = R - r;
   double rmax2 = rmax*rmax, rmin2 = rmin*rmin;
 
@@ -77,15 +78,16 @@ dmnsn_torus_bound_intersection(const dmnsn_torus_payload *payload, dmnsn_line l)
 
 /** Torus intersection callback. */
 static bool
-dmnsn_torus_intersection_fn(const dmnsn_object *torus, dmnsn_line l,
+dmnsn_torus_intersection_fn(const dmnsn_object *object, dmnsn_line l,
                             dmnsn_intersection *intersection)
 {
-  const dmnsn_torus_payload *payload = torus->ptr;
-  double R = payload->major, r = payload->minor;
+  const dmnsn_torus *torus = (const dmnsn_torus *)object;
+  double R = torus->major, r = torus->minor;
   double R2 = R*R, r2 = r*r;
 
-  if (!dmnsn_torus_bound_intersection(payload, l))
+  if (!dmnsn_torus_bound_intersection(torus, l)) {
     return false;
+  }
 
   /* This bit of algebra here is correct */
   dmnsn_vector x0mod = dmnsn_new_vector(l.x0.x, -l.x0.y, l.x0.z);
@@ -119,7 +121,7 @@ dmnsn_torus_intersection_fn(const dmnsn_object *torus, dmnsn_line l,
 
   dmnsn_vector p = dmnsn_line_point(l, t);
   dmnsn_vector center = dmnsn_vector_mul(
-    payload->major,
+    R,
     dmnsn_vector_normalized(dmnsn_new_vector(p.x, 0.0, p.z))
   );
   dmnsn_vector normal = dmnsn_vector_sub(p, center);
@@ -131,31 +133,28 @@ dmnsn_torus_intersection_fn(const dmnsn_object *torus, dmnsn_line l,
 
 /** Torus inside callback. */
 static bool
-dmnsn_torus_inside_fn(const dmnsn_object *torus, dmnsn_vector point)
+dmnsn_torus_inside_fn(const dmnsn_object *object, dmnsn_vector point)
 {
-  const dmnsn_torus_payload *payload = torus->ptr;
-  double dmajor = payload->major - sqrt(point.x*point.x + point.z*point.z);
-  return dmajor*dmajor + point.y*point.y < payload->minor*payload->minor;
+  const dmnsn_torus *torus = (const dmnsn_torus *)object;
+  double dmajor = torus->major - sqrt(point.x*point.x + point.z*point.z);
+  return dmajor*dmajor + point.y*point.y < torus->minor*torus->minor;
 }
 
 /* Allocate a new torus */
 dmnsn_object *
 dmnsn_new_torus(double major, double minor)
 {
-  dmnsn_object *torus = dmnsn_new_object();
-  torus->intersection_fn  = dmnsn_torus_intersection_fn;
-  torus->inside_fn        = dmnsn_torus_inside_fn;
-  torus->bounding_box.min = dmnsn_new_vector(-(major + minor),
-                                             -minor,
-                                             -(major + minor));
-  torus->bounding_box.max = dmnsn_new_vector(major + minor,
-                                             minor,
-                                             major + minor);
-
-  dmnsn_torus_payload *payload = DMNSN_MALLOC(dmnsn_torus_payload);
-  payload->major = major;
-  payload->minor = minor;
-  torus->ptr     = payload;
-  torus->free_fn = dmnsn_free;
-  return torus;
+  dmnsn_torus *torus = DMNSN_MALLOC(dmnsn_torus);
+  dmnsn_init_object(&torus->object);
+  torus->object.intersection_fn  = dmnsn_torus_intersection_fn;
+  torus->object.inside_fn = dmnsn_torus_inside_fn;
+  torus->object.bounding_box.min = dmnsn_new_vector(
+    -(major + minor), -minor, -(major + minor)
+  );
+  torus->object.bounding_box.max = dmnsn_new_vector(
+    major + minor, minor, major + minor
+  );
+  torus->major = major;
+  torus->minor = minor;
+  return &torus->object;
 }
diff --git a/libdimension/triangle.c b/libdimension/triangle.c
index 0e6daf4..9ddc3fc 100644
--- a/libdimension/triangle.c
+++ b/libdimension/triangle.c
@@ -25,16 +25,18 @@
 
 #include "dimension.h"
 
-typedef struct dmnsn_triangle_payload {
+/** Triangle type. */
+typedef struct {
+  dmnsn_object object;
   dmnsn_vector na, nab, nac;
-} dmnsn_triangle_payload;
+} dmnsn_triangle;
 
 /** Triangle intersection callback. */
 static bool
-dmnsn_triangle_intersection_fn(const dmnsn_object *triangle, dmnsn_line l,
+dmnsn_triangle_intersection_fn(const dmnsn_object *object, dmnsn_line l,
                                dmnsn_intersection *intersection)
 {
-  const dmnsn_triangle_payload *payload = triangle->ptr;
+  const dmnsn_triangle *triangle = (const dmnsn_triangle *)object;
 
   /* See the change of basis in dmnsn_new_triangle() */
   double t = -l.x0.z/l.n.z;
@@ -43,10 +45,10 @@ dmnsn_triangle_intersection_fn(const dmnsn_object *triangle, dmnsn_line l,
   if (t >= 0.0 && u >= 0.0 && v >= 0.0 && u + v <= 1.0) {
     intersection->t      = t;
     intersection->normal = dmnsn_vector_add(
-      payload->na,
+      triangle->na,
       dmnsn_vector_add(
-        dmnsn_vector_mul(u, payload->nab),
-        dmnsn_vector_mul(v, payload->nac)
+        dmnsn_vector_mul(u, triangle->nab),
+        dmnsn_vector_mul(v, triangle->nac)
       )
     );
     return true;
@@ -71,18 +73,16 @@ dmnsn_new_triangle(dmnsn_vector a, dmnsn_vector b, dmnsn_vector c,
   nb = dmnsn_vector_normalized(nb);
   nc = dmnsn_vector_normalized(nc);
 
-  dmnsn_triangle_payload *payload = DMNSN_MALLOC(dmnsn_triangle_payload);
-  payload->na  = na;
-  payload->nab = dmnsn_vector_sub(nb, na);
-  payload->nac = dmnsn_vector_sub(nc, na);
+  dmnsn_triangle *triangle = DMNSN_MALLOC(dmnsn_triangle);
+  triangle->na  = na;
+  triangle->nab = dmnsn_vector_sub(nb, na);
+  triangle->nac = dmnsn_vector_sub(nc, na);
 
-  dmnsn_object *triangle     = dmnsn_new_object();
-  triangle->ptr              = payload;
-  triangle->intersection_fn  = dmnsn_triangle_intersection_fn;
-  triangle->inside_fn        = dmnsn_triangle_inside_fn;
-  triangle->free_fn          = dmnsn_free;
-  triangle->bounding_box.min = dmnsn_zero;
-  triangle->bounding_box.max = dmnsn_new_vector(1.0, 1.0, 0.0);
+  dmnsn_init_object(&triangle->object);
+  triangle->object.intersection_fn  = dmnsn_triangle_intersection_fn;
+  triangle->object.inside_fn = dmnsn_triangle_inside_fn;
+  triangle->object.bounding_box.min = dmnsn_zero;
+  triangle->object.bounding_box.max = dmnsn_new_vector(1.0, 1.0, 0.0);
 
   /*
    * Make a change-of-basis matrix
@@ -93,9 +93,9 @@ dmnsn_new_triangle(dmnsn_vector a, dmnsn_vector b, dmnsn_vector c,
   dmnsn_vector ab = dmnsn_vector_sub(b, a);
   dmnsn_vector ac = dmnsn_vector_sub(c, a);
   dmnsn_vector normal = dmnsn_vector_cross(ab, ac);
-  triangle->intrinsic_trans = dmnsn_new_matrix4(ab, ac, normal, a);
+  triangle->object.intrinsic_trans = dmnsn_new_matrix4(ab, ac, normal, a);
 
-  return triangle;
+  return &triangle->object;
 }
 
 /* Allocate a new flat triangle */