---

DisplayDevice.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: DisplayDevice.h,v $
 *      $Author: johns $        $Locker:  $             $State: Exp $
 *      $Revision: 1.144 $      $Date: 2021/03/09 15:55:17 $
 *
 ***************************************************************************/
#ifndef DISPLAYDEVICE_H
#define DISPLAYDEVICE_H

#include <stdio.h>
#include <math.h>

#include "Matrix4.h"
#include "Stack.h"
#include "ResizeArray.h"
#include "utilities.h"

class VMDApp;
class VMDDisplayList;

class DisplayDevice {
public:
  VMDApp *vmdapp; 





  char *name; 

  enum DisplayEye { NOSTEREO, LEFTEYE, RIGHTEYE };

  enum Buttons { B_LEFT, B_MIDDLE, B_RIGHT, B2_LEFT, B2_MIDDLE, B2_RIGHT,
                 B_F1, B_F2, B_F3, B_F4,  B_F5,  B_F6,
                 B_F7, B_F8, B_F9, B_F10, B_F11, B_F12,
                 B_ESC, TOTAL_BUTTONS };
  
  enum EventCodes  { WIN_REDRAW, WIN_LEFT, WIN_MIDDLE, WIN_RIGHT,
                     WIN_WHEELUP, WIN_WHEELDOWN, WIN_MOUSEX, WIN_MOUSEY, 
                     WIN_KBD, 
                     WIN_KBD_ESCAPE,
                     WIN_KBD_UP, 
                     WIN_KBD_DOWN, 
                     WIN_KBD_LEFT, 
                     WIN_KBD_RIGHT, 
                     WIN_KBD_PAGE_UP, 
                     WIN_KBD_PAGE_DOWN, 
                     WIN_KBD_HOME, 
                     WIN_KBD_END, 
                     WIN_KBD_INSERT,
                     WIN_KBD_DELETE,
                     WIN_KBD_F1,  WIN_KBD_F2,  WIN_KBD_F3,  WIN_KBD_F4,
                     WIN_KBD_F5,  WIN_KBD_F6,  WIN_KBD_F7,  WIN_KBD_F8,
                     WIN_KBD_F9,  WIN_KBD_F10, WIN_KBD_F11, WIN_KBD_F12,
                     WIN_NOEVENT };

  enum CursorCodes { NORMAL_CURSOR, TRANS_CURSOR, SCALE_CURSOR, 
                     PICK_CURSOR, WAIT_CURSOR };

  int needRedraw(void) const { return _needRedraw; }
  int _needRedraw; 

  int num_display_processes;   
  int renderer_process;        

  virtual int get_num_processes()   { return num_display_processes; } 
  virtual int is_renderer_process() { return renderer_process; }
 
protected:


  int aaAvailable, cueingAvailable, cullingAvailable;
  int aaEnabled,   cueingEnabled,   cullingEnabled;
  int aoEnabled,   shadowEnabled,   dofEnabled;
  int aaPrevious;

  int my_depth_sort;

  //displays.
  const float *colorData;
  virtual void do_use_colors() {}

  enum CueMode { CUE_LINEAR, CUE_EXP, CUE_EXP2, NUM_CUE_MODES };
  CueMode cueMode;              
  float cueStart, cueEnd;       
  float cueDensity;             

  enum ShadowMode { SHADOWS_OFF, SHADOWS_ON };

  // ambient occlusion
  float aoAmbient;              
  float aoDirect;               

  // depth of field
  float dofFNumber;             
  float dofFocalDist;           

public:
  enum Projection {PERSPECTIVE, ORTHOGRAPHIC, NUM_PROJECTIONS};
  Projection projection() const { return my_projection; }

  long xOrig, yOrig, xSize, ySize;

protected:
  Stack<Matrix4> transMat;

  int backgroundmode; 


  int lineStyle, lineWidth;
  int sphereRes, sphereMode;
  int cylinderRes;


