canvas.h

Go to the documentation of this file.

//
// Copyright (c) 1999-2004 California Institute of Technology
// Copyright (c) 2004-2007 University of Southern California
// Rob Peters <rjpeters at usc dot edu>
//
// created: Mon Nov 15 18:00:27 1999
// commit: $Id: canvas.h 10065 2007-04-12 05:54:56Z rjpeters $
// $HeadURL: file:///lab/rjpeters/svnrepo/code/trunk/groovx/src/gfx/canvas.h $
//
// --------------------------------------------------------------------
//
// This file is part of GroovX.
//   [http://ilab.usc.edu/rjpeters/groovx/]
//
// GroovX is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// GroovX is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with GroovX; if not, write to the Free Software Foundation,
// Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
//

#ifndef GROOVX_GFX_CANVAS_H_UTC20050626084023_DEFINED
#define GROOVX_GFX_CANVAS_H_UTC20050626084023_DEFINED

#include "nub/object.h"
#include "nub/ref.h"

namespace rutz
{
  class file_pos;
  class fstring;
  template <class T> class dynamic_block;
}

namespace geom
{
  template <class V> class box;
  template <class V> class rect;
  template <class V> class vec2;
  template <class V> class vec3;
  class txform;
}

namespace media
{
  class bmap_data;
}

class GxRasterFont;
class GxVectorFont;

namespace Gfx
{
  class Canvas;
  class RgbaColor;




class Canvas : public virtual nub::object
{
public:
  virtual ~Canvas() throw();

  //
  // Accessors
  //


  geom::vec2<double> screenFromWorld2(const geom::vec2<double>& world_pos) const;

  virtual geom::vec3<double> screenFromWorld3(const geom::vec3<double>& world_pos) const = 0;

  virtual geom::vec3<double> worldFromScreen3(const geom::vec3<double>& screen_pos) const = 0;

  geom::rect<int> screenBoundsFromWorldRect(const geom::rect<double>& world_pos) const;

  virtual geom::rect<int> getScreenViewport() const = 0;


  virtual bool isRgba() const = 0;

  virtual bool isColorIndex() const = 0;

  virtual bool isDoubleBuffered() const = 0;

  virtual unsigned int bitsPerPixel() const = 0;

  virtual void throwIfError(const char* where,
                            const rutz::file_pos& pos) const = 0;



  typedef void (Canvas::* Manip)(const char*);

  typedef void (Canvas::* Unmanip)();

#ifndef MEMBER_TEMPLATES_BROKEN

  template <Manip doit, Unmanip undoit>
  class Saver
  {
  public:
    Saver(Canvas& canvas, const char* comment="") :
      itsCanvas(canvas)
    { (itsCanvas.*doit)(comment); }

    template <class Arg>
    Saver(Canvas& canvas, Arg a, const char* comment="") :
      itsCanvas(canvas)
    { (itsCanvas.*doit)(a, comment); }

    ~Saver()
    { (itsCanvas.*undoit)(); }

  private:
    Saver(const Saver&);
    Saver& operator=(const Saver&);

    Canvas& itsCanvas;
  };

#else
  // A macro-emulation for the Saver template class that can be used when
  // the compiler would otherwise crash on the templates (e.g. gcc-ssa).

  #define SAVER_CLASS(name, doit, undoit)                       \
  class name                                                    \
  {                                                             \
  public:                                                       \
    name(Canvas& canvas, const char* comment="") :              \
      itsCanvas(canvas)                                         \
    { itsCanvas.doit(comment); }                                \
                                                                \
    template <class Arg>                                        \
    name(Canvas& canvas, Arg a, const char* comment="") :       \
      itsCanvas(canvas)                                         \
    { itsCanvas.doit(a, comment); }                             \
                                                                \
    ~name()                                                     \
    { itsCanvas.undoit(); }                                     \
                                                                \
  private:                                                      \
    name(const name&);                                          \
    name& operator=(const name&);                               \
                                                                \
    Canvas& itsCanvas;                                          \
  }
#endif

  //
  // Attribs (saved with an AttribSaver)
  //

  virtual void pushAttribs(const char* comment="") = 0;

  virtual void popAttribs() = 0;

  virtual void drawOnFrontBuffer() = 0;

  virtual void drawOnBackBuffer() = 0;

  virtual void setColor(const Gfx::RgbaColor& rgba) = 0;
  virtual void setClearColor(const Gfx::RgbaColor& rgba) = 0;

  virtual void setColorIndex(unsigned int index) = 0;
  virtual void setClearColorIndex(unsigned int index) = 0;

  virtual void swapForeBack() = 0;

  virtual void setPolygonFill(bool on) = 0;

  virtual void setPointSize(double size) = 0;

  virtual void setLineWidth(double width) = 0;

  virtual void setLineStipple(unsigned short bit_pattern = 0xFFFF) = 0;

  virtual void enableAntialiasing() = 0;

  //
  // Viewport and projection
  //

  virtual void viewport(int x, int y, int w, int h) = 0;

  virtual void orthographic(const geom::rect<double>& bounds,
                            double zNear, double zFar) = 0;

  virtual void perspective(double fovy, double aspect,
                           double zNear, double zFar) = 0;

  //
  // Transformation matrix (saved with a MatrixSaver)
  //

  virtual void pushMatrix(const char* comment="") = 0;

  virtual void popMatrix() = 0;

  virtual void translate(const geom::vec3<double>& v) = 0;
  virtual void scale(const geom::vec3<double>& v) = 0;
  virtual void rotate(const geom::vec3<double>& v, double degrees) = 0;

