---

FileRenderer.h

Go to the documentation of this file.

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

/***************************************************************************
 * RCS INFORMATION:
 *
 *      $RCSfile: FileRenderer.h,v $
 *      $Author: johns $        $Locker:  $             $State: Exp $
 *      $Revision: 1.115 $      $Date: 2012/03/13 18:41:55 $
 *
 ***************************************************************************
 * DESCRIPTION:
 *
 * The FileRenderer class implements the data and functions needed to 
 * render a scene to a file in some format (postscript, raster3d, etc.)
 *
 ***************************************************************************/
#ifndef FILERENDERER_H
#define FILERENDERER_H

#include <stdio.h>

#include "DisplayDevice.h"
#include "Scene.h"
#include "NameList.h"
#include "Inform.h"

#define FILERENDERER_NOWARNINGS    0
#define FILERENDERER_NOMISCFEATURE 1
#define FILERENDERER_NOCLIP        2
#define FILERENDERER_NOCUEING      4
#define FILERENDERER_NOTEXTURE     8
#define FILERENDERER_NOGEOM       16
#define FILERENDERER_NOTEXT       32

class FileRenderer : public DisplayDevice {
protected:
  char *publicName;         
  char *publicPrettyName;   
  char *defaultFilename;    
  char *defaultCommandLine; 

  char *execCmd;     
  FILE *outfile;     
  int isOpened;      
  char *my_filename; 
  int has_aa;        
  int aasamples;     
  int aosamples;     
  int has_imgsize;   

  int warningflags;  


  int imgwidth, imgheight;  
  float aspectratio;        
  NameList<int> formats;    
  int curformat;     

  float textoffset_x; 
  float textoffset_y; 

  virtual void update_exec_cmd() {}

  struct LightState {
    float color[3];             
    float pos[3];               
    int on;                     
  };
  LightState lightState[DISP_LIGHTS]; 

  struct AdvancedLightState {
    float color[3];             
    float pos[3];               
    float constfactor;          
    float linearfactor;         
    float quadfactor;           
    float spotdir[3];           
    float fallstart;            
    float fallend;              
    int spoton;                 
    int on;                     
  };
  AdvancedLightState advLightState[DISP_LIGHTS]; 

  float matData[MAXCOLORS][3];
  virtual void do_use_colors();

  float backColor[3];

  float backgradientenabled;      
  float backgradienttopcolor[3];  
  float backgradientbotcolor[3];  
 
public:
  FileRenderer(const char *public_name, 
               const char *public_pretty_name,
               const char *default_file_name,
               const char *default_command_line);
  virtual ~FileRenderer(void);

  const char *visible_name(void) const { return publicName;}
  const char *pretty_name(void) const { return publicPrettyName;}
  const char *default_filename(void) const {return defaultFilename;}
  const char *default_exec_string(void) const {return defaultCommandLine;}
  const char *saved_exec_string(void) const { return execCmd; }

  void set_exec_string(const char *);

  int has_antialiasing() const { return has_aa; }

  int set_aasamples(int newval) {
    if (has_aa && (newval >= 0)) {
      aasamples = newval;
      update_exec_cmd();
    }
    return aasamples;
  }

  int set_aosamples(int newval) {
    if (newval >= 0) {
      aosamples = newval;
      update_exec_cmd();
    }
    return aosamples;
  }

  int has_imagesize() const { return has_imgsize; }

  int set_imagesize(int *w, int *h);

  float set_aspectratio(float aspect);
  
  int numformats() const { return formats.num(); }
  
  const char *format(int i) const { return formats.name(i); }
  const char *format() const { return formats.name(curformat); }
  int set_format(const char *format) {
    int ind = formats.typecode(format);
    if (ind < 0) return FALSE;
    if (curformat != ind) {
      curformat = ind;
      update_exec_cmd();
    }
    return TRUE;
  }

  virtual void set_background(const float *);

  virtual void set_backgradient(const float *top, const float *bot);

  virtual int open_file(const char *filename);

  virtual int do_define_light(int n, float *color, float *position);
  virtual int do_activate_light(int n, int turnon);

  virtual int do_define_adv_light(int n, float *color, float *position,
                                  float constant, float linear, float quad,
                                  float *spotdir, float fallstart, 
                                  float fallend, int spoton); 
  virtual int do_activate_adv_light(int n, int turnon);

private:
  int sph_nverts;   
  float *sph_verts; 

protected:
  virtual void write_header(void) {};
  void reset_state(void);

public:
  virtual int prepare3D(int); 
  virtual void render(const VMDDisplayList *); // render the display list

protected:
  virtual void write_trailer(void) {};