  //
  // eye position, clipping planes, and viewing geometry data
  //
  float eyePos[3];              
  DisplayEye whichEye;          
  float nearClip, farClip;      

  float vSize;                  
  float zDist;                  

  float Aspect;                 






  float cpUp, cpDown, cpLeft, cpRight;  


  // stereo display data
  int inStereo;                 
  int stereoSwap;               
  int stereoModes;              
  const char **stereoNames;     

  // display list caching data
  int cacheMode;                
  int cacheModes;               
  const char **cacheNames;      

  // rendering mode data
  int renderMode;               
  int renderModes;              
  const char **renderNames;     

  // display camera/eye parameters
  float eyeSep;                 
  float eyeDist;                
  float eyeDir[3];              
  float upDir[3];               
  float eyeSepDir[3];           


public:  
  virtual int do_define_light(int, float *, float *) { return TRUE; } 
  virtual int do_activate_light(int, int) { return TRUE; } 

#if 0
  // XXX need to implement advanced lights still
#endif

  void use_colors(const float *c) {
    colorData = c;
    do_use_colors();
  }

protected:
  int mouseX;                   
  int mouseY;                   

  void calc_frustum(void);

  void calc_eyedir(void);

  virtual void do_resize_window(int w, int h);
  virtual void do_reposition_window(int xpos, int ypos) {}

  int screenX, screenY;

  void find_pbc_images(const VMDDisplayList *, ResizeArray<Matrix4> &);

  void find_pbc_cells(const VMDDisplayList *, ResizeArray<int> &);

  void find_instance_images(const VMDDisplayList *, ResizeArray<Matrix4> &);

public:
  DisplayDevice(const char *);
  virtual ~DisplayDevice(void);
  
  DisplayDevice& operator=(DisplayDevice &);

  virtual int init(int argc, char **argv, VMDApp *app, int *size, int *loc) {
    if (size != NULL)
      resize_window(size[0], size[1]);

    vmdapp=app; // set VMDApp ptr to allow DisplayDevice control over use of
                // GPU memory resources during ray tracing, etc.

    return TRUE;
  }

  virtual int supports_gui() { return FALSE; }


  //
  // event handling routines
  //

  virtual void queue_events(void);

  virtual int read_event(long &, long &);

  // get the current state of the device's pointer (i.e. cursor if it has one)
  virtual int x(void); 
  virtual int y(void); 

  enum { 
    SHIFT = 1, 
    CONTROL = 2, 
    ALT = 4, 
    AUX = 8
  }; 

  virtual int shift_state(void); 

  virtual int spaceball(int *, int *, int *, int *, int *, int *, int *) { return 0; }

  virtual void set_cursor(int);

private:
  Projection my_projection;     
  static const char *projNames[NUM_PROJECTIONS];
  static const char *cueModeNames[NUM_CUE_MODES];

public:

  float aspect(void) { return Aspect; }
  float near_clip(void) const { return nearClip; }
  float far_clip(void) const { return farClip; }
  float clip_width(void) const { return (farClip - nearClip); }
  float addto_near_clip(float ac) { return set_near_clip(nearClip + ac); }
  float addto_far_clip(float ac) { return set_far_clip(farClip + ac); }
  float set_near_clip(float nc) {
    // near clip plane must be > 0.0, and less than far clip plane
    if (nc < farClip && nc > 0.0) {
      nearClip = nc;
      calc_frustum();
      _needRedraw = 1;
    } 
    return nearClip;
  }

  float set_far_clip(float fc) {
    if(fc > nearClip) {
      farClip = fc;
      _needRedraw = 1;
    }
    return farClip;
  }




  // turn on hardware depth-cueing
  virtual void cueing_on(void) {
    if (cueingAvailable && !cueingEnabled) {
      cueingEnabled = TRUE;
      _needRedraw = 1;
    }
  }

  // turn off hardware depth-cueing
  virtual void cueing_off(void) {
    if (cueingAvailable && cueingEnabled) {
      cueingEnabled = FALSE;
      _needRedraw = 1;
    }
  }

