---

OptiXRenderer.h

Go to the documentation of this file.

/***************************************************************************
 *cr                                                                       
 *cr            (C) Copyright 1995-2019 The Board of Trustees of the           
 *cr                        University of Illinois                       
 *cr                         All Rights Reserved                        
 *cr                                                                   
 ***************************************************************************/

/***************************************************************************
* RCS INFORMATION:
*
*      $RCSfile: OptiXRenderer.h,v $
*      $Author: johns $      $Locker:  $               $State: Exp $
*      $Revision: 1.133 $         $Date: 2021/05/14 22:35:37 $
*
***************************************************************************/
#ifndef LIBOPTIXRENDERER
#define LIBOPTIXRENDERER

#if defined(_WIN32) || defined(_WIN64) || defined(_MSC_VER)
// OptiX headers require NOMINMAX be defined for Windows builds
#define NOMINMAX 1
#endif

#include <optix.h>
#include <optix_math.h>
#include <stdio.h>
#include <stdlib.h>
#include "Matrix4.h"
#include "ResizeArray.h"
#include "WKFUtils.h"

class VMDApp;
class VMDDisplayList;

// Compile-time flag for collection and reporting of ray statistics
#if 0
#define ORT_RAYSTATS 1
#endif

// Compile-time flag to enable the use of RTX hardware ray tracing
// acceleration APIs in OptiX
#if OPTIX_VERSION >= 60000
#define ORT_USERTXAPIS 1
#endif


// XXX OptiX 4.0 and later versions have a significant performance impact
//     on VMD startup if we use 256-way combinatorial shader specialization.
//     Shader template specialization had very little impact on
//     OptiX versions 3.[789].x previously.  The new LLVM based compiler
//     back-end used in recent versions of OptiX has much more overhead
//     when processing large numbers of shaders single PTX files.
//     If we want to retain the template specialization approach,
//     we will have to generate shader code and store it in many separate
//     PTX files to mitigate overheads in back-end compiler infrastructure.
#if OPTIX_VERSION < 40000
// this macro enables or disables the use of an array of
// template-specialized shaders for every combination of
// scene-wide and material-specific shader features.
#define ORT_USE_TEMPLATE_SHADERS 1
#endif

// #define VMDOPTIX_VCA_TABSZHACK 1
#ifdef VMDOPTIX_VCA_TABSZHACK
#define ORTMTABSZ 64
#else
#define ORTMTABSZ 256
#endif

// When compiling with OptiX 3.8 or greater, we use the new
// progressive rendering APIs rather than our previous hand-coded
// progressive renderer.
#if (defined(VMDOPTIX_VCA) || (OPTIX_VERSION >= 3080)) // && !defined(VMDUSEOPENHMD)
#define VMDOPTIX_PROGRESSIVEAPI 1
#endif

#if 1 || defined(VMDOPTIX_PROGRESSIVEAPI)
#define VMDOPTIX_LIGHTUSEROBJS 1
#endif

// Prevent interactive RT window code from being compiled when
// VMD isn't compiled with an interactive GUI
#if defined(VMDOPTIX_INTERACTIVE_OPENGL) && !defined(VMDOPENGL)
#undef VMDOPTIX_INTERACTIVE_OPENGL
#endif

#if defined(VMDOPTIX_INTERACTIVE_OPENGL)
#include "glwin.h"
#endif

typedef struct {
  RTmaterial mat; 
  int isvalid;
  float ambient;
  float diffuse;
  float specular;
  float shininess;
  float reflectivity;
  float opacity;
  float outline;
  float outlinewidth;
  int transmode;
  int ind;
} ort_material;

typedef struct {
  float dir[3];
  float color[3]; // XXX ignored for now
} ort_directional_light;

typedef struct {
  float pos[3];
  float color[3]; // XXX ignored for now
} ort_positional_light;