  virtual void close_file(void);

public:
  virtual void update(int) {
    if (isOpened) {
      write_trailer();
      close_file();
      isOpened = FALSE;
  
      // Emit any pending warning messages for missing or unsupported
      // geometric primitives.
      if (warningflags & FILERENDERER_NOCLIP)
        msgWarn << "User-defined clipping planes not exported for this renderer" << sendmsg;

      if (warningflags & FILERENDERER_NOTEXT)
        msgWarn << "Text not exported for this renderer" << sendmsg;

      if (warningflags & FILERENDERER_NOTEXTURE)
        msgWarn << "Texture mapping not exported for this renderer" << sendmsg;

      if (warningflags & FILERENDERER_NOCUEING)
        msgWarn << "Depth cueing not exported for this renderer" << sendmsg;

      if (warningflags & FILERENDERER_NOGEOM)
        msgWarn << "One or more geometry types not exported for this renderer" << sendmsg;

      if (warningflags != FILERENDERER_NOWARNINGS)
        msgWarn << "Unimplemented features may negatively affect the appearance of the scene" << sendmsg;
    }
  }

protected:
  // (for those that do not want to take care of it themselves)
  // the 'super_' version is called by render to set the matrix.  It
  // then calls the non-super version
  Stack<Matrix4> transMat;
  void super_load(float *cmdptr);
  virtual void load(const Matrix4& /*mat*/) {}
  void super_multmatrix(const float *cmdptr);
  virtual void multmatrix(const Matrix4& /*mat*/) {}
  void super_translate(float *cmdptr);
  virtual void translate(float /*x*/, float /*y*/, float /*z*/) {}
  void super_rot(float *cmdptr);
  virtual void rot(float /*ang*/, char /*axis*/) {}
  void super_scale(float *cmdptr);
  void super_scale(float);
  virtual void scale(float /*scalex*/, float /*scaley*/, 
                     float /*scalez*/) {}

  float scale_factor(void);         

  float scale_radius(float);        

  // change the color definitions
  int colorIndex;                   
  void super_set_color(int index);  
  virtual void set_color(int) {}    
  
  int nearest_index(float r, float g, float b) const;

  // change the material definition
  int materialIndex;                    
  float mat_ambient;                    
  float mat_diffuse;                    
  float mat_specular;                   
  float mat_shininess;                  
  float mat_opacity;                    
  float mat_outline;                    
  float mat_outlinewidth;               
  float mat_transmode;                  
  void super_set_material(int index);   
  virtual void set_material(int) {}     

  float clip_center[VMD_MAX_CLIP_PLANE][3]; 
  float clip_normal[VMD_MAX_CLIP_PLANE][3]; 
  float clip_color[VMD_MAX_CLIP_PLANE][3];  
  int clip_mode[VMD_MAX_CLIP_PLANE];        

  virtual void start_clipgroup();       
  virtual void end_clipgroup() {}       

  // change the line definitions
  int lineWidth, lineStyle, pointSize;
  virtual void set_line_width(int new_width) {
    lineWidth = new_width;
  }
  virtual void set_line_style(int /*new_style*/) {}  

  // change the sphere definitions
  int sphereResolution, sphereStyle;
  virtual void set_sphere_res(int /*res*/) {}        
  virtual void set_sphere_style(int /*style*/) {}    

  int materials_on;
  void super_materials(int on_or_off);
  virtual void activate_materials(void) {}           
  virtual void deactivate_materials(void) {}         
  


  virtual void cone(float * xyz1, float * xyz2, float radius, int resolution) { 
    cone(xyz1, xyz2, radius, 0.0, resolution);
  }

  virtual void cone(float * /*xyz1*/, float * /*xyz2*/, 
                    float /* radius*/, float /* radius2 */, int /*resolution*/);


  virtual void cylinder(float * base, float * apex, float radius, int filled);


  virtual void line(float * a, float * b);

  virtual void line_array(int num, float thickness, float *points);

  virtual void polyline_array(int num, float thickness, float *points);


  virtual void point(float * xyz) {
    float xyzr[4];
    vec_copy(xyzr, xyz);
    xyzr[3] = lineWidth * 0.002f; // hack for renderers that don't have points
  }

  virtual void point_array(int num, float size, float *xyz, float *colors);

  virtual void point_array_lit(int num, float size, 
                               float *xyz, float *norm, float *colors);


