---

FileRenderer.h

Go to the documentation of this file.

/***************************************************************************
 *cr                                                                       
 *cr            (C) Copyright 1995-2008 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.86 $       $Date: 2008/03/27 19:36:39 $
 *
 ***************************************************************************
 * 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:
  // default parameters for this instance; these don't ever change.
  char *publicName, *defaultFilename, *defaultCommandLine;
  char *execCmd;     
  FILE *outfile;     
  int isOpened;      
  char *my_filename; 
  int has_aa;        
  int aalevel;       
  int has_imgsize;   

  int warningflags;  


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

  virtual void update_exec_cmd() {}

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

  LightState lightState[DISP_LIGHTS]; 

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

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

  const char *visible_name(void) const { return publicName;}
  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_aalevel(int newval) {
    if (has_aa && newval >= 0) {
      aalevel = newval;
      update_exec_cmd();
    }
    return aalevel;
  }

  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 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);

private:
  void reset_state(void);
  int sph_nverts;   
  float *sph_verts; 

protected:
  virtual void write_header(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:
  float *dataBlock;
  
  // (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_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;                    
  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) {}         
  


  // single-radius cones (pointy top)
  virtual void cone(float * xyz1, float * xyz2, float radius, int resolution) { 
    cone(xyz1, xyz2, radius, 0.0, resolution);
  }


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


  // cylinders, with optional caps
  virtual void cylinder(float * base, float * apex, float radius, int filled);


  // simple lines
  virtual void line(float * a, float * b);


  // simple 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
  }


  // simple sphere
  virtual void sphere(float * xyzr);


  // quadrilateral
  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);
  }


  // single color triangle with interpolated surface normals
  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
  }


  // triangle with interpolated surface normals and vertex colors
  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   
  }


  // triangle mesh built from a vertex array and facet vertex index arrays
  virtual void trimesh(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);
    }           
  }


  // triangle strips built from a vertex array and vertex index arrays
  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
    }
  }


  // define a volumetric texture map
  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;
  }


  // enable volumetric texturing, either in "replace" or "modulate" mode
  virtual void volume_texture_on(int texmode) {
    warningflags |= FILERENDERER_NOTEXTURE;
  }


  // disable volumetric texturing
  virtual void volume_texture_off(void) {
    warningflags |= FILERENDERER_NOTEXTURE;
  }


  // wire mesh built from a vertex array and an vertex index array
  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 text(const char *);
  virtual void comment(const char *) {}

  float textpos[3];
  void super_text_position(float x, float y, float z);
  virtual void text_position(float /* x*/, float /* y*/, float /* z*/) {
    warningflags |= FILERENDERER_NOTEXT;
  }

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

};

#endif

---