class OptiXRenderer {
public: 
  enum ClipMode { RT_CLIP_NONE=0, RT_CLIP_PLANE=1, RT_CLIP_SPHERE=2 };
  enum HeadlightMode { RT_HEADLIGHT_OFF=0, RT_HEADLIGHT_ON=1 };
  enum FogMode  { RT_FOG_NONE=0, RT_FOG_LINEAR=1, RT_FOG_EXP=2, RT_FOG_EXP2=3 };
  enum CameraProjection { RT_PERSPECTIVE=0, 
                          RT_ORTHOGRAPHIC=1,
                          RT_CUBEMAP=2,
                          RT_DOME_MASTER=3,
                          RT_EQUIRECTANGULAR=4,
                          RT_OCULUS_RIFT
                        };
  enum Verbosity { RT_VERB_MIN=0, RT_VERB_TIMING=1, RT_VERB_DEBUG=2 };
  enum BGMode { RT_BACKGROUND_TEXTURE_SOLID=0,
                RT_BACKGROUND_TEXTURE_SKY_SPHERE=1,
                RT_BACKGROUND_TEXTURE_SKY_ORTHO_PLANE=2 };
  enum RayType { RT_RAY_TYPE_RADIANCE=0,      
                 RT_RAY_TYPE_SHADOW=1,        
                 RT_RAY_TYPE_COUNT=2 };       
  enum RayGen  { RT_RAY_GEN_CLEAR_ACCUMULATION_BUFFER=0,
                 RT_RAY_GEN_ACCUMULATE=1,     
                 RT_RAY_GEN_COPY_FINISH=2,    
#if defined(ORT_RAYSTATS)
                 RT_RAY_GEN_CLEAR_RAYSTATS=3, 
                 RT_RAY_GEN_COUNT=4 };        
#else
                 RT_RAY_GEN_COUNT=3 };        
#endif

private:
  VMDApp *app;                            
  Verbosity verbose;                      
  int width;                              
  int height;                             
  char shaderpath[8192];                  

  wkf_timerhandle ort_timer;              
  double time_ctx_create;                 
  double time_ctx_setup;                  
  double time_ctx_validate;               
  double time_ctx_AS_build;               
  double time_ctx_destroy_scene;          
  double time_ray_tracing;                
  double time_image_io;                   

  // OptiX objects managed by VMD
  int context_created;                    
  RTcontext ctx;                          
  RTresult lasterror;                     

#if defined(ORT_USERTXAPIS)
  int rtx_enabled;                        
  int hwtri_enabled;                      
#endif
  int buffers_allocated;                  
  int buffers_progressive;                
  RTbuffer framebuffer;                   
  RTvariable framebuffer_v;               
  RTbuffer accumulation_buffer;           
  RTvariable accumulation_buffer_v;       
  RTvariable accum_count_v;               
#if defined(ORT_RAYSTATS)
  // the ray stats buffers get cleared when clearing the accumulation buffer
  RTbuffer raystats1_buffer;              
  RTvariable raystats1_buffer_v;          
  RTbuffer raystats2_buffer;              
  RTvariable raystats2_buffer_v;          
#endif

  int clipview_mode;                      
  RTvariable clipview_mode_v;             
  float clipview_start;                   
  RTvariable clipview_start_v;            
  float clipview_end;                     
  RTvariable clipview_end_v;              

  int headlight_mode;                     
  RTvariable headlight_mode_v;            

#if defined(VMDOPTIX_LIGHTUSEROBJS)
  RTvariable dir_light_list_v;            
  RTvariable pos_light_list_v;            
#else
  RTvariable dir_lightbuffer_v;           
  RTbuffer dir_lightbuffer;               
  RTvariable pos_lightbuffer_v;           
  RTbuffer pos_lightbuffer;               
#endif

  RTvariable ao_ambient_v;                
  float ao_ambient;                       
  RTvariable ao_direct_v;                 
  float ao_direct;                        
  RTvariable ao_maxdist_v;                
  float ao_maxdist;                       

  RTprogram exception_pgm;                

  int set_accum_raygen_pgm(CameraProjection &proj, int stereo_on, int dof_on);

#if defined(ORT_RAYSTATS)
  RTprogram clear_raystats_buffers_pgm;        