  int cueing_available(void) { return cueingAvailable; }
  int cueing_enabled(void) { return cueingEnabled; }

  const char *get_cue_mode() const { return cueModeNames[cueMode]; }
  int num_cue_modes() const { return NUM_CUE_MODES; }
  const char *cue_mode_name(int i) const {
    if (i < 0 || i >= NUM_CUE_MODES) return NULL;
    return cueModeNames[i];
  }
  int set_cue_mode(const char *mode) { 
    for (int i=0; i<NUM_CUE_MODES; i++) {
      if (!strupcmp(mode, cueModeNames[i])) {
        cueMode = (CueMode)i;
        _needRedraw = 1;
        return TRUE;
      }
    }
    return FALSE; // no match
  }

  float get_cue_start() const { return cueStart; }
  float set_cue_start(float s) { 
    if (s < cueEnd && s >= 0.0) { 
      cueStart = s; 
      _needRedraw = 1;
      return TRUE;
    } 
    return FALSE;
  }   

  float get_cue_end() const { return cueEnd; }
  float set_cue_end(float e) { 
    if (e > cueStart) { 
      cueEnd = e; 
      _needRedraw = 1;
      return TRUE;
    } 
    return FALSE;
  }   
  
  float get_cue_density() const { return cueDensity; }
  int set_cue_density(float d) {
    // XXX check for legal value here
    cueDensity = d;
    _needRedraw = 1;
    return TRUE;
  }



  virtual void aa_on(void);
  virtual void aa_off(void);
  int aa_available(void) { return aaAvailable; }
  int aa_enabled(void) { return aaEnabled; }



  virtual void culling_on(void);
  virtual void culling_off(void);
  int culling_available(void) { return cullingAvailable; }
  int culling_enabled(void) { return cullingEnabled; }



  int set_shadow_mode(int onoff) {
    if (onoff)
      shadowEnabled=1;
    else
      shadowEnabled=0;
    _needRedraw = 1;
    return TRUE;
  }  
  int shadows_enabled(void) { return shadowEnabled; }



  int set_ao_mode(int onoff) {
    if (onoff)
      aoEnabled=1;
    else
      aoEnabled=0;
    _needRedraw = 1;
    return TRUE;
  }  
  int ao_enabled(void) { return aoEnabled; }

  float get_ao_ambient() const { return aoAmbient; }
  int set_ao_ambient(float a) {
    aoAmbient = a;
    _needRedraw = 1;
    return TRUE;
  }

  float get_ao_direct() const { return aoDirect; }
  int set_ao_direct(float d) {
    aoDirect = d;
    _needRedraw = 1;
    return TRUE;
  }



  int set_dof_mode(int onoff) {
    if (onoff)
      dofEnabled=1;
    else
      dofEnabled=0;
    _needRedraw = 1;
    return TRUE;
  }  
  int dof_enabled(void) { return dofEnabled; }

  float get_dof_fnumber() const { return dofFNumber; }
  int set_dof_fnumber(float f) {
    dofFNumber = f;
    _needRedraw = 1;
    return TRUE;
  }

  float get_dof_focal_dist() const { return dofFocalDist; }
  int set_dof_focal_dist(float d) {
    dofFocalDist = d;
    _needRedraw = 1;
    return TRUE;
  }


  //
  // camera and view frustum parameters 
  //

  float distance_to_screen(void) { return zDist; }
  void distance_to_screen(float zd) {
    zDist = zd;
    calc_frustum();
    _needRedraw = 1;
  }
  
  float screen_height(void) { return vSize; }
  void screen_height(float vs) {
    if(vs > 0.0) {
      vSize = vs;
      calc_frustum();
      _needRedraw = 1;
    }
  }

  void set_screen_pos(float vsize, float zdist, float asp) {
    Aspect = asp;  vSize = vsize;  zDist = zdist;
    calc_frustum();    
  }
  
  void set_screen_pos(float vs, float zd) { set_screen_pos(vs, zd, aspect()); }
  
