Public API Reference

cstool/pen.h

Go to the documentation of this file.

/*
  Copyright (C) 2011 by Jorrit Tyberghein
  Copyright (C) 2005 by Christopher Nelson

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Library General Public
  License as published by the Free Software Foundation; either
  version 2 of the License, or (at your option) any later version.

  This library 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
  Library General Public License for more details.

  You should have received a copy of the GNU Library General Public
  License along with this library; if not, write to the Free
  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CS_CSTOOL_PEN_H__
#define __CS_CSTOOL_PEN_H__

#include "csgeom/poly3d.h"
#include "csgeom/polyidx.h"
#include "csgeom/vector4.h"
#include "csgeom/vector2.h"
#include "csutil/cscolor.h"
#include "csutil/dirtyaccessarray.h"
#include "csutil/ref.h"
#include "csutil/refarr.h"
#include "csutil/memfile.h"

#include "ivideo/graph2d.h"
#include "ivideo/graph3d.h"
#include "ivideo/texture.h"

struct iFont;

enum CS_PEN_TEXT_ALIGN
{
  CS_PEN_TA_TOP,
  CS_PEN_TA_BOT,
  CS_PEN_TA_LEFT,
  CS_PEN_TA_RIGHT,
  CS_PEN_TA_CENTER
};

enum CS_PEN_FLAGS
{
  CS_PEN_FILL = 1,
  CS_PEN_SWAPCOLORS = 2,
  CS_PEN_TEXTURE_ONLY = 4,
  CS_PEN_TEXTURE = 5 /* fill | 4 */
};
 
struct csPenCoordinate
{
  int x, y;
  csPenCoordinate (int x, int y) : x (x), y (y) { }
};

struct csPenCoordinatePair
{
  csPenCoordinate c1, c2;
  csPenCoordinatePair (int x1, int y1, int x2, int y2) :
    c1 (x1, y1), c2 (x2, y2) { }
};

class csPen;

class CS_CRYSTALSPACE_EXPORT csPenCache
{
private:
  struct PRMesh
  {
    csSimpleRenderMesh mesh;
    csSimpleMeshFlags flags;
    size_t offsetVertices;
    size_t offsetIndices;
    size_t vertexCount;
    size_t indexCount;
    PRMesh () : offsetVertices (0), offsetIndices (0),
      vertexCount (0), indexCount (0) { }
  };

  csArray<PRMesh> meshes;

  csDirtyAccessArray<csVector3> vertices;

  csDirtyAccessArray<uint> vertexIndices;

  csDirtyAccessArray<csVector4> colors;

  csDirtyAccessArray<csVector2> texcoords;

  bool IsMergeable (csSimpleRenderMesh* mesh1, csSimpleRenderMesh* mesh2);

  void MergeMesh (csSimpleRenderMesh* mesh);

public:
  void PushMesh (csSimpleRenderMesh* mesh, csSimpleMeshFlags flags);

  void Render (iGraphics3D* g3d);

  void Clear ();

  void SetTransform (const csReversibleTransform& trans);
};


class CS_CRYSTALSPACE_EXPORT csPen
{
private:
  csRef<iGraphics3D> g3d;

  csRef<iGraphics2D> g2d;

  csSimpleRenderMesh mesh;

  csPolyIndexed poly_idx;

  csPoly3D poly;

  csVector4 color;

  csVector4 alt_color;

  csRef<iTextureHandle> tex;

  csVector3 tt;

  csDirtyAccessArray<csVector4> colors;

  csDirtyAccessArray<csVector2> texcoords;

  csArray<csReversibleTransform> transforms;

  csArray<csVector3> translations;

  float pen_width;

  uint flags;

  struct point
  {
    float x,y;
  };

  csArray<point> line_points;

  point last[2];

  float sh_w, sh_h;

  bool gen_tex_coords;

  csPenCache* penCache;

protected:
  void Start();

  void AddVertex (float x, float y, bool force_add=false);

  inline void AddTexCoord (float x, float y);

  void SetupMesh();

  void DrawMesh (csRenderMeshType mesh_type);

  void SetAutoTexture (float w, float h);

  void AddThickPoints (float x1, float y1, float x2, float y2);

public:
  csPen(iGraphics2D *_g2d, iGraphics3D *_g3d);
  ~csPen();

  void SetActiveCache (csPenCache* cache) { penCache = cache; }

  void SetFlag (uint flag);
  void ClearFlag (uint flag);

  void SetMixMode (uint mode);

  void SetColor (float r, float g, float b, float a);
  void SetColor (const csColor4 &color);

  void SetTexture (iTextureHandle* tex);

  void SwapColors();

  void SetPenWidth(float width);

  void ClearTransform();

  void PushTransform();

  void PopTransform();

  void SetOrigin(const csVector3 &o);

  void Translate(const csVector3 &t);

  void Rotate(const float &a);

  void SetTransform (const csReversibleTransform& trans);

  bool ClipLine (int& x1, int& y1, int& x2, int& y2);

  void DrawLine (int x1, int y1, int x2, int y2);
  void DrawLine (const csPenCoordinatePair& coords)
  {
    DrawLine (coords.c1.x, coords.c1.y, coords.c2.x, coords.c2.y);
  }
  void DrawThickLine (int x1, int y1, int x2, int y2);