  virtual void sphere(float * xyzr);

  virtual void sphere_array(int num, int res, float *centers, float *radii, float *colors);


  virtual void square(float * norm, float * a, float * b, 
                      float * c, float * d) {
    // draw as two triangles, with correct winding order etc
    triangle(a, b, c, norm, norm, norm);
    triangle(a, c, d, norm, norm, norm);
  }


  virtual void triangle(const float * /*xyz1*/, const float * /*xyz2*/, const float * /*xyz3*/, 
                        const float * /*n1*/, const float * /*n2*/, const float * /*n3*/) {
    warningflags |= FILERENDERER_NOGEOM; // no triangles written
  }


  virtual void tricolor(const float * xyz1, const float * xyz2, const float * xyz3, 
                        const float * n1, const float * n2, const float * n3,
                        const float *c1, const float *c2, const float *c3) {
    int index = 1;
    float r, g, b;
    r = (c1[0] + c2[0] + c3[0]) / 3.0f; // average three vertex colors 
    g = (c1[1] + c2[1] + c3[1]) / 3.0f;
    b = (c1[2] + c2[2] + c3[2]) / 3.0f;

    index = nearest_index(r,g,b); // lookup nearest color here.
    super_set_color(index); // use the closest color

    triangle(xyz1, xyz2, xyz3, n1, n2, n3); // draw a regular triangle   
  }

  virtual void trimesh_n3v3(float *n, float *v, int numfacets) { 
    int i;
    for (i=0; i<numfacets*9; i+=9) {
      triangle(v + i    , 
               v + i + 3, 
               v + i + 6,
               n + i    , 
               n + i + 3, 
               n + i + 6); 
    }           
  }

  virtual void trimesh_c3n3v3(float *c, float *n, float *v, int numfacets) { 
    int i;
    for (i=0; i<numfacets*9; i+=9) {
      tricolor(v + i    ,
               v + i + 3, 
               v + i + 6, 
               n + i    , 
               n + i + 3, 
               n + i + 6, 
               c + i    , 
               c + i + 3, 
               c + i + 6);
    }           
  }

  virtual void trimesh_c4n3v3(int /* numverts */, float * cnv, 
                              int numfacets, int * facets) { 
    int i;
    for (i=0; i<numfacets*3; i+=3) {
      int v0 = facets[i    ] * 10;
      int v1 = facets[i + 1] * 10;
      int v2 = facets[i + 2] * 10;
      tricolor(cnv + v0 + 7, // vertices 0, 1, 2
               cnv + v1 + 7, 
               cnv + v2 + 7,
               cnv + v0 + 4, // normals 0, 1, 2
               cnv + v1 + 4, 
               cnv + v2 + 4,
               cnv + v0,     // colors 0, 1, 2
               cnv + v1, 
               cnv + v2);
    }           
  }


  virtual void trimesh_singlecolor(int cindex, int /* numverts */, float * nv, 
                                   int numfacets, int * facets) { 
    super_set_color(cindex); // set current color

    int i;
    for (i=0; i<numfacets*3; i+=3) {
      int v0 = facets[i    ] * 6;
      int v1 = facets[i + 1] * 6; 
      int v2 = facets[i + 2] * 6;
      triangle(nv + v0 + 3, // vertices 0, 1, 2
               nv + v1 + 3, 
               nv + v2 + 3,
               nv + v0,     // normals 0, 1, 2
               nv + v1, 
               nv + v2);
    }           
  }


  virtual void tristrip(int /* numverts */, const float * cnv, 
                        int numstrips, const int *vertsperstrip, 
                        const int *facets) { 
    // render triangle strips one triangle at a time
    // triangle winding order is:
    //   v0, v1, v2, then v2, v1, v3, then v2, v3, v4, etc.
    int strip, t, v = 0;
    int stripaddr[2][3] = { {0, 1, 2}, {1, 0, 2} };
 
    // loop over all of the triangle strips
    for (strip=0; strip < numstrips; strip++) {       
      // loop over all triangles in this triangle strip
      for (t = 0; t < (vertsperstrip[strip] - 2); t++) {
        // render one triangle, using lookup table to fix winding order
        int v0 = facets[v + (stripaddr[t & 0x01][0])] * 10;
        int v1 = facets[v + (stripaddr[t & 0x01][1])] * 10;
        int v2 = facets[v + (stripaddr[t & 0x01][2])] * 10;
 
        tricolor(cnv + v0 + 7, // vertices 0, 1, 2
                 cnv + v1 + 7, 
                 cnv + v2 + 7,
                 cnv + v0 + 4, // normals 0, 1, 2
                 cnv + v1 + 4, 
                 cnv + v2 + 4,
                 cnv + v0,     // colors 0, 1, 2
                 cnv + v1, 
                 cnv + v2);
        v++; // move on to next vertex
      }
      v+=2; // last two vertices are already used by last triangle
    }
  }