  void set_screen_pos(float asp) { set_screen_pos(vSize, zDist, asp); }
  
  void set_screen_pos(void) { set_screen_pos(vSize, zDist); }

  void resize_window(int w, int h) {
    if (w > 0 && h > 0) {
      do_resize_window(w, h);
    }
  }
  void reposition_window(int xpos, int ypos) {
    if (xpos >= 0 && xpos < screenX && ypos >= 0 && ypos < screenY) {
      do_reposition_window(xpos, -1+screenY-ypos);
    }
  } 
#if 0
  // XXX This doesn't work...
  void window_position(int *xpos, int *ypos) {
    *xpos = xOrig;
    //*ypos = screenY - 1 - yOrig;
    *ypos = yOrig + screenY - 1;
  }
#endif

  //
  // routines to deal with stereo display
  //
  
  virtual void set_stereo_mode(int = 0);

  int stereo_mode(void) { return inStereo; }

  void set_stereo_swap(int onoff) { 
     stereoSwap = (!(onoff == 0)); 
    _needRedraw = 1;
  }

  int stereo_swap(void) { return stereoSwap; };
 
  virtual int forced_stereo_draws(void) { return 0; }
 
  int num_stereo_modes(void) { return stereoModes; }
  
  const char *stereo_name(int n) {
    const char *retval = stereoNames[0];
    if(n >= 0 && n < stereoModes)
      retval = stereoNames[n];
    return retval;
  }

  //
  // routines to deal with special rendering modes/features
  //
  
  virtual void set_cache_mode(int = 0);

  int cache_mode(void) { return cacheMode; }

  int num_cache_modes(void) { return cacheModes; }
  
  const char *cache_name(int n) {
    const char *retval = cacheNames[0];
    if(n >= 0 && n < cacheModes)
      retval = cacheNames[n];
    return retval;
  }
  

  virtual void set_render_mode(int = 0);

  int render_mode(void) { return renderMode; }
  
  int num_render_modes(void) { return renderModes; }
  
  const char *render_name(int n) {
    const char *retval = renderNames[0];
    if(n >= 0 && n < renderModes)
      retval = renderNames[n];
    return retval;
  }


  int set_eye_defaults(void);

  int set_eye_pos(float * pos) {
    if (!pos) return FALSE;
    vec_copy(&eyePos[0], pos); 
    _needRedraw = 1;
    return TRUE; 
  }

  int get_eye_pos(float * pos) {
    if (!pos) return FALSE;
    vec_copy(pos, &eyePos[0]); 
    return TRUE; 
  }
 
  int set_eye_dir(float * dir) {
    if (!dir) return FALSE;
    vec_copy(&eyeDir[0], dir); 
    _needRedraw = 1;
    return TRUE; 
  }

  int get_eye_dir(float * dir) {
    if (!dir) return FALSE;
    vec_copy(dir, &eyeDir[0]); 
    return TRUE; 
  }
 
  int set_eye_up(float *updir) {
    if (!updir) return FALSE;
    vec_copy(&upDir[0], updir); 
    calc_eyedir(); // recalculate related eye parameters
    _needRedraw = 1;
    return TRUE; 
  }

  int get_eye_up(float *updir) {
    if (!updir) return FALSE;
    vec_copy(updir, &upDir[0]); 
    return TRUE; 
  }

  float eye_dist(void) const { return eyeDist; }

  int set_eye_dist(float flen) {
    if (!eyeDist) return FALSE; // XXX is this possible?
    float fl = flen/eyeDist;
    for (int i=0; i<3; i++) eyeDir[i] *= fl;
    eyeDist = flen; 
    calc_eyedir(); // XXX should really be called calc_eyesep 
    _needRedraw = 1;
    return TRUE;
  }
   
  float eyesep(void) const { return eyeSep; }

  float set_eyesep(float newsep) {
    if(newsep >= 0.0) {
      eyeSep = newsep;
      calc_eyedir();
    }
    _needRedraw = 1;
    return eyeSep;
  }