  void DrawLines (const csArray<csPenCoordinatePair>& pairs);
  void DrawThickLines (const csArray<csPenCoordinatePair>& pairs);

  void DrawPoint (int x1, int y2);
  void DrawPoint (const csPenCoordinate& c) { DrawPoint (c.x, c.y); }

  void DrawRect (int x1, int y1, int x2, int y2);
  void DrawRect (const csPenCoordinatePair& coords)
  {
    DrawRect (coords.c1.x, coords.c1.y, coords.c2.x, coords.c2.y);
  }

  void DrawMiteredRect (int x1, int y1, int x2, int y2,
    uint miter);
  void DrawMiteredRect (const csPenCoordinatePair& coords,
    uint miter)
  {
    DrawMiteredRect (coords.c1.x, coords.c1.y, coords.c2.x, coords.c2.y,
        miter);
  }

  void DrawRoundedRect (int x1, int y1, int x2, int y2,
    uint roundness);
  void DrawRoundedRect (const csPenCoordinatePair& coords,
    uint roundness)
  {
    DrawRoundedRect (coords.c1.x, coords.c1.y, coords.c2.x, coords.c2.y,
        roundness);
  }

  void DrawArc (int x1, int y1, int x2, int y2,
        float start_angle = 0, float end_angle = 6.2831853);
  void DrawArc (const csPenCoordinatePair& coords,
        float start_angle = 0, float end_angle = 6.2831853)
  {
    DrawArc (coords.c1.x, coords.c1.y, coords.c2.x, coords.c2.y,
        start_angle, end_angle);
  }

  void DrawTriangle (int x1, int y1, int x2, int y2, int x3, int y3);
  void DrawTriangle (const csPenCoordinate& c1,
      const csPenCoordinate& c2, const csPenCoordinate& c3)
  {
    DrawTriangle (c1.x, c1.y, c2.x, c2.y, c3.x, c3.y);
  }

  void Write (iFont *font, int x1, int y1, const char *text);
  void Write (iFont *font, const csPenCoordinate& c, const char *text)
  {
    Write (font, c.x, c.y, text);
  }
  void WriteLines (iFont *font, int x1, int y1, const csStringArray& lines);
  void WriteLines (iFont *font, const csPenCoordinate& c,
      const csStringArray& lines)
  {
    WriteLines (font, c.x, c.y, lines);
  }

  void WriteBoxed (iFont *font, int x1, int y1, int x2, int y2,
    uint h_align, uint v_align, const char *text);
  void WriteBoxed (iFont *font, const csPenCoordinatePair& coords,
    uint h_align, uint v_align, const char *text)
  {
    WriteBoxed (font, coords.c1.x, coords.c1.y, coords.c2.x, coords.c2.y,
        h_align, v_align, text);
  }

  void WriteLinesBoxed (iFont *font, int x1, int y1, int x2, int y2,
    uint h_align, uint v_align, const csStringArray& lines);
  void WriteLinesBoxed (iFont *font, const csPenCoordinatePair& coords,
    uint h_align, uint v_align, const csStringArray& lines)
  {
    WriteLinesBoxed (font, coords.c1.x, coords.c1.y, coords.c2.x, coords.c2.y,
        h_align, v_align, lines);
  }
};

struct csPen3DCoordinatePair
{
  csVector3 c1, c2;
  csPen3DCoordinatePair (const csVector3& c1, const csVector3& c2) :
    c1 (c1), c2 (c2) { }
};

class CS_CRYSTALSPACE_EXPORT csPen3D
{
private:
  csRef<iGraphics3D> g3d;

  csRef<iGraphics2D> g2d;

  csSimpleRenderMesh mesh;

  csVector4 color;

  csPolyIndexed poly_idx;

  csPoly3D poly;

  csDirtyAccessArray<csVector4> colors;

  csDirtyAccessArray<csVector2> texcoords;

  csPenCache* penCache;

  csReversibleTransform local2object;

protected:
  void Start();

  void AddVertex (const csVector3& v);

  void SetupMesh();

  void DrawMesh (csRenderMeshType mesh_type);

public:
  csPen3D (iGraphics2D *_g2d, iGraphics3D *_g3d);
  ~csPen3D ();

  void SetActiveCache (csPenCache* cache) { penCache = cache; }

  void SetMixMode (uint mode);

  void SetColor (float r, float g, float b, float a);
  void SetColor (const csColor4 &color);

  void SetTransform (const csReversibleTransform& trans);

  void SetLocal2ObjectTransform (const csReversibleTransform& trans)
  {
    local2object = trans;
  }

  const csReversibleTransform& GetLocal2ObjectTransform () const
  {
    return local2object;
  }

  void DrawLine (const csVector3& v1, const csVector3& v2);
  void DrawLine (const csPen3DCoordinatePair& coords)
  {
    DrawLine (coords.c1, coords.c2);
  }

  void DrawLines (const csArray<csPen3DCoordinatePair>& pairs);

  void DrawBox (const csBox3& box);

  void DrawArc (const csVector3& c1, const csVector3& c2,
        int axis, float start_angle = 0, float end_angle = 6.2831853);

  void DrawCylinder (const csBox3& box, int axis);
};


#endif

---