---

DispCmds.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: DispCmds.h,v $
 *      $Author: johns $        $Locker:  $             $State: Exp $
 *      $Revision: 1.121 $      $Date: 2021/05/14 22:47:22 $
 *
 ***************************************************************************/
#ifndef DISPCMDS_H
#define DISPCMDS_H

class VMDDisplayList;
class Scene;

#define VMDMAXVERTEXBUFSZ (128*1024*1024)

enum { DBEGINREPGEOMGROUP, DPOINT, DPOINTARRAY, DLITPOINTARRAY, 
       DLINE, DLINEARRAY, DPOLYLINEARRAY, 
       DCYLINDER, 
#if defined(VMDOPTIXRTRT)
       DCYLINDERARRAY, 
#endif
       DSPHERE, DSPHEREARRAY, DCUBEARRAY,
       DTRIANGLE, DSQUARE, DCONE, 
       DTRIMESH_C4F_N3F_V3F, DTRIMESH_C3F_N3F_V3F, 
       DTRIMESH_C4U_N3F_V3F, DTRIMESH_C4U_N3B_V3F,
       DTRISTRIP, DWIREMESH,
       DCOLORINDEX, DMATERIALON, DMATERIALOFF, 
       DTEXT, DCOMMENT, 
       DCLIPPLANE, DVOLSLICE, DVOLTEXON, DVOLTEXOFF, DVOLUMETEXTURE,
       DSPHERERES, DSPHERETYPE, DLINEWIDTH, DLINESTYLE,
       DPICKPOINT_ARRAY, DLASTCOMMAND=-1};

enum { SOLIDSPHERE, POINTSPHERE };
enum { SOLIDLINE, DASHEDLINE };


struct DispCmdBeginRepGeomGroup {
  void putdata(const char *, VMDDisplayList *);
};


struct DispCmdComment {
  void putdata(const char *, VMDDisplayList *);
};


struct DispCmdPoint {
  void putdata(const float *, VMDDisplayList *);
  float pos[3];
};


struct DispCmdSphere {
  void putdata(float *, float, VMDDisplayList *);
  float pos_r[4]; 

};


#if defined(VMDOPTIXRTRT)

struct DispCmdCylinderArray {
  static void putdata(const float * points, const float * radii, 
                      const float * colors, int num_cyls, 
                      int cyl_res, int cyl_caps, VMDDisplayList * dobj);

  inline void getpointers(
    float *& points,
    float *& radii,
    float *& colors
    ) const {
    char *rawptr = (char *)this;
    points = (float *) (rawptr + sizeof(DispCmdCylinderArray));
    radii  = (float *) (rawptr + sizeof(DispCmdCylinderArray) +
                        sizeof(float) * numcylinders * 6L);
    colors = (float *) (rawptr + sizeof(DispCmdCylinderArray) +
                        sizeof(float) * numcylinders * 6L +
                        sizeof(float) * numcylinders);
  }

  int numcylinders;
  int cylinderres;
  int cylindercaps;
};

#endif


struct DispCmdSphereArray {
  static void putdata(const float * centers, const float * radii, 
                      const float * colors, int num_spheres, 
                      int sphere_res, VMDDisplayList * dobj);

  inline void getpointers(
    float *& centers,
    float *& radii,
    float *& colors
    ) const {
    char *rawptr = (char *)this;
    centers = (float *) (rawptr + sizeof(DispCmdSphereArray));
    radii   = (float *) (rawptr + sizeof(DispCmdSphereArray) +
                         sizeof(float) * numspheres * 3L);
    colors  = (float *) (rawptr + sizeof(DispCmdSphereArray) +
                         sizeof(float) * numspheres * 3L +
                         sizeof(float) * numspheres);
  }

  int numspheres;
  int sphereres;
};


// position, radii (from center to each wall), and color arrays
struct DispCmdLatticeCubeArray {
  static void putdata(const float * centers, const float * radii, 
                      const float * colors, int num_cubes, 
                      VMDDisplayList * dobj);

  inline void getpointers(
    float *& centers,
    float *& radii,
    float *& colors
    ) const {
    char *rawptr = (char *)this;
    centers = (float *) (rawptr + sizeof(DispCmdLatticeCubeArray));
    radii   = (float *) (rawptr + sizeof(DispCmdLatticeCubeArray) +
                         sizeof(float) * numcubes * 3L);
    colors  = (float *) (rawptr + sizeof(DispCmdLatticeCubeArray) +
                         sizeof(float) * numcubes * 3L +
                         sizeof(float) * numcubes);
  }

  int numcubes;
};


struct DispCmdPointArray {
  static void putdata(const float * centers, const float * colors, float size,
                      int num_points, VMDDisplayList * dobj);

