cylinder.cpp File Reference

#include "machine.h"
#include "types.h"
#include "macros.h"
#include "vector.h"
#include "intersect.h"
#include "util.h"
#include "cylinder.h"

Include dependency graph for cylinder.cpp:

Go to the source code of this file.

Defines
#define	CYLINDER_PRIVATE
Functions
static int	cylinder_bbox (void *obj, vector *min, vector *max)
static void	cylinder_intersect (cylinder *cyl, ray *ry)
static void	cylinder_normal (cylinder *cyl, vector *pnt, ray *incident, vector *N)
static int	fcylinder_bbox (void *obj, vector *min, vector *max)
static void	fcylinder_intersect (cylinder *cyl, ray *ry)
object *	newcylinder (void *tex, vector ctr, vector axis, flt rad)
object *	newfcylinder (void *tex, vector ctr, vector axis, flt rad)
Variables
static object_methods	cylinder_methods
static object_methods	fcylinder_methods

---

Define Documentation

#define CYLINDER_PRIVATE

Definition at line 71 of file cylinder.cpp.

---

Function Documentation

static int cylinder_bbox	(	void *	obj,
		vector *	min,
		vector *	max
	)		[static]

Definition at line 103 of file cylinder.cpp.

                                                                 {
  return 0; /* infinite / unbounded object */
}

static void cylinder_intersect	(	cylinder *	cyl,
		ray *	ry
	)		[static]

Definition at line 107 of file cylinder.cpp.

References add_intersection(), ray::d, D, FHUGE, ray::o, test::s, VCross(), VDOT, VNorm(), vector::x, vector::y, and vector::z.

                                                         {
  vector rc, n, D, O;  
  flt t, s, tin, tout, ln, d; 

  rc.x = ry->o.x - cyl->ctr.x;
  rc.y = ry->o.y - cyl->ctr.y;
  rc.z = ry->o.z - cyl->ctr.z; 

  VCross(&ry->d, &cyl->axis, &n);

  VDOT(ln, n, n);
  ln=sqrt(ln);    /* finish length calculation */

  if (ln == 0.0) {  /* ray is parallel to the cylinder.. */
    VDOT(d, rc, cyl->axis);         
    D.x = rc.x - d * cyl->axis.x; 
    D.y = rc.y - d * cyl->axis.y;
    D.z = rc.z - d * cyl->axis.z;
    VDOT(d, D, D);
    d = sqrt(d);
    tin = -FHUGE;
    tout = FHUGE;
    /* if (d <= cyl->rad) then ray is inside cylinder.. else outside */
  }

  VNorm(&n);
  VDOT(d, rc, n);
  d = fabs(d); 

  if (d <= cyl->rad) {  /* ray intersects cylinder.. */
    VCross(&rc, &cyl->axis, &O);
    VDOT(t, O, n);
    t = - t / ln;
    VCross(&n, &cyl->axis, &O); 
    VNorm(&O);
    VDOT(s, ry->d, O);
    s = fabs(sqrt(cyl->rad*cyl->rad - d*d) / s);
    tin = t - s;
    add_intersection(tin, (object *) cyl, ry); 
    tout = t + s;
    add_intersection(tout, (object *) cyl, ry);
  }
}

static void cylinder_normal	(	cylinder *	cyl,
		vector *	pnt,
		ray *	incident,
		vector *	N
	)		[static]

Definition at line 151 of file cylinder.cpp.

References ray::d, VDot(), VDOT, VNorm(), VSub(), vector::x, vector::y, and vector::z.

                                                                                      {
  vector a,b,c;
  flt t;

  VSub((vector *) pnt, &(cyl->ctr), &a);

  c=cyl->axis;

  VNorm(&c);
 
  VDOT(t, a, c);

  b.x = c.x * t + cyl->ctr.x; 
  b.y = c.y * t + cyl->ctr.y;
  b.z = c.z * t + cyl->ctr.z;

  VSub(pnt, &b, N); 
  VNorm(N);

  if (VDot(N, &(incident->d)) > 0.0)  { /* make cylinder double sided */
    N->x=-N->x;
    N->y=-N->y;
    N->z=-N->z;
  } 
}

static int fcylinder_bbox	(	void *	obj,
		vector *	min,
		vector *	max
	)		[static]

Definition at line 192 of file cylinder.cpp.

References MYMAX, MYMIN, vector::x, vector::y, and vector::z.

                                                                  {
  cylinder * c = (cylinder *) obj;
  vector mintmp, maxtmp;

  mintmp.x = c->ctr.x;
  mintmp.y = c->ctr.y;
  mintmp.z = c->ctr.z;
  maxtmp.x = c->ctr.x + c->axis.x;
  maxtmp.y = c->ctr.y + c->axis.y;
  maxtmp.z = c->ctr.z + c->axis.z;

  min->x = MYMIN(mintmp.x, maxtmp.x);
  min->y = MYMIN(mintmp.y, maxtmp.y);
  min->z = MYMIN(mintmp.z, maxtmp.z);
  min->x -= c->rad;
  min->y -= c->rad;
  min->z -= c->rad;

  max->x = MYMAX(mintmp.x, maxtmp.x);
  max->y = MYMAX(mintmp.y, maxtmp.y);
  max->z = MYMAX(mintmp.z, maxtmp.z);
  max->x += c->rad;
  max->y += c->rad;
  max->z += c->rad;

  return 1;
}

