---

Displayable.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: Displayable.h,v $
 *      $Author: johns $        $Locker:  $             $State: Exp $
 *      $Revision: 1.86 $       $Date: 2010/12/16 04:08:12 $
 *
 ***************************************************************************
 * DESCRIPTION:
 *
 * Base class for all objects which are drawn in the DisplayDevice.
 * Each Displayable is also a linked list of other Displayables, which act
 * as 'children' to the parent, i.e. they get the parent's tranformation as
 * well as their own.
 *
 ***************************************************************************/
#ifndef DISPLAYABLE_H
#define DISPLAYABLE_H

#include "Matrix4.h"
#include "ResizeArray.h"
#include "Pickable.h"
#include "utilities.h"
#include "VMDDisplayList.h"
#include "MaterialList.h"

class DisplayDevice;
class Scene;

class Displayable : public Pickable {
public:
  void *operator new(size_t);
  void operator delete(void *, size_t);
 
  Matrix4 rotm;    
  float globt[3];  
  float centt[3];  
  float scale;     
  Matrix4 tm;      
  
  int needUpdate(void) { return _needUpdate; } 

private:
  int _needUpdate;

  int needMatrixRecalc;

  void do_create();

protected:
  VMDDisplayList *cmdList;

  Scene *scene;

  void append(int d) { cmdList->append(d, 0); }

  int doCent, doRot, doGlob, doScale;

  int isFixed;
  
  int isOn;

  void recalc_mat(void);

  Displayable *parent;

  Displayable **children;
  int num_children;
  int max_children;

  virtual void do_color_changed(int cat) {}
  virtual void do_color_rgb_changed(int color) {}
  virtual void do_color_scale_changed() {}

public:
  Displayable(Displayable *);

  Displayable(Scene *);

  virtual ~Displayable(void);

  void reset_disp_list(void);

  void need_matrix_recalc(void) { needMatrixRecalc = TRUE; }

  //
  // routines for working as a Pickable
  //
  
  virtual VMDDisplayList *pick_cmd_list(void);

  virtual int pickable_on(void);
      
  void color_changed(int cat);

  void color_rgb_changed(int color);

  void color_scale_changed();

  //
  // deal with child Displayable's
  //

  Displayable *child(int N) const { return children[N]; }
  
  int child_index(Displayable *d) { 
    for (int i=0; i<num_children; i++) 
      if (d == child(i)) return i;
    return -1; 
  }

  void add_child(Displayable *);

  int remove_child(Displayable *);

  int remove_child(int N) { return remove_child(child(N)); }

  int displayed(void) const {  
    return isOn;
  }
  void off(void);            
  void on(void);             

  // make the object fixed (not responsive to scale/rot/trans commands
  int fixed(void) const { return isFixed; }
  void fix(void)   { isFixed = TRUE;  }
  void unfix(void) { isFixed = FALSE; }

  //
  // preparation/update routines
  //
  
  // Return 0 if we do not require a redraw, or 1 if we do. 
  int draw_prepare();

  virtual void prepare();

  void draw(DisplayDevice *) const;

  //
  // command to set whether to be affected by particular trans routines
  //
  void scale_on(void) { doScale = TRUE; }
  void scale_off(void) { doScale = FALSE; }
  int scaling(void) const { return doScale && !fixed(); }
  
  void rot_on(void) { doRot = TRUE; }
  void rot_off(void) { doRot = FALSE; }
  int rotating(void) const { return doRot && !fixed(); }

  void cent_trans_on(void) { doCent = TRUE; }
  void cent_trans_off(void) {  doCent = FALSE; }
  int cent_translating(void) const { return doCent; }

  void glob_trans_on(void) { doGlob = TRUE; }
  void glob_trans_off(void) { doGlob = FALSE; }
  int glob_translating(void) const { return doGlob && !fixed(); }

  //
  // command to change transformation
  //

  virtual void reset_transformation(void);

  void set_scale(float s);           
  void mult_scale(float s);          
  
  void add_rot(float x, char axis);  
  void add_rot(const Matrix4 &);     
  void set_rot(float x, char axis);  
  void set_rot(const Matrix4 &);     

  void set_glob_trans(float, float, float); 
  void add_glob_trans(float, float, float); 

  void set_cent_trans(float, float, float); 
  void add_cent_trans(float, float, float); 

  void change_center(float x, float y, float z);

  void cacheskip(int onoff);         

  // 
  // Material functions 
  // 
  void change_material(const Material *);
  int curr_material() const;
  void update_material(const Material *mat);
  void delete_material(int n, const MaterialList *);

  //
  // Clipping plane functions; these are just wrappers for the VMDDisplayList
  // methods
  //
  const VMDClipPlane *clipplane(int i) {
    return cmdList->clipplane(i);
  }
  int set_clip_center(int i, const float *center) {
    int rc = cmdList->set_clip_center(i, center);
    if (rc) _needUpdate = 1;
    return rc;
  }
  int set_clip_normal(int i, const float *normal) {
    int rc = cmdList->set_clip_normal(i, normal);
    if (rc) _needUpdate = 1;
    return rc;
  }
  int set_clip_color(int i, const float *color) {
    int rc = cmdList->set_clip_color(i, color);
    if (rc) _needUpdate = 1;
    return rc;
  }
  int set_clip_status(int i, int mode) {
    int rc = cmdList->set_clip_status(i, mode);
    if (rc) _needUpdate = 1;
    return rc;
  } 
};

#endif

---