  static void putdata(const float * centers, const int *, Scene *, float size,
                      int num_points, const int *, int selected, 
                      VMDDisplayList * dobj);

  inline void getpointers(
    float *& centers,
    float *& colors
    ) const {
    char *rawptr = (char *)this;
    centers = (float *) (rawptr + sizeof(DispCmdPointArray));
    colors  = (float *) (rawptr + sizeof(DispCmdPointArray) +
                         sizeof(float) * numpoints * 3L);
  }
  float size;
  int numpoints;
};


struct DispCmdLitPointArray {
  static void putdata(const float * centers, const float * normals, 
               const float * colors, float size, int num_points, 
               VMDDisplayList * dobj);

  inline void getpointers(
    float *& centers,
    float *& normals,
    float *& colors
    ) const {
    char *rawptr = (char *)this;
    centers = (float *) (rawptr + sizeof(DispCmdLitPointArray));
    normals = (float *) (rawptr + sizeof(DispCmdLitPointArray) + 
                         sizeof(float) * numpoints * 3L);
    colors  = (float *) (rawptr + sizeof(DispCmdLitPointArray) +
                         sizeof(float) * numpoints * 6L);
  }

  float size;
  int numpoints;
};


struct DispCmdLine {
  void putdata(float *, float *, VMDDisplayList *);
  float pos1[3];
  float pos2[3];
};


struct DispCmdLineArray {
  void putdata(float *v, int nlines, VMDDisplayList *);
}; 


struct DispCmdPolyLineArray {
  void putdata(float *v, int nlines, VMDDisplayList *);
}; 

 
struct DispCmdTriangle {
  void putdata(const float *, const float *, const float *, VMDDisplayList *);
  void putdata(const float *, const float *, const float *,
               const float *, const float *, const float *, VMDDisplayList *);

  float pos1[3], pos2[3], pos3[3];
  float norm1[3], norm2[3], norm3[3];
  void set_array(const float *, const float *, const float *, 
                 const float *, const float *, const float *,
                 VMDDisplayList *);
};
 
struct DispCmdSquare {
  float pos1[3], pos2[3], pos3[3], pos4[3];
  float norml[3];
  void putdata(float *p1, float *p2, float *p3, VMDDisplayList *);
};


struct DispCmdTriMesh {
  static void putdata(const float * vertices, 
                      const float * normals,
                      const float * colors,
                      int num_facets,
                      VMDDisplayList *);

  static void putdata(const float * vertices,
                      const float * normals,
                      const unsigned char * colors,
                      int num_facets,
                      VMDDisplayList *);

  static void putdata(const float * vertices,
                      const char * normals,
                      const unsigned char * colors,
                      int num_facets,
                      VMDDisplayList *);

  static void putdata(const float * vertices, 
                      const float * normals,
                      const float * colors,
                      int num_verts,
                      const int * facets, 
                      int num_facets, 
                      int enablestrips,
                      VMDDisplayList *);

#if defined(VMDCUDA)

  static void cuda_putdata(const float * vertices_d, 
                           const float * normals_d,
                           const float * colors_d,
                           int num_facets,
                           VMDDisplayList *);

  static void cuda_putdata(const float * vertices_d, 
                           const float * normals_d,
                           const unsigned char * colors_d,
                           int num_facets,
                           VMDDisplayList *);

  static void cuda_putdata(const float * vertices_d, 
                           const char * normals_d,
                           const unsigned char * colors_d,
                           int num_facets,
                           VMDDisplayList *);
#endif

  inline void getpointers(float *& cnv, int *& f) const {
    cnv = (float *)(((char *)this) + sizeof(DispCmdTriMesh));
    f = (int *)(cnv + 10L*numverts);
  }

  inline void getpointers(float *&c, float *&n, float *&v) const {
    c = (float *)(((char *)this) + sizeof(DispCmdTriMesh));
    n = c + 3L * numverts;
    v = n + 3L * numverts;
  }

  inline void getpointers(unsigned char *&c, float *&n, float *&v) const {
    c = (unsigned char *)(((char *)this) + sizeof(DispCmdTriMesh));
    n = (float *) (c + numverts * 4L * sizeof(unsigned char));
    v = n + 3L * numverts;
  }

  inline void getpointers(unsigned char *&c, signed char *&n, float *&v) const {
    c = (unsigned char *)(((char *)this) + sizeof(DispCmdTriMesh));
    v = (float *) (c + numverts * 4L * sizeof(unsigned char));
    n = (signed char *) (v + 3L * numverts);
  }

