home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / raytrace / radiance / simplerd.lha / simplerad / FinalFTP / Light / raycube.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-05-21  |  5.4 KB  |  203 lines
  1. /**********************************************************************/
  2. /* raycube.c                                                          */
  3. /*                                                                    */
  4. /* Ray / cube intersection routines                                   */
  5. /*                                                                    */
  6. /* Modified from Optik v(1.2e) (C) 1987 John Amanatides & Andrew Woo  */
  7. /*                                                                    */
  8. /* Copyright (C) 1992, Bernard Kwok                                   */
  9. /* All rights reserved.                                               */
  10. /* Revision 1.0                                                       */
  11. /* May, 1992                                                          */
  12. /**********************************************************************/
  13. #include <stdio.h>
  14. #include <math.h>
  15. #include "geo.h"
  16. #include "io.h"
  17. #include "misc.h"
  18. #include "struct.h"
  19. #include "ray.h"
  20.  
  21. extern RayStats_Type RayStats;
  22. extern OptionType Option;
  23.  
  24. /**********************************************************************/
  25. /* Find ray intersect of ray (if any) with cube.                      */
  26. /* If checking form factors, return 1st hit closer than maximum hit   */
  27. /* distance. */
  28. /**********************************************************************/
  29. void RayCube(ray, hit, optr)
  30.      register Ray *ray;
  31.      register HitData *hit;
  32.      register Objectt *optr;
  33. {
  34.   register int X, Y, Z;
  35.   double t, x, y, z;
  36.  
  37.   RayStats.rayCube++;
  38.   if (Option.debug)
  39.     printf("\t\tRay-Cube: (%g,%g,%g) > (%g,%g,%g)\n",
  40.        ray->origin.x, ray->origin.y, ray->origin.z, 
  41.        ray->dir.x, ray->dir.y, ray->dir.z);
  42.   
  43.   /* Check direction of ray */
  44.   X = BSGN(ray->dir.x);
  45.   Y = BSGN(ray->dir.y);
  46.   Z = BSGN(ray->dir.z);
  47.   
  48.   /* Check right face of cube */
  49.   if (X != ZERO) {
  50.     t= (1.0-ray->origin.x)/ray->dir.x;
  51.     if (t > MIN_DISTANCE && t < hit->distance) {
  52.       y= ray->origin.y + t*ray->dir.y;
  53.       if (y > -1.0 && y < 1.0) {
  54.     z= ray->origin.z + t*ray->dir.z;
  55.     
  56.     /* Store hit data */
  57.     if (z > -1.0 && z < 1.0) {
  58.       RayStats.intCube++;
  59.       if (Option.visibility == FORM_FACTOR)
  60.         ray->visible = 0.0;
  61.       Store_HitInter(hit,optr,t,1.0,y,z);
  62.       if (!ray->shadow) {
  63.         Store_HitNorm(hit,1.0,0.0,0.0);
  64.         hit->texture= hit->intersect;
  65.       }
  66.     }
  67.       }
  68.     }
  69.   }
  70.  
  71.   /* check left face */
  72.   if (Option.visibility == FORM_FACTOR)
  73.     if (ray->visible == 0.0)
  74.       return;
  75.   if (X != ZERO) {
  76.     t= (-1.-ray->origin.x)/ray->dir.x;
  77.     if (t > MIN_DISTANCE && t < hit->distance) {
  78.       y= ray->origin.y + t*ray->dir.y;
  79.       if (y > -1.0 && y < 1.0) {
  80.     z= ray->origin.z + t*ray->dir.z;
  81.  
  82.     /* Store hit data */
  83.     if (z > -1.0 && z < 1.0) {
  84.       RayStats.intCube++;
  85.       if (Option.visibility == FORM_FACTOR)
  86.         ray->visible = 0.0;
  87.       Store_HitInter(hit, optr, t, -1., y, z);
  88.       if (!ray->shadow) {
  89.         Store_HitNorm(hit, -1., 0., 0.);
  90.         hit->texture= hit->intersect;
  91.       }
  92.     }
  93.       }
  94.     }
  95.   }
  96.  
  97.   /* check back face */
  98.   if (Option.visibility == FORM_FACTOR)
  99.     if (ray->visible == 0.0)
  100.       return;
  101.   if (Y != ZERO) {
  102.     t= (1.-ray->origin.y)/ray->dir.y;
  103.     if (t > MIN_DISTANCE && t < hit->distance) {
  104.       x= ray->origin.x + t*ray->dir.x;
  105.       if (x > -1. && x < 1.) {
  106.     z= ray->origin.z + t*ray->dir.z;
  107.     
  108.     /* Store hit data */
  109.     RayStats.intCube++;
  110.     if (Option.visibility == FORM_FACTOR)
  111.       ray->visible == 0.0;
  112.     if (z > -1.0 && z < 1.0) {
  113.       Store_HitInter(hit, optr, t, x, 1.0, z);
  114.       if (!ray->shadow) {
  115.         Store_HitNorm(hit, 0., 1. ,0.);
  116.         hit->texture= hit->intersect;
  117.       }
  118.     }
  119.       }
  120.     }
  121.   }
  122.  
  123.  
  124.   /* check front face */
  125.   if (Option.visibility == FORM_FACTOR)
  126.     if (ray->visible == 0.0)
  127.       return;
  128.   if (Y != ZERO) {
  129.     t= (-1.-ray->origin.y)/ray->dir.y;
  130.     if (t > MIN_DISTANCE && t < hit->distance) {
  131.       x= ray->origin.x + t*ray->dir.x;
  132.       if (x > -1. && x < 1.) {
  133.     z= ray->origin.z + t*ray->dir.z;
  134.  
  135.     /* Store hit data */
  136.     RayStats.intCube++;
  137.     if (z > -1 && z < 1.) {
  138.       if (Option.visibility == FORM_FACTOR)
  139.         ray->visible == 0.0;
  140.       Store_HitInter(hit, optr, t, x, -1. ,z);
  141.       if (!ray->shadow) {
  142.         Store_HitNorm(hit, 0., -1., 0.);
  143.         hit->texture= hit->intersect;
  144.       }
  145.     }
  146.       }
  147.     }
  148.   }
  149.  
  150.   /* check top face */
  151.   if (Option.visibility == FORM_FACTOR)
  152.     if (ray->visible == 0.0)
  153.       return;
  154.   if (Z != ZERO) {
  155.     t= (1.-ray->origin.z)/ray->dir.z;
  156.     if (t > MIN_DISTANCE && t < hit->distance) {
  157.       x= ray->origin.x + t*ray->dir.x;
  158.       if (x > -1. && x < 1.) {
  159.     y= ray->origin.y + t*ray->dir.y;
  160.     if (y > -1 && y < 1.0) {
  161.  
  162.       /* Store hit data */
  163.       RayStats.intCube++;
  164.       if (Option.visibility == FORM_FACTOR)
  165.         ray->visible == 0.0;
  166.       Store_HitInter(hit, optr, t, x, y, 1.);
  167.       if (!ray->shadow) {
  168.         Store_HitNorm(hit, 0. , 0. ,1.);
  169.         hit->texture= hit->intersect;
  170.       }
  171.     }
  172.       }
  173.     }
  174.   }
  175.  
  176.   /* check bottom face */
  177.   if (Option.visibility == FORM_FACTOR)
  178.     if (ray->visible == 0.0)
  179.       return;
  180.   if (Z != ZERO) {
  181.     t= (-1.-ray->origin.z)/ray->dir.z;
  182.     if (t > MIN_DISTANCE && t < hit->distance) {
  183.       x= ray->origin.x + t*ray->dir.x;
  184.       if (x > -1.0 && x < 1.0) {
  185.     y= ray->origin.y + t*ray->dir.y;
  186.     if (y > -1.0 && y < 1.0) {
  187.  
  188.       /* Store hit data */
  189.       RayStats.intCube++;
  190.       if (Option.visibility == FORM_FACTOR)
  191.         ray->visible == 0.0;
  192.       Store_HitInter(hit, optr, t, x, y, -1.);
  193.       if (!ray->shadow) {
  194.         Store_HitNorm(hit, 0., 0., -1.);
  195.         hit->texture= hit->intersect;
  196.       }
  197.     }
  198.       }
  199.     }
  200.   }
  201. }
  202.  
  203.