SimpleObj.H

Go to the documentation of this file.

#ifndef SIMPLEOBJ_H
#define SIMPLEOBJ_H

#include <IS3DCommon.H>
#include "DrawObj.H"
#include "IS3DEngine.H"
#include "ConfigVal.H"

namespace IS3D {

typedef ReferenceCountedPointer<class BoxObj> BoxObjRef;
class BoxObj : public DrawObj {
public:
  BoxObj(const Box &box, 
     const Color4 &solidColor=Color4(1,.2,.2,.5), 
     const Color4 &wireColor=Color3::black()) : DrawObj("BoxObj") {
    _box = box;
    _solidColor = solidColor;
    _wireColor = wireColor;
  }

  virtual ~BoxObj() {}
  
  void draw() {
    Draw::box(_box, RD, _solidColor, _wireColor);
  }
protected:
  Box _box;
  Color4 _solidColor;
  Color4 _wireColor;
};


typedef ReferenceCountedPointer<class ArrowObj> ArrowObjRef;
class ArrowObj : public DrawObj {
public:
  ArrowObj(const Vector3 &start, const Vector3 &direction,
           const Color4 &color=Color3::orange(),
           double scale=1.0) :
    DrawObj("ArrowObj") {
    _start = start;
    _dir = direction;
    _color = color;
    _scale = scale;
  }

  virtual ~ArrowObj() {}
  
  void draw() {
    Draw::arrow(_start, _dir, RD, _color, _scale);
  }
protected:
  Vector3 _start;
  Vector3 _dir;
  Color4  _color;
  double  _scale;
};

  
typedef ReferenceCountedPointer<class AxesObj> AxesObjRef;
class AxesObj : public DrawObj {
public:
  AxesObj(double scale=1.0) : DrawObj("AxesObj") {
    _xcol = Color3::red();
    _ycol = Color3::green();
    _zcol = Color3::blue();
    _scale = scale;
  }
  
  AxesObj(Color4 xcol, Color4 ycol, Color4 zcol, double scale=1.0) : 
    DrawObj("AxesObj") {
    _xcol = xcol;
    _ycol = ycol;
    _zcol = zcol;
    _scale = scale;
  }

  virtual ~AxesObj() {}
  
  void draw() {
    // the object's xform is already on the stack, so just send the
    // identity cframe to the axes draw call.  Lighting on these is
    // funky, so just turn it off.
    RD->disableLighting();
    Draw::axes(CoordinateFrame(), RD, _xcol, _ycol, _zcol, _scale);
    RD->enableLighting();
  }

protected:
  Color4 _xcol, _ycol, _zcol;
  double _scale;
};

    
typedef ReferenceCountedPointer<class SphereObj> SphereObjRef;
class SphereObj : public DrawObj {
public:
  SphereObj(const Sphere &sphere, 
        const Color4 &solidColor=Color4(1,.2,.2,.5), 
        const Color4 &wireColor=Color3::black()) : DrawObj("SphereObj") {
    _sphere = sphere;
    _solidColor = solidColor;
    _wireColor = wireColor;
  }
  
  virtual ~SphereObj() {}

  void draw() {
    Draw::sphere(_sphere, RD, _solidColor, _wireColor);
  }
protected:
  Sphere _sphere;
  Color4 _solidColor;
  Color4 _wireColor;
};


typedef ReferenceCountedPointer<class TextObj> TextObjRef;
class TextObj : public DrawObj {
public:
  TextObj(const std::string &str, const double textHeight,  
      const Color4 &textColor=Color3::white(), 
      const Color4 &outlineColor=Color4::clear()) : DrawObj("TextObj") {
    _str = str;
    _height = textHeight;
    _textColor = textColor;
    _outlineColor = outlineColor;
    _font = IS3DEngine::getFont();
  }
  
  virtual ~TextObj() {}

  void setString(const std::string &newStr) { _str = newStr; }
  void setOffsetFrame(CoordinateFrame cf) { _offset = cf; }

  void draw() {
    CoordinateFrame xform = RD->getObjectToWorldMatrix() * _offset;
    RD->pushState();
    RD->disableLighting();
    _font->draw3D(RD, _str, xform, _height, _textColor, _outlineColor,
          GFont::XALIGN_CENTER, GFont::YALIGN_CENTER);
    RD->popState();
  }

protected:
  std::string _str;
  double      _height;
  Color4      _textColor;
  Color4      _outlineColor;
  GFontRef    _font;
  CoordinateFrame _offset;
};


typedef ReferenceCountedPointer<class ScreenTextObj> ScreenTextObjRef;
class ScreenTextObj : public DrawObj {
public:
  ScreenTextObj(const std::string &str, const double textHeight,  
                const Color4 &textColor=Color3::white(), 
                const Color4 &outlineColor=Color4::clear()) : DrawObj("ScreenTextObj") {
    _str = str;
    _height = textHeight;
    _textColor = textColor;
    _outlineColor = outlineColor;
    _pos = Vector2(20,20);
    _font = IS3DEngine::getFont();
  }
  
  virtual ~ScreenTextObj() {}

  void setString(const std::string &newStr) { _str = newStr; }
  void setPosition(Vector2 pos) { _pos = pos; }

  void draw() {
    RD->pushState();
    RD->push2D();
    RD->disableLighting();
    _font->draw2D(RD, _str, _pos, _height, _textColor, _outlineColor,
          GFont::XALIGN_CENTER, GFont::YALIGN_CENTER);
    RD->pop2D();
    RD->popState();
  }

protected:
  std::string _str;
  double      _height;
  Color4      _textColor;
  Color4      _outlineColor;
  GFontRef    _font;
  Vector2     _pos;
};


  
typedef ReferenceCountedPointer<class NamedAxesObj> NamedAxesObjRef;
class NamedAxesObj : public DrawObj {
public:
  NamedAxesObj(const std::string &str, const double scale,  
           const Color4 &textColor=Color3::white(), 
           const Color4 &outlineColor=Color4::clear()) : DrawObj("NamedAxesObj") {
    _str = str;
    _scale = scale;
    _textColor = textColor;
    _outlineColor = outlineColor;
    _font = IS3DEngine::getFont();
  }
  
  virtual ~NamedAxesObj() {}

  void setString(const std::string &newStr) { _str = newStr; }

  void draw() {
    CoordinateFrame offset(Vector3(0,-_scale*.666,0));
    CoordinateFrame xform = RD->getObjectToWorldMatrix() * offset;
    RD->pushState();
    RD->disableLighting();
    _font->draw3D(RD, _str, xform, _scale/3.0, _textColor, _outlineColor,
          GFont::XALIGN_CENTER, GFont::YALIGN_CENTER);

    Draw::axes(CoordinateFrame(), RD, Color3::red(), Color3::green(), 
           Color3::blue(), _scale);

    RD->popState();
  }

protected:
  std::string _str;
  double      _scale;
  Color4      _textColor;
  Color4      _outlineColor;
  GFontRef    _font;
};


} // end namespace

#endif

---