#endif

  RTprogram clear_accumulation_buffer_pgm;     
  RTprogram draw_accumulation_buffer_pgm;      
  RTprogram draw_accumulation_buffer_stub_pgm; 

  RTprogram ray_gen_pgm_cubemap;                    
  RTprogram ray_gen_pgm_cubemap_dof;                
  RTprogram ray_gen_pgm_cubemap_stereo;             
  RTprogram ray_gen_pgm_cubemap_stereo_dof;         

  RTprogram ray_gen_pgm_dome_master;                
  RTprogram ray_gen_pgm_dome_master_dof;            
  RTprogram ray_gen_pgm_dome_master_stereo;         
  RTprogram ray_gen_pgm_dome_master_stereo_dof;     

  RTprogram ray_gen_pgm_equirectangular;            
  RTprogram ray_gen_pgm_equirectangular_dof;        
  RTprogram ray_gen_pgm_equirectangular_stereo;     
  RTprogram ray_gen_pgm_equirectangular_stereo_dof; 

  RTprogram ray_gen_pgm_oculus_rift;                
  RTprogram ray_gen_pgm_oculus_rift_dof;            
  RTprogram ray_gen_pgm_oculus_rift_stereo;         
  RTprogram ray_gen_pgm_oculus_rift_stereo_dof;     

  RTprogram ray_gen_pgm_perspective;           
  RTprogram ray_gen_pgm_perspective_dof;       
  RTprogram ray_gen_pgm_perspective_stereo;    
  RTprogram ray_gen_pgm_perspective_stereo_dof; //< perspective cam (stereo)

  RTprogram ray_gen_pgm_orthographic;            
  RTprogram ray_gen_pgm_orthographic_dof;        
  RTprogram ray_gen_pgm_orthographic_stereo;     
  RTprogram ray_gen_pgm_orthographic_stereo_dof; 

  RTprogram closest_hit_pgm_general;             
#if defined(ORT_USE_TEMPLATE_SHADERS)
  RTprogram closest_hit_pgm_special[ORTMTABSZ];  
#endif
#if defined(ORT_USERTXAPIS)
  RTprogram closest_hit_pgm_general_hwtri;       
#if defined(ORT_USE_TEMPLATE_SHADERS)
  RTprogram closest_hit_pgm_special_hwtri[ORTMTABSZ];  
#endif
#endif

  RTprogram any_hit_pgm_opaque;            
  RTprogram any_hit_pgm_transmission;      
  RTprogram any_hit_pgm_clip_sphere;       

  RTprogram miss_pgm_solid;                
  RTprogram miss_pgm_sky_sphere;           
  RTprogram miss_pgm_sky_ortho_plane;      


  RTmaterial material_general;             
#if defined(ORT_USE_TEMPLATE_SHADERS)
  RTmaterial material_special[ORTMTABSZ];  
#endif
#if defined(ORT_USERTXAPIS)
  RTmaterial material_general_hwtri;       
#if defined(ORT_USE_TEMPLATE_SHADERS)
  RTmaterial material_special_hwtri[ORTMTABSZ];  
#endif
#endif
  int material_special_counts[ORTMTABSZ];  


  // cylinder array primitive
  RTprogram cylinder_array_isct_pgm;       
  RTprogram cylinder_array_bbox_pgm;       
  long cylinder_array_cnt;                 

  // color-per-cylinder array primitive
  RTprogram cylinder_array_color_isct_pgm; 
  RTprogram cylinder_array_color_bbox_pgm; 
  long cylinder_array_color_cnt;           


  // color-per-ring array primitive
  RTprogram ring_array_color_isct_pgm;    
  RTprogram ring_array_color_bbox_pgm;    
  long ring_array_color_cnt;              


  // sphere array primitive
  RTprogram sphere_array_isct_pgm;        
  RTprogram sphere_array_bbox_pgm;        
  long sphere_array_cnt;                  

  // color-per-sphere array primitive
  RTprogram sphere_array_color_isct_pgm;  
  RTprogram sphere_array_color_bbox_pgm;  
  long sphere_array_color_cnt;            


  // triangle mesh primitives of various types
  RTprogram tricolor_isct_pgm;            
  RTprogram tricolor_bbox_pgm;            
  long tricolor_cnt;                      

  RTprogram trimesh_c4u_n3b_v3f_isct_pgm; 
  RTprogram trimesh_c4u_n3b_v3f_bbox_pgm; 
  long trimesh_c4u_n3b_v3f_cnt;           

  RTprogram trimesh_n3f_v3f_isct_pgm;     
  RTprogram trimesh_n3f_v3f_bbox_pgm;     
  long trimesh_n3b_v3f_cnt;               

  RTprogram trimesh_n3b_v3f_isct_pgm;     
  RTprogram trimesh_n3b_v3f_bbox_pgm;     
  long trimesh_n3f_v3f_cnt;               

  RTprogram trimesh_v3f_isct_pgm;         
  RTprogram trimesh_v3f_bbox_pgm;         
  long trimesh_v3f_cnt;                   

  // state variables to hold scene geometry
  int scene_created;
  RTgeometrygroup geometrygroup;          
  RTacceleration  acceleration;           
