---

CmdDisplay.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: CmdDisplay.h,v $
 *      $Author: johns $        $Locker:  $             $State: Exp $
 *      $Revision: 1.65 $       $Date: 2011/02/17 23:17:18 $
 *
 ***************************************************************************
 * DESCRIPTION:
 *   These are the Commands that control the various aspects
 * of the display, like, the clipping planes, eye separation, etc.
 *
 ***************************************************************************/
#ifndef CMDDISPLAY_H
#define CMDDISPLAY_H

#include "Command.h"
#include "DisplayDevice.h"
#include "utilities.h"

class VMDApp;
class Axes;

// These are the Command:: enums used by this file:
//  DISP_RESETVIEW, DISP_STEREO, DISP_PROJ, DISP_EYESEP, 
//  DISP_FOCALLEN, DISP_LIGHT_ON, DISP_LIGHT_HL, DISP_LIGHT_ROT, 
//  DISP_MATERIALS_CHANGE, DISP_CLIP, DISP_DEPTHCUE, DISP_ANTIALIAS, 
//  DISP_CULLING, DISP_BACKGROUNDGRADIENT,
//  DISP_UPDATE, CMD_AXES, CMD_STAGE

class CmdResetView : public Command {
protected:
  virtual void create_text(void);
public:
  CmdResetView();
};


class CmdDisplayStereo : public Command {
private:
  char *mode;
protected:
  virtual void create_text(void);
public:
  CmdDisplayStereo(const char *newmode);
  ~CmdDisplayStereo();
};


class CmdDisplayStereoSwap : public Command {
private:
  int onoff;
protected:
  virtual void create_text(void);
public:
  CmdDisplayStereoSwap(int turnon);
};


class CmdDisplayCacheMode : public Command {
private:
  char *mode;
protected:
  virtual void create_text(void);
public:
  CmdDisplayCacheMode(const char *newmode);
  ~CmdDisplayCacheMode();
};


class CmdDisplayRenderMode : public Command {
private:
  char *mode;
protected:
  virtual void create_text(void);
public:
  CmdDisplayRenderMode(const char *newmode);
  ~CmdDisplayRenderMode();
};


class CmdDisplayProj : public Command {
public:
  CmdDisplayProj(const char *proj);
  ~CmdDisplayProj();
private:
  char *projection;
protected:
  virtual void create_text(void);
};


class CmdDisplayEyesep : public Command {
private:
  float sep;
protected:
  virtual void create_text(void);
public:
  CmdDisplayEyesep(float newsep);
};


class CmdDisplayFocallen : public Command {
private:
  float flen;
protected:
  virtual void create_text(void);
public:
  CmdDisplayFocallen(float newlen);
};


class CmdDisplayScreenHeight : public Command {
private:
  float val;
protected:
  virtual void create_text(void);
public:
  CmdDisplayScreenHeight(float newval);
};


class CmdDisplayScreenDistance : public Command {
private:
  float val;
protected:
  virtual void create_text(void);
public:
  CmdDisplayScreenDistance(float newval);
};


class CmdDisplayAAOn : public Command {
private:
  int onoff;
protected:
  virtual void create_text(void);
public:
  CmdDisplayAAOn(int turnon);
};


class CmdDisplayDepthcueOn : public Command {
private:
  int onoff;
protected:
  virtual void create_text(void);
public:
  CmdDisplayDepthcueOn(int turnon);
};


class CmdDisplayCullingOn : public Command {
private:
  int onoff;
protected:
  virtual void create_text(void);
public:
  CmdDisplayCullingOn(int turnon);
};

class CmdDisplayBackgroundGradientOn : public Command {
private:
  int onoff;
protected:
  virtual void create_text(void);
public:
  CmdDisplayBackgroundGradientOn(int turnon);
};



class CmdDisplayFPSOn : public Command {
private:
  int onoff;
protected:
  virtual void create_text(void);
public:
  CmdDisplayFPSOn(int turnon);
};


class CmdDisplayClip : public Command {
private:
  int changenear;               // near (T) or far (F) clip plane
  int setval;                   // absolute (T) or relative (F) change
  float amount;                 // how much to change
protected:
  virtual void create_text(void);
public:
  CmdDisplayClip(int ischangenear, int issetval, float newamt);
};


class CmdDisplayClipNear : public CmdDisplayClip {
 public:
   CmdDisplayClipNear(float nearval) : 
        CmdDisplayClip(TRUE, TRUE, nearval) {
   }
};