static void fcylinder_intersect	(	cylinder *	cyl,
		ray *	ry
	)		[static]

Definition at line 221 of file cylinder.cpp.

References add_intersection(), ray::d, ray::o, RAYPNT, test::s, VCross(), VDOT, VNorm(), vector::x, vector::y, and vector::z.

                                                          {
  vector rc, n, O, hit, tmp2, ctmp4;
  flt t, s, tin, tout, ln, d, tmp, tmp3;
 
  rc.x = ry->o.x - cyl->ctr.x;  
  rc.y = ry->o.y - cyl->ctr.y;
  rc.z = ry->o.z - cyl->ctr.z;
 
  VCross(&ry->d, &cyl->axis, &n);
 
  VDOT(ln, n, n);
  ln=sqrt(ln);    /* finish length calculation */
 
  if (ln == 0.0) {  /* ray is parallel to the cylinder.. */
    return;       /* in this case, we want to miss or go through the "hole" */
  }
 
  VNorm(&n);
  VDOT(d, rc, n);
  d = fabs(d);
 
  if (d <= cyl->rad) {  /* ray intersects cylinder.. */
    VCross(&rc, &cyl->axis, &O);
    VDOT(t, O, n);
    t = - t / ln;
    VCross(&n, &cyl->axis, &O);
    VNorm(&O);
    VDOT(s, ry->d, O);
    s = fabs(sqrt(cyl->rad*cyl->rad - d*d) / s);
    tin = t - s;

    RAYPNT(hit, (*ry), tin); 

    ctmp4=cyl->axis;
    VNorm(&ctmp4);

    tmp2.x = hit.x - cyl->ctr.x;   
    tmp2.y = hit.y - cyl->ctr.y;   
    tmp2.z = hit.z - cyl->ctr.z;   

    VDOT(tmp,  tmp2, ctmp4);
    VDOT(tmp3, cyl->axis, cyl->axis);

    if ((tmp > 0.0) && (tmp < sqrt(tmp3))) 
      add_intersection(tin, (object *) cyl, ry);
    tout = t + s;

    RAYPNT(hit, (*ry), tout); 

    tmp2.x = hit.x - cyl->ctr.x;   
    tmp2.y = hit.y - cyl->ctr.y;   
    tmp2.z = hit.z - cyl->ctr.z;   

    VDOT(tmp,  tmp2, ctmp4); 
    VDOT(tmp3, cyl->axis, cyl->axis);

    if ((tmp > 0.0) && (tmp < sqrt(tmp3))) 
      add_intersection(tout, (object *) cyl, ry);
  }
}

object* newcylinder	(	void *	tex,
		vector	ctr,
		vector	axis,
		flt	rad
	)

Definition at line 89 of file cylinder.cpp.

References cylinder_methods, and rt_getmem().

Referenced by rt_cylinder().

                                                                   {
  cylinder * c;
  
  c=(cylinder *) rt_getmem(sizeof(cylinder));
  memset(c, 0, sizeof(cylinder));
  c->methods = &cylinder_methods;

  c->tex=(texture *) tex;
  c->ctr=ctr;
  c->axis=axis;
  c->rad=rad;
  return (object *) c;
}

object* newfcylinder	(	void *	tex,
		vector	ctr,
		vector	axis,
		flt	rad
	)

Definition at line 177 of file cylinder.cpp.

References fcylinder_methods, and rt_getmem().

Referenced by rt_fcylinder().

                                                                    {
  cylinder * c;
  
  c=(cylinder *) rt_getmem(sizeof(cylinder));
  memset(c, 0, sizeof(cylinder));
  c->methods = &fcylinder_methods;

  c->tex=(texture *) tex;
  c->ctr=ctr;
  c->axis=axis;
  c->rad=rad;

  return (object *) c;
}

---

Variable Documentation

object_methods cylinder_methods [static]

Initial value:

 {
  (void (*)(void *, void *))(cylinder_intersect),
  (void (*)(void *, void *, void *, void *))(cylinder_normal),
  cylinder_bbox, 
  free 
}

Definition at line 74 of file cylinder.cpp.

Referenced by newcylinder().

object_methods fcylinder_methods [static]

Initial value:

 {
  (void (*)(void *, void *))(fcylinder_intersect),
  (void (*)(void *, void *, void *, void *))(cylinder_normal),
  fcylinder_bbox, 
  free 
}

Definition at line 81 of file cylinder.cpp.

Referenced by newfcylinder().