#if defined(ORT_USERTXAPIS)
  // OptiX RTX hardware-accelerated triangles API
  RTgeometrygroup geometrytrianglesgroup; 
  RTacceleration  trianglesacceleration;  
#endif

  RTgroup         root_group;             
  RTacceleration  root_acceleration;      
  RTvariable      root_object_v;          
  RTvariable      root_shadower_v;        

  //
  // OptiX shader state variables and the like
  //

  // progressive rendering mode (vs. batch)
  RTvariable progressive_enabled_v;     

  unsigned int scene_max_depth;         
  int scene_max_trans;                  
  RTvariable max_depth_v;               
  RTvariable max_trans_v;               

  RTvariable radiance_ray_type_v;       
  RTvariable shadow_ray_type_v;         
  RTvariable scene_epsilon_v;           

  // shadow rendering mode 
  RTvariable shadows_enabled_v;         
  int shadows_enabled;                  

  RTvariable cam_zoom_v;                
  float cam_zoom;                       
  
  RTvariable cam_pos_v;                 
  RTvariable cam_U_v;                   
  RTvariable cam_V_v;                   
  RTvariable cam_W_v;                   

  RTvariable cam_stereo_eyesep_v;           
  float cam_stereo_eyesep;                  
  RTvariable cam_stereo_convergence_dist_v; 
  float cam_stereo_convergence_dist;        

  int dof_enabled;                      
  RTvariable cam_dof_focal_dist_v;      
  RTvariable cam_dof_aperture_rad_v;    
  float cam_dof_focal_dist;             
  float cam_dof_fnumber;                

#if 0
  RTvariable camera_projection_v;       
#endif
  CameraProjection camera_projection;   

  int ext_aa_loops;                     

  RTvariable accum_norm_v;              

  RTvariable aa_samples_v;              
  int aa_samples;                       

  RTvariable ao_samples_v;              
  int ao_samples;                       

  // background color and/or gradient parameters
  BGMode scene_background_mode;         
  RTvariable scene_bg_color_v;          
  float scene_bg_color[3];              
  RTvariable scene_bg_grad_top_v;       
  float scene_bg_grad_top[3];           
  RTvariable scene_bg_grad_bot_v;       
  float scene_bg_grad_bot[3];           
  RTvariable scene_gradient_v;          
  float scene_gradient[3];              
  RTvariable scene_gradient_topval_v;   
  float scene_gradient_topval;          
  RTvariable scene_gradient_botval_v;   
  float scene_gradient_botval;          
  RTvariable scene_gradient_invrange_v; 
  float scene_gradient_invrange;        

  // clipping plane/sphere parameters
  int clip_mode;                        
  float clip_start;                     
  float clip_end;                       

  // fog / depth cueing parameters
  RTvariable fog_mode_v;                
  int fog_mode;                         
  RTvariable fog_start_v;               
  float fog_start;                      
  RTvariable fog_end_v;                 
  float fog_end;                        
  RTvariable fog_density_v;             
  float fog_density;                    

  ResizeArray<ort_material> materialcache; 

  ResizeArray<ort_directional_light> directional_lights; 
  ResizeArray<ort_positional_light> positional_lights;   

  // keep track of all of the OptiX objects we create on-the-fly...
  ResizeArray<RTbuffer> bufferlist;                  
  ResizeArray<RTgeometry> geomlist;                  
  ResizeArray<RTgeometryinstance> geominstancelist;  
#if defined(ORT_USERTXAPIS)
  // OptiX RTX hardware-accelerated triangles API
  ResizeArray<RTgeometrytriangles> geomtriangleslist;
  ResizeArray<RTgeometryinstance> geomtrianglesinstancelist;
#endif

  void append_objects(RTbuffer buf, RTgeometry geom, 
                      RTgeometryinstance instance) {
    bufferlist.append(buf);
    geomlist.append(geom);
    geominstancelist.append(instance);
  }

#if defined(ORT_USERTXAPIS)
  // OptiX RTX hardware-accelerated triangles API
  void append_objects(RTbuffer nbuf, RTbuffer cbuf,
                      RTgeometrytriangles geom_hwtri, 
                      RTgeometryinstance instance_hwtri) {
    bufferlist.append(nbuf);
    bufferlist.append(cbuf);
    geomtriangleslist.append(geom_hwtri);
    geomtrianglesinstancelist.append(instance_hwtri);
  }

  void append_buffer(RTbuffer buf) {
    bufferlist.append(buf);
  }