  virtual void tristrip_singlecolor(int /* numverts */, const float * nv, 
                                    int numstrips, const int *stripcolindex,
                                    const int *vertsperstrip, const int *facets) { 
    // render triangle strips one triangle at a time
    // triangle winding order is:
    //   v0, v1, v2, then v2, v1, v3, then v2, v3, v4, etc.
    int strip, t, v = 0;
    int stripaddr[2][3] = { {0, 1, 2}, {1, 0, 2} };
 
    // loop over all of the triangle strips
    for (strip=0; strip < numstrips; strip++) {       
      super_set_color(stripcolindex[strip]); // set current color
      
      // loop over all triangles in this triangle strip
      for (t = 0; t < (vertsperstrip[strip] - 2); t++) {
        // render one triangle, using lookup table to fix winding order
        int v0 = facets[v + (stripaddr[t & 0x01][0])] * 6;
        int v1 = facets[v + (stripaddr[t & 0x01][1])] * 6;
        int v2 = facets[v + (stripaddr[t & 0x01][2])] * 6;
 
        triangle(nv + v0 + 3, // vertices 0, 1, 2
                 nv + v1 + 3, 
                 nv + v2 + 3,
                 nv + v0, // normals 0, 1, 2
                 nv + v1, 
                 nv + v2);
        v++; // move on to next vertex
      }
      v+=2; // last two vertices are already used by last triangle
    }
  }


  virtual void trifan_singlecolor(int /* numverts */, const float * nv,
                                  int numfans, const int *fancolindex,
                                  const int *vertsperfan, const int *facets) {
    // render triangle fans one triangle at a time
    // triangle winding order is:
    //   v0, v1, v2, then v0, v2, v3, then v0, v3, v4, etc.
    int fan, t, v = 0;

    // loop over all of the triangle fans
    for (fan=0; fan < numfans; fan++) {
      super_set_color(fancolindex[fan]); // set current color

      // loop over all triangles in this triangle fan
      int v0 = facets[v] * 6;
      v++;
      for (t = 1; t < (vertsperfan[fan] - 1); t++) {
        // render one triangle with correct winding order
        int v1 = facets[v    ] * 6;
        int v2 = facets[v + 1] * 6;

        triangle(nv + v0 + 3, // vertices 0, 1, 2
                 nv + v1 + 3,
                 nv + v2 + 3,
                 nv + v0, // normals 0, 1, 2
                 nv + v1,
                 nv + v2);
        v++; // move on to next vertex
      }
      v++; // last vertex is already used by last triangle
    }
  }


  virtual void define_volume_texture(int ID, int xs, int ys, int zs,
                                     const float *xplaneeq, 
                                     const float *yplaneeq,
                                     const float *zplaneeq,
                                     unsigned char *texmap) {
    warningflags |= FILERENDERER_NOTEXTURE;
  }


  virtual void volume_texture_on(int texmode) {
    warningflags |= FILERENDERER_NOTEXTURE;
  }


  virtual void volume_texture_off(void) {
    warningflags |= FILERENDERER_NOTEXTURE;
  }


  virtual void wiremesh(int /* numverts */, float * cnv, 
                       int numlines, int * lines) { 
    int i;
    int index = 1;

    for (i=0; i<numlines; i++) {
      float r, g, b;
      int ind = i * 2;
      int v0 = lines[ind    ] * 10;
      int v1 = lines[ind + 1] * 10;

      r = cnv[v0 + 0] + cnv[v1 + 0] / 2.0f;
      g = cnv[v0 + 1] + cnv[v1 + 1] / 2.0f;
      b = cnv[v0 + 2] + cnv[v1 + 2] / 2.0f;

      index = nearest_index(r,g,b); // lookup nearest color here.
      super_set_color(index); // use the closest color

      line(cnv + v0 + 7, cnv + v1 + 7); 
    }           
  }

  virtual void beginrepgeomgroup(const char *) {}

  virtual void comment(const char *) {}

  virtual void text(float *pos, float size, float thickness, const char *str);

  virtual void pick_point(float * /*xyz*/, int /*id*/) {}

};

#endif

---