  inline void getpointers(float *&n, float *&v) const {
    n = (float *)(((char *)this) + sizeof(DispCmdTriMesh));
    v = n + 3L * numverts;
  }

  inline void getpointers(signed char *&n, float *&v) const {
    v = (float *)(((char *)this) + sizeof(DispCmdTriMesh));
    n = (signed char *) (v + 3L * numverts);
  }

  int pervertexcolors;   
  int pervertexnormals;  
  int numverts;          
  int numfacets;         
};


struct DispCmdTriStrips {
  static void putdata(const float * vertices, 
               const float * normals,
               const float * colors,
               int num_verts,
               const int * verts_per_strip,
               int num_strips, 
               const unsigned int * strip_data,
               const int num_strip_verts,
               int double_sided_lighting,
               VMDDisplayList * dobj);

  inline void getpointers(
      float *& cnv,
      int   *& f,
      int   *& vertsperstrip) const {

    char *rawptr = (char *)this;
    cnv= (float *)         (rawptr +
                            sizeof(DispCmdTriStrips));
  
    f= (int *)             (rawptr +
                            sizeof(DispCmdTriStrips) +
                            sizeof(float) * numverts * 10L);
  
    vertsperstrip= (int *) (rawptr +
                            sizeof(DispCmdTriStrips) +
                            sizeof(float) * numverts * 10L +
                            sizeof(int)   * numstripverts);
  }

  int numverts;         
  int numstrips;        
  int numstripverts;    
  int doublesided;      
}; 


struct DispCmdWireMesh {
  static void putdata(const float * vertices, 
               const float * normals,
               const float * colors,
               int num_verts,
               const int * lines, 
               int num_lines, VMDDisplayList *);

  inline void getpointers(
    float *& cnv,          
    int   *& l             
    ) const {
    char *rawptr = (char *)this;
    cnv=(float *) (rawptr + sizeof(DispCmdWireMesh)); 
    l=(int *) (rawptr + sizeof(DispCmdWireMesh) + sizeof(float) * numverts * 10L);
  }

  int numverts;         
  int numlines;         
};


#define CYLINDER_TRAILINGCAP 1
#define CYLINDER_LEADINGCAP  2

struct DispCmdCylinder {
  DispCmdCylinder(void);
  float rot[2];         
  int lastres;
  void putdata(const float *, const float *, float, int, int filled, 
               VMDDisplayList *); 
};
 

struct DispCmdCone {
  void putdata(const float *, const float *, float, float, 
               int, VMDDisplayList *);
  float pos1[3], pos2[3]; 
  float radius, radius2; 
  int res;
};


struct DispCmdColorIndex {
  void putdata(int, VMDDisplayList *);
  int color;
};


struct DispCmdText {
  void putdata(const float *, const char *, float thickness, 
               float size, float ox, float oy, VMDDisplayList *);
};

struct DispCmdVolSlice {
  void putdata(int mode, const float *norm, const float *verts, const float *texcoords, 
      VMDDisplayList *);
  int texmode;            
  float normal[3];        
  float v[12];
  float t[12];
};

struct DispCmdVolumeTexture {
  void putdata(unsigned long texID, const int size[3], 
      unsigned char *texptr, const float vp0[3], const float vp1[3], 
      const float vp2[3], const float vp3[3], VMDDisplayList *);
  unsigned char * texmap; 
  unsigned long ID;       
  unsigned xsize;
  unsigned ysize;
  unsigned zsize;
  float v0[3];            
  float v1[3];            
  float v2[3];            
  float v3[3];            
};

struct DispCmdSphereRes {
  void putdata(int, VMDDisplayList *);
  int res;
};


struct DispCmdSphereType {
  void putdata(int, VMDDisplayList *);
  int type;
};


struct DispCmdLineType {
  void putdata(int, VMDDisplayList *);
  int type;
};


struct DispCmdLineWidth {
  void putdata(int, VMDDisplayList *);
  int width;
};


struct DispCmdPickPoint {
  void putdata(float *, int, VMDDisplayList *);
  float postag[3];
  int tag;
};


struct DispCmdPickPointArray {
  void putdata(int num, int numsel, int firstsel,
               int *on, float *coords, VMDDisplayList *);

  void putdata(int num, int *indices, float *coords, VMDDisplayList *);

  inline void getpointers(float *& coords, int *& tags) const {
    char *rawptr = (char *)this;
    coords = (float *) (rawptr + sizeof(DispCmdPickPointArray));

    if (allselected) {
      tags = NULL;
      return;
    }

    tags = (int *) (rawptr + sizeof(DispCmdPickPointArray) + 
                    3L * sizeof(float) * numpicks);
  }

  int numpicks;
  int allselected;
  int firstindex;
};

#endif

---