#endif

  float calc_matrix_scale_factor(const float *matrix);


public:
  OptiXRenderer(VMDApp *vmdapp);
  ~OptiXRenderer(void);

  static unsigned int device_list(int **, char ***);
  static unsigned int device_count(void);
  static unsigned int optix_version(void);

  static int material_shader_table_size(void);

  void check_verbose_env();

  void create_context(void);
  void setup_context(int width, int height);
  
  void report_context_stats(void);

  void shadows_on(int onoff) { shadows_enabled = (onoff != 0); }

  void set_aa_samples(int cnt) { aa_samples = cnt; }

  void set_camera_projection(CameraProjection m) { camera_projection = m; }

  void set_camera_zoom(float zoomfactor) { cam_zoom = zoomfactor; }

  void set_camera_stereo_eyesep(float eyesep) { cam_stereo_eyesep = eyesep; }
  
  void set_camera_stereo_convergence_dist(float dist) {
    cam_stereo_convergence_dist = dist;
  }

  void dof_on(int onoff) { dof_enabled = (onoff != 0); }

  void set_camera_dof_focal_dist(float d) { cam_dof_focal_dist = d; }

  void set_camera_dof_fnumber(float n) { cam_dof_fnumber = n; }

  void set_ao_samples(int cnt) { ao_samples = cnt; }

  void set_ao_ambient(float aoa) { ao_ambient = aoa; }

  void set_ao_direct(float aod) { ao_direct = aod; }

  void set_bg_mode(BGMode m) { scene_background_mode = m; }
  void set_bg_color(float *rgb) { memcpy(scene_bg_color, rgb, sizeof(scene_bg_color)); }
  void set_bg_color_grad_top(float *rgb) { memcpy(scene_bg_grad_top, rgb, sizeof(scene_bg_grad_top)); }
  void set_bg_color_grad_bot(float *rgb) { memcpy(scene_bg_grad_bot, rgb, sizeof(scene_bg_grad_bot)); }
  void set_bg_gradient(float *vec) { memcpy(scene_gradient, vec, sizeof(scene_gradient)); }
  void set_bg_gradient_topval(float v) { scene_gradient_topval = v; }
  void set_bg_gradient_botval(float v) { scene_gradient_botval = v; }

  void set_clip_sphere(ClipMode mode, float start, float end) {
    clip_mode = mode;
    clip_start = start;
    clip_end = end;
  }

  void set_cue_mode(FogMode mode, float start, float end, float density) {
    fog_mode = mode;
    fog_start = start;
    fog_end = end;
    fog_density = density;
  }

  void init_materials();
  void add_material(int matindex, float ambient, float diffuse,
                    float specular, float shininess, float reflectivity,
                    float opacity, float outline, float outlinewidth, 
                    int transmode);
  void set_material(RTgeometryinstance instance, int matindex, 
                    const float *uniform_color, int hwtri=0);

  void clear_all_lights() { 
    directional_lights.clear(); 
    positional_lights.clear(); 
  }
  void set_clipview_mode(int mode) { 
    clipview_mode = mode;
  };
  void set_headlight_onoff(int onoff) { 
    headlight_mode = (onoff==1) ? RT_HEADLIGHT_ON : RT_HEADLIGHT_OFF; 
  };
  void add_directional_light(const float *dir, const float *color);
  void add_positional_light(const float *pos, const float *color);

  void update_rendering_state(int interactive);

  void framebuffer_config(int fbwidth, int fbheight, int interactive);
  void framebuffer_resize(int fbwidth, int fbheight);
  void framebuffer_map_rgb4u(unsigned char **imgrgb4u);
  void framebuffer_unmap();
  void framebuffer_destroy(void);

  void render_compile_and_validate(void);
  void render_to_file(const char *filename, int writealpha); 
#if defined(VMDOPTIX_INTERACTIVE_OPENGL)
  void render_to_glwin(const char *filename, int writealpha);
#endif
  void render_to_videostream(const char *filename, int writealpha);

#if defined(VMDOPTIXRTRT)

  void add_material_cmdlist(const VMDDisplayList *cmdList);

  void scene_aggregate_cmdlist(const VMDDisplayList *cmdList, 
                               const float *colorData);

  void scene_aggregation_complete();

  void render_current_scene();  