class CmdDisplayClipNearRel : public CmdDisplayClip {
 public:
   CmdDisplayClipNearRel(float nearval) : 
         CmdDisplayClip(TRUE, FALSE, nearval) {
   }
};


class CmdDisplayClipFar : public CmdDisplayClip {
 public:
   CmdDisplayClipFar(float farclip) : 
          CmdDisplayClip(FALSE, TRUE, farclip) {
   }
};


class CmdDisplayClipFarRel : public CmdDisplayClip {
 public:
   CmdDisplayClipFarRel(float farclip) : 
          CmdDisplayClip(FALSE, FALSE, farclip) {
   }
};


class CmdDisplayCueMode : public Command {
private:
  char *mode;
protected:
  void create_text();
public:
  CmdDisplayCueMode(const char *newmode)
  : Command(DISP_CUEMODE) {
    mode = stringdup(newmode);
  }
  ~CmdDisplayCueMode() { delete [] mode; }
};


class CmdDisplayCueStart : public Command {
private:
  float value;
protected:
  void create_text();
public:
  CmdDisplayCueStart(float newvalue)
  : Command(DISP_CUESTART), value(newvalue) {}
};


class CmdDisplayCueEnd : public Command {
private:
  float value;
protected:
  void create_text();
public:
  CmdDisplayCueEnd(float newvalue)
  : Command(DISP_CUEEND), value(newvalue) {}
};


class CmdDisplayCueDensity : public Command {
private:
  float value;
protected:
  void create_text();
public:
  CmdDisplayCueDensity(float newvalue)
  : Command(DISP_CUEDENSITY), value(newvalue) {}
};

class CmdDisplayShadowOn : public Command {
private:
  int onoff;
protected:
  void create_text();
public:
  CmdDisplayShadowOn(int turnon);
};

class CmdDisplayAOOn : public Command {
private:
  int onoff;
protected:
  void create_text();
public:
  CmdDisplayAOOn(int turnon);
};

class CmdDisplayAOAmbient : public Command {
private:
  float value;
protected:
  void create_text();
public:
  CmdDisplayAOAmbient(float newvalue)
  : Command(DISP_AO_AMBIENT), value(newvalue) {}
};

class CmdDisplayAODirect : public Command {
private:
  float value;
protected:
  void create_text();
public:
  CmdDisplayAODirect(float newvalue)
  : Command(DISP_AO_DIRECT), value(newvalue) {}
};


class CmdDisplayAxes : public Command {
private:
  char *pos;
protected:
  virtual void create_text();
public:
  CmdDisplayAxes(const char *newpos)
  : Command(CMD_AXES) { 
    pos = stringdup(newpos);
  }
  ~CmdDisplayAxes() { delete [] pos; }
};
    

class CmdDisplayStageLocation : public Command { 
public:
  CmdDisplayStageLocation(const char *newpos)
  : Command(CMD_STAGE) { 
    pos = stringdup(newpos);
  }
  ~CmdDisplayStageLocation() { delete [] pos; }
protected:
  void create_text();
private:
  char *pos;
};


class CmdDisplayStagePanels : public Command {
public:
  CmdDisplayStagePanels(int newnum)
  : Command(CMD_STAGE), num(newnum) {}
protected:
  void create_text();
private:
  int num;
};


class CmdDisplayStageSize : public Command {
public:
  CmdDisplayStageSize(float newsz)
  : Command(CMD_STAGE), sz(newsz) {}
protected:
  void create_text();
private:
  float sz;
};


class CmdDisplayLightOn : public Command {
private:
  int n, onoff;
protected:
  void create_text();
public:
  CmdDisplayLightOn(int ln, int turnon)
  : Command(DISP_LIGHT_ON), n(ln), onoff(turnon) {}
};


class CmdDisplayLightHL : public Command {
private:
  int n, hl;
protected:
  void create_text();
public:
  CmdDisplayLightHL(int ln, int highlt)
  : Command(DISP_LIGHT_HL), n(ln), hl(highlt) {}
};


class CmdDisplayLightRot : public Command {
private:
  float theta;
  char axis;
  int n;
protected:
  void create_text();
public:
  CmdDisplayLightRot(int ln, float th, char ax)
  : Command(DISP_LIGHT_ROT), theta(th), axis(ax), n(ln) {}
};


class CmdDisplayLightMove : public Command {
private:
  float pos[3];
  int n;
protected:
  void create_text();
public:
  CmdDisplayLightMove(int ln, const float *newpos)
  : Command(DISP_LIGHT_MOVE), n(ln) {
    for (int i=0; i<3; i++) pos[i] = newpos[i];
  }
};
 
#endif

---