  void right_eye_dir(float& x, float& y, float& z) const {
    x = eyeSepDir[0];  y = eyeSepDir[1];  z = eyeSepDir[2];
  }  

  int num_projections() const { return NUM_PROJECTIONS; }
  const char *projection_name(int i) const {
    if (i < 0 || i >= NUM_PROJECTIONS) return NULL;
    return projNames[i];
  }
  const char *get_projection() const { return projNames[my_projection]; }
  int set_projection(const char *proj) {
    if (!proj) return FALSE;
    for (int i=0; i<NUM_PROJECTIONS; i++) {
      if (!strupcmp(proj, projNames[i])) {
        my_projection = (Projection)i;
        _needRedraw = 1;
        return TRUE;
      }
    }
    return FALSE;
  }

  //
  // virtual routines to find characteristics of display itself
  //

  virtual void abs_screen_loc_3D(float *, float *);

  virtual void abs_screen_loc_2D(float *, float *);

  virtual void rel_screen_pos(float &x, float &y) {
    x = (x - (float)xOrig) / ((float)xSize);
    y = (y - (float)yOrig) / ((float)ySize);
  }

  void abs_screen_pos(float &x, float &y) {
    x = x * (float)xSize + (float)xOrig;
    y = y * (float)ySize + (float)yOrig;
  }

  // Given a 3D point (pos A),
  // and a 2D rel screen pos point (for pos B), computes the 3D point
  // which goes with the second 2D point at pos B.  Result returned in 3rd arg.
  virtual void find_3D_from_2D(const float *, const float *, float *) {}


  //
  // virtual routines to affect the device's transformation matrix
  //
  virtual void loadmatrix(const Matrix4 &); 
  virtual void multmatrix(const Matrix4 &); 


  //
  // set the background colors
  //
  void set_background_mode(int newmode) { backgroundmode = newmode; } 
  int background_mode(void) { return backgroundmode; } 
  virtual void set_background(const float *) {} 
  virtual void set_backgradient(const float *, const float *) {} 

 
  //
  // virtual routines for preparing to draw, drawing, and finishing drawing
  //
  virtual int prepare3D(int = TRUE);    
  virtual int prepareOpaque(void) { return 1; } 
  virtual int prepareTrans(void){ return 0; }   
  virtual void clear(void);             
  virtual void left(void);              
  virtual void right(void);             
  virtual void normal(void);            
  virtual void update(int = TRUE);      
  virtual void reshape(void);           

  virtual unsigned char * readpixels_rgb3u(int &x, int &y);

  virtual unsigned char * readpixels_rgba4u(int &x, int &y);

  virtual int drawpixels_rgba4u(unsigned char *rgba, int &x, int &y) { return -1; };
  
  
  virtual void render(const VMDDisplayList *) { _needRedraw = 0; } 
                                          
  virtual void render_done() {}
  
  // pick objects based on given list of draw commands.
  // arguments are dimension of picking (2 or 3), position of pointer,
  // draw command list, and returned distance from object to eye position.
  // Returns ID code ('tag') for item closest to pointer, or (-1) if no pick.
  // If an object is picked, the eye distance argument is set to the distance
  // from the display's eye position to the object (after its position has been
  // found from the transformation matrix).  If the value of the argument when
  // 'pick' is called is <= 0, a pick will be generated if any item is near the
  // pointer.  If the value of the argument is > 0, a pick will be generated
  // only if an item is closer to the eye position than the value of the
  // argument.
  // For 2D picking, coordinates are relative position in window from
  //    lower-left corner (both in range 0 ... 1)
  // For 3D picking, coordinates are the world coords of the pointer.  They
  //    are the coords of the pointer after its transformation matrix has been
  //    applied, and these coordinates are compared to the coords of the objects
  //    when their transformation matrices are applied.
  // The window_size argument tells pick how close the picked item must be.
  virtual int pick(int, const float *, const VMDDisplayList *, float &, int *,
                   float window_size); 

};

#endif

---