#endif

  void destroy_scene(void);
  void destroy_context(void);

  void cylinder_array(Matrix4 *wtrans, float rscale, const float *uniform_color,
                      int cylnum, const float *points, int matindex);

  void cylinder_array_color(Matrix4 *wtrans, float rscale, int cylnum, 
                            const float *points, const float *radii, 
                            const float *colors, int matindex);

  void ring_array_color(Matrix4 & wtrans, float rscale, int rnum, 
                        const float *centers, const float *norms, 
                        const float *radii, const float *colors, int matindex);

  void sphere_array(Matrix4 *wtrans, float rscale, const float *uniform_color,
                    int spnum, const float *centers, const float *radii, 
                    int matindex);

  void sphere_array_color(Matrix4 & wtrans, float rscale, int spnum, 
                          const float *centers, const float *radii, 
                          const float *colors, int matindex);


  // 
  // Triangle mesh geometry
  //   Beginning with OptiX 5.2 and Turing-class GPUs, VMD uses the new
  //   NVIDIA RTX hardware-accelerated triangle APIs.  In combination with
  //   general OptiX software improvements, the Turing GPUs implement 
  //   hardware-accelerated BVH traversal, BVH-embedded storage of
  //   triangle meshes, and hardware-accelerated triangle intersection.
  //   In combination, these advances can provide a factor of ~8x
  //   performance gain compared with the classic OptiX APIs running on 
  //   Volta-class hardware.
  // 
#if defined(ORT_USERTXAPIS)
  void tricolor_list_hwtri(Matrix4 & wtrans, 
                           int numtris, const float *vnc, int matindex);
#endif
  void tricolor_list(Matrix4 & wtrans, 
                     int numtris, const float *vnc, int matindex);


#if defined(ORT_USERTXAPIS)
  void trimesh_c4n3v3_hwtri(Matrix4 & wtrans, 
                            int numverts, const float *cnv, 
                            int numfacets, const int * facets, 
                            int matindex);
#endif
  void trimesh_c4n3v3(Matrix4 & wtrans, 
                      int numverts, const float *cnv, 
                      int numfacets, const int * facets, 
                      int matindex);


#if defined(ORT_USERTXAPIS)
  void trimesh_c4u_n3b_v3f_hwtri(Matrix4 & wtrans, const unsigned char *c, 
                                 const signed char *n, const float *v, 
                                 int numfacets, int matindex);
#endif
  void trimesh_c4u_n3b_v3f(Matrix4 & wtrans, const unsigned char *c, 
                           const signed char *n, const float *v, 
                           int numfacets, int matindex);


#if defined(ORT_USERTXAPIS)
  void trimesh_c4u_n3f_v3f_hwtri(Matrix4 & wtrans, const unsigned char *c, 
                                 const float *n, const float *v, 
                                 int numfacets, int matindex);
#endif
  void trimesh_c4u_n3f_v3f(Matrix4 & wtrans, const unsigned char *c, 
                           const float *n, const float *v, 
                           int numfacets, int matindex);


#if defined(ORT_USERTXAPIS)
  void trimesh_n3b_v3f_hwtri(Matrix4 & wtrans, const float *uniform_color, 
                             const signed char *n, const float *v, 
                             int numfacets, int matindex);
#endif
  void trimesh_n3b_v3f(Matrix4 & wtrans, const float *uniform_color, 
                       const signed char *n, const float *v, 
                       int numfacets, int matindex);


#if defined(ORT_USERTXAPIS)
  void trimesh_n3f_v3f_hwtri(Matrix4 & wtrans, const float *uniform_color, 
                             const float *n, const float *v, 
                             int numfacets, int matindex);
#endif
  void trimesh_n3f_v3f(Matrix4 & wtrans, const float *uniform_color, 
                       const float *n, const float *v, 
                       int numfacets, int matindex);


#if defined(ORT_USERTXAPIS)
  void trimesh_v3f_hwtri(Matrix4 & wtrans, const float *uniform_color, 
                         const float *v, int numfacets, int matindex);
#endif
  void trimesh_v3f(Matrix4 & wtrans, const float *uniform_color, 
                   const float *v, int numfacets, int matindex);


#if defined(ORT_USERTXAPIS)
  void tristrip_hwtri(Matrix4 & wtrans, 
                      int numverts, const float * cnv,
                      int numstrips, const int *vertsperstrip,
                      const int *facets, int matindex);
#endif
  void tristrip(Matrix4 & wtrans, 
                int numverts, const float * cnv,
                int numstrips, const int *vertsperstrip,
                const int *facets, int matindex);

}; 

#endif

---