  virtual void transform(const geom::txform& tx) = 0;

  virtual void loadMatrix(const geom::txform& tx) = 0;

  //
  // Drawing
  //

  virtual void drawPixels(const media::bmap_data& data,
                          const geom::vec3<double>& world_pos,
                          const geom::vec2<double>& zoom) = 0;

  virtual void drawBitmap(const media::bmap_data& data,
                          const geom::vec3<double>& world_pos) = 0;

  virtual void grabPixels(const geom::rect<int>& bounds,
                          media::bmap_data& data_out) = 0;

  virtual void clearColorBuffer() = 0;

  virtual void clearColorBuffer(const geom::rect<int>& screen_rect) = 0;

  virtual void drawRect(const geom::rect<double>& rect) = 0;

  void drawRect(const geom::rect<double>& rect, bool filled);

  virtual void drawBox(const geom::box<double>& box);

  virtual void drawCircle(double inner_radius, double outer_radius, bool fill,
                          unsigned int slices, unsigned int loops) = 0;

  virtual void drawCylinder(double base_radius, double top_radius,
                            double height, int slices, int stacks,
                            bool fill) = 0;

  virtual void drawSphere(double radius, int slices, int stacks,
                          bool fill) = 0;

  virtual void drawBezier4(const geom::vec3<double>& p1,
                           const geom::vec3<double>& p2,
                           const geom::vec3<double>& p3,
                           const geom::vec3<double>& p4,
                           unsigned int subdivisions);

  virtual void drawBezierFill4(const geom::vec3<double>& center,
                               const geom::vec3<double>& p1,
                               const geom::vec3<double>& p2,
                               const geom::vec3<double>& p3,
                               const geom::vec3<double>& p4,
                               unsigned int subdivisions);


  virtual void drawNurbsCurve
    (const rutz::dynamic_block<float>& knots,
     const rutz::dynamic_block<geom::vec3<float> >& pts);

  virtual void beginPoints(const char* comment="") = 0;         
  virtual void beginLines(const char* comment="") = 0;          
  virtual void beginLineStrip(const char* comment="") = 0;      
  virtual void beginLineLoop(const char* comment="") = 0;       
  virtual void beginTriangles(const char* comment="") = 0;      
  virtual void beginTriangleStrip(const char* comment="") = 0;  
  virtual void beginTriangleFan(const char* comment="") = 0;    
  virtual void beginQuads(const char* comment="") = 0;          
  virtual void beginQuadStrip(const char* comment="") = 0;      
  virtual void beginPolygon(const char* comment="") = 0;        

  enum VertexStyle
    {
      // NOTE: Don't change these numeric values since they are
      // required for compatibility of serialized object dumps
      POINTS          = 1,
      LINES           = 2,
      LINE_STRIP      = 3,
      LINE_LOOP       = 4,
      TRIANGLES       = 5,
      TRIANGLE_STRIP  = 6,
      TRIANGLE_FAN    = 7,
      QUADS           = 8,
      QUAD_STRIP      = 9,
      POLYGON         = 10
    };

  void begin(VertexStyle s, const char* comment="");

  virtual void vertex2(const geom::vec2<double>& v) = 0;
  virtual void vertex3(const geom::vec3<double>& v) = 0;

  virtual void end() = 0;

  virtual void drawRasterText(const rutz::fstring& text,
                              const GxRasterFont& font) = 0;

  virtual void drawVectorText(const rutz::fstring& text,
                              const GxVectorFont& font) = 0;

  virtual void flushOutput() = 0;


  virtual void finishDrawing();
};

#ifndef MEMBER_TEMPLATES_BROKEN
#define BLOCK_TYPEDEF(name) \
  typedef Canvas::Saver<&Canvas::begin##name, &Canvas::end> name##Block
#else
#define BLOCK_TYPEDEF(name) \
  SAVER_CLASS(name##Block, begin##name, end)
#endif

  BLOCK_TYPEDEF(Points);
  BLOCK_TYPEDEF(Lines);
  BLOCK_TYPEDEF(LineStrip);
  BLOCK_TYPEDEF(LineLoop);
  BLOCK_TYPEDEF(Triangles);
  BLOCK_TYPEDEF(TriangleStrip);
  BLOCK_TYPEDEF(TriangleFan);
  BLOCK_TYPEDEF(Quads);
  BLOCK_TYPEDEF(QuadStrip);
  BLOCK_TYPEDEF(Polygon);

#undef BLOCK_TYPEDEF

#ifndef MEMBER_TEMPLATES_BROKEN

  typedef Canvas::Saver<&Canvas::pushMatrix, &Canvas::popMatrix>
  MatrixSaver;

  typedef Canvas::Saver<&Canvas::pushAttribs, &Canvas::popAttribs>
  AttribSaver;

#else
  SAVER_CLASS(MatrixSaver, pushMatrix, popMatrix);
  SAVER_CLASS(AttribSaver, pushAttribs, popAttribs);
#endif

} // end namespace Gfx

static const char __attribute__((used)) vcid_groovx_gfx_canvas_h_utc20050626084023[] = "$Id: canvas.h 10065 2007-04-12 05:54:56Z rjpeters $ $HeadURL: file:
#endif // !GROOVX_GFX_CANVAS_H_UTC20050626084023_DEFINED

---

The software described here is Copyright (c) 1998-2005, Rob Peters.
This page was generated Wed Dec 3 06:49:38 2008 by Doxygen version 1.5.5.