tachyon.h

Go to the documentation of this file.

/*
 * tachyon.h - Tachyon public APIs used to drive the ray tracing engine.
 *
 * (C) Copyright 1994-2022 John E. Stone
 * SPDX-License-Identifier: BSD-3-Clause
 *
 * $Id: tachyon.h,v 1.146 2022/04/23 15:23:51 johns Exp $
 *
 */

#if !defined(TACHYON_H)
#define TACHYON_H 1

#ifdef  __cplusplus
extern "C" {
#endif

#include "util.h"    /* rt_timer_xxx() and rt_rand() */
#include "hash.h"    /* rt_hash_xxx() */

/******************************************************************/
/* Constants and types defined for use with the Tachyon API calls */
/******************************************************************/

/*
 * Tachyon version strings for feature detection and compatibility testing.
 */
#define TACHYON_VERSION_STRING      "0.99.5"  
#define TACHYON_MAJOR_VERSION       0         
#define TACHYON_MINOR_VERSION       99        
#define TACHYON_PATCH_VERSION       5         
/*
 * Build Tachyon and its interfaces using either double- or single-precision
 * floating point types, based on compile-time defition of the
 * USESINGLEFLT macro.
 */
#ifdef USESINGLEFLT
typedef float flt;   
#else
typedef double flt;  
#endif
typedef flt apiflt;  
typedef void * SceneHandle;

typedef struct {
   flt x;          
   flt y;          
   flt z;          
} apivector;

typedef struct {
   float r;        
   float g;        
   float b;        
} apicolor;

typedef struct {
  int texturefunc; 
  apicolor col;    
  int shadowcast;  
  flt ambient;     
  flt diffuse;     
  flt specular;    
  flt opacity;     
  apivector ctr;   
  apivector rot;   
  apivector scale; 
  apivector uaxs;  
  apivector vaxs;  
  apivector waxs;  
  char imap[96];   
} apitexture;

/********************************************/
/* Functions implemented to provide the API */
/********************************************/

apivector rt_vector(flt x, flt y, flt z);

apicolor  rt_color(flt r, flt g, flt b);  
void rt_set_ui_message(void (* func) (int, char *)); 

void rt_set_ui_progress(void (* func) (int));

/* Backwards compatibility with older revs of Tachyon that provided 
 * convenience wrappers for parallel runs on the Intel iPSC/860 NX OS.
 */
int rt_mynode(void);    
int rt_numnodes(void);  
int rt_initialize_nompi(); 

int rt_initialize(int *, char ***); 


int rt_initialize_mpi_comm_world(); 

int rt_initialize_mpi_comm(void *mpicomm);

int rt_initialize_mpi_comm_split(void *mpicomm, int color, int key);

int rt_set_mpi_comm(void *mpicomm);

int rt_set_mpi_comm_split(void *mpicomm, int color, int key);

int rt_set_mpi_comm_world(void);

int rt_set_mpi_comm_world_split(int color, int key);

int rt_set_mpi_comm_world_split_all(void);


void rt_finalize(void); 

SceneHandle rt_newscene(void); 

void rt_deletescene(SceneHandle);

void rt_renderscene(SceneHandle);

void rt_outputfile(SceneHandle, const char * outname); 

/* 
 * 24-bit color image formats
 */
#define RT_FORMAT_TARGA                 0  
#define RT_FORMAT_PPM                   1  
#define RT_FORMAT_SGIRGB                2  
#define RT_FORMAT_JPEG                  3  
#define RT_FORMAT_WINBMP                4  
#define RT_FORMAT_PNG                   5  
/*
 * 48-bit deep-color image formats
 */
#define RT_FORMAT_PPM48                 6  
#define RT_FORMAT_PSD48                 7  
void rt_outputformat(SceneHandle, int format);

void rt_resolution(SceneHandle, int hres, int vres);

void rt_get_resolution(SceneHandle, int *hres, int *vres);

void rt_aspectratio(SceneHandle voidscene, float aspectratio);

void rt_get_aspectratio(SceneHandle voidscene, float *aspectratio);

/*
 * Image cropping modes
 */
#define RT_CROP_DISABLED                0  
#define RT_CROP_ENABLED                 1  
void rt_crop_output(SceneHandle, int hres, int vres, int lx, int ly);

void rt_crop_disable(SceneHandle);

void rt_aa_maxsamples(SceneHandle, int maxsamples);

void rt_verbose(SceneHandle, int v);

/*
 * Surface normal and winding order fixup mode constants used
 * to optionally auto-correct triangles with interpolate normals
 */
#define RT_NORMAL_FIXUP_OFF   0  
#define RT_NORMAL_FIXUP_FLIP  1  
#define RT_NORMAL_FIXUP_GUESS 2  
void rt_normal_fixup_mode(SceneHandle, int mode);

void rt_image_clamp(SceneHandle voidscene);

void rt_image_normalize(SceneHandle voidscene);

void rt_image_gamma(SceneHandle voidscene, float gamma);

void rt_rawimage_rgb24(SceneHandle, unsigned char *rawimage);

void rt_rawimage_rgb96f(SceneHandle, float *rawimage);

#if 1
/*
 * Accumulation buffer mode constants
 */
#define RT_ACCUMULATE_OFF      0  
#define RT_ACCUMULATE_ON       1  
#define RT_ACCUMULATE_CLEAR    2  
void rt_accumulation_mode(SceneHandle, int mode);
#endif

void rt_set_numthreads(SceneHandle, int);

void rt_background(SceneHandle, apicolor);

void rt_background_gradient(SceneHandle, apivector up, 
                            flt topval, flt botval,
                            apicolor topcolor, apicolor botcolor);

/* 
 * Background texture modes for rt_background_mode, 
 * determines behavior to use when rays don't hit any objects.
 */
#define RT_BACKGROUND_TEXTURE_SOLID            0  
#define RT_BACKGROUND_TEXTURE_SKY_SPHERE       1  
#define RT_BACKGROUND_TEXTURE_SKY_ORTHO_PLANE  2  
void rt_background_mode(SceneHandle, int mode);

/*
 * Fog modes for rt_fog_rendering_mode()
 */
#define RT_FOG_NORMAL     0  
#define RT_FOG_OPENGL     1  
#define RT_FOG_VMD        1  
void rt_fog_rendering_mode(SceneHandle, int);

/*
 * Fog type parameters.
 */
#define RT_FOG_NONE       0  
#define RT_FOG_LINEAR     1  
#define RT_FOG_EXP        2  
#define RT_FOG_EXP2       3  
void rt_fog_mode(SceneHandle, int);

void rt_fog_parms(SceneHandle, apicolor col, 
                  flt start, flt end, flt density);

void rt_trans_max_surfaces(SceneHandle, int maxsurfaces);

/*
 * Transparency mode flags for rt_trans_mode()
 */
#define RT_TRANS_ORIG     0  
#define RT_TRANS_VMD      1  
#define RT_TRANS_RASTER3D 2  
void rt_trans_mode(SceneHandle, int mode);

void rt_shadow_filtering(SceneHandle, int mode);


/*
 * Parameter values for rt_boundmode()
 */
#define RT_BOUNDING_DISABLED 0  
#define RT_BOUNDING_ENABLED  1  
void rt_boundmode(SceneHandle, int mode);

void rt_boundthresh(SceneHandle, int threshold);


/**************************/
/* Camera definition APIs */
/**************************/

/*
 * Parameter values for rt_camera_projection()
 */
#define RT_PROJECTION_PERSPECTIVE      0  
#define RT_PROJECTION_ORTHOGRAPHIC     1  
#define RT_PROJECTION_PERSPECTIVE_DOF  2  
#define RT_PROJECTION_ORTHOGRAPHIC_DOF 3  
#define RT_PROJECTION_EQUIRECTANGULAR  4  
#define RT_PROJECTION_FISHEYE          5  
#define RT_PROJECTION_STEREO_EQUIRECTANGULAR  6  
void rt_camera_projection(SceneHandle, int mode);

void rt_camera_position(SceneHandle, apivector center, apivector viewdir, 
                        apivector updir);

void rt_camera_position3fv(SceneHandle, const float *center, 
                           const float *viewdir, const float *updir);

void rt_get_camera_position(SceneHandle, apivector *center, apivector *viewdir,
                            apivector *updir, apivector *rightdir);

void rt_get_camera_position3fv(SceneHandle, float *center, float *viewdir,
                               float *updir, float *rightdir);

void rt_camera_raydepth(SceneHandle, int maxdepth);

void rt_camera_zoom(SceneHandle, flt zoom);

flt rt_get_camera_zoom(SceneHandle);

void rt_camera_eye_separation(SceneHandle, flt eyesep);

flt rt_get_camera_eye_separation(SceneHandle);

void rt_camera_modulate_eye_separation(SceneHandle, flt cospow);

flt rt_get_camera_modulate_eye_separation(SceneHandle);

void rt_camera_vfov(SceneHandle, flt vfov);

flt rt_get_camera_vfov(SceneHandle);


void rt_camera_frustum(SceneHandle, flt left, flt right, flt bottom, flt top);

void rt_camera_dof(SceneHandle voidscene, flt focaldist, flt aperture);


/***********************/
/*Texture mapping APIs */
/***********************/

/*
 * Object texture mapping functions.
 */
#define RT_TEXTURE_CONSTANT             0  
#define RT_TEXTURE_3D_CHECKER           1  
#define RT_TEXTURE_GRIT                 2  
#define RT_TEXTURE_MARBLE               3  
#define RT_TEXTURE_WOOD                 4  
#define RT_TEXTURE_GRADIENT             5  
#define RT_TEXTURE_CYLINDRICAL_CHECKER  6  
#define RT_TEXTURE_CYLINDRICAL_IMAGE    7  
#define RT_TEXTURE_SPHERICAL_IMAGE      8  
#define RT_TEXTURE_PLANAR_IMAGE         9  
#define RT_TEXTURE_VOLUME_IMAGE        10  
void * rt_texture(SceneHandle, apitexture *);

void rt_define_teximage_rgb24(const char *name, int xsize, int ysize, int zsize,
                              unsigned char *rgb24data);

void * rt_texture_copy_standard(SceneHandle, void *oldtex);

void * rt_texture_copy_vcstri(SceneHandle, void *oldtex);


/*****************************/
/* Shading and lighting APIs */
/*****************************/

/*
 * Shader mode settings for rt_shadermode()
 * These are sorted from lowest quality (and fastest execution)
 * to highest quality (and slowest execution)
 */
#define RT_SHADER_AUTO       0  
#define RT_SHADER_LOWEST     1  
#define RT_SHADER_LOW        2  
#define RT_SHADER_MEDIUM     3  
#define RT_SHADER_HIGH       4  
#define RT_SHADER_FULL       5  
void rt_shadermode(SceneHandle voidscene, int mode);


/*
 * Shader modes for rt_phong_shader()
 */
#define RT_SHADER_NULL_PHONG 0 
#define RT_SHADER_BLINN_FAST 1 
#define RT_SHADER_BLINN      2 
#define RT_SHADER_PHONG      3 
void rt_phong_shader(SceneHandle voidscene, int mode);

/*
 * Phong types
 */
#define RT_PHONG_PLASTIC     0  
#define RT_PHONG_METAL       1  
void rt_tex_phong(void * voidtex, flt phong, flt phongexp, int type); 

void rt_tex_transmode(void * voidtex, int transmode);

void rt_tex_outline(void * voidtex, flt outline, flt outlinewidth); 


void rt_rescale_lights(SceneHandle, flt lightscale);


void * rt_light(SceneHandle, void *tex, apivector center, flt radius);     

void * rt_light3fv(SceneHandle, void *tex, const float *center, float radius);


void * rt_directional_light(SceneHandle, void *tex, apivector direction);     

void * rt_directional_light3fv(SceneHandle, void *tex, const float *direction);


void * rt_spotlight(SceneHandle, void *tex, apivector center, flt radius,
                    apivector direction, flt fallstart, flt fallend);     
void * rt_spotlight3fv(SceneHandle, void *tex, const float *center, 
                       float radius, const float *direction, 
                       float fallstart, float fallend);     


void rt_light_attenuation(void *light, flt constfactor, 
                          flt linearfactor, flt quadfactor);

#define RT_AO_MAXDIST_UNLIMITED 3.402823e+38 
void rt_ambient_occlusion(void *scene, int numsamples, 
                          flt maxdist, apicolor col);

/************************/
/* Object Creation APIs */
/************************/
void rt_clip_fv(SceneHandle, int numplanes, const float * planes);

void rt_clip_dv(SceneHandle, int numplanes, const double * planes);

void rt_clip_off(SceneHandle);


void rt_cylinder(SceneHandle, void *tex, apivector center, 
                 apivector axis, flt radius);
void rt_cylinder3fv(SceneHandle, void *tex, const float *center, 
                    const float *axis, float radius);


void rt_fcylinder(SceneHandle, void *tex, apivector center, 
                  apivector axis, flt radius);
void rt_fcylinder3fv(SceneHandle, void *tex, const float *center, 
                     const float *axis, float radius);


void rt_polycylinder(SceneHandle, void *tex, apivector *points, 
                     int numpoints, flt radius);
void rt_polycylinder3fv(SceneHandle, void *tex, const float *points, 
                        int numpoints, float radius);


void rt_sphere(SceneHandle, void *tex, apivector center, flt radius);
void rt_sphere3fv(SceneHandle, void *tex, const float *center, float radius);


void rt_plane(SceneHandle, void *tex, apivector center, apivector normal);
void rt_plane3fv(SceneHandle, void *tex, const float *center, 
                 const float *normal);


void rt_ring(SceneHandle, void *tex, apivector center, apivector mormal, 
             flt innerrad, flt outerrad); 
void rt_ring3fv(SceneHandle, void *tex, const float *center, 
                const float *normal, float innerrad, float outerrad); 


void rt_tri(SceneHandle, void *tex, apivector v0, apivector v1, apivector v2);  
void rt_tri3fv(SceneHandle, void *tex,
               const float *v0, const float *v1, const float *v2);  


void rt_stri(SceneHandle, void *, apivector v0, apivector v1, apivector v2, 
             apivector n0, apivector n1, apivector n2); 
void rt_stri3fv(SceneHandle, void *, 
                const float *v0, const float *v1, const float *v2, 
                const float *n0, const float *n1, const float *n2); 


void rt_vcstri(SceneHandle, void *tex, apivector v0, apivector v1, apivector v2,
               apivector n0, apivector n1, apivector n2,
               apicolor c0, apicolor c1, apicolor c2); 
void rt_vcstri3fv(SceneHandle, void *tex, 
                  const float *v0, const float *v1, const float *v2,
                  const float *n0, const float *n1, const float *n2,
                  const float *c0, const float *c1, const float *c2); 


void rt_tristripscnv3fv(SceneHandle scene, void * tex,
                        int numverts, const float * cnv,
                        int numstrips, const int *vertsperstrip, 
                        const int *facets);


void rt_extvol(SceneHandle, void *tex, 
               apivector mincoord, apivector maxcoord, 
               int samples, flt (* evaluator)(flt, flt, flt)); 

void rt_scalarvol(SceneHandle, void *tex, 
                  apivector mincoord, apivector maxcoord,
                  int xsize, int ysize, int zsize, 
                  const char *filename, void *invol); 


void rt_heightfield(SceneHandle, void *tex, apivector center, 
                    int m, int n, flt *field, flt wx, flt wy);

void rt_landscape(SceneHandle, void *tex, int m, int n, 
                  apivector center,  flt wx, flt wy);


void rt_box(SceneHandle, void *tex, apivector mincoord, apivector maxcoord);  


void rt_quadsphere(SceneHandle, void *tex, apivector center, flt rad);


/*
 * Include now-deprecated Tachyon APIs, unless the user has told us not to
 */
#if !defined(TACHYON_NO_DEPRECATED)
#include "tachyon_dep.h"
#endif


/*
 * Internal Tachyon APIs and data structures.
 * Application developers should not be using anything below this point
 * in the header file.
 */
#if defined(TACHYON_INTERNAL)

#ifdef USESINGLEFLT
/* All floating point types will be based on "float" */
#define SPEPSILON   0.0004f     
#define EPSILON     0.0004f     
#define FHUGE       1e18f       
#define TWOPI       6.28318531f 
#define MINCONTRIB  0.001959f   
#else
/* All floating point types will be based on "double" */
#define SPEPSILON   0.000000001 
#define EPSILON     0.000000001 
#define FHUGE       1e18        
#define TWOPI       6.28318531  
#define MINCONTRIB  0.001959    
#endif

#define BOUNDTHRESH 16          
/* 
 * Maximum internal table sizes 
 * Use prime numbers for best memory system performance
 * (helps avoid cache aliasing..)
 */
#define MAXIMGS   39            
/* 
 * Ray flags 
 *
 * These are used in order to skip calculations which are only
 * needed some of the time.  For example, when shooting shadow
 * rays, we only have to find *one* intersection that's valid, 
 * if we find even one, we can quit early, thus saving lots of work.
 */
#define RT_RAY_PRIMARY   1  
#define RT_RAY_REGULAR   2  
#define RT_RAY_SHADOW    4  
#define RT_RAY_FINISHED  8  
#define RT_SHADE_NOFLAGS                0  
#define RT_SHADE_LIGHTING               1  
#define RT_SHADE_PHONG                  2  
#define RT_SHADE_TEXTURE_MAPS           4  
#define RT_SHADE_MIPMAP                 8  
#define RT_SHADE_REFLECTION            16  
#define RT_SHADE_REFRACTION            32  
#define RT_SHADE_SHADOWS               64  
#define RT_SHADE_VOLUMETRIC           128  
#define RT_SHADE_ANTIALIASING         256  
#define RT_SHADE_DEPTH_OF_FIELD       512  
#define RT_SHADE_SOFT_SHADOW         1024  
#define RT_SHADE_VOLUMETRIC_SHADOW   2048  
#define RT_SHADE_CLIPPING            4096  
#define RT_SHADE_AMBIENTOCCLUSION    8192  
/* 
 * Texture flags
 * 
 * These are used in order to skip calculations that are only needed
 * some of the time.
 */
#define RT_TEXTURE_NOFLAGS      0 
#define RT_TEXTURE_SHADOWCAST   1 
#define RT_TEXTURE_ISLIGHT      2 
/*
 * Image buffer format flags
 */
#define RT_IMAGE_BUFFER_RGB24   0 
#define RT_IMAGE_BUFFER_RGB96F  1 
/*
 * Image post-processing flags
 */
#define RT_IMAGE_CLAMP          0 
#define RT_IMAGE_NORMALIZE      1 
#define RT_IMAGE_GAMMA          2 
struct ray_t;
typedef unsigned char byte; /* 1 byte */
typedef apivector vector;
typedef apicolor color;


typedef struct {         
  int loaded;            
  int xres;              
  int yres;              
  int zres;              
  int bpp;               
  char name[96];         
  unsigned char * data;  
} rawimage;


typedef struct {
  int levels;
  rawimage ** images;
} mipmap;


typedef struct {         
  int loaded;            
  int xres;              
  int yres;              
  int zres;              
  flt opacity;           
  char name[96];         
  unsigned char * data;  
} scalarvol;


/*
 * Background texture data structure
 */
typedef struct {
  color bg_color;        
  color bg_grad_top;     
  color bg_grad_bot;     
  vector bg_grad_updir;  
  flt bg_grad_topval;    
  flt bg_grad_botval;    
  flt bg_grad_invrange;  
  flt bg_grad_noisemag;  
} background_texture;

/*
 * Object texture data structures
 */
typedef struct {
  void (* freetex)(void *);   
} texture_methods;

#define RT_TEXTURE_HEAD \
  color (* texfunc)(const void *, const void *, void *);                   \
  texture_methods * methods;                 \
  unsigned int flags;                      \
  float ambient;                                   \
  float diffuse;                                 \
  float phong;                            \
  float phongexp;                   \
  int phongtype;                  \
  float specular;                               \
  float opacity;                           \
  int transmode;                       \
  float outline;                               \
  float outlinewidth;         
typedef struct {
  RT_TEXTURE_HEAD
} texture;

typedef struct {
  RT_TEXTURE_HEAD
  color  col;         
  vector ctr;         
  vector rot;         
  vector scale;       
  vector uaxs;        
  vector vaxs;        
  vector waxs;        
  void * img;         
  void * obj;         
} standard_texture;

typedef struct {
  RT_TEXTURE_HEAD
  void * obj;         
  color c0;           
  color c1;           
  color c2;           
} vcstri_texture;


/*
 * Object data structures
 */
typedef struct {
  void (* intersect)(const void *, void *);      
  void (* normal)(const void *, const void *, const void *, void *); 
  int (* bbox)(void *, vector *, vector *);      
  void (* freeobj)(void *);                      
} object_methods;


/*
 * Clipping plane data structure
 */
typedef struct {
  int numplanes;             
  flt * planes;              
} clip_group;
 

#define RT_OBJECT_HEAD \
  unsigned int id;            \
  void * nextobj;             \
  object_methods * methods;   \
  clip_group * clip;          \
  texture * tex;             
typedef struct {
  RT_OBJECT_HEAD
} object; 


typedef struct {
  const object * obj;        
  flt t;                     
} intersection;


typedef struct {
  int num;                   
  intersection closest;      
  flt shadowfilter;          
} intersectstruct;


/* camera related defines etc */
#define RT_CAMERA_FRUSTUM_AUTO 0   
#define RT_CAMERA_FRUSTUM_USER 1   
typedef struct {
  int frustumcalc;           
  int projection;            
  vector center;             
  vector viewvec;            
  vector rightvec;           
  vector upvec;              
  flt camzoom;               
  flt px;                    
  flt py;                    
  flt psx;                   
  flt psy;                   
  flt dof_focaldist;         
  flt left;                  
  flt right;                 
  flt top;                   
  flt bottom;                
  flt dof_aperture_rad;      
  vector projcent;           
  flt eyeshift;              
  int modulate_eyeshift;     
  flt modulate_eyeshift_pow; 
  color (* cam_ray)(void *, flt, flt);   
  vector lowleft;            
  vector iplaneright;        
  vector iplaneup;           
} camdef;

typedef struct fogdata_t {
  color (* fog_fctn)(struct fogdata_t *, color, flt);   
  int type;                  
  color col;                 
  flt start;                 
  flt end;                   
  flt density;               
} fogdata;

typedef struct amboccdata_t {
  int numsamples;            
  flt ao_maxdist;            
  color col;                 
} amboccludedata;

typedef struct {
  int numcpus;               
  flt cpuspeed;              
  flt nodespeed;             
  char machname[512];        
  void *cpucaps;             
} nodeinfo;

typedef struct list {
  void * item;
  struct list * next;
} list;

typedef struct {
  vector hit;  
  vector N;    
  vector L;    
  flt    Llen; 
} shadedata;

typedef struct {
  int cropmode; 
  int xres;     
  int yres;     
  int xstart;   
  int ystart;   
} cropinfo;

typedef struct {
  object * boundedobj;       
  object * unboundedobj;     
  int numobjects;            
} displist;

typedef void * rt_parhandle;
typedef void * rt_parbuf;
 
typedef struct {
  char outfilename[256];     
  int writeimagefile;        
  void * img;                
  int imginternal;           
  int imgprocess;            
  float imggamma;            
  int imgbufformat;          
  int imgfileformat;         
  cropinfo imgcrop;          
#if defined(RT_ACCUMULATE_ON)
  float *accum_buf;          
  unsigned int accum_count;  
  int accum_mode;            
#endif
  int numthreads;            
  int nodes;                 
  int mynode;                
  nodeinfo * cpuinfo;        
  int hres;                  
  int vres;                  
  flt aspectratio;           
  int raydepth;              
  int transcount;            
  int shadowfilter;          
  int antialiasing;          
  int verbosemode;           
  int boundmode;             
  int boundthresh;           
  list * texlist;            
  list * cliplist;           
  unsigned int flags;        
  camdef camera;             
  color (* shader)(void *);  
  flt (* phongfunc)(const struct ray_t * incident, const shadedata * shadevars, flt specpower);              
  int transmode;             
  background_texture bgtex;  
  color (* bgtexfunc)(struct ray_t * incident); 
  fogdata fog;               
  displist objgroup;         
  list * lightlist;          
  flt light_scale;           
  int numlights;             
  amboccludedata ambocc;     
  int scenecheck;            
  rt_parhandle parhnd;       
  rt_parbuf parbuf;          
  void * threads;            
  void * threadparms;        
  clip_group * curclipgroup; 
  int normalfixupmode;       
} scenedef;


typedef struct ray_t {
  vector o;              
  vector d;              
  flt maxdist;           
  flt opticdist;         
  void (* add_intersection)(flt, const object *, struct ray_t *); 
  intersectstruct intstruct; 
  unsigned int depth;    
  int transcnt;          
  unsigned int flags;    
  unsigned long serial;  
  unsigned long * mbox;  
  scenedef * scene;      
  unsigned int idx;      
  unsigned int randval;  
  rng_frand_handle frng; 
} ray;


#endif

#ifdef  __cplusplus
}
#endif
#endif