gl2ps.cxx File Reference

#include "VP1HEPVis/gl2ps.h"
#include <math.h>
#include <string.h>
#include <sys/types.h>
#include <stdarg.h>
#include <time.h>
#include <float.h>

Include dependency graph for gl2ps.cxx:

Go to the source code of this file.

Classes
struct	_GL2PSbsptree2d
struct	GL2PSlist
struct	_GL2PSbsptree
struct	GL2PSvertex
struct	GL2PStriangle
struct	GL2PSstring
struct	GL2PSimage
struct	_GL2PSimagemap
struct	GL2PSprimitive
struct	GL2PScompress
struct	GL2PSpdfgroup
struct	GL2PScontext
struct	GL2PSbackend

Macros
#define	GL2PS_EPSILON   5.0e-3F
#define	GL2PS_ZSCALE   1000.0F
#define	GL2PS_ZOFFSET   5.0e-2F
#define	GL2PS_ZOFFSET_LARGE   20.0F
#define	GL2PS_ZERO(arg)
#define	GL2PS_NO_TYPE   -1
#define	GL2PS_TEXT   1
#define	GL2PS_POINT   2
#define	GL2PS_LINE   3
#define	GL2PS_QUADRANGLE   4
#define	GL2PS_TRIANGLE   5
#define	GL2PS_PIXMAP   6
#define	GL2PS_IMAGEMAP   7
#define	GL2PS_IMAGEMAP_WRITTEN   8
#define	GL2PS_IMAGEMAP_VISIBLE   9
#define	GL2PS_SPECIAL   10
#define	GL2PS_COINCIDENT   1
#define	GL2PS_IN_FRONT_OF   2
#define	GL2PS_IN_BACK_OF   3
#define	GL2PS_SPANNING   4
#define	GL2PS_POINT_COINCIDENT   0
#define	GL2PS_POINT_INFRONT   1
#define	GL2PS_POINT_BACK   2
#define	GL2PS_BEGIN_OFFSET_TOKEN   1
#define	GL2PS_END_OFFSET_TOKEN   2
#define	GL2PS_BEGIN_BOUNDARY_TOKEN   3
#define	GL2PS_END_BOUNDARY_TOKEN   4
#define	GL2PS_BEGIN_STIPPLE_TOKEN   5
#define	GL2PS_END_STIPPLE_TOKEN   6
#define	GL2PS_POINT_SIZE_TOKEN   7
#define	GL2PS_LINE_WIDTH_TOKEN   8
#define	GL2PS_BEGIN_BLEND_TOKEN   9
#define	GL2PS_END_BLEND_TOKEN   10
#define	GL2PS_SRC_BLEND_TOKEN   11
#define	GL2PS_DST_BLEND_TOKEN   12
#define	GL2PS_IMAGEMAP_TOKEN   13
#define	GL2PS_DRAW_PIXELS_TOKEN   14
#define	GL2PS_TEXT_TOKEN   15

Typedefs
typedef GLfloat	GL2PSxyz[3]
typedef GLfloat	GL2PSplane[4]
typedef struct _GL2PSbsptree2d	GL2PSbsptree2d
typedef struct _GL2PSbsptree	GL2PSbsptree
typedef struct _GL2PSimagemap	GL2PSimagemap

Enumerations
enum	GL2PS_TRIANGLE_PROPERTY {   T_UNDEFINED = -1 , T_CONST_COLOR = 1 , T_VAR_COLOR = 1<<1 , T_ALPHA_1 = 1<<2 ,   T_ALPHA_LESS_1 = 1<<3 , T_VAR_ALPHA = 1<<4 }

Functions
static GLint	gl2psPrintPrimitives (void)
static void	gl2psMsg (GLint level, const char *fmt,...)
static void *	gl2psMalloc (size_t size)
static void *	gl2psRealloc (void *ptr, size_t size)
static void	gl2psFree (void *ptr)
static size_t	gl2psWriteBigEndian (unsigned long data, size_t bytes)
static int	gl2psPrintf (const char *fmt,...)
static void	gl2psPrintGzipHeader ()
static void	gl2psPrintGzipFooter ()
static void	gl2psListRealloc (GL2PSlist *list, GLint n)
static GL2PSlist *	gl2psListCreate (GLint n, GLint incr, GLint size)
static void	gl2psListReset (GL2PSlist *list)
static void	gl2psListDelete (GL2PSlist *list)
static void	gl2psListAdd (GL2PSlist *list, void *data)
static int	gl2psListNbr (GL2PSlist *list)
static void *	gl2psListPointer (GL2PSlist *list, GLint index)
static void	gl2psListSort (GL2PSlist *list, int(*fcmp)(const void *a, const void *b))
static void	gl2psListAction (GL2PSlist *list, void(*action)(void *data))
static void	gl2psListActionInverse (GL2PSlist *list, void(*action)(void *data))
static GLboolean	gl2psSameColor (GL2PSrgba rgba1, GL2PSrgba rgba2)
static GLboolean	gl2psVertsSameColor (const GL2PSprimitive *prim)
static GLboolean	gl2psSameColorThreshold (int n, GL2PSrgba rgba[], GL2PSrgba threshold)
static void	gl2psSetLastColor (GL2PSrgba rgba)
static GLfloat	gl2psGetRGB (GL2PSimage *im, GLuint x, GLuint y, GLfloat *red, GLfloat *green, GLfloat *blue)
static GL2PSimage *	gl2psCopyPixmap (GL2PSimage *im)
static void	gl2psFreePixmap (GL2PSimage *im)
static GLint	gl2psAddText (GLint type, const char *str, const char *fontname, GLshort fontsize, GLint alignment, GLfloat angle)
static GL2PSstring *	gl2psCopyText (GL2PSstring *t)
static void	gl2psFreeText (GL2PSstring *text)
static GLboolean	gl2psSupportedBlendMode (GLenum sfactor, GLenum dfactor)
static void	gl2psAdaptVertexForBlending (GL2PSvertex *v)
static void	gl2psAssignTriangleProperties (GL2PStriangle *t)
static void	gl2psFillTriangleFromPrimitive (GL2PStriangle *t, GL2PSprimitive *p, GLboolean assignprops)
static void	gl2psInitTriangle (GL2PStriangle *t)
static GL2PSprimitive *	gl2psCopyPrimitive (GL2PSprimitive *p)
static GLboolean	gl2psSamePosition (GL2PSxyz p1, GL2PSxyz p2)
static GLfloat	gl2psComparePointPlane (GL2PSxyz point, GL2PSplane plane)
static GLfloat	gl2psPsca (GLfloat *a, GLfloat *b)
static void	gl2psPvec (GLfloat *a, GLfloat *b, GLfloat *c)
static GLfloat	gl2psNorm (GLfloat *a)
static void	gl2psGetNormal (GLfloat *a, GLfloat *b, GLfloat *c)
static void	gl2psGetPlane (GL2PSprimitive *prim, GL2PSplane plane)
static void	gl2psCutEdge (GL2PSvertex *a, GL2PSvertex *b, GL2PSplane plane, GL2PSvertex *c)
static void	gl2psCreateSplitPrimitive (GL2PSprimitive *parent, GL2PSplane plane, GL2PSprimitive *child, GLshort numverts, GLshort *index0, GLshort *index1)
static void	gl2psAddIndex (GLshort *index0, GLshort *index1, GLshort *nb, GLshort i, GLshort j)
static GLshort	gl2psGetIndex (GLshort i, GLshort num)
static GLint	gl2psTestSplitPrimitive (GL2PSprimitive *prim, GL2PSplane plane)
static GLint	gl2psSplitPrimitive (GL2PSprimitive *prim, GL2PSplane plane, GL2PSprimitive **front, GL2PSprimitive **back)
static void	gl2psDivideQuad (GL2PSprimitive *quad, GL2PSprimitive **t1, GL2PSprimitive **t2)
static int	gl2psCompareDepth (const void *a, const void *b)
static int	gl2psTrianglesFirst (const void *a, const void *b)
static GLint	gl2psFindRoot (GL2PSlist *primitives, GL2PSprimitive **root)
static void	gl2psFreeImagemap (GL2PSimagemap *list)
static void	gl2psFreePrimitive (void *data)
static void	gl2psAddPrimitiveInList (GL2PSprimitive *prim, GL2PSlist *list)
static void	gl2psFreeBspTree (GL2PSbsptree **tree)
static GLboolean	gl2psGreater (GLfloat f1, GLfloat f2)
static GLboolean	gl2psLess (GLfloat f1, GLfloat f2)
static void	gl2psBuildBspTree (GL2PSbsptree *tree, GL2PSlist *primitives)
static void	gl2psTraverseBspTree (GL2PSbsptree *tree, GL2PSxyz eye, GLfloat epsilon, GLboolean(*compare)(GLfloat f1, GLfloat f2), void(*action)(void *data), int inverse)
static void	gl2psRescaleAndOffset ()
static GLint	gl2psGetPlaneFromPoints (GL2PSxyz a, GL2PSxyz b, GL2PSplane plane)
static void	gl2psFreeBspImageTree (GL2PSbsptree2d **tree)
static GLint	gl2psCheckPoint (GL2PSxyz point, GL2PSplane plane)
static void	gl2psAddPlanesInBspTreeImage (GL2PSprimitive *prim, GL2PSbsptree2d **tree)
static GLint	gl2psCheckPrimitive (GL2PSprimitive *prim, GL2PSplane plane)
static GL2PSprimitive *	gl2psCreateSplitPrimitive2D (GL2PSprimitive *parent, GLshort numverts, GL2PSvertex *vertx)
static void	gl2psSplitPrimitive2D (GL2PSprimitive *prim, GL2PSplane plane, GL2PSprimitive **front, GL2PSprimitive **back)
static GLint	gl2psAddInBspImageTree (GL2PSprimitive *prim, GL2PSbsptree2d **tree)
static void	gl2psAddInImageTree (void *data)
static void	gl2psAddBoundaryInList (GL2PSprimitive *prim, GL2PSlist *list)
static void	gl2psBuildPolygonBoundary (GL2PSbsptree *tree)
static void	gl2psAddPolyPrimitive (GLshort type, GLshort numverts, GL2PSvertex *verts, GLint offset, GLushort pattern, GLint factor, GLfloat width, char boundary)
static GLint	gl2psGetVertex (GL2PSvertex *v, GLfloat *p)
static void	gl2psParseFeedbackBuffer (GLint used)
static void	gl2psWriteByte (unsigned char byte)
static void	gl2psPrintPostScriptPixmap (GLfloat x, GLfloat y, GL2PSimage *im)
static void	gl2psPrintPostScriptImagemap (GLfloat x, GLfloat y, GLsizei width, GLsizei height, const unsigned char *imagemap)
static void	gl2psPrintPostScriptHeader (void)
static void	gl2psPrintPostScriptColor (GL2PSrgba rgba)
static void	gl2psResetPostScriptColor (void)
static void	gl2psEndPostScriptLine (void)
static void	gl2psParseStipplePattern (GLushort pattern, GLint factor, int *nb, int array[10])
static int	gl2psPrintPostScriptDash (GLushort pattern, GLint factor, const char *str)
static void	gl2psPrintPostScriptPrimitive (void *data)
static void	gl2psPrintPostScriptFooter (void)
static void	gl2psPrintPostScriptBeginViewport (GLint viewport[4])
static GLint	gl2psPrintPostScriptEndViewport (void)
static void	gl2psPrintPostScriptFinalPrimitive (void)
static void	gl2psPrintTeXHeader (void)
static void	gl2psPrintTeXPrimitive (void *data)
static void	gl2psPrintTeXFooter (void)
static void	gl2psPrintTeXBeginViewport (GLint viewport[4])
static GLint	gl2psPrintTeXEndViewport (void)
static void	gl2psPrintTeXFinalPrimitive (void)
static int	gl2psPrintPDFCompressorType (void)
static int	gl2psPrintPDFStrokeColor (GL2PSrgba rgba)
static int	gl2psPrintPDFFillColor (GL2PSrgba rgba)
static int	gl2psPrintPDFLineWidth (GLfloat lw)
static void	gl2psPutPDFText (GL2PSstring *text, int cnt, GLfloat x, GLfloat y)
static void	gl2psPutPDFImage (GL2PSimage *image, int cnt, GLfloat x, GLfloat y)
static void	gl2psPDFstacksInit (void)
static void	gl2psPDFgroupObjectInit (GL2PSpdfgroup *gro)
static void	gl2psPDFgroupListInit (void)
static void	gl2psSortOutTrianglePDFgroup (GL2PSpdfgroup *gro)
static void	gl2psPDFgroupListWriteMainStream (void)
static int	gl2psPDFgroupListWriteGStateResources (void)
static int	gl2psPDFgroupListWriteShaderResources (void)
static int	gl2psPDFgroupListWriteXObjectResources (void)
static int	gl2psPDFgroupListWriteFontResources (void)
static void	gl2psPDFgroupListDelete (void)
static int	gl2psPrintPDFInfo (void)
static int	gl2psPrintPDFCatalog (void)
static int	gl2psPrintPDFPages (void)
static int	gl2psOpenPDFDataStream (void)
static int	gl2psOpenPDFDataStreamWritePreface (void)
static void	gl2psPrintPDFHeader (void)
static void	gl2psPrintPDFPrimitive (void *data)
static int	gl2psClosePDFDataStream (void)
static int	gl2psPrintPDFDataStreamLength (int val)
static int	gl2psPrintPDFOpenPage (void)
static int	gl2psPDFgroupListWriteVariableResources (void)
static int	gl2psPrintPDFGSObject (void)
static int	gl2psPrintPDFShaderStreamDataCoord (GL2PSvertex *vertex, size_t(*action)(unsigned long data, size_t size), GLfloat dx, GLfloat dy, GLfloat xmin, GLfloat ymin)
static int	gl2psPrintPDFShaderStreamDataRGB (GL2PSvertex *vertex, size_t(*action)(unsigned long data, size_t size))
static int	gl2psPrintPDFShaderStreamDataAlpha (GL2PSvertex *vertex, size_t(*action)(unsigned long data, size_t size), int sigbyte)
static int	gl2psPrintPDFShaderStreamData (GL2PStriangle *triangle, GLfloat dx, GLfloat dy, GLfloat xmin, GLfloat ymin, size_t(*action)(unsigned long data, size_t size), int gray)
static void	gl2psPDFRectHull (GLfloat *xmin, GLfloat *xmax, GLfloat *ymin, GLfloat *ymax, GL2PStriangle *triangles, int cnt)
static int	gl2psPrintPDFShader (int obj, GL2PStriangle *triangles, int size, int gray)
static int	gl2psPrintPDFShaderMask (int obj, int childobj)
static int	gl2psPrintPDFShaderExtGS (int obj, int childobj)
static int	gl2psPrintPDFShaderSimpleExtGS (int obj, GLfloat alpha)
static int	gl2psPrintPDFPixmapStreamData (GL2PSimage *im, size_t(*action)(unsigned long data, size_t size), int gray)
static int	gl2psPrintPDFPixmap (int obj, int childobj, GL2PSimage *im, int gray)
static int	gl2psPrintPDFText (int obj, GL2PSstring *s, int fontnumber)
static int	gl2psPDFgroupListWriteObjects (int entryoffs)
static void	gl2psPrintPDFFooter (void)
static void	gl2psPrintPDFBeginViewport (GLint viewport[4])
static GLint	gl2psPrintPDFEndViewport (void)
static void	gl2psPrintPDFFinalPrimitive (void)
static void	gl2psSVGGetCoordsAndColors (int n, GL2PSvertex *verts, GL2PSxyz *xyz, GL2PSrgba *rgba)
static void	gl2psSVGGetColorString (GL2PSrgba rgba, char str[32])
static void	gl2psPrintSVGHeader (void)
static void	gl2psPrintSVGSmoothTriangle (GL2PSxyz xyz[3], GL2PSrgba rgba[3])
static void	gl2psPrintSVGDash (GLushort pattern, GLint factor)
static void	gl2psEndSVGLine (void)
static void	gl2psPrintSVGPixmap (GLfloat, GLfloat, GL2PSimage *)
static void	gl2psPrintSVGPrimitive (void *data)
static void	gl2psPrintSVGFooter (void)
static void	gl2psPrintSVGBeginViewport (GLint viewport[4])
static GLint	gl2psPrintSVGEndViewport (void)
static void	gl2psPrintSVGFinalPrimitive (void)
static void	gl2psPrintPGFColor (GL2PSrgba rgba)
static void	gl2psPrintPGFHeader (void)
static void	gl2psPrintPGFDash (GLushort pattern, GLint factor)
static const char *	gl2psPGFTextAlignment (int align)
static void	gl2psPrintPGFPrimitive (void *data)
static void	gl2psPrintPGFFooter (void)
static void	gl2psPrintPGFBeginViewport (GLint viewport[4])
static GLint	gl2psPrintPGFEndViewport (void)
static void	gl2psPrintPGFFinalPrimitive (void)
static void	gl2psComputeTightBoundingBox (void *data)
GL2PSDLL_API GLint	gl2psBeginPage (const char *title, const char *producer, GLint viewport[4], GLint format, GLint sort, GLint options, GLint colormode, GLint colorsize, GL2PSrgba *colormap, GLint nr, GLint ng, GLint nb, GLint buffersize, FILE *stream, const char *filename)
GL2PSDLL_API GLint	gl2psEndPage (void)
GL2PSDLL_API GLint	gl2psBeginViewport (GLint viewport[4])
GL2PSDLL_API GLint	gl2psEndViewport (void)
GL2PSDLL_API GLint	gl2psTextOpt (const char *str, const char *fontname, GLshort fontsize, GLint alignment, GLfloat angle)
GL2PSDLL_API GLint	gl2psText (const char *str, const char *fontname, GLshort fontsize)
GL2PSDLL_API GLint	gl2psSpecial (GLint format, const char *str)
GL2PSDLL_API GLint	gl2psDrawPixels (GLsizei width, GLsizei height, GLint xorig, GLint yorig, GLenum format, GLenum type, const void *pixels)
GL2PSDLL_API GLint	gl2psDrawImageMap (GLsizei width, GLsizei height, const GLfloat position[3], const unsigned char *imagemap)
GL2PSDLL_API GLint	gl2psEnable (GLint mode)
GL2PSDLL_API GLint	gl2psDisable (GLint mode)
GL2PSDLL_API GLint	gl2psPointSize (GLfloat value)
GL2PSDLL_API GLint	gl2psLineWidth (GLfloat value)
GL2PSDLL_API GLint	gl2psBlendFunc (GLenum sfactor, GLenum dfactor)
GL2PSDLL_API GLint	gl2psSetOptions (GLint options)
GL2PSDLL_API GLint	gl2psGetOptions (GLint *options)
GL2PSDLL_API const char *	gl2psGetFileExtension (GLint format)
GL2PSDLL_API const char *	gl2psGetFormatDescription (GLint format)

Variables
static GL2PScontext *	gl2ps = NULL
static GL2PSbackend	gl2psPS
static GL2PSbackend	gl2psEPS
static GL2PSbackend	gl2psTEX
static GL2PSbackend	gl2psPDF
static GL2PSbackend	gl2psSVG
static GL2PSbackend	gl2psPGF
static GL2PSbackend *	gl2psbackends []

Macro Definition Documentation

GL2PS_BEGIN_BLEND_TOKEN

#define GL2PS_BEGIN_BLEND_TOKEN   9

Definition at line 109 of file gl2ps.cxx.

GL2PS_BEGIN_BOUNDARY_TOKEN

#define GL2PS_BEGIN_BOUNDARY_TOKEN   3

Definition at line 103 of file gl2ps.cxx.

GL2PS_BEGIN_OFFSET_TOKEN

#define GL2PS_BEGIN_OFFSET_TOKEN   1

Definition at line 101 of file gl2ps.cxx.

GL2PS_BEGIN_STIPPLE_TOKEN

#define GL2PS_BEGIN_STIPPLE_TOKEN   5

Definition at line 105 of file gl2ps.cxx.

GL2PS_COINCIDENT

#define GL2PS_COINCIDENT   1

Definition at line 88 of file gl2ps.cxx.

GL2PS_DRAW_PIXELS_TOKEN

#define GL2PS_DRAW_PIXELS_TOKEN   14

Definition at line 114 of file gl2ps.cxx.

GL2PS_DST_BLEND_TOKEN

#define GL2PS_DST_BLEND_TOKEN   12

Definition at line 112 of file gl2ps.cxx.

GL2PS_END_BLEND_TOKEN

#define GL2PS_END_BLEND_TOKEN   10

Definition at line 110 of file gl2ps.cxx.

GL2PS_END_BOUNDARY_TOKEN

#define GL2PS_END_BOUNDARY_TOKEN   4

Definition at line 104 of file gl2ps.cxx.

GL2PS_END_OFFSET_TOKEN

#define GL2PS_END_OFFSET_TOKEN   2

Definition at line 102 of file gl2ps.cxx.

GL2PS_END_STIPPLE_TOKEN

#define GL2PS_END_STIPPLE_TOKEN   6

Definition at line 106 of file gl2ps.cxx.

GL2PS_EPSILON

#define GL2PS_EPSILON   5.0e-3F

Definition at line 66 of file gl2ps.cxx.

GL2PS_IMAGEMAP

#define GL2PS_IMAGEMAP   7

Definition at line 81 of file gl2ps.cxx.

GL2PS_IMAGEMAP_TOKEN

#define GL2PS_IMAGEMAP_TOKEN   13

Definition at line 113 of file gl2ps.cxx.

GL2PS_IMAGEMAP_VISIBLE

#define GL2PS_IMAGEMAP_VISIBLE   9

Definition at line 83 of file gl2ps.cxx.

GL2PS_IMAGEMAP_WRITTEN

#define GL2PS_IMAGEMAP_WRITTEN   8

Definition at line 82 of file gl2ps.cxx.

GL2PS_IN_BACK_OF

#define GL2PS_IN_BACK_OF   3

Definition at line 90 of file gl2ps.cxx.

GL2PS_IN_FRONT_OF

#define GL2PS_IN_FRONT_OF   2

Definition at line 89 of file gl2ps.cxx.

GL2PS_LINE

#define GL2PS_LINE   3

Definition at line 77 of file gl2ps.cxx.

GL2PS_LINE_WIDTH_TOKEN

#define GL2PS_LINE_WIDTH_TOKEN   8

Definition at line 108 of file gl2ps.cxx.

GL2PS_NO_TYPE

#define GL2PS_NO_TYPE   -1

Definition at line 74 of file gl2ps.cxx.

GL2PS_PIXMAP

#define GL2PS_PIXMAP   6

Definition at line 80 of file gl2ps.cxx.

GL2PS_POINT

#define GL2PS_POINT   2

Definition at line 76 of file gl2ps.cxx.

GL2PS_POINT_BACK

#define GL2PS_POINT_BACK   2

Definition at line 97 of file gl2ps.cxx.

GL2PS_POINT_COINCIDENT

#define GL2PS_POINT_COINCIDENT   0

Definition at line 95 of file gl2ps.cxx.

GL2PS_POINT_INFRONT

#define GL2PS_POINT_INFRONT   1

Definition at line 96 of file gl2ps.cxx.

GL2PS_POINT_SIZE_TOKEN

#define GL2PS_POINT_SIZE_TOKEN   7

Definition at line 107 of file gl2ps.cxx.

GL2PS_QUADRANGLE

#define GL2PS_QUADRANGLE   4

Definition at line 78 of file gl2ps.cxx.

GL2PS_SPANNING

#define GL2PS_SPANNING   4

Definition at line 91 of file gl2ps.cxx.

GL2PS_SPECIAL

#define GL2PS_SPECIAL   10

Definition at line 84 of file gl2ps.cxx.

GL2PS_SRC_BLEND_TOKEN

#define GL2PS_SRC_BLEND_TOKEN   11

Definition at line 111 of file gl2ps.cxx.

GL2PS_TEXT

#define GL2PS_TEXT   1

Definition at line 75 of file gl2ps.cxx.

GL2PS_TEXT_TOKEN

#define GL2PS_TEXT_TOKEN   15

Definition at line 115 of file gl2ps.cxx.

GL2PS_TRIANGLE

#define GL2PS_TRIANGLE   5

Definition at line 79 of file gl2ps.cxx.

GL2PS_ZERO

#define GL2PS_ZERO

(

arg

)

Value:

(fabs(arg) < 1.e-20)

Definition at line 70 of file gl2ps.cxx.

GL2PS_ZOFFSET

#define GL2PS_ZOFFSET   5.0e-2F

Definition at line 68 of file gl2ps.cxx.

GL2PS_ZOFFSET_LARGE

#define GL2PS_ZOFFSET_LARGE   20.0F

Definition at line 69 of file gl2ps.cxx.

GL2PS_ZSCALE

#define GL2PS_ZSCALE   1000.0F

Definition at line 67 of file gl2ps.cxx.

Typedef Documentation

GL2PSbsptree

typedef struct _GL2PSbsptree GL2PSbsptree

Definition at line 141 of file gl2ps.cxx.

GL2PSbsptree2d

typedef struct _GL2PSbsptree2d GL2PSbsptree2d

Definition at line 129 of file gl2ps.cxx.

GL2PSimagemap

typedef struct _GL2PSimagemap GL2PSimagemap

Definition at line 177 of file gl2ps.cxx.

GL2PSplane

typedef GLfloat GL2PSplane[4]

Definition at line 127 of file gl2ps.cxx.

GL2PSxyz

typedef GLfloat GL2PSxyz[3]

Definition at line 126 of file gl2ps.cxx.

Enumeration Type Documentation

GL2PS_TRIANGLE_PROPERTY

enum GL2PS_TRIANGLE_PROPERTY

Enumerator
T_UNDEFINED
T_CONST_COLOR
T_VAR_COLOR
T_ALPHA_1
T_ALPHA_LESS_1
T_VAR_ALPHA

Definition at line 117 of file gl2ps.cxx.

             {
  T_UNDEFINED    = -1,
  T_CONST_COLOR  = 1,
  T_VAR_COLOR    = 1<<1,
  T_ALPHA_1      = 1<<2,
  T_ALPHA_LESS_1 = 1<<3,
  T_VAR_ALPHA    = 1<<4
} GL2PS_TRIANGLE_PROPERTY;

Function Documentation

gl2psAdaptVertexForBlending()

void gl2psAdaptVertexForBlending ( GL2PSvertex * v )

static

Definition at line 924 of file gl2ps.cxx.

{
  /* Transforms vertex depending on the actual blending function -
     currently the vertex v is considered as source vertex and his
     alpha value is changed to 1.0 if source blending GL_ONE is
     active. This might be extended in the future */
 
  if(!v || !gl2ps)
    return;
 
  if(gl2ps->options & GL2PS_NO_BLENDING || !gl2ps->blending){
    v->rgba[3] = 1.0F;
    return;
  }
 
  switch(gl2ps->blendfunc[0]){
  case GL_ONE:
    v->rgba[3] = 1.0F;
    break;
  default:
    break;
  }
}

gl2psAddBoundaryInList()

void gl2psAddBoundaryInList ( GL2PSprimitive * prim, GL2PSlist * list )

static

Definition at line 2060 of file gl2ps.cxx.

{
  GL2PSprimitive *b;
  GLshort i;
  GL2PSxyz c;
 
  c[0] = c[1] = c[2] = 0.0F;
  for(i = 0; i < prim->numverts; i++){
    c[0] += prim->verts[i].xyz[0];
    c[1] += prim->verts[i].xyz[1];
  }
  c[0] /= prim->numverts;
  c[1] /= prim->numverts;
 
  for(i = 0; i < prim->numverts; i++){
    if(prim->boundary & (GLint)pow(2., i)){
      b = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive));
      b->type = GL2PS_LINE;
      b->offset = prim->offset;
      b->pattern = prim->pattern;
      b->factor = prim->factor;
      b->culled = prim->culled;
      b->width = prim->width;
      b->boundary = 0;
      b->numverts = 2;
      b->verts = (GL2PSvertex*)gl2psMalloc(2 * sizeof(GL2PSvertex));
 
#if 0 /* FIXME: need to work on boundary offset... */
      v[0] = c[0] - prim->verts[i].xyz[0];
      v[1] = c[1] - prim->verts[i].xyz[1];
      v[2] = 0.0F;
      norm = gl2psNorm(v);
      v[0] /= norm;
      v[1] /= norm;
      b->verts[0].xyz[0] = prim->verts[i].xyz[0] +0.1*v[0];
      b->verts[0].xyz[1] = prim->verts[i].xyz[1] +0.1*v[1];
      b->verts[0].xyz[2] = prim->verts[i].xyz[2];
      v[0] = c[0] - prim->verts[gl2psGetIndex(i, prim->numverts)].xyz[0];
      v[1] = c[1] - prim->verts[gl2psGetIndex(i, prim->numverts)].xyz[1];
      norm = gl2psNorm(v);
      v[0] /= norm;
      v[1] /= norm;
      b->verts[1].xyz[0] = prim->verts[gl2psGetIndex(i, prim->numverts)].xyz[0] +0.1*v[0];
      b->verts[1].xyz[1] = prim->verts[gl2psGetIndex(i, prim->numverts)].xyz[1] +0.1*v[1];
      b->verts[1].xyz[2] = prim->verts[gl2psGetIndex(i, prim->numverts)].xyz[2];
#else
      b->verts[0].xyz[0] = prim->verts[i].xyz[0];
      b->verts[0].xyz[1] = prim->verts[i].xyz[1];
      b->verts[0].xyz[2] = prim->verts[i].xyz[2];
      b->verts[1].xyz[0] = prim->verts[gl2psGetIndex(i, prim->numverts)].xyz[0];
      b->verts[1].xyz[1] = prim->verts[gl2psGetIndex(i, prim->numverts)].xyz[1];
      b->verts[1].xyz[2] = prim->verts[gl2psGetIndex(i, prim->numverts)].xyz[2];
#endif
 
      b->verts[0].rgba[0] = 0.0F;
      b->verts[0].rgba[1] = 0.0F;
      b->verts[0].rgba[2] = 0.0F;
      b->verts[0].rgba[3] = 0.0F;
      b->verts[1].rgba[0] = 0.0F;
      b->verts[1].rgba[1] = 0.0F;
      b->verts[1].rgba[2] = 0.0F;
      b->verts[1].rgba[3] = 0.0F;
      gl2psListAdd(list, &b);
    }
  }
 
}

gl2psAddInBspImageTree()

GLint gl2psAddInBspImageTree ( GL2PSprimitive * prim, GL2PSbsptree2d ** tree )

static

Definition at line 1984 of file gl2ps.cxx.

{
  GLint ret = 0;
  GL2PSprimitive *frontprim = NULL, *backprim = NULL;
 
  /* FIXME: until we consider the actual extent of text strings and
     pixmaps, never cull them. Otherwise the whole string/pixmap gets
     culled as soon as the reference point is hidden */
  if(prim->type == GL2PS_PIXMAP ||
     prim->type == GL2PS_TEXT ||
     prim->type == GL2PS_SPECIAL){
    return 1;
  }
 
  if(*tree == NULL){
    if((prim->type != GL2PS_IMAGEMAP) && (GL_FALSE == gl2ps->zerosurfacearea)){
      gl2psAddPlanesInBspTreeImage(gl2ps->primitivetoadd, tree);
    }
    return 1;
  }
  else{
    switch(gl2psCheckPrimitive(prim, (*tree)->plane)){
    case GL2PS_IN_BACK_OF: return gl2psAddInBspImageTree(prim, &(*tree)->back);
    case GL2PS_IN_FRONT_OF:
      if((*tree)->front != NULL) return gl2psAddInBspImageTree(prim, &(*tree)->front);
      else                       return 0;
    case GL2PS_SPANNING:
      gl2psSplitPrimitive2D(prim, (*tree)->plane, &frontprim, &backprim);
      ret = gl2psAddInBspImageTree(backprim, &(*tree)->back);
      if((*tree)->front != NULL){
        if(gl2psAddInBspImageTree(frontprim, &(*tree)->front)){
          ret = 1;
        }
      }
      gl2psFree(frontprim->verts);
      gl2psFree(frontprim);
      gl2psFree(backprim->verts);
      gl2psFree(backprim);
      return ret;
    case GL2PS_COINCIDENT:
      if((*tree)->back != NULL){
        gl2ps->zerosurfacearea = GL_TRUE;
        ret = gl2psAddInBspImageTree(prim, &(*tree)->back);
        gl2ps->zerosurfacearea = GL_FALSE;
        if(ret) return ret;
      }
      if((*tree)->front != NULL){
        gl2ps->zerosurfacearea = GL_TRUE;
        ret = gl2psAddInBspImageTree(prim, &(*tree)->front);
        gl2ps->zerosurfacearea = GL_FALSE;
        if(ret) return ret;
      }
      if(prim->type == GL2PS_LINE) return 1;
      else                         return 0;
    }
  }
  return 0;
}

gl2psAddIndex()

void gl2psAddIndex ( GLshort * index0, GLshort * index1, GLshort * nb, GLshort i, GLshort j )

static

Definition at line 1231 of file gl2ps.cxx.

{
  GLint k;
 
  for(k = 0; k < *nb; k++){
    if((index0[k] == i && index1[k] == j) ||
       (index1[k] == i && index0[k] == j)) return;
  }
  index0[*nb] = i;
  index1[*nb] = j;
  (*nb)++;
}

gl2psAddInImageTree()

void gl2psAddInImageTree ( void * data )

static

Definition at line 2043 of file gl2ps.cxx.

{
  GL2PSprimitive *prim = *(GL2PSprimitive **)data;
  gl2ps->primitivetoadd = prim;
  if(prim->type == GL2PS_IMAGEMAP && prim->data.image->format == GL2PS_IMAGEMAP_VISIBLE){
    prim->culled = 1;
  }
  else if(!gl2psAddInBspImageTree(prim, &gl2ps->imagetree)){
    prim->culled = 1;
  }
  else if(prim->type == GL2PS_IMAGEMAP){
    prim->data.image->format = GL2PS_IMAGEMAP_VISIBLE;
  }
}

gl2psAddPlanesInBspTreeImage()

void gl2psAddPlanesInBspTreeImage ( GL2PSprimitive * prim, GL2PSbsptree2d ** tree )

static

Definition at line 1749 of file gl2ps.cxx.

{
  GLint ret = 0;
  GLint i;
  GLint offset = 0;
  GL2PSbsptree2d *head = NULL, *cur = NULL;
 
  if((*tree == NULL) && (prim->numverts > 2)){
    /* don't cull if transparent
    for(i = 0; i < prim->numverts - 1; i++)
      if(prim->verts[i].rgba[3] < 1.0F) return;
    */
    head = (GL2PSbsptree2d*)gl2psMalloc(sizeof(GL2PSbsptree2d));
    for(i = 0; i < prim->numverts-1; i++){
      if(!gl2psGetPlaneFromPoints(prim->verts[i].xyz,
                                  prim->verts[i+1].xyz,
                                  head->plane)){
        if(prim->numverts-i > 3){
          offset++;
        }
        else{
          gl2psFree(head);
          return;
        }
      }
      else{
        break;
      }
    }
    head->back = NULL;
    head->front = NULL;
    for(i = 2+offset; i < prim->numverts; i++){
      ret = gl2psCheckPoint(prim->verts[i].xyz, head->plane);
      if(ret != GL2PS_POINT_COINCIDENT) break;
    }
    switch(ret){
    case GL2PS_POINT_INFRONT :
      cur = head;
      for(i = 1+offset; i < prim->numverts-1; i++){
        if(cur->front == NULL){
          cur->front = (GL2PSbsptree2d*)gl2psMalloc(sizeof(GL2PSbsptree2d));
        }
        if(gl2psGetPlaneFromPoints(prim->verts[i].xyz,
                                   prim->verts[i+1].xyz,
                                   cur->front->plane)){
          cur = cur->front;
          cur->front = NULL;
          cur->back = NULL;
        }
      }
      if(cur->front == NULL){
        cur->front = (GL2PSbsptree2d*)gl2psMalloc(sizeof(GL2PSbsptree2d));
      }
      if(gl2psGetPlaneFromPoints(prim->verts[i].xyz,
                                 prim->verts[offset].xyz,
                                 cur->front->plane)){
        cur->front->front = NULL;
        cur->front->back = NULL;
      }
      else{
        gl2psFree(cur->front);
        cur->front = NULL;
      }
      break;
    case GL2PS_POINT_BACK :
      for(i = 0; i < 4; i++){
        head->plane[i] = -head->plane[i];
      }
      cur = head;
      for(i = 1+offset; i < prim->numverts-1; i++){
        if(cur->front == NULL){
          cur->front = (GL2PSbsptree2d*)gl2psMalloc(sizeof(GL2PSbsptree2d));
        }
        if(gl2psGetPlaneFromPoints(prim->verts[i+1].xyz,
                                   prim->verts[i].xyz,
                                   cur->front->plane)){
          cur = cur->front;
          cur->front = NULL;
          cur->back = NULL;
        }
      }
      if(cur->front == NULL){
        cur->front = (GL2PSbsptree2d*)gl2psMalloc(sizeof(GL2PSbsptree2d));
      }
      if(gl2psGetPlaneFromPoints(prim->verts[offset].xyz,
                                 prim->verts[i].xyz,
                                 cur->front->plane)){
        cur->front->front = NULL;
        cur->front->back = NULL;
      }
      else{
        gl2psFree(cur->front);
        cur->front = NULL;
      }
      break;
    default:
      gl2psFree(head);
      return;
    }
    (*tree) = head;
  }
}

gl2psAddPolyPrimitive()

void gl2psAddPolyPrimitive ( GLshort type, GLshort numverts, GL2PSvertex * verts, GLint offset, GLushort pattern, GLint factor, GLfloat width, char boundary )

static

Definition at line 2148 of file gl2ps.cxx.

{
  GL2PSprimitive *prim;
 
  prim = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive));
  prim->type = type;
  prim->numverts = numverts;
  prim->verts = (GL2PSvertex*)gl2psMalloc(numverts * sizeof(GL2PSvertex));
  memcpy(prim->verts, verts, numverts * sizeof(GL2PSvertex));
  prim->boundary = boundary;
  prim->offset = offset;
  prim->pattern = pattern;
  prim->factor = factor;
  prim->width = width;
  prim->culled = 0;
 
  /* FIXME: here we should have an option to split stretched
     tris/quads to enhance SIMPLE_SORT */
 
  gl2psListAdd(gl2ps->primitives, &prim);
}

gl2psAddPrimitiveInList()

void gl2psAddPrimitiveInList ( GL2PSprimitive * prim, GL2PSlist * list )

static

Definition at line 1479 of file gl2ps.cxx.

{
  GL2PSprimitive *t1, *t2;
 
  if(prim->type != GL2PS_QUADRANGLE){
    gl2psListAdd(list, &prim);
  }
  else{
    gl2psDivideQuad(prim, &t1, &t2);
    gl2psListAdd(list, &t1);
    gl2psListAdd(list, &t2);
    gl2psFreePrimitive(&prim);
  }
 
}

gl2psAddText()

GLint gl2psAddText ( GLint type, const char * str, const char * fontname, GLshort fontsize, GLint alignment, GLfloat angle )

static

Definition at line 843 of file gl2ps.cxx.

{
  GLfloat pos[4];
  GL2PSprimitive *prim;
  GLboolean valid;
 
  if(!gl2ps || !str || !fontname) return GL2PS_UNINITIALIZED;
 
  if(gl2ps->options & GL2PS_NO_TEXT) return GL2PS_SUCCESS;
 
  glGetBooleanv(GL_CURRENT_RASTER_POSITION_VALID, &valid);
  if(GL_FALSE == valid) return GL2PS_SUCCESS; /* the primitive is culled */
 
  glGetFloatv(GL_CURRENT_RASTER_POSITION, pos);
 
  prim = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive));
  prim->type = type;
  prim->boundary = 0;
  prim->numverts = 1;
  prim->verts = (GL2PSvertex*)gl2psMalloc(sizeof(GL2PSvertex));
  prim->verts[0].xyz[0] = pos[0];
  prim->verts[0].xyz[1] = pos[1];
  prim->verts[0].xyz[2] = pos[2];
  prim->culled = 0;
  prim->offset = 0;
  prim->pattern = 0;
  prim->factor = 0;
  prim->width = 1;
  glGetFloatv(GL_CURRENT_RASTER_COLOR, prim->verts[0].rgba);
  prim->data.text = (GL2PSstring*)gl2psMalloc(sizeof(GL2PSstring));
  prim->data.text->str = (char*)gl2psMalloc((strlen(str)+1)*sizeof(char));
  strcpy(prim->data.text->str, str);
  prim->data.text->fontname = (char*)gl2psMalloc((strlen(fontname)+1)*sizeof(char));
  strcpy(prim->data.text->fontname, fontname);
  prim->data.text->fontsize = fontsize;
  prim->data.text->alignment = alignment;
  prim->data.text->angle = angle;
 
  gl2psListAdd(gl2ps->auxprimitives, &prim);
  glPassThrough(GL2PS_TEXT_TOKEN);
 
  return GL2PS_SUCCESS;
}

gl2psAssignTriangleProperties()

void gl2psAssignTriangleProperties ( GL2PStriangle * t )

static

Definition at line 948 of file gl2ps.cxx.

{
  /* int i; */
 
  t->prop = T_VAR_COLOR;
 
  /* Uncommenting the following lines activates an even more fine
     grained distinction between triangle types - please don't delete,
     a remarkable amount of PDF handling code inside this file depends
     on it if activated */
  /*
  t->prop = T_CONST_COLOR;
  for(i = 0; i < 3; ++i){
    if(!GL2PS_ZERO(t->vertex[0].rgba[i] - t->vertex[1].rgba[i]) ||
       !GL2PS_ZERO(t->vertex[1].rgba[i] - t->vertex[2].rgba[i])){
      t->prop = T_VAR_COLOR;
      break;
    }
  }
  */
 
  if(!GL2PS_ZERO(t->vertex[0].rgba[3] - t->vertex[1].rgba[3]) ||
     !GL2PS_ZERO(t->vertex[1].rgba[3] - t->vertex[2].rgba[3])){
    t->prop |= T_VAR_ALPHA;
  }
  else{
    if(t->vertex[0].rgba[3] < 1)
      t->prop |= T_ALPHA_LESS_1;
    else
      t->prop |= T_ALPHA_1;
  }
}

gl2psBeginPage()

GL2PSDLL_API GLint gl2psBeginPage	(	const char *	title,
		const char *	producer,
		GLint	viewport[4],
		GLint	format,
		GLint	sort,
		GLint	options,
		GLint	colormode,
		GLint	colorsize,
		GL2PSrgba *	colormap,
		GLint	nr,
		GLint	ng,
		GLint	nb,
		GLint	buffersize,
		FILE *	stream,
		const char *	filename )

Definition at line 5584 of file gl2ps.cxx.

{
  GLint index;
  int i;
 
  if(gl2ps){
    gl2psMsg(GL2PS_ERROR, "gl2psBeginPage called in wrong program state");
    return GL2PS_ERROR;
  }
 
  gl2ps = (GL2PScontext*)gl2psMalloc(sizeof(GL2PScontext));
 
  if(format >= 0 && format < (GLint)(sizeof(gl2psbackends) / sizeof(gl2psbackends[0]))){
    gl2ps->format = format;
  }
  else {
    gl2psMsg(GL2PS_ERROR, "Unknown output format: %d", format);
    gl2psFree(gl2ps);
    gl2ps = NULL;
    return GL2PS_ERROR;
  }
 
  switch(sort){
  case GL2PS_NO_SORT :
  case GL2PS_SIMPLE_SORT :
  case GL2PS_BSP_SORT :
    gl2ps->sort = sort;
    break;
  default :
    gl2psMsg(GL2PS_ERROR, "Unknown sorting algorithm: %d", sort);
    gl2psFree(gl2ps);
    gl2ps = NULL;
    return GL2PS_ERROR;
  }
 
  if(stream){
    gl2ps->stream = stream;
  }
  else{
    gl2psMsg(GL2PS_ERROR, "Bad file pointer");
    gl2psFree(gl2ps);
    gl2ps = NULL;
    return GL2PS_ERROR;
  }
 
  gl2ps->header = GL_TRUE;
  gl2ps->maxbestroot = 10;
  gl2ps->options = options;
  gl2ps->compress = NULL;
  gl2ps->imagemap_head = NULL;
  gl2ps->imagemap_tail = NULL;
 
  if(gl2ps->options & GL2PS_USE_CURRENT_VIEWPORT){
    glGetIntegerv(GL_VIEWPORT, gl2ps->viewport);
  }
  else{
    for(i = 0; i < 4; i++){
      gl2ps->viewport[i] = viewport[i];
    }
  }
 
  if(!gl2ps->viewport[2] || !gl2ps->viewport[3]){
    gl2psMsg(GL2PS_ERROR, "Incorrect viewport (x=%d, y=%d, width=%d, height=%d)",
             gl2ps->viewport[0], gl2ps->viewport[1],
             gl2ps->viewport[2], gl2ps->viewport[3]);
    gl2psFree(gl2ps);
    gl2ps = NULL;
    return GL2PS_ERROR;
  }
 
  gl2ps->threshold[0] = nr ? 1.0F / (GLfloat)nr : 0.064F;
  gl2ps->threshold[1] = ng ? 1.0F / (GLfloat)ng : 0.034F;
  gl2ps->threshold[2] = nb ? 1.0F / (GLfloat)nb : 0.100F;
  gl2ps->colormode = colormode;
  gl2ps->buffersize = buffersize > 0 ? buffersize : 2048 * 2048;
  for(i = 0; i < 3; i++){
    gl2ps->lastvertex.xyz[i] = -1.0F;
  }
  for(i = 0; i < 4; i++){
    gl2ps->lastvertex.rgba[i] = -1.0F;
    gl2ps->lastrgba[i] = -1.0F;
  }
  gl2ps->lastlinewidth = -1.0F;
  gl2ps->lastpattern = 0;
  gl2ps->lastfactor = 0;
  gl2ps->imagetree = NULL;
  gl2ps->primitivetoadd = NULL;
  gl2ps->zerosurfacearea = GL_FALSE;
  gl2ps->pdfprimlist = NULL;
  gl2ps->pdfgrouplist = NULL;
  gl2ps->xreflist = NULL;
 
  /* get default blending mode from current OpenGL state (enabled by
     default for SVG) */
  gl2ps->blending = (gl2ps->format == GL2PS_SVG) ? GL_TRUE : glIsEnabled(GL_BLEND);
  glGetIntegerv(GL_BLEND_SRC, &gl2ps->blendfunc[0]);
  glGetIntegerv(GL_BLEND_DST, &gl2ps->blendfunc[1]);
 
  if(gl2ps->colormode == GL_RGBA){
    gl2ps->colorsize = 0;
    gl2ps->colormap = NULL;
    glGetFloatv(GL_COLOR_CLEAR_VALUE, gl2ps->bgcolor);
  }
  else if(gl2ps->colormode == GL_COLOR_INDEX){
    if(!colorsize || !colormap){
      gl2psMsg(GL2PS_ERROR, "Missing colormap for GL_COLOR_INDEX rendering");
      gl2psFree(gl2ps);
      gl2ps = NULL;
      return GL2PS_ERROR;
    }
    gl2ps->colorsize = colorsize;
    gl2ps->colormap = (GL2PSrgba*)gl2psMalloc(gl2ps->colorsize * sizeof(GL2PSrgba));
    memcpy(gl2ps->colormap, colormap, gl2ps->colorsize * sizeof(GL2PSrgba));
    glGetIntegerv(GL_INDEX_CLEAR_VALUE, &index);
    gl2ps->bgcolor[0] = gl2ps->colormap[index][0];
    gl2ps->bgcolor[1] = gl2ps->colormap[index][1];
    gl2ps->bgcolor[2] = gl2ps->colormap[index][2];
    gl2ps->bgcolor[3] = 1.0F;
  }
  else{
    gl2psMsg(GL2PS_ERROR, "Unknown color mode in gl2psBeginPage");
    gl2psFree(gl2ps);
    gl2ps = NULL;
    return GL2PS_ERROR;
  }
 
  if(!title){
    gl2ps->title = (char*)gl2psMalloc(sizeof(char));
    gl2ps->title[0] = '\0';
  }
  else{
    gl2ps->title = (char*)gl2psMalloc((strlen(title)+1)*sizeof(char));
    strcpy(gl2ps->title, title);
  }
 
  if(!producer){
    gl2ps->producer = (char*)gl2psMalloc(sizeof(char));
    gl2ps->producer[0] = '\0';
  }
  else{
    gl2ps->producer = (char*)gl2psMalloc((strlen(producer)+1)*sizeof(char));
    strcpy(gl2ps->producer, producer);
  }
 
  if(!filename){
    gl2ps->filename = (char*)gl2psMalloc(sizeof(char));
    gl2ps->filename[0] = '\0';
  }
  else{
    gl2ps->filename = (char*)gl2psMalloc((strlen(filename)+1)*sizeof(char));
    strcpy(gl2ps->filename, filename);
  }
 
  gl2ps->primitives = gl2psListCreate(500, 500, sizeof(GL2PSprimitive*));
  gl2ps->auxprimitives = gl2psListCreate(100, 100, sizeof(GL2PSprimitive*));
  gl2ps->feedback = (GLfloat*)gl2psMalloc(gl2ps->buffersize * sizeof(GLfloat));
  glFeedbackBuffer(gl2ps->buffersize, GL_3D_COLOR, gl2ps->feedback);
  glRenderMode(GL_FEEDBACK);
 
  return GL2PS_SUCCESS;
}

gl2psBeginViewport()

GL2PSDLL_API GLint gl2psBeginViewport

(

GLint

viewport[4]

)

Definition at line 5778 of file gl2ps.cxx.

{
  if(!gl2ps) return GL2PS_UNINITIALIZED;
 
  (gl2psbackends[gl2ps->format]->beginViewport)(viewport);
 
  return GL2PS_SUCCESS;
}

gl2psBlendFunc()

GL2PSDLL_API GLint gl2psBlendFunc	(	GLenum	sfactor,
		GLenum	dfactor )

Definition at line 6002 of file gl2ps.cxx.

{
  if(!gl2ps) return GL2PS_UNINITIALIZED;
 
  if(GL_FALSE == gl2psSupportedBlendMode(sfactor, dfactor))
    return GL2PS_WARNING;
 
  glPassThrough(GL2PS_SRC_BLEND_TOKEN);
  glPassThrough((GLfloat)sfactor);
  glPassThrough(GL2PS_DST_BLEND_TOKEN);
  glPassThrough((GLfloat)dfactor);
 
  return GL2PS_SUCCESS;
}

gl2psBuildBspTree()

void gl2psBuildBspTree ( GL2PSbsptree * tree, GL2PSlist * primitives )

static

Definition at line 1521 of file gl2ps.cxx.

{
  GL2PSprimitive *prim = nullptr, *frontprim = nullptr, *backprim = nullptr;
  GL2PSlist *frontlist, *backlist;
  GLint i, index;
 
  tree->front = nullptr;
  tree->back = nullptr;
  tree->primitives = gl2psListCreate(1, 2, sizeof(GL2PSprimitive*));
  index = gl2psFindRoot(primitives, &prim);
  gl2psGetPlane(prim, tree->plane);
  gl2psAddPrimitiveInList(prim, tree->primitives);
 
  frontlist = gl2psListCreate(1, 2, sizeof(GL2PSprimitive*));
  backlist = gl2psListCreate(1, 2, sizeof(GL2PSprimitive*));
 
  for(i = 0; i < gl2psListNbr(primitives); i++){
    if(i != index){
      prim = *(GL2PSprimitive**)gl2psListPointer(primitives,i);
      switch(gl2psSplitPrimitive(prim, tree->plane, &frontprim, &backprim)){
      case GL2PS_COINCIDENT:
        gl2psAddPrimitiveInList(prim, tree->primitives);
        break;
      case GL2PS_IN_BACK_OF:
        gl2psAddPrimitiveInList(prim, backlist);
        break;
      case GL2PS_IN_FRONT_OF:
        gl2psAddPrimitiveInList(prim, frontlist);
        break;
      case GL2PS_SPANNING:
        gl2psAddPrimitiveInList(backprim, backlist);
        gl2psAddPrimitiveInList(frontprim, frontlist);
        gl2psFreePrimitive(&prim);
        break;
      }
    }
  }
 
  if(gl2psListNbr(tree->primitives)){
    gl2psListSort(tree->primitives, gl2psTrianglesFirst);
  }
 
  if(gl2psListNbr(frontlist)){
    gl2psListSort(frontlist, gl2psTrianglesFirst);
    tree->front = (GL2PSbsptree*)gl2psMalloc(sizeof(GL2PSbsptree));
    gl2psBuildBspTree(tree->front, frontlist);
  }
  else{
    gl2psListDelete(frontlist);
  }
 
  if(gl2psListNbr(backlist)){
    gl2psListSort(backlist, gl2psTrianglesFirst);
    tree->back = (GL2PSbsptree*)gl2psMalloc(sizeof(GL2PSbsptree));
    gl2psBuildBspTree(tree->back, backlist);
  }
  else{
    gl2psListDelete(backlist);
  }
 
  gl2psListDelete(primitives);
}

gl2psBuildPolygonBoundary()

void gl2psBuildPolygonBoundary ( GL2PSbsptree * tree )

static

Definition at line 2128 of file gl2ps.cxx.

{
  GLint i;
  GL2PSprimitive *prim;
 
  if(!tree) return;
  gl2psBuildPolygonBoundary(tree->back);
  for(i = 0; i < gl2psListNbr(tree->primitives); i++){
    prim = *(GL2PSprimitive**)gl2psListPointer(tree->primitives, i);
    if(prim->boundary) gl2psAddBoundaryInList(prim, tree->primitives);
  }
  gl2psBuildPolygonBoundary(tree->front);
}

gl2psCheckPoint()

GLint gl2psCheckPoint ( GL2PSxyz point, GL2PSplane plane )

static

Definition at line 1739 of file gl2ps.cxx.

{
  GLfloat pt_dis;
 
  pt_dis = gl2psComparePointPlane(point, plane);
  if(pt_dis > GL2PS_EPSILON)        return GL2PS_POINT_INFRONT;
  else if(pt_dis < -GL2PS_EPSILON)  return GL2PS_POINT_BACK;
  else                              return GL2PS_POINT_COINCIDENT;
}

gl2psCheckPrimitive()

GLint gl2psCheckPrimitive ( GL2PSprimitive * prim, GL2PSplane plane )

static

Definition at line 1853 of file gl2ps.cxx.

{
  GLint i;
  GLint pos;
 
  pos = gl2psCheckPoint(prim->verts[0].xyz, plane);
  for(i = 1; i < prim->numverts; i++){
    pos |= gl2psCheckPoint(prim->verts[i].xyz, plane);
    if(pos == (GL2PS_POINT_INFRONT | GL2PS_POINT_BACK)) return GL2PS_SPANNING;
  }
  if(pos & GL2PS_POINT_INFRONT)   return GL2PS_IN_FRONT_OF;
  else if(pos & GL2PS_POINT_BACK) return GL2PS_IN_BACK_OF;
  else                            return GL2PS_COINCIDENT;
}

gl2psClosePDFDataStream()

int gl2psClosePDFDataStream ( void )

static

Definition at line 4069 of file gl2ps.cxx.

{
  int offs = 0;
 
#if defined(GL2PS_HAVE_ZLIB)
  if(gl2ps->options & GL2PS_COMPRESS){
    if(Z_OK != gl2psDeflate())
      gl2psMsg(GL2PS_ERROR, "Zlib deflate error");
    else
      fwrite(gl2ps->compress->dest, gl2ps->compress->destLen, 1, gl2ps->stream);
    gl2ps->streamlength += gl2ps->compress->destLen;
 
    offs += gl2ps->streamlength;
    gl2psFreeCompress();
  }
#endif
 
  offs += fprintf(gl2ps->stream,
                  "endstream\n"
                  "endobj\n");
  return offs;
}

gl2psCompareDepth()

int gl2psCompareDepth ( const void * a, const void * b )

static

Definition at line 1367 of file gl2ps.cxx.

{
  GL2PSprimitive *q, *w;
  GLfloat dq = 0.0F, dw = 0.0F, diff;
  int i;
 
  q = *(GL2PSprimitive**)a;
  w = *(GL2PSprimitive**)b;
 
  for(i = 0; i < q->numverts; i++){
    dq += q->verts[i].xyz[2];
  }
  dq /= (GLfloat)q->numverts;
 
  for(i = 0; i < w->numverts; i++){
    dw += w->verts[i].xyz[2];
  }
  dw /= (GLfloat)w->numverts;
 
  diff = dq - dw;
  if(diff > 0.){
    return -1;
  }
  else if(diff < 0.){
    return 1;
  }
  else{
    return 0;
  }
}

gl2psComparePointPlane()

GLfloat gl2psComparePointPlane ( GL2PSxyz point, GL2PSplane plane )

static

Definition at line 1054 of file gl2ps.cxx.

{
  return (plane[0] * point[0] +
          plane[1] * point[1] +
          plane[2] * point[2] +
          plane[3]);
}

gl2psComputeTightBoundingBox()

void gl2psComputeTightBoundingBox ( void * data )

static

Definition at line 5485 of file gl2ps.cxx.

{
  GL2PSprimitive *prim;
  int i;
 
  prim = *(GL2PSprimitive**)data;
 
  for(i = 0; i < prim->numverts; i++){
    if(prim->verts[i].xyz[0] < gl2ps->viewport[0])
      gl2ps->viewport[0] = (GLint)prim->verts[i].xyz[0];
    if(prim->verts[i].xyz[0] > gl2ps->viewport[2])
      gl2ps->viewport[2] = (GLint)(prim->verts[i].xyz[0] + 0.5F);
    if(prim->verts[i].xyz[1] < gl2ps->viewport[1])
      gl2ps->viewport[1] = (GLint)prim->verts[i].xyz[1];
    if(prim->verts[i].xyz[1] > gl2ps->viewport[3])
      gl2ps->viewport[3] = (GLint)(prim->verts[i].xyz[1] + 0.5F);
  }
}

gl2psCopyPixmap()

GL2PSimage * gl2psCopyPixmap ( GL2PSimage * im )

static

Definition at line 743 of file gl2ps.cxx.

{
  int size;
  GL2PSimage *image = (GL2PSimage*)gl2psMalloc(sizeof(GL2PSimage));
 
  image->width = im->width;
  image->height = im->height;
  image->format = im->format;
  image->type = im->type;
 
  switch(image->format){
  case GL_RGBA:
    size = image->height * image->width * 4 * sizeof(GLfloat);
    break;
  case GL_RGB:
  default:
    size = image->height * image->width * 3 * sizeof(GLfloat);
    break;
  }
 
  image->pixels = (GLfloat*)gl2psMalloc(size);
  memcpy(image->pixels, im->pixels, size);
 
  return image;
}

gl2psCopyPrimitive()

GL2PSprimitive * gl2psCopyPrimitive ( GL2PSprimitive * p )

static

Definition at line 1002 of file gl2ps.cxx.

{
  GL2PSprimitive *prim;
 
  if(!p){
    gl2psMsg(GL2PS_ERROR, "Trying to copy an empty primitive");
    return NULL;
  }
 
  prim = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive));
 
  prim->type = p->type;
  prim->numverts = p->numverts;
  prim->boundary = p->boundary;
  prim->offset = p->offset;
  prim->pattern = p->pattern;
  prim->factor = p->factor;
  prim->culled = p->culled;
  prim->width = p->width;
  prim->verts = (GL2PSvertex*)gl2psMalloc(p->numverts*sizeof(GL2PSvertex));
  memcpy(prim->verts, p->verts, p->numverts * sizeof(GL2PSvertex));
 
  switch(prim->type){
  case GL2PS_PIXMAP :
    prim->data.image = gl2psCopyPixmap(p->data.image);
    break;
  case GL2PS_TEXT :
  case GL2PS_SPECIAL :
    prim->data.text = gl2psCopyText(p->data.text);
    break;
  default:
    break;
  }
 
  return prim;
}

gl2psCopyText()

GL2PSstring * gl2psCopyText ( GL2PSstring * t )

static

Definition at line 888 of file gl2ps.cxx.

{
  GL2PSstring *text = (GL2PSstring*)gl2psMalloc(sizeof(GL2PSstring));
  text->str = (char*)gl2psMalloc((strlen(t->str)+1)*sizeof(char));
  strcpy(text->str, t->str);
  text->fontname = (char*)gl2psMalloc((strlen(t->fontname)+1)*sizeof(char));
  strcpy(text->fontname, t->fontname);
  text->fontsize = t->fontsize;
  text->alignment = t->alignment;
  text->angle = t->angle;
 
  return text;
}

gl2psCreateSplitPrimitive()

void gl2psCreateSplitPrimitive ( GL2PSprimitive * parent, GL2PSplane plane, GL2PSprimitive * child, GLshort numverts, GLshort * index0, GLshort * index1 )

static

Definition at line 1187 of file gl2ps.cxx.

{
  GLshort i;
 
  if(parent->type == GL2PS_IMAGEMAP){
    child->type = GL2PS_IMAGEMAP;
    child->data.image = parent->data.image;
  }
  else{
    if(numverts > 4){
      gl2psMsg(GL2PS_WARNING, "%d vertices in polygon", numverts);
      numverts = 4;
    }
    switch(numverts){
    case 1 : child->type = GL2PS_POINT; break;
    case 2 : child->type = GL2PS_LINE; break;
    case 3 : child->type = GL2PS_TRIANGLE; break;
    case 4 : child->type = GL2PS_QUADRANGLE; break;
    default: child->type = GL2PS_NO_TYPE; break;
    }
  }
 
  child->boundary = 0; /* FIXME: not done! */
  child->culled = parent->culled;
  child->offset = parent->offset;
  child->pattern = parent->pattern;
  child->factor = parent->factor;
  child->width = parent->width;
  child->numverts = numverts;
  child->verts = (GL2PSvertex*)gl2psMalloc(numverts * sizeof(GL2PSvertex));
 
  for(i = 0; i < numverts; i++){
    if(index1[i] < 0){
      child->verts[i] = parent->verts[index0[i]];
    }
    else{
      gl2psCutEdge(&parent->verts[index0[i]], &parent->verts[index1[i]],
                   plane, &child->verts[i]);
    }
  }
}

gl2psCreateSplitPrimitive2D()

GL2PSprimitive * gl2psCreateSplitPrimitive2D ( GL2PSprimitive * parent, GLshort numverts, GL2PSvertex * vertx )

static

Definition at line 1868 of file gl2ps.cxx.

{
  GLint i;
  GL2PSprimitive *child = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive));
 
  if(parent->type == GL2PS_IMAGEMAP){
    child->type = GL2PS_IMAGEMAP;
    child->data.image = parent->data.image;
  }
  else {
    switch(numverts){
    case 1 : child->type = GL2PS_POINT; break;
    case 2 : child->type = GL2PS_LINE; break;
    case 3 : child->type = GL2PS_TRIANGLE; break;
    case 4 : child->type = GL2PS_QUADRANGLE; break;
    default: child->type = GL2PS_NO_TYPE; break; /* FIXME */
    }
  }
  child->boundary = 0; /* FIXME: not done! */
  child->culled = parent->culled;
  child->offset = parent->offset;
  child->pattern = parent->pattern;
  child->factor = parent->factor;
  child->width = parent->width;
  child->numverts = numverts;
  child->verts = (GL2PSvertex*)gl2psMalloc(numverts * sizeof(GL2PSvertex));
  for(i = 0; i < numverts; i++){
    child->verts[i] = vertx[i];
  }
  return child;
}

gl2psCutEdge()

void gl2psCutEdge ( GL2PSvertex * a, GL2PSvertex * b, GL2PSplane plane, GL2PSvertex * c )

static

Definition at line 1162 of file gl2ps.cxx.

{
  GL2PSxyz v;
  GLfloat sect, psca;
 
  v[0] = b->xyz[0] - a->xyz[0];
  v[1] = b->xyz[1] - a->xyz[1];
  v[2] = b->xyz[2] - a->xyz[2];
 
  if(!GL2PS_ZERO(psca = gl2psPsca(plane, v)))
    sect = -gl2psComparePointPlane(a->xyz, plane) / psca;
  else
    sect = 0.0F;
 
  c->xyz[0] = a->xyz[0] + v[0] * sect;
  c->xyz[1] = a->xyz[1] + v[1] * sect;
  c->xyz[2] = a->xyz[2] + v[2] * sect;
 
  c->rgba[0] = (1 - sect) * a->rgba[0] + sect * b->rgba[0];
  c->rgba[1] = (1 - sect) * a->rgba[1] + sect * b->rgba[1];
  c->rgba[2] = (1 - sect) * a->rgba[2] + sect * b->rgba[2];
  c->rgba[3] = (1 - sect) * a->rgba[3] + sect * b->rgba[3];
}

gl2psDisable()

GL2PSDLL_API GLint gl2psDisable

(

GLint

mode

)

Definition at line 5957 of file gl2ps.cxx.

{
  if(!gl2ps) return GL2PS_UNINITIALIZED;
 
  switch(mode){
  case GL2PS_POLYGON_OFFSET_FILL :
    glPassThrough(GL2PS_END_OFFSET_TOKEN);
    break;
  case GL2PS_POLYGON_BOUNDARY :
    glPassThrough(GL2PS_END_BOUNDARY_TOKEN);
    break;
  case GL2PS_LINE_STIPPLE :
    glPassThrough(GL2PS_END_STIPPLE_TOKEN);
    break;
  case GL2PS_BLEND :
    glPassThrough(GL2PS_END_BLEND_TOKEN);
    break;
  default :
    gl2psMsg(GL2PS_WARNING, "Unknown mode in gl2psDisable: %d", mode);
    return GL2PS_WARNING;
  }
 
  return GL2PS_SUCCESS;
}

gl2psDivideQuad()

void gl2psDivideQuad ( GL2PSprimitive * quad, GL2PSprimitive ** t1, GL2PSprimitive ** t2 )

static

Definition at line 1343 of file gl2ps.cxx.

{
  *t1 = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive));
  *t2 = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive));
  (*t1)->type = (*t2)->type = GL2PS_TRIANGLE;
  (*t1)->numverts = (*t2)->numverts = 3;
  (*t1)->culled = (*t2)->culled = quad->culled;
  (*t1)->offset = (*t2)->offset = quad->offset;
  (*t1)->pattern = (*t2)->pattern = quad->pattern;
  (*t1)->factor = (*t2)->factor = quad->factor;
  (*t1)->width = (*t2)->width = quad->width;
  (*t1)->verts = (GL2PSvertex*)gl2psMalloc(3 * sizeof(GL2PSvertex));
  (*t2)->verts = (GL2PSvertex*)gl2psMalloc(3 * sizeof(GL2PSvertex));
  (*t1)->verts[0] = quad->verts[0];
  (*t1)->verts[1] = quad->verts[1];
  (*t1)->verts[2] = quad->verts[2];
  (*t1)->boundary = ((quad->boundary & 1) ? 1 : 0) | ((quad->boundary & 2) ? 2 : 0);
  (*t2)->verts[0] = quad->verts[0];
  (*t2)->verts[1] = quad->verts[2];
  (*t2)->verts[2] = quad->verts[3];
  (*t2)->boundary = ((quad->boundary & 4) ? 2 : 0) | ((quad->boundary & 4) ? 2 : 0);
}

gl2psDrawImageMap()

GL2PSDLL_API GLint gl2psDrawImageMap	(	GLsizei	width,
		GLsizei	height,
		const GLfloat	position[3],
		const unsigned char *	imagemap )

Definition at line 5898 of file gl2ps.cxx.

                                                                   {
  int size, i;
  int sizeoffloat = sizeof(GLfloat);
 
  if(!gl2ps || !imagemap) return GL2PS_UNINITIALIZED;
 
  if((width <= 0) || (height <= 0)) return GL2PS_ERROR;
 
  size = height + height * ((width - 1) / 8);
  glPassThrough(GL2PS_IMAGEMAP_TOKEN);
  glBegin(GL_POINTS);
  glVertex3f(position[0], position[1],position[2]);
  glEnd();
  glPassThrough((GLfloat)width);
  glPassThrough((GLfloat)height);
  for(i = 0; i < size; i += sizeoffloat){
    // cppcheck-suppress invalidPointerCast
    const float *value = reinterpret_cast<const float*>(imagemap);
    glPassThrough(*value);
    imagemap += sizeoffloat;
  }
  return GL2PS_SUCCESS;
}

gl2psDrawPixels()

GL2PSDLL_API GLint gl2psDrawPixels	(	GLsizei	width,
		GLsizei	height,
		GLint	xorig,
		GLint	yorig,
		GLenum	format,
		GLenum	type,
		const void *	pixels )

Definition at line 5817 of file gl2ps.cxx.

{
  int size, i;
  GLfloat pos[4], *piv;
  GL2PSprimitive *prim;
  GLboolean valid;
 
  if(!gl2ps || !pixels) return GL2PS_UNINITIALIZED;
 
  if((width <= 0) || (height <= 0)) return GL2PS_ERROR;
 
  if(gl2ps->options & GL2PS_NO_PIXMAP) return GL2PS_SUCCESS;
 
  if((format != GL_RGB && format != GL_RGBA) || type != GL_FLOAT){
    gl2psMsg(GL2PS_ERROR, "gl2psDrawPixels only implemented for "
             "GL_RGB/GL_RGBA, GL_FLOAT pixels");
    return GL2PS_ERROR;
  }
 
  glGetBooleanv(GL_CURRENT_RASTER_POSITION_VALID, &valid);
  if(GL_FALSE == valid) return GL2PS_SUCCESS; /* the primitive is culled */
 
  glGetFloatv(GL_CURRENT_RASTER_POSITION, pos);
 
  prim = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive));
  prim->type = GL2PS_PIXMAP;
  prim->boundary = 0;
  prim->numverts = 1;
  prim->verts = (GL2PSvertex*)gl2psMalloc(sizeof(GL2PSvertex));
  prim->verts[0].xyz[0] = pos[0] + xorig;
  prim->verts[0].xyz[1] = pos[1] + yorig;
  prim->verts[0].xyz[2] = pos[2];
  prim->culled = 0;
  prim->offset = 0;
  prim->pattern = 0;
  prim->factor = 0;
  prim->width = 1;
  glGetFloatv(GL_CURRENT_RASTER_COLOR, prim->verts[0].rgba);
  prim->data.image = (GL2PSimage*)gl2psMalloc(sizeof(GL2PSimage));
  prim->data.image->width = width;
  prim->data.image->height = height;
  prim->data.image->format = format;
  prim->data.image->type = type;
 
  switch(format){
  case GL_RGBA:
    if(gl2ps->options & GL2PS_NO_BLENDING || !gl2ps->blending){
      /* special case: blending turned off */
      prim->data.image->format = GL_RGB;
      size = height * width * 3;
      prim->data.image->pixels = (GLfloat*)gl2psMalloc(size * sizeof(GLfloat));
      piv = (GLfloat*)pixels;
      for(i = 0; i < size; ++i, ++piv){
        prim->data.image->pixels[i] = *piv;
        if(!((i+1)%3))
          ++piv;
      }
    }
    else{
      size = height * width * 4;
      prim->data.image->pixels = (GLfloat*)gl2psMalloc(size * sizeof(GLfloat));
      memcpy(prim->data.image->pixels, pixels, size * sizeof(GLfloat));
    }
    break;
  case GL_RGB:
  default:
    size = height * width * 3;
    prim->data.image->pixels = (GLfloat*)gl2psMalloc(size * sizeof(GLfloat));
    memcpy(prim->data.image->pixels, pixels, size * sizeof(GLfloat));
    break;
  }
 
  gl2psListAdd(gl2ps->auxprimitives, &prim);
  glPassThrough(GL2PS_DRAW_PIXELS_TOKEN);
 
  return GL2PS_SUCCESS;
}

gl2psEnable()

GL2PSDLL_API GLint gl2psEnable

(

GLint

mode

)

Definition at line 5924 of file gl2ps.cxx.

{
  GLint tmp;
 
  if(!gl2ps) return GL2PS_UNINITIALIZED;
 
  switch(mode){
  case GL2PS_POLYGON_OFFSET_FILL :
    glPassThrough(GL2PS_BEGIN_OFFSET_TOKEN);
    glGetFloatv(GL_POLYGON_OFFSET_FACTOR, &gl2ps->offset[0]);
    glGetFloatv(GL_POLYGON_OFFSET_UNITS, &gl2ps->offset[1]);
    break;
  case GL2PS_POLYGON_BOUNDARY :
    glPassThrough(GL2PS_BEGIN_BOUNDARY_TOKEN);
    break;
  case GL2PS_LINE_STIPPLE :
    glPassThrough(GL2PS_BEGIN_STIPPLE_TOKEN);
    glGetIntegerv(GL_LINE_STIPPLE_PATTERN, &tmp);
    glPassThrough((GLfloat)tmp);
    glGetIntegerv(GL_LINE_STIPPLE_REPEAT, &tmp);
    glPassThrough((GLfloat)tmp);
    break;
  case GL2PS_BLEND :
    glPassThrough(GL2PS_BEGIN_BLEND_TOKEN);
    break;
  default :
    gl2psMsg(GL2PS_WARNING, "Unknown mode in gl2psEnable: %d", mode);
    return GL2PS_WARNING;
  }
 
  return GL2PS_SUCCESS;
}

gl2psEndPage()

GL2PSDLL_API GLint gl2psEndPage

(

void

)

Definition at line 5751 of file gl2ps.cxx.

{
  GLint res;
 
  if(!gl2ps) return GL2PS_UNINITIALIZED;
 
  res = gl2psPrintPrimitives();
 
  if(res != GL2PS_OVERFLOW)
    (gl2psbackends[gl2ps->format]->printFooter)();
 
  fflush(gl2ps->stream);
 
  gl2psListDelete(gl2ps->primitives);
  gl2psListDelete(gl2ps->auxprimitives);
  gl2psFreeImagemap(gl2ps->imagemap_head);
  gl2psFree(gl2ps->colormap);
  gl2psFree(gl2ps->title);
  gl2psFree(gl2ps->producer);
  gl2psFree(gl2ps->filename);
  gl2psFree(gl2ps->feedback);
  gl2psFree(gl2ps);
  gl2ps = NULL;
 
  return res;
}

gl2psEndPostScriptLine()

void gl2psEndPostScriptLine ( void )

static

Definition at line 2895 of file gl2ps.cxx.

{
  int i;
  if(gl2ps->lastvertex.rgba[0] >= 0.){
    gl2psPrintf("%g %g LE\n", gl2ps->lastvertex.xyz[0], gl2ps->lastvertex.xyz[1]);
    for(i = 0; i < 3; i++)
      gl2ps->lastvertex.xyz[i] = -1.;
    for(i = 0; i < 4; i++)
      gl2ps->lastvertex.rgba[i] = -1.;
  }
}

gl2psEndSVGLine()

void gl2psEndSVGLine ( void )

static

Definition at line 5001 of file gl2ps.cxx.

{
  int i;
  if(gl2ps->lastvertex.rgba[0] >= 0.){
    gl2psPrintf("%g,%g\"/>\n", gl2ps->lastvertex.xyz[0],
                gl2ps->viewport[3] - gl2ps->lastvertex.xyz[1]);
    for(i = 0; i < 3; i++)
      gl2ps->lastvertex.xyz[i] = -1.;
    for(i = 0; i < 4; i++)
      gl2ps->lastvertex.rgba[i] = -1.;
  }
}

gl2psEndViewport()

GL2PSDLL_API GLint gl2psEndViewport

(

void

)

Definition at line 5787 of file gl2ps.cxx.

{
  GLint res;
 
  if(!gl2ps) return GL2PS_UNINITIALIZED;
 
  res = (gl2psbackends[gl2ps->format]->endViewport)();
 
  /* reset last used colors, line widths */
  gl2ps->lastlinewidth = -1.0F;
 
  return res;
}

gl2psFillTriangleFromPrimitive()

void gl2psFillTriangleFromPrimitive ( GL2PStriangle * t, GL2PSprimitive * p, GLboolean assignprops )

static

Definition at line 981 of file gl2ps.cxx.

{
  t->vertex[0] = p->verts[0];
  t->vertex[1] = p->verts[1];
  t->vertex[2] = p->verts[2];
  if(GL_TRUE == assignprops)
    gl2psAssignTriangleProperties(t);
}

gl2psFindRoot()

GLint gl2psFindRoot ( GL2PSlist * primitives, GL2PSprimitive ** root )

static

Definition at line 1407 of file gl2ps.cxx.

{
  GLint i, j, count, best = 1000000, index = 0;
  GL2PSprimitive *prim1, *prim2;
  GL2PSplane plane;
  GLint maxp;
 
  if(!gl2psListNbr(primitives)){
    gl2psMsg(GL2PS_ERROR, "Cannot fint root in empty primitive list");
    return 0;
  }
 
  *root = *(GL2PSprimitive**)gl2psListPointer(primitives, 0);
 
  if(gl2ps->options & GL2PS_BEST_ROOT){
    maxp = gl2psListNbr(primitives);
    if(maxp > gl2ps->maxbestroot){
      maxp = gl2ps->maxbestroot;
    }
    for(i = 0; i < maxp; i++){
      prim1 = *(GL2PSprimitive**)gl2psListPointer(primitives, i);
      gl2psGetPlane(prim1, plane);
      count = 0;
      for(j = 0; j < gl2psListNbr(primitives); j++){
        if(j != i){
          prim2 = *(GL2PSprimitive**)gl2psListPointer(primitives, j);
          count += gl2psTestSplitPrimitive(prim2, plane);
        }
        if(count > best) break;
      }
      if(count < best){
        best = count;
        index = i;
        *root = prim1;
        if(!count) return index;
      }
    }
    /* if(index) gl2psMsg(GL2PS_INFO, "GL2PS_BEST_ROOT was worth it: %d", index); */
    return index;
  }
  else{
    return 0;
  }
}

gl2psFree()

void gl2psFree ( void * ptr )

static

Definition at line 320 of file gl2ps.cxx.

{
  if(!ptr) return;
  free(ptr);
}

gl2psFreeBspImageTree()

void gl2psFreeBspImageTree ( GL2PSbsptree2d ** tree )

static

Definition at line 1729 of file gl2ps.cxx.

{
  if(*tree){
    if((*tree)->back)  gl2psFreeBspImageTree(&(*tree)->back);
    if((*tree)->front) gl2psFreeBspImageTree(&(*tree)->front);
    gl2psFree(*tree);
    *tree = NULL;
  }
}

gl2psFreeBspTree()

void gl2psFreeBspTree ( GL2PSbsptree ** tree )

static

Definition at line 1495 of file gl2ps.cxx.

{
  if(*tree){
    if((*tree)->back) gl2psFreeBspTree(&(*tree)->back);
    if((*tree)->primitives){
      gl2psListAction((*tree)->primitives, gl2psFreePrimitive);
      gl2psListDelete((*tree)->primitives);
    }
    if((*tree)->front) gl2psFreeBspTree(&(*tree)->front);
    gl2psFree(*tree);
    *tree = NULL;
  }
}

gl2psFreeImagemap()

void gl2psFreeImagemap ( GL2PSimagemap * list )

static

Definition at line 1452 of file gl2ps.cxx.

{
  GL2PSimagemap *next;
  while(list != NULL){
    next = list->next;
    gl2psFree(list->image->pixels);
    gl2psFree(list->image);
    gl2psFree(list);
    list = next;
  }
}

gl2psFreePixmap()

void gl2psFreePixmap ( GL2PSimage * im )

static

Definition at line 769 of file gl2ps.cxx.

{
  if(!im)
    return;
  gl2psFree(im->pixels);
  gl2psFree(im);
}

gl2psFreePrimitive()

void gl2psFreePrimitive ( void * data )

static

Definition at line 1464 of file gl2ps.cxx.

{
  GL2PSprimitive *q;
 
  q = *(GL2PSprimitive**)data;
  gl2psFree(q->verts);
  if(q->type == GL2PS_TEXT || q->type == GL2PS_SPECIAL){
    gl2psFreeText(q->data.text);
  }
  else if(q->type == GL2PS_PIXMAP){
    gl2psFreePixmap(q->data.image);
  }
  gl2psFree(q);
}

gl2psFreeText()

void gl2psFreeText ( GL2PSstring * text )

static

Definition at line 902 of file gl2ps.cxx.

{
  if(!text)
    return;
  gl2psFree(text->str);
  gl2psFree(text->fontname);
  gl2psFree(text);
}

gl2psGetFileExtension()

GL2PSDLL_API const char * gl2psGetFileExtension

(

GLint

format

)

Definition at line 6038 of file gl2ps.cxx.

{
  if(format >= 0 && format < (GLint)(sizeof(gl2psbackends) / sizeof(gl2psbackends[0])))
    return gl2psbackends[format]->file_extension;
  else
    return "Unknown format";
}

gl2psGetFormatDescription()

GL2PSDLL_API const char * gl2psGetFormatDescription

(

GLint

format

)

Definition at line 6046 of file gl2ps.cxx.

{
  if(format >= 0 && format < (GLint)(sizeof(gl2psbackends) / sizeof(gl2psbackends[0])))
    return gl2psbackends[format]->description;
  else
    return "Unknown format";
}

gl2psGetIndex()

GLshort gl2psGetIndex ( GLshort i, GLshort num )

static

Definition at line 1245 of file gl2ps.cxx.

{
  return (i < num - 1) ? i + 1 : 0;
}

gl2psGetNormal()

void gl2psGetNormal ( GLfloat * a, GLfloat * b, GLfloat * c )

static

Definition at line 1079 of file gl2ps.cxx.

{
  GLfloat norm;
 
  gl2psPvec(a, b, c);
  if(!GL2PS_ZERO(norm = gl2psNorm(c))){
    c[0] = c[0] / norm;
    c[1] = c[1] / norm;
    c[2] = c[2] / norm;
  }
  else{
    /* The plane is still wrong despite our tests in gl2psGetPlane.
       Let's return a dummy value for now (this is a hack: we should
       do more intelligent tests in GetPlane) */
    c[0] = c[1] = 0.0F;
    c[2] = 1.0F;
  }
}

gl2psGetOptions()

GL2PSDLL_API GLint gl2psGetOptions

(

GLint *

options

)

Definition at line 6026 of file gl2ps.cxx.

{
  if(!gl2ps) {
    *options = 0;
    return GL2PS_UNINITIALIZED;
  }
 
  *options = gl2ps->options;
 
  return GL2PS_SUCCESS;
}

gl2psGetPlane()

void gl2psGetPlane ( GL2PSprimitive * prim, GL2PSplane plane )

static

Definition at line 1098 of file gl2ps.cxx.

{
  GL2PSxyz v = {0.0F, 0.0F, 0.0F}, w = {0.0F, 0.0F, 0.0F};
 
  switch(prim->type){
  case GL2PS_TRIANGLE :
  case GL2PS_QUADRANGLE :
    v[0] = prim->verts[1].xyz[0] - prim->verts[0].xyz[0];
    v[1] = prim->verts[1].xyz[1] - prim->verts[0].xyz[1];
    v[2] = prim->verts[1].xyz[2] - prim->verts[0].xyz[2];
    w[0] = prim->verts[2].xyz[0] - prim->verts[0].xyz[0];
    w[1] = prim->verts[2].xyz[1] - prim->verts[0].xyz[1];
    w[2] = prim->verts[2].xyz[2] - prim->verts[0].xyz[2];
    if((GL2PS_ZERO(v[0]) && GL2PS_ZERO(v[1]) && GL2PS_ZERO(v[2])) ||
       (GL2PS_ZERO(w[0]) && GL2PS_ZERO(w[1]) && GL2PS_ZERO(w[2]))){
      plane[0] = plane[1] = 0.0F;
      plane[2] = 1.0F;
      plane[3] = -prim->verts[0].xyz[2];
    }
    else{
      gl2psGetNormal(v, w, plane);
      plane[3] =
        - plane[0] * prim->verts[0].xyz[0]
        - plane[1] * prim->verts[0].xyz[1]
        - plane[2] * prim->verts[0].xyz[2];
    }
    break;
  case GL2PS_LINE :
    v[0] = prim->verts[1].xyz[0] - prim->verts[0].xyz[0];
    v[1] = prim->verts[1].xyz[1] - prim->verts[0].xyz[1];
    v[2] = prim->verts[1].xyz[2] - prim->verts[0].xyz[2];
    if(GL2PS_ZERO(v[0]) && GL2PS_ZERO(v[1]) && GL2PS_ZERO(v[2])){
      plane[0] = plane[1] = 0.0F;
      plane[2] = 1.0F;
      plane[3] = -prim->verts[0].xyz[2];
    }
    else{
      if(GL2PS_ZERO(v[0]))      w[0] = 1.0F;
      else if(GL2PS_ZERO(v[1])) w[1] = 1.0F;
      else                      w[2] = 1.0F;
      gl2psGetNormal(v, w, plane);
      plane[3] =
        - plane[0] * prim->verts[0].xyz[0]
        - plane[1] * prim->verts[0].xyz[1]
        - plane[2] * prim->verts[0].xyz[2];
    }
    break;
  case GL2PS_POINT :
  case GL2PS_PIXMAP :
  case GL2PS_TEXT :
  case GL2PS_SPECIAL :
  case GL2PS_IMAGEMAP:
    plane[0] = plane[1] = 0.0F;
    plane[2] = 1.0F;
    plane[3] = -prim->verts[0].xyz[2];
    break;
  default :
    gl2psMsg(GL2PS_ERROR, "Unknown primitive type in BSP tree");
    plane[0] = plane[1] = plane[3] = 0.0F;
    plane[2] = 1.0F;
    break;
  }
}

gl2psGetPlaneFromPoints()

GLint gl2psGetPlaneFromPoints ( GL2PSxyz a, GL2PSxyz b, GL2PSplane plane )

static

Definition at line 1707 of file gl2ps.cxx.

{
  GLfloat n;
 
  plane[0] = b[1] - a[1];
  plane[1] = a[0] - b[0];
  n = (GLfloat)sqrt(plane[0]*plane[0] + plane[1]*plane[1]);
  plane[2] = 0.0F;
  if(!GL2PS_ZERO(n)){
    plane[0] /= n;
    plane[1] /= n;
    plane[3] = -plane[0]*a[0]-plane[1]*a[1];
    return 1;
  }
  else{
    plane[0] = -1.0F;
    plane[1] = 0.0F;
    plane[3] = a[0];
    return 0;
  }
}

gl2psGetRGB()

GLfloat gl2psGetRGB ( GL2PSimage * im, GLuint x, GLuint y, GLfloat * red, GLfloat * green, GLfloat * blue )

static

Definition at line 715 of file gl2ps.cxx.

{
 
  GLsizei width = im->width;
  GLsizei height = im->height;
  GLfloat *pixels = im->pixels;
  GLfloat *pimag;
 
  /* OpenGL image is from down to up, PS image is up to down */
  switch(im->format){
  case GL_RGBA:
    pimag = pixels + 4 * (width * (height - 1 - y) + x);
    break;
  case GL_RGB:
  default:
    pimag = pixels + 3 * (width * (height - 1 - y) + x);
    break;
  }
  *red = *pimag; pimag++;
  *green = *pimag; pimag++;
  *blue = *pimag; pimag++;
 
  return (im->format == GL_RGBA) ? *pimag : 1.0F;
}

gl2psGetVertex()

GLint gl2psGetVertex ( GL2PSvertex * v, GLfloat * p )

static

Definition at line 2173 of file gl2ps.cxx.

{
  GLint i;
 
  v->xyz[0] = p[0];
  v->xyz[1] = p[1];
  v->xyz[2] = p[2];
 
  if(gl2ps->colormode == GL_COLOR_INDEX && gl2ps->colorsize > 0){
    i = (GLint)(p[3] + 0.5);
    v->rgba[0] = gl2ps->colormap[i][0];
    v->rgba[1] = gl2ps->colormap[i][1];
    v->rgba[2] = gl2ps->colormap[i][2];
    v->rgba[3] = gl2ps->colormap[i][3];
    return 4;
  }
  else{
    v->rgba[0] = p[3];
    v->rgba[1] = p[4];
    v->rgba[2] = p[5];
    v->rgba[3] = p[6];
    return 7;
  }
}

gl2psGreater()

GLboolean gl2psGreater ( GLfloat f1, GLfloat f2 )

static

Definition at line 1509 of file gl2ps.cxx.

{
  if(f1 > f2) return GL_TRUE;
  else return GL_FALSE;
}

gl2psInitTriangle()

void gl2psInitTriangle ( GL2PStriangle * t )

static

Definition at line 991 of file gl2ps.cxx.

{
  int i;
  GL2PSvertex vertex = { {-1.0F, -1.0F, -1.0F}, {-1.0F, -1.0F, -1.0F, -1.0F} };
  for(i = 0; i < 3; i++)
    t->vertex[i] = vertex;
  t->prop = T_UNDEFINED;
}

gl2psLess()

GLboolean gl2psLess ( GLfloat f1, GLfloat f2 )

static

Definition at line 1515 of file gl2ps.cxx.

{
  if(f1 < f2) return GL_TRUE;
  else return GL_FALSE;
}

gl2psLineWidth()

GL2PSDLL_API GLint gl2psLineWidth

(

GLfloat

value

)

Definition at line 5992 of file gl2ps.cxx.

{
  if(!gl2ps) return GL2PS_UNINITIALIZED;
 
  glPassThrough(GL2PS_LINE_WIDTH_TOKEN);
  glPassThrough(value);
 
  return GL2PS_SUCCESS;
}

gl2psListAction()

void gl2psListAction ( GL2PSlist * list, void(* action )(void *data) )

static

Definition at line 595 of file gl2ps.cxx.

{
  GLint i;
 
  for(i = 0; i < gl2psListNbr(list); i++){
    (*action)(gl2psListPointer(list, i));
  }
}

gl2psListActionInverse()

void gl2psListActionInverse ( GL2PSlist * list, void(* action )(void *data) )

static

Definition at line 604 of file gl2ps.cxx.

{
  GLint i;
 
  for(i = gl2psListNbr(list); i > 0; i--){
    (*action)(gl2psListPointer(list, i-1));
  }
}

gl2psListAdd()

void gl2psListAdd ( GL2PSlist * list, void * data )

static

Definition at line 556 of file gl2ps.cxx.

{
  if(!list){
    gl2psMsg(GL2PS_ERROR, "Cannot add into unallocated list");
    return;
  }
  list->n++;
  gl2psListRealloc(list, list->n);
  memcpy(&list->array[(list->n - 1) * list->size], data, list->size);
}

gl2psListCreate()

GL2PSlist * gl2psListCreate ( GLint n, GLint incr, GLint size )

static

Definition at line 527 of file gl2ps.cxx.

{
  GL2PSlist *list;
 
  if(n < 0) n = 0;
  if(incr <= 0) incr = 1;
  list = (GL2PSlist*)gl2psMalloc(sizeof(GL2PSlist));
  list->nmax = 0;
  list->incr = incr;
  list->size = size;
  list->n = 0;
  list->array = NULL;
  gl2psListRealloc(list, n);
  return list;
}

gl2psListDelete()

void gl2psListDelete ( GL2PSlist * list )

static

Definition at line 549 of file gl2ps.cxx.

{
  if(!list) return;
  gl2psFree(list->array);
  gl2psFree(list);
}

gl2psListNbr()

int gl2psListNbr ( GL2PSlist * list )

static

Definition at line 567 of file gl2ps.cxx.

{
  if(!list)
    return 0;
  return list->n;
}

gl2psListPointer()

void * gl2psListPointer ( GL2PSlist * list, GLint index )

static

Definition at line 574 of file gl2ps.cxx.

{
  if(!list){
    gl2psMsg(GL2PS_ERROR, "Cannot point into unallocated list");
    return NULL;
  }
  if((index < 0) || (index >= list->n)){
    gl2psMsg(GL2PS_ERROR, "Wrong list index in gl2psListPointer");
    return NULL;
  }
  return &list->array[index * list->size];
}

gl2psListRealloc()

void gl2psListRealloc ( GL2PSlist * list, GLint n )

static

Definition at line 507 of file gl2ps.cxx.

{
  if(!list){
    gl2psMsg(GL2PS_ERROR, "Cannot reallocate NULL list");
    return;
  }
  if(n <= 0) return;
  if(!list->array){
    list->nmax = n;
    list->array = (char*)gl2psMalloc(list->nmax * list->size);
  }
  else{
    if(n > list->nmax){
      list->nmax = ((n - 1) / list->incr + 1) * list->incr;
      list->array = (char*)gl2psRealloc(list->array,
                                        list->nmax * list->size);
    }
  }
}

gl2psListReset()

void gl2psListReset ( GL2PSlist * list )

static

Definition at line 543 of file gl2ps.cxx.

{
  if(!list) return;
  list->n = 0;
}

gl2psListSort()

void gl2psListSort ( GL2PSlist * list, int(* fcmp )(const void *a, const void *b) )

static

Definition at line 587 of file gl2ps.cxx.

{
  if(!list)
    return;
  qsort(list->array, list->n, list->size, fcmp);
}

gl2psMalloc()

void * gl2psMalloc ( size_t size )

static

Definition at line 296 of file gl2ps.cxx.

{
  void *ptr;
 
  if(!size) return NULL;
  ptr = malloc(size);
  if(!ptr){
    gl2psMsg(GL2PS_ERROR, "Couldn't allocate requested memory");
    return NULL;
  }
  return ptr;
}

gl2psMsg()

void gl2psMsg ( GLint level, const char * fmt, ... )

static

Definition at line 278 of file gl2ps.cxx.

{
  va_list args;
 
  if(!(gl2ps->options & GL2PS_SILENT)){
    switch(level){
    case GL2PS_INFO : fprintf(stderr, "GL2PS info: "); break;
    case GL2PS_WARNING : fprintf(stderr, "GL2PS warning: "); break;
    case GL2PS_ERROR : fprintf(stderr, "GL2PS error: "); break;
    }
    va_start(args, fmt);
    vfprintf(stderr, fmt, args);
    va_end(args);
    fprintf(stderr, "\n");
  }
  /* if(level == GL2PS_ERROR) exit(1); */
}

gl2psNorm()

GLfloat gl2psNorm ( GLfloat * a )

static

Definition at line 1074 of file gl2ps.cxx.

{
  return (GLfloat)sqrt(a[0]*a[0] + a[1]*a[1] + a[2]*a[2]);
}

gl2psOpenPDFDataStream()

int gl2psOpenPDFDataStream ( void )

static

Definition at line 3988 of file gl2ps.cxx.

{
  int offs = 0;
 
  offs += fprintf(gl2ps->stream,
                  "4 0 obj\n"
                  "<<\n"
                  "/Length 5 0 R\n" );
  offs += gl2psPrintPDFCompressorType();
  offs += fprintf(gl2ps->stream,
                  ">>\n"
                  "stream\n");
  return offs;
}

gl2psOpenPDFDataStreamWritePreface()

int gl2psOpenPDFDataStreamWritePreface ( void )

static

Definition at line 4005 of file gl2ps.cxx.

{
  int offs;
 
  offs = gl2psPrintf("/GSa gs\n");
 
  if(gl2ps->options & GL2PS_DRAW_BACKGROUND){
    offs += gl2psPrintPDFFillColor(gl2ps->bgcolor);
    offs += gl2psPrintf("%d %d %d %d re\n",
                        (int)gl2ps->viewport[0], (int)gl2ps->viewport[1],
                        (int)gl2ps->viewport[2], (int)gl2ps->viewport[3]);
    offs += gl2psPrintf("f\n");
  }
  return offs;
}

gl2psParseFeedbackBuffer()

void gl2psParseFeedbackBuffer ( GLint used )

static

Definition at line 2198 of file gl2ps.cxx.

{
  char flag;
  GLushort pattern = 0;
  GLboolean boundary;
  GLint i, sizeoffloat, count, v, vtot, offset = 0, factor = 0, auxindex = 0;
  GLfloat lwidth = 1.0F, psize = 1.0F;
  GLfloat *current;
  GL2PSvertex vertices[3];
  GL2PSprimitive *prim;
  GL2PSimagemap *node;
 
  current = gl2ps->feedback;
  boundary = gl2ps->boundary = GL_FALSE;
 
  while(used > 0){
 
    if(GL_TRUE == boundary) gl2ps->boundary = GL_TRUE;
 
    switch((GLint)*current){
    case GL_POINT_TOKEN :
      current ++;
      used --;
      i = gl2psGetVertex(&vertices[0], current);
      current += i;
      used    -= i;
      gl2psAddPolyPrimitive(GL2PS_POINT, 1, vertices, 0,
                            pattern, factor, psize, 0);
      break;
    case GL_LINE_TOKEN :
    case GL_LINE_RESET_TOKEN :
      current ++;
      used --;
      i = gl2psGetVertex(&vertices[0], current);
      current += i;
      used    -= i;
      i = gl2psGetVertex(&vertices[1], current);
      current += i;
      used    -= i;
      gl2psAddPolyPrimitive(GL2PS_LINE, 2, vertices, 0,
                            pattern, factor, lwidth, 0);
      break;
    case GL_POLYGON_TOKEN :
      count = (GLint)current[1];
      current += 2;
      used -= 2;
      v = vtot = 0;
      while(count > 0 && used > 0){
        i = gl2psGetVertex(&vertices[v], current);
        gl2psAdaptVertexForBlending(&vertices[v]);
        current += i;
        used    -= i;
        count --;
        vtot++;
        if(v == 2){
          if(GL_TRUE == boundary){
            if(!count && vtot == 2) flag = 1|2|4;
            else if(!count) flag = 2|4;
            else if(vtot == 2) flag = 1|2;
            else flag = 2;
          }
          else
            flag = 0;
          gl2psAddPolyPrimitive(GL2PS_TRIANGLE, 3, vertices, offset,
                                pattern, factor, 1, flag);
          vertices[1] = vertices[2];
        }
        else
          v ++;
      }
      break;
    case GL_BITMAP_TOKEN :
    case GL_DRAW_PIXEL_TOKEN :
    case GL_COPY_PIXEL_TOKEN :
      current ++;
      used --;
      i = gl2psGetVertex(&vertices[0], current);
      current += i;
      used    -= i;
      break;
    case GL_PASS_THROUGH_TOKEN :
      switch((GLint)current[1]){
      case GL2PS_BEGIN_OFFSET_TOKEN : offset = 1; break;
      case GL2PS_END_OFFSET_TOKEN : offset = 0; break;
      case GL2PS_BEGIN_BOUNDARY_TOKEN : boundary = GL_TRUE; break;
      case GL2PS_END_BOUNDARY_TOKEN : boundary = GL_FALSE; break;
      case GL2PS_END_STIPPLE_TOKEN : pattern = factor = 0; break;
      case GL2PS_BEGIN_BLEND_TOKEN : gl2ps->blending = GL_TRUE; break;
      case GL2PS_END_BLEND_TOKEN : gl2ps->blending = GL_FALSE; break;
      case GL2PS_BEGIN_STIPPLE_TOKEN :
        current += 2;
        used -= 2;
        pattern = (GLushort)current[1];
        current += 2;
        used -= 2;
        factor = (GLint)current[1];
        break;
      case GL2PS_SRC_BLEND_TOKEN :
        current += 2;
        used -= 2;
        gl2ps->blendfunc[0] = (GLint)current[1];
        break;
      case GL2PS_DST_BLEND_TOKEN :
        current += 2;
        used -= 2;
        gl2ps->blendfunc[1] = (GLint)current[1];
        break;
      case GL2PS_POINT_SIZE_TOKEN :
        current += 2;
        used -= 2;
        psize = current[1];
        break;
      case GL2PS_LINE_WIDTH_TOKEN :
        current += 2;
        used -= 2;
        lwidth = current[1];
        break;
      case GL2PS_IMAGEMAP_TOKEN :
        prim = (GL2PSprimitive *)gl2psMalloc(sizeof(GL2PSprimitive));
        prim->type = GL2PS_IMAGEMAP;
        prim->boundary = 0;
        prim->numverts = 4;
        prim->verts = (GL2PSvertex *)gl2psMalloc(4 * sizeof(GL2PSvertex));
        prim->culled = 0;
        prim->offset = 0;
        prim->pattern = 0;
        prim->factor = 0;
        prim->width = 1;
 
        node = static_cast<GL2PSimagemap*>(gl2psMalloc(sizeof(GL2PSimagemap)));
        node->image = static_cast<GL2PSimage*>(gl2psMalloc(sizeof(GL2PSimage)));
        node->image->type = 0;
        node->image->format = 0;
        node->next = NULL;
 
        if(gl2ps->imagemap_head == NULL)
          gl2ps->imagemap_head = node;
        else
          gl2ps->imagemap_tail->next = node;
        gl2ps->imagemap_tail = node;
        prim->data.image = node->image;
 
        current += 2; used -= 2;
        i = gl2psGetVertex(&prim->verts[0], &current[1]);
        current += i; used -= i;
 
        node->image->width = (GLint)current[2];
        current += 2; used -= 2;
        node->image->height = (GLint)current[2];
        prim->verts[0].xyz[0] = prim->verts[0].xyz[0] - (int)(node->image->width / 2) + 0.5F;
        prim->verts[0].xyz[1] = prim->verts[0].xyz[1] - (int)(node->image->height / 2) + 0.5F;
        for(i = 1; i < 4; i++){
          for(v = 0; v < 3; v++){
            prim->verts[i].xyz[v] = prim->verts[0].xyz[v];
            prim->verts[i].rgba[v] = prim->verts[0].rgba[v];
          }
          prim->verts[i].rgba[v] = prim->verts[0].rgba[v];
        }
        prim->verts[1].xyz[0] = prim->verts[1].xyz[0] + node->image->width;
        prim->verts[2].xyz[0] = prim->verts[1].xyz[0];
        prim->verts[2].xyz[1] = prim->verts[2].xyz[1] + node->image->height;
        prim->verts[3].xyz[1] = prim->verts[2].xyz[1];
 
        sizeoffloat = sizeof(GLfloat);
        v = 2 * sizeoffloat;
        vtot = node->image->height + node->image->height *
          ((node->image->width - 1) / 8);
        node->image->pixels = (GLfloat*)gl2psMalloc(v + vtot);
        node->image->pixels[0] = prim->verts[0].xyz[0];
        node->image->pixels[1] = prim->verts[0].xyz[1];
 
        for(i = 0; i < vtot; i += sizeoffloat){
          current += 2; used -= 2;
          if((vtot - i) >= 4)
            memcpy(&(node->image->pixels[i + v]), &(current[2]), sizeoffloat);
          else
            memcpy(&(node->image->pixels[i + v]), &(current[2]), vtot - i);
        }
        current++; used--;
        gl2psListAdd(gl2ps->primitives, &prim);
        break;
      case GL2PS_DRAW_PIXELS_TOKEN :
      case GL2PS_TEXT_TOKEN :
        if(auxindex < gl2psListNbr(gl2ps->auxprimitives))
          gl2psListAdd(gl2ps->primitives,
                       gl2psListPointer(gl2ps->auxprimitives, auxindex++));
        else
          gl2psMsg(GL2PS_ERROR, "Wrong number of auxiliary tokens in buffer");
        break;
      }
      current += 2;
      used -= 2;
      break;
    default :
      gl2psMsg(GL2PS_WARNING, "Unknown token in buffer");
      current ++;
      used --;
      break;
    }
  }
 
  gl2psListReset(gl2ps->auxprimitives);
}

gl2psParseStipplePattern()

void gl2psParseStipplePattern ( GLushort pattern, GLint factor, int * nb, int array[10] )

static

Definition at line 2907 of file gl2ps.cxx.

{
  int i, n;
  int on[8] = {0, 0, 0, 0, 0, 0, 0, 0};
  int off[8] = {0, 0, 0, 0, 0, 0, 0, 0};
  char tmp[16];
 
  /* extract the 16 bits from the OpenGL stipple pattern */
  for(n = 15; n >= 0; n--){
    tmp[n] = (char)(pattern & 0x01);
    pattern >>= 1;
  }
  /* compute the on/off pixel sequence */
  n = 0;
  for(i = 0; i < 8; i++){
    while(n < 16 && !tmp[n]){ off[i]++; n++; }
    while(n < 16 && tmp[n]){ on[i]++; n++; }
    if(n >= 15){ i++; break; }
  }
 
  /* store the on/off array from right to left, starting with off
     pixels. The PostScript specification allows for at most 11
     elements in the on/off array, so we limit ourselves to 5 on/off
     couples (our longest possible array is thus [on4 off4 on3 off3
     on2 off2 on1 off1 on0 off0]) */
  *nb = 0;
  for(n = i - 1; n >= 0 && *nb <= 8; n--){
    array[(*nb)++] = factor * on[n];
    array[(*nb)++] = factor * off[n];
  }
}

gl2psPDFgroupListDelete()

void gl2psPDFgroupListDelete ( void )

static

Definition at line 3904 of file gl2ps.cxx.

{
  int i;
  GL2PSpdfgroup *gro = NULL;
 
  if(!gl2ps->pdfgrouplist)
    return;
 
  for(i = 0; i < gl2psListNbr(gl2ps->pdfgrouplist); ++i){
    gro = (GL2PSpdfgroup*)gl2psListPointer(gl2ps->pdfgrouplist,i);
    gl2psListDelete(gro->ptrlist);
  }
 
  gl2psListDelete(gl2ps->pdfgrouplist);
  gl2ps->pdfgrouplist = NULL;
}

gl2psPDFgroupListInit()

void gl2psPDFgroupListInit ( void )

static

Definition at line 3466 of file gl2ps.cxx.

{
  int i;
  GL2PSprimitive *p = NULL;
  GL2PSpdfgroup gro;
  int lasttype = GL2PS_NO_TYPE;
  GL2PSrgba lastrgba = {-1.0F, -1.0F, -1.0F, -1.0F};
  GLushort lastpattern = 0;
  GLint lastfactor = 0;
  GLfloat lastwidth = 1;
  GL2PStriangle lastt, tmpt;
  int lastTriangleWasNotSimpleWithSameColor = 0;
 
  if(!gl2ps->pdfprimlist)
    return;
 
  gl2ps->pdfgrouplist = gl2psListCreate(500, 500, sizeof(GL2PSpdfgroup));
  gl2psInitTriangle(&lastt);
 
  for(i = 0; i < gl2psListNbr(gl2ps->pdfprimlist); ++i){
    p = *(GL2PSprimitive**)gl2psListPointer(gl2ps->pdfprimlist, i);
    switch(p->type){
    case GL2PS_PIXMAP:
      gl2psPDFgroupObjectInit(&gro);
      gro.ptrlist = gl2psListCreate(1, 2, sizeof(GL2PSprimitive*));
      gro.imno = gl2ps->im_stack++;
      gl2psListAdd(gro.ptrlist, &p);
      gl2psListAdd(gl2ps->pdfgrouplist, &gro);
      break;
    case GL2PS_TEXT:
      gl2psPDFgroupObjectInit(&gro);
      gro.ptrlist = gl2psListCreate(1, 2, sizeof(GL2PSprimitive*));
      gro.fontno = gl2ps->font_stack++;
      gl2psListAdd(gro.ptrlist, &p);
      gl2psListAdd(gl2ps->pdfgrouplist, &gro);
      break;
    case GL2PS_LINE:
      if(lasttype != p->type || lastwidth != p->width ||
         lastpattern != p->pattern || lastfactor != p->factor ||
         !gl2psSameColor(p->verts[0].rgba, lastrgba)){
        gl2psPDFgroupObjectInit(&gro);
        gro.ptrlist = gl2psListCreate(1, 2, sizeof(GL2PSprimitive*));
        gl2psListAdd(gro.ptrlist, &p);
        gl2psListAdd(gl2ps->pdfgrouplist, &gro);
      }
      else{
        gl2psListAdd(gro.ptrlist, &p);
      }
      lastpattern = p->pattern;
      lastfactor = p->factor;
      lastwidth = p->width;
      lastrgba[0] = p->verts[0].rgba[0];
      lastrgba[1] = p->verts[0].rgba[1];
      lastrgba[2] = p->verts[0].rgba[2];
      break;
    case GL2PS_POINT:
      if(lasttype != p->type || lastwidth != p->width ||
         !gl2psSameColor(p->verts[0].rgba, lastrgba)){
        gl2psPDFgroupObjectInit(&gro);
        gro.ptrlist = gl2psListCreate(1,2,sizeof(GL2PSprimitive*));
        gl2psListAdd(gro.ptrlist, &p);
        gl2psListAdd(gl2ps->pdfgrouplist, &gro);
      }
      else{
        gl2psListAdd(gro.ptrlist, &p);
      }
      lastwidth = p->width;
      lastrgba[0] = p->verts[0].rgba[0];
      lastrgba[1] = p->verts[0].rgba[1];
      lastrgba[2] = p->verts[0].rgba[2];
      break;
    case GL2PS_TRIANGLE:
      gl2psFillTriangleFromPrimitive(&tmpt, p, GL_TRUE);
      lastTriangleWasNotSimpleWithSameColor =
        !(tmpt.prop & T_CONST_COLOR && tmpt.prop & T_ALPHA_1) ||
        !gl2psSameColor(tmpt.vertex[0].rgba, lastt.vertex[0].rgba);
      if(lasttype == p->type && tmpt.prop == lastt.prop &&
         lastTriangleWasNotSimpleWithSameColor){
        /* TODO Check here for last alpha */
        gl2psListAdd(gro.ptrlist, &p);
      }
      else{
        gl2psPDFgroupObjectInit(&gro);
        gro.ptrlist = gl2psListCreate(1, 2, sizeof(GL2PSprimitive*));
        gl2psListAdd(gro.ptrlist, &p);
        gl2psListAdd(gl2ps->pdfgrouplist, &gro);
      }
      lastt = tmpt;
      break;
    default:
      break;
    }
    lasttype = p->type;
  }
}

gl2psPDFgroupListWriteFontResources()

int gl2psPDFgroupListWriteFontResources ( void )

static

Definition at line 3884 of file gl2ps.cxx.

{
  int i;
  GL2PSpdfgroup *gro;
  int offs = 0;
 
  offs += fprintf(gl2ps->stream, "/Font\n<<\n");
 
  for(i = 0; i < gl2psListNbr(gl2ps->pdfgrouplist); ++i){
    gro = (GL2PSpdfgroup*)gl2psListPointer(gl2ps->pdfgrouplist, i);
    if(gro->fontno < 0)
      continue;
    gro->fontobjno = gl2ps->objects_stack++;
    offs += fprintf(gl2ps->stream, "/F%d %d 0 R\n", gro->fontno, gro->fontobjno);
  }
  offs += fprintf(gl2ps->stream, ">>\n");
 
  return offs;
}

gl2psPDFgroupListWriteGStateResources()

int gl2psPDFgroupListWriteGStateResources ( void )

static

Definition at line 3804 of file gl2ps.cxx.

{
  GL2PSpdfgroup *gro;
  int offs = 0;
  int i;
 
  offs += fprintf(gl2ps->stream,
                  "/ExtGState\n"
                  "<<\n"
                  "/GSa 7 0 R\n");
  for(i = 0; i < gl2psListNbr(gl2ps->pdfgrouplist); ++i){
    gro = (GL2PSpdfgroup*)gl2psListPointer(gl2ps->pdfgrouplist, i);
    if(gro->gsno >= 0)
      offs += fprintf(gl2ps->stream, "/GS%d %d 0 R\n", gro->gsno, gro->gsobjno);
  }
  offs += fprintf(gl2ps->stream, ">>\n");
  return offs;
}

gl2psPDFgroupListWriteMainStream()

void gl2psPDFgroupListWriteMainStream ( void )

static

Definition at line 3616 of file gl2ps.cxx.

{
  int i, j, lastel;
  GL2PSprimitive *prim = NULL, *prev = NULL;
  GL2PSpdfgroup *gro;
  GL2PStriangle t;
 
  if(!gl2ps->pdfgrouplist)
    return;
 
  for(i = 0; i < gl2psListNbr(gl2ps->pdfgrouplist); ++i){
    gro = (GL2PSpdfgroup*)gl2psListPointer(gl2ps->pdfgrouplist, i);
 
    lastel = gl2psListNbr(gro->ptrlist) - 1;
    if(lastel < 0)
      continue;
 
    prim = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, 0);
 
    switch(prim->type){
    case GL2PS_POINT:
      gl2ps->streamlength += gl2psPrintf("1 J\n");
      gl2ps->streamlength += gl2psPrintPDFLineWidth(prim->width);
      gl2ps->streamlength += gl2psPrintPDFStrokeColor(prim->verts[0].rgba);
      for(j = 0; j <= lastel; ++j){
        prim = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, j);
        gl2ps->streamlength +=
          gl2psPrintf("%f %f m %f %f l\n",
                      prim->verts[0].xyz[0], prim->verts[0].xyz[1],
                      prim->verts[0].xyz[0], prim->verts[0].xyz[1]);
      }
      gl2ps->streamlength += gl2psPrintf("S\n");
      gl2ps->streamlength += gl2psPrintf("0 J\n");
      break;
    case GL2PS_LINE:
      /* We try to use as few paths as possible to draw lines, in
         order to get nice stippling even when the individual segments
         are smaller than the stipple */
      gl2ps->streamlength += gl2psPrintPDFLineWidth(prim->width);
      gl2ps->streamlength += gl2psPrintPDFStrokeColor(prim->verts[0].rgba);
      gl2ps->streamlength += gl2psPrintPostScriptDash(prim->pattern, prim->factor, "d");
      /* start new path */
      gl2ps->streamlength +=
        gl2psPrintf("%f %f m\n",
                    prim->verts[0].xyz[0], prim->verts[0].xyz[1]);
 
      for(j = 1; j <= lastel; ++j){
        prev = prim;
        prim = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, j);
        if(!gl2psSamePosition(prim->verts[0].xyz, prev->verts[1].xyz)){
          /* the starting point of the new segment does not match the
             end point of the previous line, so we end the current
             path and start a new one */
          gl2ps->streamlength +=
            gl2psPrintf("%f %f l\n",
                        prev->verts[1].xyz[0], prev->verts[1].xyz[1]);
          gl2ps->streamlength +=
            gl2psPrintf("%f %f m\n",
                        prim->verts[0].xyz[0], prim->verts[0].xyz[1]);
        }
        else{
          /* the two segements are connected, so we just append to the
             current path */
          gl2ps->streamlength +=
            gl2psPrintf("%f %f l\n",
                        prim->verts[0].xyz[0], prim->verts[0].xyz[1]);
        }
      }
      /* end last path */
      gl2ps->streamlength +=
        gl2psPrintf("%f %f l\n",
                    prim->verts[1].xyz[0], prim->verts[1].xyz[1]);
      gl2ps->streamlength += gl2psPrintf("S\n");
      break;
    case GL2PS_TRIANGLE:
      gl2psFillTriangleFromPrimitive(&t, prim, GL_TRUE);
      gl2psSortOutTrianglePDFgroup(gro);
 
      /* No alpha and const color: Simple PDF draw orders  */
      if(t.prop & T_CONST_COLOR && t.prop & T_ALPHA_1){
        gl2ps->streamlength += gl2psPrintPDFFillColor(t.vertex[0].rgba);
        for(j = 0; j <= lastel; ++j){
          prim = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, j);
          gl2psFillTriangleFromPrimitive(&t, prim, GL_FALSE);
          gl2ps->streamlength
            += gl2psPrintf("%f %f m\n"
                           "%f %f l\n"
                           "%f %f l\n"
                           "h f\n",
                           t.vertex[0].xyz[0], t.vertex[0].xyz[1],
                           t.vertex[1].xyz[0], t.vertex[1].xyz[1],
                           t.vertex[2].xyz[0], t.vertex[2].xyz[1]);
        }
      }
      /* Const alpha < 1 and const color: Simple PDF draw orders
         and an extra extended Graphics State for the alpha const */
      else if(t.prop & T_CONST_COLOR && t.prop & T_ALPHA_LESS_1){
        gl2ps->streamlength += gl2psPrintf("q\n"
                                           "/GS%d gs\n",
                                           gro->gsno);
        gl2ps->streamlength += gl2psPrintPDFFillColor(prim->verts[0].rgba);
        for(j = 0; j <= lastel; ++j){
          prim = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, j);
          gl2psFillTriangleFromPrimitive(&t, prim, GL_FALSE);
          gl2ps->streamlength
            += gl2psPrintf("%f %f m\n"
                           "%f %f l\n"
                           "%f %f l\n"
                           "h f\n",
                           t.vertex[0].xyz[0], t.vertex[0].xyz[1],
                           t.vertex[1].xyz[0], t.vertex[1].xyz[1],
                           t.vertex[2].xyz[0], t.vertex[2].xyz[1]);
        }
        gl2ps->streamlength += gl2psPrintf("Q\n");
      }
      /* Variable alpha and const color: Simple PDF draw orders
         and an extra extended Graphics State + Xobject + Shader
         object for the alpha mask */
      else if(t.prop & T_CONST_COLOR && t.prop & T_VAR_ALPHA){
        gl2ps->streamlength += gl2psPrintf("q\n"
                                           "/GS%d gs\n"
                                           "/TrG%d Do\n",
                                           gro->gsno, gro->trgroupno);
        gl2ps->streamlength += gl2psPrintPDFFillColor(prim->verts[0].rgba);
        for(j = 0; j <= lastel; ++j){
          prim = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, j);
          gl2psFillTriangleFromPrimitive(&t, prim, GL_FALSE);
          gl2ps->streamlength
            += gl2psPrintf("%f %f m\n"
                           "%f %f l\n"
                           "%f %f l\n"
                           "h f\n",
                           t.vertex[0].xyz[0], t.vertex[0].xyz[1],
                           t.vertex[1].xyz[0], t.vertex[1].xyz[1],
                           t.vertex[2].xyz[0], t.vertex[2].xyz[1]);
        }
        gl2ps->streamlength += gl2psPrintf("Q\n");
      }
      /* Variable color and no alpha: Shader Object for the colored
         triangle(s) */
      else if(t.prop & T_VAR_COLOR && t.prop & T_ALPHA_1){
        gl2ps->streamlength += gl2psPrintf("/Sh%d sh\n", gro->shno);
      }
      /* Variable color and const alpha < 1: Shader Object for the
         colored triangle(s) and an extra extended Graphics State
         for the alpha const */
      else if(t.prop & T_VAR_COLOR && t.prop & T_ALPHA_LESS_1){
        gl2ps->streamlength += gl2psPrintf("q\n"
                                           "/GS%d gs\n"
                                           "/Sh%d sh\n"
                                           "Q\n",
                                           gro->gsno, gro->shno);
      }
      /* Variable alpha and color: Shader Object for the colored
         triangle(s) and an extra extended Graphics State
         + Xobject + Shader object for the alpha mask */
      else if(t.prop & T_VAR_COLOR && t.prop & T_VAR_ALPHA){
        gl2ps->streamlength += gl2psPrintf("q\n"
                                           "/GS%d gs\n"
                                           "/TrG%d Do\n"
                                           "/Sh%d sh\n"
                                           "Q\n",
                                           gro->gsno, gro->trgroupno, gro->shno);
      }
      break;
    case GL2PS_PIXMAP:
      for(j = 0; j <= lastel; ++j){
        prim = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, j);
        gl2psPutPDFImage(prim->data.image, gro->imno, prim->verts[0].xyz[0],
                         prim->verts[0].xyz[1]);
      }
      break;
    case GL2PS_TEXT:
      for(j = 0; j <= lastel; ++j){
        prim = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, j);
        gl2ps->streamlength += gl2psPrintPDFFillColor(prim->verts[0].rgba);
        gl2psPutPDFText(prim->data.text, gro->fontno, prim->verts[0].xyz[0],
                        prim->verts[0].xyz[1]);
      }
      break;
    default:
      break;
    }
  }
}

gl2psPDFgroupListWriteObjects()

int gl2psPDFgroupListWriteObjects ( int entryoffs )

static

Definition at line 4625 of file gl2ps.cxx.

{
  int i,j;
  GL2PSprimitive *p = NULL;
  GL2PSpdfgroup *gro;
  int offs = entryoffs;
  GL2PStriangle *triangles;
  int size = 0;
 
  if(!gl2ps->pdfgrouplist)
    return offs;
 
  for(i = 0; i < gl2psListNbr(gl2ps->pdfgrouplist); ++i){
    gro = (GL2PSpdfgroup*)gl2psListPointer(gl2ps->pdfgrouplist, i);
    if(!gl2psListNbr(gro->ptrlist))
      continue;
    p = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, 0);
    switch(p->type){
    case GL2PS_POINT:
      break;
    case GL2PS_LINE:
      break;
    case GL2PS_TRIANGLE:
      size = gl2psListNbr(gro->ptrlist);
      triangles = (GL2PStriangle*)gl2psMalloc(sizeof(GL2PStriangle) * size);
      for(j = 0; j < size; ++j){
        p = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, j);
        gl2psFillTriangleFromPrimitive(&triangles[j], p, GL_TRUE);
      }
      if(triangles[0].prop & T_VAR_COLOR){
        gl2ps->xreflist[gro->shobjno] = offs;
        offs += gl2psPrintPDFShader(gro->shobjno, triangles, size, 0);
      }
      if(triangles[0].prop & T_ALPHA_LESS_1){
        gl2ps->xreflist[gro->gsobjno] = offs;
        offs += gl2psPrintPDFShaderSimpleExtGS(gro->gsobjno, triangles[0].vertex[0].rgba[3]);
      }
      if(triangles[0].prop & T_VAR_ALPHA){
        gl2ps->xreflist[gro->gsobjno] = offs;
        offs += gl2psPrintPDFShaderExtGS(gro->gsobjno, gro->trgroupobjno);
        gl2ps->xreflist[gro->trgroupobjno] = offs;
        offs += gl2psPrintPDFShaderMask(gro->trgroupobjno, gro->maskshno);
        gl2ps->xreflist[gro->maskshobjno] = offs;
        offs += gl2psPrintPDFShader(gro->maskshobjno, triangles, size, 8);
      }
      gl2psFree(triangles);
      break;
    case GL2PS_PIXMAP:
      gl2ps->xreflist[gro->imobjno] = offs;
      offs += gl2psPrintPDFPixmap(gro->imobjno, gro->imobjno+1, p->data.image, 0);
      if(p->data.image->format == GL_RGBA){
        gl2ps->xreflist[gro->imobjno+1] = offs;
        offs += gl2psPrintPDFPixmap(gro->imobjno+1, -1, p->data.image, 8);
      }
      break;
    case GL2PS_TEXT:
      gl2ps->xreflist[gro->fontobjno] = offs;
      offs += gl2psPrintPDFText(gro->fontobjno,p->data.text,gro->fontno);
      break;
    case GL2PS_SPECIAL :
      /* alignment contains the format for which the special output text
         is intended */
      if(p->data.text->alignment == GL2PS_PDF)
        offs += fprintf(gl2ps->stream, "%s\n", p->data.text->str);
      break;
    default:
      break;
    }
  }
  return offs;
}

gl2psPDFgroupListWriteShaderResources()

int gl2psPDFgroupListWriteShaderResources ( void )

static

Definition at line 3825 of file gl2ps.cxx.

{
  GL2PSpdfgroup *gro;
  int offs = 0;
  int i;
 
  offs += fprintf(gl2ps->stream,
                  "/Shading\n"
                  "<<\n");
  for(i = 0; i < gl2psListNbr(gl2ps->pdfgrouplist); ++i){
    gro = (GL2PSpdfgroup*)gl2psListPointer(gl2ps->pdfgrouplist, i);
    if(gro->shno >= 0)
      offs += fprintf(gl2ps->stream, "/Sh%d %d 0 R\n", gro->shno, gro->shobjno);
    if(gro->maskshno >= 0)
      offs += fprintf(gl2ps->stream, "/TrSh%d %d 0 R\n", gro->maskshno, gro->maskshobjno);
  }
  offs += fprintf(gl2ps->stream,">>\n");
  return offs;
}

gl2psPDFgroupListWriteVariableResources()

int gl2psPDFgroupListWriteVariableResources ( void )

static

Definition at line 4133 of file gl2ps.cxx.

{
  int offs = 0;
 
  /* a) Graphics States for shader alpha masks*/
  offs += gl2psPDFgroupListWriteGStateResources();
 
  /* b) Shader and shader masks */
  offs += gl2psPDFgroupListWriteShaderResources();
 
  /* c) XObjects (Images & Shader Masks) */
  offs += gl2psPDFgroupListWriteXObjectResources();
 
  /* d) Fonts */
  offs += gl2psPDFgroupListWriteFontResources();
 
  /* End resources and page */
  offs += fprintf(gl2ps->stream,
                  ">>\n"
                  ">>\n"
                  "endobj\n");
  return offs;
}

gl2psPDFgroupListWriteXObjectResources()

int gl2psPDFgroupListWriteXObjectResources ( void )

static

Definition at line 3847 of file gl2ps.cxx.

{
  int i;
  GL2PSprimitive *p = NULL;
  GL2PSpdfgroup *gro;
  int offs = 0;
 
  offs += fprintf(gl2ps->stream,
                  "/XObject\n"
                  "<<\n");
 
  for(i = 0; i < gl2psListNbr(gl2ps->pdfgrouplist); ++i){
    gro = (GL2PSpdfgroup*)gl2psListPointer(gl2ps->pdfgrouplist, i);
    if(!gl2psListNbr(gro->ptrlist))
      continue;
    p = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, 0);
    switch(p->type){
    case GL2PS_PIXMAP:
      gro->imobjno = gl2ps->objects_stack++;
      if(GL_RGBA == p->data.image->format)  /* reserve one object for image mask */
        gl2ps->objects_stack++;
      offs += fprintf(gl2ps->stream, "/Im%d %d 0 R\n", gro->imno, gro->imobjno);
      break;
    case GL2PS_TRIANGLE:
      if(gro->trgroupno >=0)
        offs += fprintf(gl2ps->stream, "/TrG%d %d 0 R\n", gro->trgroupno, gro->trgroupobjno);
      break;
    default:
      break;
    }
  }
  offs += fprintf(gl2ps->stream,">>\n");
  return offs;
}

gl2psPDFgroupObjectInit()

void gl2psPDFgroupObjectInit ( GL2PSpdfgroup * gro )

static

Definition at line 3453 of file gl2ps.cxx.

{
  if(!gro)
    return;
 
  gro->ptrlist = NULL;
  gro->fontno = gro->gsno = gro->imno = gro->maskshno = gro->shno
    = gro->trgroupno = gro->fontobjno = gro->imobjno = gro->shobjno
    = gro->maskshobjno = gro->gsobjno = gro->trgroupobjno = -1;
}

gl2psPDFRectHull()

void gl2psPDFRectHull ( GLfloat * xmin, GLfloat * xmax, GLfloat * ymin, GLfloat * ymax, GL2PStriangle * triangles, int cnt )

static

Definition at line 4305 of file gl2ps.cxx.

{
  int i, j;
 
  *xmin = triangles[0].vertex[0].xyz[0];
  *xmax = triangles[0].vertex[0].xyz[0];
  *ymin = triangles[0].vertex[0].xyz[1];
  *ymax = triangles[0].vertex[0].xyz[1];
 
  for(i = 0; i < cnt; ++i){
    for(j = 0; j < 3; ++j){
      if(*xmin > triangles[i].vertex[j].xyz[0])
        *xmin = triangles[i].vertex[j].xyz[0];
      if(*xmax < triangles[i].vertex[j].xyz[0])
        *xmax = triangles[i].vertex[j].xyz[0];
      if(*ymin > triangles[i].vertex[j].xyz[1])
        *ymin = triangles[i].vertex[j].xyz[1];
      if(*ymax < triangles[i].vertex[j].xyz[1])
        *ymax = triangles[i].vertex[j].xyz[1];
    }
  }
}

gl2psPDFstacksInit()

void gl2psPDFstacksInit ( void )

static

Definition at line 3442 of file gl2ps.cxx.

{
  gl2ps->objects_stack = 7 /* FIXED_XREF_ENTRIES */ + 1;
  gl2ps->extgs_stack = 0;
  gl2ps->font_stack = 0;
  gl2ps->im_stack = 0;
  gl2ps->trgroupobjects_stack = 0;
  gl2ps->shader_stack = 0;
  gl2ps->mshader_stack = 0;
}

gl2psPGFTextAlignment()

const char * gl2psPGFTextAlignment ( int align )

static

Definition at line 5306 of file gl2ps.cxx.

{
  switch(align){
  case GL2PS_TEXT_C  : return "center";
  case GL2PS_TEXT_CL : return "west";
  case GL2PS_TEXT_CR : return "east";
  case GL2PS_TEXT_B  : return "south";
  case GL2PS_TEXT_BR : return "south east";
  case GL2PS_TEXT_T  : return "north";
  case GL2PS_TEXT_TL : return "north west";
  case GL2PS_TEXT_TR : return "north east";
  case GL2PS_TEXT_BL :
  default            : return "south west";
  }
}

gl2psPointSize()

GL2PSDLL_API GLint gl2psPointSize

(

GLfloat

value

)

Definition at line 5982 of file gl2ps.cxx.

{
  if(!gl2ps) return GL2PS_UNINITIALIZED;
 
  glPassThrough(GL2PS_POINT_SIZE_TOKEN);
  glPassThrough(value);
 
  return GL2PS_SUCCESS;
}

gl2psPrintf()

int gl2psPrintf ( const char * fmt, ... )

static

Definition at line 419 of file gl2ps.cxx.

{
  int ret;
  va_list args;
 
#if defined(GL2PS_HAVE_ZLIB)
  unsigned int oldsize = 0;
  static char buf[1000];
  if(gl2ps->options & GL2PS_COMPRESS){
    va_start(args, fmt);
    ret = vsprintf(buf, fmt, args);
    va_end(args);
    oldsize = gl2ps->compress->srcLen;
    gl2ps->compress->start = (Bytef*)gl2psReallocCompress(oldsize + ret);
    memcpy(gl2ps->compress->start+oldsize, buf, ret);
    ret = 0;
  }
  else{
#endif
    va_start(args, fmt);
    ret = vfprintf(gl2ps->stream, fmt, args);
    va_end(args);
#if defined(GL2PS_HAVE_ZLIB)
  }
#endif
  return ret;
}

gl2psPrintGzipFooter()

void gl2psPrintGzipFooter ( )

static

Definition at line 465 of file gl2ps.cxx.

{
#if defined(GL2PS_HAVE_ZLIB)
  int n;
  uLong crc, len;
  char tmp[8];
 
  if(gl2ps->options & GL2PS_COMPRESS){
    if(Z_OK != gl2psDeflate()){
      gl2psMsg(GL2PS_ERROR, "Zlib deflate error");
    }
    else{
      /* determine the length of the header in the zlib stream */
      n = 2; /* CMF+FLG */
      if(gl2ps->compress->dest[1] & (1<<5)){
        n += 4; /* DICTID */
      }
      /* write the data, without the zlib header and footer */
      fwrite(gl2ps->compress->dest+n, gl2ps->compress->destLen-(n+4),
             1, gl2ps->stream);
      /* add the gzip file footer */
      crc = crc32(0L, gl2ps->compress->start, gl2ps->compress->srcLen);
      for(n = 0; n < 4; ++n){
        tmp[n] = (char)(crc & 0xff);
        crc >>= 8;
      }
      len = gl2ps->compress->srcLen;
      for(n = 4; n < 8; ++n){
        tmp[n] = (char)(len & 0xff);
        len >>= 8;
      }
      fwrite(tmp, 8, 1, gl2ps->stream);
    }
    gl2psFreeCompress();
    gl2psFree(gl2ps->compress);
    gl2ps->compress = NULL;
  }
#endif
}

gl2psPrintGzipHeader()

void gl2psPrintGzipHeader ( )

static

Definition at line 447 of file gl2ps.cxx.

{
#if defined(GL2PS_HAVE_ZLIB)
  char tmp[10] = {'\x1f', '\x8b', /* magic numbers: 0x1f, 0x8b */
                  8, /* compression method: Z_DEFLATED */
                  0, /* flags */
                  0, 0, 0, 0, /* time */
                  2, /* extra flags: max compression */
                  '\x03'}; /* OS code: 0x03 (Unix) */
 
  if(gl2ps->options & GL2PS_COMPRESS){
    gl2psSetupCompress();
    /* add the gzip file header */
    fwrite(tmp, 10, 1, gl2ps->stream);
  }
#endif
}

gl2psPrintPDFBeginViewport()

void gl2psPrintPDFBeginViewport ( GLint viewport[4] )

static

Definition at line 4766 of file gl2ps.cxx.

{
  int offs = 0;
  GLint index;
  GLfloat rgba[4];
  int x = viewport[0], y = viewport[1], w = viewport[2], h = viewport[3];
 
  glRenderMode(GL_FEEDBACK);
 
  if(gl2ps->header){
    gl2psPrintPDFHeader();
    gl2ps->header = GL_FALSE;
  }
 
  offs += gl2psPrintf("q\n");
 
  if(gl2ps->options & GL2PS_DRAW_BACKGROUND){
    if(gl2ps->colormode == GL_RGBA || gl2ps->colorsize == 0){
      glGetFloatv(GL_COLOR_CLEAR_VALUE, rgba);
    }
    else{
      glGetIntegerv(GL_INDEX_CLEAR_VALUE, &index);
      rgba[0] = gl2ps->colormap[index][0];
      rgba[1] = gl2ps->colormap[index][1];
      rgba[2] = gl2ps->colormap[index][2];
      rgba[3] = 1.0F;
    }
    offs += gl2psPrintPDFFillColor(rgba);
    offs += gl2psPrintf("%d %d %d %d re\n"
                        "W\n"
                        "f\n",
                        x, y, w, h);
  }
  else{
    offs += gl2psPrintf("%d %d %d %d re\n"
                        "W\n"
                        "n\n",
                        x, y, w, h);
  }
 
  gl2ps->streamlength += offs;
}

gl2psPrintPDFCatalog()

int gl2psPrintPDFCatalog ( void )

static

Definition at line 3963 of file gl2ps.cxx.

{
  return fprintf(gl2ps->stream,
                 "2 0 obj\n"
                 "<<\n"
                 "/Type /Catalog\n"
                 "/Pages 3 0 R\n"
                 ">>\n"
                 "endobj\n");
}

gl2psPrintPDFCompressorType()

int gl2psPrintPDFCompressorType ( void )

static

Definition at line 3352 of file gl2ps.cxx.

{
#if defined(GL2PS_HAVE_ZLIB)
  if(gl2ps->options & GL2PS_COMPRESS){
    return fprintf(gl2ps->stream, "/Filter [/FlateDecode]\n");
  }
#endif
  return 0;
}

gl2psPrintPDFDataStreamLength()

int gl2psPrintPDFDataStreamLength ( int val )

static

Definition at line 4094 of file gl2ps.cxx.

{
  return fprintf(gl2ps->stream,
                 "5 0 obj\n"
                 "%d\n"
                 "endobj\n", val);
}

gl2psPrintPDFEndViewport()

GLint gl2psPrintPDFEndViewport ( void )

static

Definition at line 4809 of file gl2ps.cxx.

{
  GLint res;
 
  res = gl2psPrintPrimitives();
  gl2ps->streamlength += gl2psPrintf("Q\n");
  return res;
}

gl2psPrintPDFFillColor()

int gl2psPrintPDFFillColor ( GL2PSrgba rgba )

static

Definition at line 3379 of file gl2ps.cxx.

{
  int i, offs = 0;
 
  for(i = 0; i < 3; ++i){
    if(GL2PS_ZERO(rgba[i]))
      offs += gl2psPrintf("%.0f ", 0.);
    else if(rgba[i] < 1e-4 || rgba[i] > 1e6) /* avoid %e formatting */
      offs += gl2psPrintf("%f ", rgba[i]);
    else
      offs += gl2psPrintf("%g ", rgba[i]);
  }
  offs += gl2psPrintf("rg\n");
  return offs;
}

gl2psPrintPDFFinalPrimitive()

void gl2psPrintPDFFinalPrimitive ( void )

static

Definition at line 4818 of file gl2ps.cxx.

{
}

gl2psPrintPDFFooter()

void gl2psPrintPDFFooter ( void )

static

Definition at line 4701 of file gl2ps.cxx.

{
  int i, offs;
 
  gl2psPDFgroupListInit();
  gl2psPDFgroupListWriteMainStream();
 
  offs = gl2ps->xreflist[5] + gl2ps->streamlength;
  offs += gl2psClosePDFDataStream();
  gl2ps->xreflist[5] = offs;
 
  offs += gl2psPrintPDFDataStreamLength(gl2ps->streamlength);
  gl2ps->xreflist[6] = offs;
  gl2ps->streamlength = 0;
 
  offs += gl2psPrintPDFOpenPage();
  offs += gl2psPDFgroupListWriteVariableResources();
  gl2ps->xreflist = (int*)gl2psRealloc(gl2ps->xreflist,
                                       sizeof(int) * (gl2ps->objects_stack + 1));
  gl2ps->xreflist[7] = offs;
 
  offs += gl2psPrintPDFGSObject();
  gl2ps->xreflist[8] = offs;
 
  gl2ps->xreflist[gl2ps->objects_stack] =
    gl2psPDFgroupListWriteObjects(gl2ps->xreflist[8]);
 
  /* Start cross reference table. The file has to been opened in
     binary mode to preserve the 20 digit string length! */
  fprintf(gl2ps->stream,
          "xref\n"
          "0 %d\n"
          "%010d 65535 f \n", gl2ps->objects_stack, 0);
 
  for(i = 1; i < gl2ps->objects_stack; ++i)
    fprintf(gl2ps->stream, "%010d 00000 n \n", gl2ps->xreflist[i]);
 
  fprintf(gl2ps->stream,
          "trailer\n"
          "<<\n"
          "/Size %d\n"
          "/Info 1 0 R\n"
          "/Root 2 0 R\n"
          ">>\n"
          "startxref\n%d\n"
          "%%%%EOF\n",
          gl2ps->objects_stack, gl2ps->xreflist[gl2ps->objects_stack]);
 
  /* Free auxiliary lists and arrays */
  gl2psFree(gl2ps->xreflist);
  gl2psListAction(gl2ps->pdfprimlist, gl2psFreePrimitive);
  gl2psListDelete(gl2ps->pdfprimlist);
  gl2psPDFgroupListDelete();
 
#if defined(GL2PS_HAVE_ZLIB)
  if(gl2ps->options & GL2PS_COMPRESS){
    gl2psFreeCompress();
    gl2psFree(gl2ps->compress);
    gl2ps->compress = NULL;
  }
#endif
}

gl2psPrintPDFGSObject()

int gl2psPrintPDFGSObject ( void )

static

Definition at line 4159 of file gl2ps.cxx.

{
  return fprintf(gl2ps->stream,
                 "7 0 obj\n"
                 "<<\n"
                 "/Type /ExtGState\n"
                 "/SA false\n"
                 "/SM 0.02\n"
                 "/OP false\n"
                 "/op false\n"
                 "/OPM 0\n"
                 "/BG2 /Default\n"
                 "/UCR2 /Default\n"
                 "/TR2 /Default\n"
                 ">>\n"
                 "endobj\n");
}

gl2psPrintPDFHeader()

void gl2psPrintPDFHeader ( void )

static

Definition at line 4023 of file gl2ps.cxx.

{
  int offs = 0;
  gl2ps->pdfprimlist = gl2psListCreate(500, 500, sizeof(GL2PSprimitive*));
  gl2psPDFstacksInit();
 
  gl2ps->xreflist = (int*)gl2psMalloc(sizeof(int) * gl2ps->objects_stack);
 
#if defined(GL2PS_HAVE_ZLIB)
  if(gl2ps->options & GL2PS_COMPRESS){
    gl2psSetupCompress();
  }
#endif
  gl2ps->xreflist[0] = 0;
  offs += fprintf(gl2ps->stream, "%%PDF-1.4\n");
  gl2ps->xreflist[1] = offs;
 
  offs += gl2psPrintPDFInfo();
  gl2ps->xreflist[2] = offs;
 
  offs += gl2psPrintPDFCatalog();
  gl2ps->xreflist[3] = offs;
 
  offs += gl2psPrintPDFPages();
  gl2ps->xreflist[4] = offs;
 
  offs += gl2psOpenPDFDataStream();
  gl2ps->xreflist[5] = offs; /* finished in gl2psPrintPDFFooter */
  gl2ps->streamlength = gl2psOpenPDFDataStreamWritePreface();
}

gl2psPrintPDFInfo()

int gl2psPrintPDFInfo ( void )

static

Definition at line 3923 of file gl2ps.cxx.

{
  int offs;
  time_t now;
  struct tm newtime;
 
  time(&now);
 
  offs = fprintf(gl2ps->stream,
                 "1 0 obj\n"
                 "<<\n"
                 "/Title (%s)\n"
                 "/Creator (GL2PS %d.%d.%d%s, %s)\n"
                 "/Producer (%s)\n",
                 gl2ps->title, GL2PS_MAJOR_VERSION, GL2PS_MINOR_VERSION,
                 GL2PS_PATCH_VERSION, GL2PS_EXTRA_VERSION, GL2PS_COPYRIGHT,
                 gl2ps->producer);
 
  if(!gmtime_r(&now, &newtime)){
    offs += fprintf(gl2ps->stream,
                    ">>\n"
                    "endobj\n");
    return offs;
  }
 
  offs += fprintf(gl2ps->stream,
                  "/CreationDate (D:%d%02d%02d%02d%02d%02d)\n"
                  ">>\n"
                  "endobj\n",
                  newtime.tm_year+1900,
                  newtime.tm_mon+1,
                  newtime.tm_mday,
                  newtime.tm_hour,
                  newtime.tm_min,
                  newtime.tm_sec);
  return offs;
}

gl2psPrintPDFLineWidth()

int gl2psPrintPDFLineWidth ( GLfloat lw )

static

Definition at line 3395 of file gl2ps.cxx.

{
  if(GL2PS_ZERO(lw))
    return gl2psPrintf("%.0f w\n", 0.);
  else if(lw < 1e-4 || lw > 1e6) /* avoid %e formatting */
    return gl2psPrintf("%f w\n", lw);
  else
    return gl2psPrintf("%g w\n", lw);
}

gl2psPrintPDFOpenPage()

int gl2psPrintPDFOpenPage ( void )

static

Definition at line 4104 of file gl2ps.cxx.

{
  int offs;
 
  /* Write fixed part */
 
  offs = fprintf(gl2ps->stream,
                 "6 0 obj\n"
                 "<<\n"
                 "/Type /Page\n"
                 "/Parent 3 0 R\n"
                 "/MediaBox [%d %d %d %d]\n",
                 (int)gl2ps->viewport[0], (int)gl2ps->viewport[1],
                 (int)gl2ps->viewport[2], (int)gl2ps->viewport[3]);
 
  if(gl2ps->options & GL2PS_LANDSCAPE)
    offs += fprintf(gl2ps->stream, "/Rotate -90\n");
 
  offs += fprintf(gl2ps->stream,
                  "/Contents 4 0 R\n"
                  "/Resources\n"
                  "<<\n"
                  "/ProcSet [/PDF /Text /ImageB /ImageC]  %%/ImageI\n");
 
  return offs;
 
  /* End fixed part, proceeds in gl2psPDFgroupListWriteVariableResources() */
}

gl2psPrintPDFPages()

int gl2psPrintPDFPages ( void )

static

Definition at line 3974 of file gl2ps.cxx.

{
  return fprintf(gl2ps->stream,
                 "3 0 obj\n"
                 "<<\n"
                 "/Type /Pages\n"
                 "/Kids [6 0 R]\n"
                 "/Count 1\n"
                 ">>\n"
                 "endobj\n");
}

gl2psPrintPDFPixmap()

int gl2psPrintPDFPixmap ( int obj, int childobj, GL2PSimage * im, int gray )

static

Definition at line 4538 of file gl2ps.cxx.

{
  int offs = 0, done = 0, sigbytes = 3;
 
  if(gray && gray !=8 && gray != 16)
    gray = 8;
 
  if(gray)
    sigbytes = gray / 8;
 
  offs += fprintf(gl2ps->stream,
                  "%d 0 obj\n"
                  "<<\n"
                  "/Type /XObject\n"
                  "/Subtype /Image\n"
                  "/Width %d\n"
                  "/Height %d\n"
                  "/ColorSpace %s \n"
                  "/BitsPerComponent 8\n",
                  obj,
                  (int)im->width, (int)im->height,
                  (gray) ? "/DeviceGray" : "/DeviceRGB" );
  if(GL_RGBA == im->format && gray == 0){
    offs += fprintf(gl2ps->stream,
                    "/SMask %d 0 R\n",
                    childobj);
  }
 
#if defined(GL2PS_HAVE_ZLIB)
  if(gl2ps->options & GL2PS_COMPRESS){
    gl2psAllocCompress((int)(im->width * im->height * sigbytes));
 
    gl2psPrintPDFPixmapStreamData(im, gl2psWriteBigEndianCompress, gray);
 
    if(Z_OK == gl2psDeflate() && 23 + gl2ps->compress->destLen < gl2ps->compress->srcLen){
      offs += gl2psPrintPDFCompressorType();
      offs += fprintf(gl2ps->stream,
                      "/Length %d "
                      ">>\n"
                      "stream\n",
                      (int)gl2ps->compress->destLen);
      offs += gl2ps->compress->destLen * fwrite(gl2ps->compress->dest, gl2ps->compress->destLen,
                                                1, gl2ps->stream);
      done = 1;
    }
    gl2psFreeCompress();
  }
#endif
 
  if(!done){
    /* no compression, or too long after compression, or compress error
       -> write non-compressed entry */
    offs += fprintf(gl2ps->stream,
                    "/Length %d "
                    ">>\n"
                    "stream\n",
                    (int)(im->width * im->height * sigbytes));
    offs += gl2psPrintPDFPixmapStreamData(im, gl2psWriteBigEndian, gray);
  }
 
  offs += fprintf(gl2ps->stream,
                  "\nendstream\n"
                  "endobj\n");
 
  return offs;
}

gl2psPrintPDFPixmapStreamData()

int gl2psPrintPDFPixmapStreamData ( GL2PSimage * im, size_t(* action )(unsigned long data, size_t size), int gray )

static

Definition at line 4498 of file gl2ps.cxx.

{
  int x, y, shift;
  GLfloat r, g, b, a;
 
  if(im->format != GL_RGBA && gray)
    return 0;
 
  if(gray && gray != 8 && gray != 16)
    gray = 8;
 
  gray /= 8;
 
  shift = (sizeof(unsigned long) - 1) * 8;
 
  for(y = 0; y < im->height; ++y){
    for(x = 0; x < im->width; ++x){
      a = gl2psGetRGB(im, x, y, &r, &g, &b);
      if(im->format == GL_RGBA && gray){
        (*action)((unsigned long)(a * 255) << shift, gray);
      }
      else{
        (*action)((unsigned long)(r * 255) << shift, 1);
        (*action)((unsigned long)(g * 255) << shift, 1);
        (*action)((unsigned long)(b * 255) << shift, 1);
      }
    }
  }
 
  switch(gray){
  case 0: return 3 * im->width * im->height;
  case 1: return im->width * im->height;
  case 2: return 2 * im->width * im->height;
  default: return 3 * im->width * im->height;
  }
}

gl2psPrintPDFPrimitive()

void gl2psPrintPDFPrimitive ( void * data )

static

Definition at line 4056 of file gl2ps.cxx.

{
  GL2PSprimitive *prim = *(GL2PSprimitive**)data;
 
  if((gl2ps->options & GL2PS_OCCLUSION_CULL) && prim->culled)
    return;
 
  prim = gl2psCopyPrimitive(prim); /* deep copy */
  gl2psListAdd(gl2ps->pdfprimlist, &prim);
}

gl2psPrintPDFShader()

int gl2psPrintPDFShader ( int obj, GL2PStriangle * triangles, int size, int gray )

static

Definition at line 4335 of file gl2ps.cxx.

{
  int i, offs = 0, vertexbytes, done = 0;
  GLfloat xmin, xmax, ymin, ymax;
 
  switch(gray){
  case 0:
    vertexbytes = 1+4+4+1+1+1;
    break;
  case 8:
    vertexbytes = 1+4+4+1;
    break;
  case 16:
    vertexbytes = 1+4+4+2;
    break;
  default:
    gray = 8;
    vertexbytes = 1+4+4+1;
    break;
  }
 
  gl2psPDFRectHull(&xmin, &xmax, &ymin, &ymax, triangles, size);
 
  offs += fprintf(gl2ps->stream,
                  "%d 0 obj\n"
                  "<< "
                  "/ShadingType 4 "
                  "/ColorSpace %s "
                  "/BitsPerCoordinate 32 "
                  "/BitsPerComponent %d "
                  "/BitsPerFlag 8 "
                  "/Decode [%f %f %f %f 0 1 %s] ",
                  obj,
                  (gray) ? "/DeviceGray" : "/DeviceRGB",
                  (gray) ? gray : 8,
                  xmin, xmax, ymin, ymax,
                  (gray) ? "" : "0 1 0 1");
 
#if defined(GL2PS_HAVE_ZLIB)
  if(gl2ps->options & GL2PS_COMPRESS){
    gl2psAllocCompress(vertexbytes * size * 3);
 
    for(i = 0; i < size; ++i)
      gl2psPrintPDFShaderStreamData(&triangles[i],
                                    xmax-xmin, ymax-ymin, xmin, ymin,
                                    gl2psWriteBigEndianCompress, gray);
 
    if(Z_OK == gl2psDeflate() && 23 + gl2ps->compress->destLen < gl2ps->compress->srcLen){
      offs += gl2psPrintPDFCompressorType();
      offs += fprintf(gl2ps->stream,
                      "/Length %d "
                      ">>\n"
                      "stream\n",
                      (int)gl2ps->compress->destLen);
      offs += gl2ps->compress->destLen * fwrite(gl2ps->compress->dest,
                                                gl2ps->compress->destLen,
                                                1, gl2ps->stream);
      done = 1;
    }
    gl2psFreeCompress();
  }
#endif
 
  if(!done){
    /* no compression, or too long after compression, or compress error
       -> write non-compressed entry */
    offs += fprintf(gl2ps->stream,
                    "/Length %d "
                    ">>\n"
                    "stream\n",
                    vertexbytes * 3 * size);
    for(i = 0; i < size; ++i)
      offs += gl2psPrintPDFShaderStreamData(&triangles[i],
                                            xmax-xmin, ymax-ymin, xmin, ymin,
                                            gl2psWriteBigEndian, gray);
  }
 
  offs += fprintf(gl2ps->stream,
                  "\nendstream\n"
                  "endobj\n");
 
  return offs;
}

gl2psPrintPDFShaderExtGS()

int gl2psPrintPDFShaderExtGS ( int obj, int childobj )

static

Definition at line 4461 of file gl2ps.cxx.

{
  int offs = 0;
 
  offs += fprintf(gl2ps->stream,
                  "%d 0 obj\n"
                  "<<\n",
                  obj);
 
  offs += fprintf(gl2ps->stream,
                  "/SMask << /S /Alpha /G %d 0 R >> ",
                  childobj);
 
  offs += fprintf(gl2ps->stream,
                  ">>\n"
                  "endobj\n");
  return offs;
}

gl2psPrintPDFShaderMask()

int gl2psPrintPDFShaderMask ( int obj, int childobj )

static

Definition at line 4422 of file gl2ps.cxx.

{
  int offs = 0, len;
 
  offs += fprintf(gl2ps->stream,
                  "%d 0 obj\n"
                  "<<\n"
                  "/Type /XObject\n"
                  "/Subtype /Form\n"
                  "/BBox [ %d %d %d %d ]\n"
                  "/Group \n<<\n/S /Transparency /CS /DeviceRGB\n"
                  ">>\n",
                  obj,
                  (int)gl2ps->viewport[0], (int)gl2ps->viewport[1],
                  (int)gl2ps->viewport[2], (int)gl2ps->viewport[3]);
 
  len = (childobj>0)
    ? strlen("/TrSh sh\n") + (int)log10((double)childobj)+1
    : strlen("/TrSh0 sh\n");
 
  offs += fprintf(gl2ps->stream,
                  "/Length %d\n"
                  ">>\n"
                  "stream\n",
                  len);
  offs += fprintf(gl2ps->stream,
                  "/TrSh%d sh\n",
                  childobj);
  offs += fprintf(gl2ps->stream,
                  "endstream\n"
                  "endobj\n");
 
  return offs;
}

gl2psPrintPDFShaderSimpleExtGS()

int gl2psPrintPDFShaderSimpleExtGS ( int obj, GLfloat alpha )

static

Definition at line 4482 of file gl2ps.cxx.

{
  int offs = 0;
 
  offs += fprintf(gl2ps->stream,
                  "%d 0 obj\n"
                  "<<\n"
                  "/ca %g"
                  ">>\n"
                  "endobj\n",
                  obj, alpha);
  return offs;
}

gl2psPrintPDFShaderStreamData()

int gl2psPrintPDFShaderStreamData ( GL2PStriangle * triangle, GLfloat dx, GLfloat dy, GLfloat xmin, GLfloat ymin, size_t(* action )(unsigned long data, size_t size), int gray )

static

Definition at line 4277 of file gl2ps.cxx.

{
  int i, offs = 0;
  GL2PSvertex v;
 
  if(gray && gray != 8 && gray != 16)
    gray = 8;
 
  for(i = 0; i < 3; ++i){
    offs += gl2psPrintPDFShaderStreamDataCoord(&triangle->vertex[i], action,
                                               dx, dy, xmin, ymin);
    if(gray){
      v = triangle->vertex[i];
      offs += gl2psPrintPDFShaderStreamDataAlpha(&v, action, gray);
    }
    else{
      offs += gl2psPrintPDFShaderStreamDataRGB(&triangle->vertex[i], action);
    }
  }
 
  return offs;
}

gl2psPrintPDFShaderStreamDataAlpha()

int gl2psPrintPDFShaderStreamDataAlpha ( GL2PSvertex * vertex, size_t(* action )(unsigned long data, size_t size), int sigbyte )

static

Definition at line 4251 of file gl2ps.cxx.

{
  int offs = 0;
  unsigned long imap;
  double dmax = static_cast<double>(~1UL);
 
  /* FIXME: temp bux fix for 64 bit archs: */
  if(sizeof(unsigned long) == 8) dmax = dmax - 2048.;
 
  if(sigbyte != 8 && sigbyte != 16)
    sigbyte = 8;
 
  sigbyte /= 8;
 
  imap = (unsigned long)((vertex->rgba[3]) * dmax);
 
  offs += (*action)(imap, sigbyte);
 
  return offs;
}

gl2psPrintPDFShaderStreamDataCoord()

int gl2psPrintPDFShaderStreamDataCoord ( GL2PSvertex * vertex, size_t(* action )(unsigned long data, size_t size), GLfloat dx, GLfloat dy, GLfloat xmin, GLfloat ymin )

static

Definition at line 4179 of file gl2ps.cxx.

{
  int offs = 0;
  unsigned long imap;
  GLfloat diff;
  double dmax = static_cast<double>(~1UL);
  char edgeflag = 0;
 
  /* FIXME: temp bux fix for 64 bit archs: */
  if(sizeof(unsigned long) == 8) dmax = dmax - 2048.;
 
  offs += (*action)(edgeflag, 1);
 
  /* The Shader stream in PDF requires to be in a 'big-endian'
     order */
 
  if(GL2PS_ZERO(dx * dy)){
    offs += (*action)(0, 4);
    offs += (*action)(0, 4);
  }
  else{
    diff = (vertex->xyz[0] - xmin) / dx;
    if(diff > 1)
      diff = 1.0F;
    else if(diff < 0)
      diff = 0.0F;
    imap = (unsigned long)(diff * dmax);
    offs += (*action)(imap, 4);
 
    diff = (vertex->xyz[1] - ymin) / dy;
    if(diff > 1)
      diff = 1.0F;
    else if(diff < 0)
      diff = 0.0F;
    imap = (unsigned long)(diff * dmax);
    offs += (*action)(imap, 4);
  }
 
  return offs;
}

gl2psPrintPDFShaderStreamDataRGB()

int gl2psPrintPDFShaderStreamDataRGB ( GL2PSvertex * vertex, size_t(* action )(unsigned long data, size_t size) )

static

Definition at line 4226 of file gl2ps.cxx.

{
  int offs = 0;
  unsigned long imap;
  double dmax = static_cast<double>(~1UL);
 
  /* FIXME: temp bux fix for 64 bit archs: */
  if(sizeof(unsigned long) == 8) dmax = dmax - 2048.;
 
  imap = (unsigned long)((vertex->rgba[0]) * dmax);
  offs += (*action)(imap, 1);
 
  imap = (unsigned long)((vertex->rgba[1]) * dmax);
  offs += (*action)(imap, 1);
 
  imap = (unsigned long)((vertex->rgba[2]) * dmax);
  offs += (*action)(imap, 1);
 
  return offs;
}

gl2psPrintPDFStrokeColor()

int gl2psPrintPDFStrokeColor ( GL2PSrgba rgba )

static

Definition at line 3362 of file gl2ps.cxx.

{
  int i, offs = 0;
 
  gl2psSetLastColor(rgba);
  for(i = 0; i < 3; ++i){
    if(GL2PS_ZERO(rgba[i]))
      offs += gl2psPrintf("%.0f ", 0.);
    else if(rgba[i] < 1e-4 || rgba[i] > 1e6) /* avoid %e formatting */
      offs += gl2psPrintf("%f ", rgba[i]);
    else
      offs += gl2psPrintf("%g ", rgba[i]);
  }
  offs += gl2psPrintf("RG\n");
  return offs;
}

gl2psPrintPDFText()

int gl2psPrintPDFText ( int obj, GL2PSstring * s, int fontnumber )

static

Definition at line 4605 of file gl2ps.cxx.

{
  int offs = 0;
 
  offs += fprintf(gl2ps->stream,
                  "%d 0 obj\n"
                  "<<\n"
                  "/Type /Font\n"
                  "/Subtype /Type1\n"
                  "/Name /F%d\n"
                  "/BaseFont /%s\n"
                  "/Encoding /MacRomanEncoding\n"
                  ">>\n"
                  "endobj\n",
                  obj, fontnumber, s->fontname);
  return offs;
}

gl2psPrintPGFBeginViewport()

void gl2psPrintPGFBeginViewport ( GLint viewport[4] )

static

Definition at line 5402 of file gl2ps.cxx.

{
  GLint index;
  GLfloat rgba[4];
  int x = viewport[0], y = viewport[1], w = viewport[2], h = viewport[3];
 
  glRenderMode(GL_FEEDBACK);
 
  if(gl2ps->header){
    gl2psPrintPGFHeader();
    gl2ps->header = GL_FALSE;
  }
 
  fprintf(gl2ps->stream, "\\begin{pgfscope}\n");
  if(gl2ps->options & GL2PS_DRAW_BACKGROUND){
    if(gl2ps->colormode == GL_RGBA || gl2ps->colorsize == 0){
      glGetFloatv(GL_COLOR_CLEAR_VALUE, rgba);
    }
    else{
      glGetIntegerv(GL_INDEX_CLEAR_VALUE, &index);
      rgba[0] = gl2ps->colormap[index][0];
      rgba[1] = gl2ps->colormap[index][1];
      rgba[2] = gl2ps->colormap[index][2];
      rgba[3] = 1.0F;
    }
    gl2psPrintPGFColor(rgba);
    fprintf(gl2ps->stream,
            "\\pgfpathrectangle{\\pgfpoint{%dpt}{%dpt}}"
            "{\\pgfpoint{%dpt}{%dpt}}\n"
            "\\pgfusepath{fill}\n",
            x, y, w, h);
  }
 
  fprintf(gl2ps->stream,
          "\\pgfpathrectangle{\\pgfpoint{%dpt}{%dpt}}"
          "{\\pgfpoint{%dpt}{%dpt}}\n"
          "\\pgfusepath{clip}\n",
          x, y, w, h);
}

gl2psPrintPGFColor()

void gl2psPrintPGFColor ( GL2PSrgba rgba )

static

Definition at line 5249 of file gl2ps.cxx.

{
  if(!gl2psSameColor(gl2ps->lastrgba, rgba)){
    gl2psSetLastColor(rgba);
    fprintf(gl2ps->stream, "\\color[rgb]{%f,%f,%f}\n", rgba[0], rgba[1], rgba[2]);
  }
}

gl2psPrintPGFDash()

void gl2psPrintPGFDash ( GLushort pattern, GLint factor )

static

Definition at line 5284 of file gl2ps.cxx.

{
  int i, n, array[10];
 
  if(pattern == gl2ps->lastpattern && factor == gl2ps->lastfactor)
    return;
 
  gl2ps->lastpattern = pattern;
  gl2ps->lastfactor = factor;
 
  if(!pattern || !factor){
    /* solid line */
    fprintf(gl2ps->stream, "\\pgfsetdash{}{0pt}\n");
  }
  else{
    gl2psParseStipplePattern(pattern, factor, &n, array);
    fprintf(gl2ps->stream, "\\pgfsetdash{");
    for(i = 0; i < n; i++) fprintf(gl2ps->stream, "{%dpt}", array[i]);
    fprintf(gl2ps->stream, "}{0pt}\n");
  }
}

gl2psPrintPGFEndViewport()

GLint gl2psPrintPGFEndViewport ( void )

static

Definition at line 5442 of file gl2ps.cxx.

{
  GLint res;
  res = gl2psPrintPrimitives();
  fprintf(gl2ps->stream, "\\end{pgfscope}\n");
  return res;
}

gl2psPrintPGFFinalPrimitive()

void gl2psPrintPGFFinalPrimitive ( void )

static

Definition at line 5450 of file gl2ps.cxx.

{
}

gl2psPrintPGFFooter()

void gl2psPrintPGFFooter ( void )

static

Definition at line 5397 of file gl2ps.cxx.

{
  fprintf(gl2ps->stream, "\\end{pgfpicture}\n");
}

gl2psPrintPGFHeader()

void gl2psPrintPGFHeader ( void )

static

Definition at line 5257 of file gl2ps.cxx.

{
  time_t now;
 
  time(&now);
 
  fprintf(gl2ps->stream,
          "%% Title: %s\n"
          "%% Creator: GL2PS %d.%d.%d%s, %s\n"
          "%% For: %s\n"
          "%% CreationDate: %s",
          gl2ps->title, GL2PS_MAJOR_VERSION, GL2PS_MINOR_VERSION,
          GL2PS_PATCH_VERSION, GL2PS_EXTRA_VERSION, GL2PS_COPYRIGHT,
          gl2ps->producer, ctime(&now));
 
  fprintf(gl2ps->stream, "\\begin{pgfpicture}\n");
  if(gl2ps->options & GL2PS_DRAW_BACKGROUND){
    gl2psPrintPGFColor(gl2ps->bgcolor);
    fprintf(gl2ps->stream,
            "\\pgfpathrectanglecorners{"
            "\\pgfpoint{%dpt}{%dpt}}{\\pgfpoint{%dpt}{%dpt}}\n"
            "\\pgfusepath{fill}\n",
            (int)gl2ps->viewport[0], (int)gl2ps->viewport[1],
            (int)gl2ps->viewport[2], (int)gl2ps->viewport[3]);
  }
}

gl2psPrintPGFPrimitive()

void gl2psPrintPGFPrimitive ( void * data )

static

Definition at line 5322 of file gl2ps.cxx.

{
  GL2PSprimitive *prim;
 
  prim = *(GL2PSprimitive**)data;
 
  switch(prim->type){
  case GL2PS_POINT :
    /* Points in openGL are rectangular */
    gl2psPrintPGFColor(prim->verts[0].rgba);
    fprintf(gl2ps->stream,
            "\\pgfpathrectangle{\\pgfpoint{%fpt}{%fpt}}"
            "{\\pgfpoint{%fpt}{%fpt}}\n\\pgfusepath{fill}\n",
            prim->verts[0].xyz[0]-0.5*prim->width,
            prim->verts[0].xyz[1]-0.5*prim->width,
            prim->width,prim->width);
    break;
  case GL2PS_LINE :
    gl2psPrintPGFColor(prim->verts[0].rgba);
    if(gl2ps->lastlinewidth != prim->width){
      gl2ps->lastlinewidth = prim->width;
      fprintf(gl2ps->stream, "\\pgfsetlinewidth{%fpt}\n", gl2ps->lastlinewidth);
    }
    gl2psPrintPGFDash(prim->pattern, prim->factor);
    fprintf(gl2ps->stream,
            "\\pgfpathmoveto{\\pgfpoint{%fpt}{%fpt}}\n"
            "\\pgflineto{\\pgfpoint{%fpt}{%fpt}}\n"
            "\\pgfusepath{stroke}\n",
            prim->verts[1].xyz[0], prim->verts[1].xyz[1],
            prim->verts[0].xyz[0], prim->verts[0].xyz[1]);
    break;
  case GL2PS_TRIANGLE :
    if(gl2ps->lastlinewidth != 0){
      gl2ps->lastlinewidth = 0;
      fprintf(gl2ps->stream, "\\pgfsetlinewidth{0.01pt}\n");
    }
    gl2psPrintPGFColor(prim->verts[0].rgba);
    fprintf(gl2ps->stream,
            "\\pgfpathmoveto{\\pgfpoint{%fpt}{%fpt}}\n"
            "\\pgflineto{\\pgfpoint{%fpt}{%fpt}}\n"
            "\\pgflineto{\\pgfpoint{%fpt}{%fpt}}\n"
            "\\pgfpathclose\n"
            "\\pgfusepath{fill,stroke}\n",
            prim->verts[2].xyz[0], prim->verts[2].xyz[1],
            prim->verts[1].xyz[0], prim->verts[1].xyz[1],
            prim->verts[0].xyz[0], prim->verts[0].xyz[1]);
    break;
  case GL2PS_TEXT :
    fprintf(gl2ps->stream, "{\n\\pgftransformshift{\\pgfpoint{%fpt}{%fpt}}\n",
            prim->verts[0].xyz[0], prim->verts[0].xyz[1]);
 
    if(prim->data.text->angle)
      fprintf(gl2ps->stream, "\\pgftransformrotate{%f}{", prim->data.text->angle);
 
    fprintf(gl2ps->stream, "\\pgfnode{rectangle}{%s}{\\fontsize{%d}{0}\\selectfont",
            gl2psPGFTextAlignment(prim->data.text->alignment),
            prim->data.text->fontsize);
 
    fprintf(gl2ps->stream, "\\textcolor[rgb]{%g,%g,%g}{{%s}}",
            prim->verts[0].rgba[0], prim->verts[0].rgba[1],
            prim->verts[0].rgba[2], prim->data.text->str);
 
    fprintf(gl2ps->stream, "}{}{\\pgfusepath{discard}}}\n");
    break;
  case GL2PS_SPECIAL :
    /* alignment contains the format for which the special output text
       is intended */
    if (prim->data.text->alignment == GL2PS_PGF)
      fprintf(gl2ps->stream, "%s\n", prim->data.text->str);
    break;
  default :
    break;
  }
}

gl2psPrintPostScriptBeginViewport()

void gl2psPrintPostScriptBeginViewport ( GLint viewport[4] )

static

Definition at line 3119 of file gl2ps.cxx.

{
  GLint index;
  GLfloat rgba[4];
  int x = viewport[0], y = viewport[1], w = viewport[2], h = viewport[3];
 
  glRenderMode(GL_FEEDBACK);
 
  if(gl2ps->header){
    gl2psPrintPostScriptHeader();
    gl2ps->header = GL_FALSE;
  }
 
  gl2psPrintf("gsave\n"
              "1.0 1.0 scale\n");
 
  if(gl2ps->options & GL2PS_DRAW_BACKGROUND){
    if(gl2ps->colormode == GL_RGBA || gl2ps->colorsize == 0){
      glGetFloatv(GL_COLOR_CLEAR_VALUE, rgba);
    }
    else{
      glGetIntegerv(GL_INDEX_CLEAR_VALUE, &index);
      rgba[0] = gl2ps->colormap[index][0];
      rgba[1] = gl2ps->colormap[index][1];
      rgba[2] = gl2ps->colormap[index][2];
      rgba[3] = 1.0F;
    }
    gl2psPrintf("%g %g %g C\n"
                "newpath %d %d moveto %d %d lineto %d %d lineto %d %d lineto\n"
                "closepath fill\n",
                rgba[0], rgba[1], rgba[2],
                x, y, x+w, y, x+w, y+h, x, y+h);
  }
 
  gl2psPrintf("newpath %d %d moveto %d %d lineto %d %d lineto %d %d lineto\n"
              "closepath clip\n",
              x, y, x+w, y, x+w, y+h, x, y+h);
 
}

gl2psPrintPostScriptColor()

void gl2psPrintPostScriptColor ( GL2PSrgba rgba )

static

Definition at line 2882 of file gl2ps.cxx.

{
  if(!gl2psSameColor(gl2ps->lastrgba, rgba)){
    gl2psSetLastColor(rgba);
    gl2psPrintf("%g %g %g C\n", rgba[0], rgba[1], rgba[2]);
  }
}

gl2psPrintPostScriptDash()

int gl2psPrintPostScriptDash ( GLushort pattern, GLint factor, const char * str )

static

Definition at line 2940 of file gl2ps.cxx.

{
  int len = 0, i, n, array[10];
 
  if(pattern == gl2ps->lastpattern && factor == gl2ps->lastfactor)
    return 0;
 
  gl2ps->lastpattern = pattern;
  gl2ps->lastfactor = factor;
 
  if(!pattern || !factor){
    /* solid line */
    len += gl2psPrintf("[] 0 %s\n", str);
  }
  else{
    gl2psParseStipplePattern(pattern, factor, &n, array);
    len += gl2psPrintf("[");
    for(i = 0; i < n; i++){
      if(i) len += gl2psPrintf(" ");
      len += gl2psPrintf("%d", array[i]);
    }
    len += gl2psPrintf("] 0 %s\n", str);
  }
 
  return len;
}

gl2psPrintPostScriptEndViewport()

GLint gl2psPrintPostScriptEndViewport ( void )

static

Definition at line 3159 of file gl2ps.cxx.

{
  GLint res;
 
  res = gl2psPrintPrimitives();
  gl2psPrintf("grestore\n");
  return res;
}

gl2psPrintPostScriptFinalPrimitive()

void gl2psPrintPostScriptFinalPrimitive ( void )

static

Definition at line 3168 of file gl2ps.cxx.

{
  /* End any remaining line, if any */
  gl2psEndPostScriptLine();
}

gl2psPrintPostScriptFooter()

void gl2psPrintPostScriptFooter ( void )

static

Definition at line 3106 of file gl2ps.cxx.

{
  gl2psPrintf("grestore\n"
              "showpage\n"
              "cleartomark\n"
              "%%%%PageTrailer\n"
              "%%%%Trailer\n"
              "end\n"
              "%%%%EOF\n");
 
  gl2psPrintGzipFooter();
}

gl2psPrintPostScriptHeader()

void gl2psPrintPostScriptHeader ( void )

static

Definition at line 2643 of file gl2ps.cxx.

{
  time_t now;
 
  /* Since compression is not part of the PostScript standard,
     compressed PostScript files are just gzipped PostScript files
     ("ps.gz" or "eps.gz") */
  gl2psPrintGzipHeader();
 
  time(&now);
 
  if(gl2ps->format == GL2PS_PS){
    gl2psPrintf("%%!PS-Adobe-3.0\n");
  }
  else{
    gl2psPrintf("%%!PS-Adobe-3.0 EPSF-3.0\n");
  }
 
  gl2psPrintf("%%%%Title: %s\n"
              "%%%%Creator: GL2PS %d.%d.%d%s, %s\n"
              "%%%%For: %s\n"
              "%%%%CreationDate: %s"
              "%%%%LanguageLevel: 3\n"
              "%%%%DocumentData: Clean7Bit\n"
              "%%%%Pages: 1\n",
              gl2ps->title, GL2PS_MAJOR_VERSION, GL2PS_MINOR_VERSION,
              GL2PS_PATCH_VERSION, GL2PS_EXTRA_VERSION, GL2PS_COPYRIGHT,
              gl2ps->producer, ctime(&now));
 
  if(gl2ps->format == GL2PS_PS){
    gl2psPrintf("%%%%Orientation: %s\n"
                "%%%%DocumentMedia: Default %d %d 0 () ()\n",
                (gl2ps->options & GL2PS_LANDSCAPE) ? "Landscape" : "Portrait",
                (gl2ps->options & GL2PS_LANDSCAPE) ? (int)gl2ps->viewport[3] :
                (int)gl2ps->viewport[2],
                (gl2ps->options & GL2PS_LANDSCAPE) ? (int)gl2ps->viewport[2] :
                (int)gl2ps->viewport[3]);
  }
 
  gl2psPrintf("%%%%BoundingBox: %d %d %d %d\n"
              "%%%%EndComments\n",
              (gl2ps->options & GL2PS_LANDSCAPE) ? (int)gl2ps->viewport[1] :
              (int)gl2ps->viewport[0],
              (gl2ps->options & GL2PS_LANDSCAPE) ? (int)gl2ps->viewport[0] :
              (int)gl2ps->viewport[1],
              (gl2ps->options & GL2PS_LANDSCAPE) ? (int)gl2ps->viewport[3] :
              (int)gl2ps->viewport[2],
              (gl2ps->options & GL2PS_LANDSCAPE) ? (int)gl2ps->viewport[2] :
              (int)gl2ps->viewport[3]);
 
  /* RGB color: r g b C (replace C by G in output to change from rgb to gray)
     Grayscale: r g b G
     Font choose: size fontname FC
     Text string: (string) x y size fontname S??
     Rotated text string: (string) angle x y size fontname S??R
     Point primitive: x y size P
     Line width: width W
     Line start: x y LS
     Line joining last point: x y L
     Line end: x y LE
     Flat-shaded triangle: x3 y3 x2 y2 x1 y1 T
     Smooth-shaded triangle: x3 y3 r3 g3 b3 x2 y2 r2 g2 b2 x1 y1 r1 g1 b1 ST */
 
  gl2psPrintf("%%%%BeginProlog\n"
              "/gl2psdict 64 dict def gl2psdict begin\n"
              "0 setlinecap 0 setlinejoin\n"
              "/tryPS3shading %s def %% set to false to force subdivision\n"
              "/rThreshold %g def %% red component subdivision threshold\n"
              "/gThreshold %g def %% green component subdivision threshold\n"
              "/bThreshold %g def %% blue component subdivision threshold\n",
              (gl2ps->options & GL2PS_NO_PS3_SHADING) ? "false" : "true",
              gl2ps->threshold[0], gl2ps->threshold[1], gl2ps->threshold[2]);
 
  gl2psPrintf("/BD { bind def } bind def\n"
              "/C  { setrgbcolor } BD\n"
              "/G  { 0.082 mul exch 0.6094 mul add exch 0.3086 mul add neg 1.0 add setgray } BD\n"
              "/W  { setlinewidth } BD\n");
 
  gl2psPrintf("/FC { findfont exch /SH exch def SH scalefont setfont } BD\n"
              "/SW { dup stringwidth pop } BD\n"
              "/S  { FC moveto show } BD\n"
              "/SBC{ FC moveto SW -2 div 0 rmoveto show } BD\n"
              "/SBR{ FC moveto SW neg 0 rmoveto show } BD\n"
              "/SCL{ FC moveto 0 SH -2 div rmoveto show } BD\n"
              "/SCC{ FC moveto SW -2 div SH -2 div rmoveto show } BD\n"
              "/SCR{ FC moveto SW neg SH -2 div rmoveto show } BD\n"
              "/STL{ FC moveto 0 SH neg rmoveto show } BD\n"
              "/STC{ FC moveto SW -2 div SH neg rmoveto show } BD\n"
              "/STR{ FC moveto SW neg SH neg rmoveto show } BD\n");
 
  /* rotated text routines: same nameanem with R appended */
 
  gl2psPrintf("/FCT { FC translate 0 0 } BD\n"
              "/SR  { gsave FCT moveto rotate show grestore } BD\n"
              "/SBCR{ gsave FCT moveto rotate SW -2 div 0 rmoveto show grestore } BD\n"
              "/SBRR{ gsave FCT moveto rotate SW neg 0 rmoveto show grestore } BD\n"
              "/SCLR{ gsave FCT moveto rotate 0 SH -2 div rmoveto show grestore} BD\n");
  gl2psPrintf("/SCCR{ gsave FCT moveto rotate SW -2 div SH -2 div rmoveto show grestore} BD\n"
              "/SCRR{ gsave FCT moveto rotate SW neg SH -2 div rmoveto show grestore} BD\n"
              "/STLR{ gsave FCT moveto rotate 0 SH neg rmoveto show grestore } BD\n"
              "/STCR{ gsave FCT moveto rotate SW -2 div SH neg rmoveto show grestore } BD\n"
              "/STRR{ gsave FCT moveto rotate SW neg SH neg rmoveto show grestore } BD\n");
 
  gl2psPrintf("/P  { newpath 0.0 360.0 arc closepath fill } BD\n"
              "/LS { newpath moveto } BD\n"
              "/L  { lineto } BD\n"
              "/LE { lineto stroke } BD\n"
              "/T  { newpath moveto lineto lineto closepath fill } BD\n");
 
  /* Smooth-shaded triangle with PostScript level 3 shfill operator:
        x3 y3 r3 g3 b3 x2 y2 r2 g2 b2 x1 y1 r1 g1 b1 STshfill */
 
  gl2psPrintf("/STshfill {\n"
              "      /b1 exch def /g1 exch def /r1 exch def /y1 exch def /x1 exch def\n"
              "      /b2 exch def /g2 exch def /r2 exch def /y2 exch def /x2 exch def\n"
              "      /b3 exch def /g3 exch def /r3 exch def /y3 exch def /x3 exch def\n"
              "      gsave << /ShadingType 4 /ColorSpace [/DeviceRGB]\n"
              "      /DataSource [ 0 x1 y1 r1 g1 b1 0 x2 y2 r2 g2 b2 0 x3 y3 r3 g3 b3 ] >>\n"
              "      shfill grestore } BD\n");
 
  /* Flat-shaded triangle with middle color:
        x3 y3 r3 g3 b3 x2 y2 r2 g2 b2 x1 y1 r1 g1 b1 Tm */
 
  gl2psPrintf(/* stack : x3 y3 r3 g3 b3 x2 y2 r2 g2 b2 x1 y1 r1 g1 b1 */
              "/Tm { 3 -1 roll 8 -1 roll 13 -1 roll add add 3 div\n" /* r = (r1+r2+r3)/3 */
              /* stack : x3 y3 g3 b3 x2 y2 g2 b2 x1 y1 g1 b1 r */
              "      3 -1 roll 7 -1 roll 11 -1 roll add add 3 div\n" /* g = (g1+g2+g3)/3 */
              /* stack : x3 y3 b3 x2 y2 b2 x1 y1 b1 r g b */
              "      3 -1 roll 6 -1 roll 9 -1 roll add add 3 div" /* b = (b1+b2+b3)/3 */
              /* stack : x3 y3 x2 y2 x1 y1 r g b */
              " C T } BD\n");
 
  /* Split triangle in four sub-triangles (at sides middle points) and call the
     STnoshfill procedure on each, interpolating the colors in RGB space:
        x3 y3 r3 g3 b3 x2 y2 r2 g2 b2 x1 y1 r1 g1 b1 STsplit
     (in procedure comments key: (Vi) = xi yi ri gi bi) */
 
  gl2psPrintf("/STsplit {\n"
              "      4 index 15 index add 0.5 mul\n" /* x13 = (x1+x3)/2 */
              "      4 index 15 index add 0.5 mul\n" /* y13 = (y1+y3)/2 */
              "      4 index 15 index add 0.5 mul\n" /* r13 = (r1+r3)/2 */
              "      4 index 15 index add 0.5 mul\n" /* g13 = (g1+g3)/2 */
              "      4 index 15 index add 0.5 mul\n" /* b13 = (b1+b3)/2 */
              "      5 copy 5 copy 25 15 roll\n");
 
  /* at his point, stack = (V3) (V13) (V13) (V13) (V2) (V1) */
 
  gl2psPrintf("      9 index 30 index add 0.5 mul\n" /* x23 = (x2+x3)/2 */
              "      9 index 30 index add 0.5 mul\n" /* y23 = (y2+y3)/2 */
              "      9 index 30 index add 0.5 mul\n" /* r23 = (r2+r3)/2 */
              "      9 index 30 index add 0.5 mul\n" /* g23 = (g2+g3)/2 */
              "      9 index 30 index add 0.5 mul\n" /* b23 = (b2+b3)/2 */
              "      5 copy 5 copy 35 5 roll 25 5 roll 15 5 roll\n");
 
  /* stack = (V3) (V13) (V23) (V13) (V23) (V13) (V23) (V2) (V1) */
 
  gl2psPrintf("      4 index 10 index add 0.5 mul\n" /* x12 = (x1+x2)/2 */
              "      4 index 10 index add 0.5 mul\n" /* y12 = (y1+y2)/2 */
              "      4 index 10 index add 0.5 mul\n" /* r12 = (r1+r2)/2 */
              "      4 index 10 index add 0.5 mul\n" /* g12 = (g1+g2)/2 */
              "      4 index 10 index add 0.5 mul\n" /* b12 = (b1+b2)/2 */
              "      5 copy 5 copy 40 5 roll 25 5 roll 15 5 roll 25 5 roll\n");
 
  /* stack = (V3) (V13) (V23) (V13) (V12) (V23) (V13) (V1) (V12) (V23) (V12) (V2) */
 
  gl2psPrintf("      STnoshfill STnoshfill STnoshfill STnoshfill } BD\n");
 
  /* Gouraud shaded triangle using recursive subdivision until the difference
     between corner colors does not exceed the thresholds:
        x3 y3 r3 g3 b3 x2 y2 r2 g2 b2 x1 y1 r1 g1 b1 STnoshfill  */
 
  gl2psPrintf("/STnoshfill {\n"
              "      2 index 8 index sub abs rThreshold gt\n" /* |r1-r2|>rth */
              "      { STsplit }\n"
              "      { 1 index 7 index sub abs gThreshold gt\n" /* |g1-g2|>gth */
              "        { STsplit }\n"
              "        { dup 6 index sub abs bThreshold gt\n" /* |b1-b2|>bth */
              "          { STsplit }\n"
              "          { 2 index 13 index sub abs rThreshold gt\n" /* |r1-r3|>rht */
              "            { STsplit }\n"
              "            { 1 index 12 index sub abs gThreshold gt\n" /* |g1-g3|>gth */
              "              { STsplit }\n"
              "              { dup 11 index sub abs bThreshold gt\n" /* |b1-b3|>bth */
              "                { STsplit }\n"
              "                { 7 index 13 index sub abs rThreshold gt\n"); /* |r2-r3|>rht */
  gl2psPrintf("                  { STsplit }\n"
              "                  { 6 index 12 index sub abs gThreshold gt\n" /* |g2-g3|>gth */
              "                    { STsplit }\n"
              "                    { 5 index 11 index sub abs bThreshold gt\n" /* |b2-b3|>bth */
              "                      { STsplit }\n"
              "                      { Tm }\n" /* all colors sufficiently similar */
              "                      ifelse }\n"
              "                    ifelse }\n"
              "                  ifelse }\n"
              "                ifelse }\n"
              "              ifelse }\n"
              "            ifelse }\n"
              "          ifelse }\n"
              "        ifelse }\n"
              "      ifelse } BD\n");
 
  gl2psPrintf("tryPS3shading\n"
              "{ /shfill where\n"
              "  { /ST { STshfill } BD }\n"
              "  { /ST { STnoshfill } BD }\n"
              "  ifelse }\n"
              "{ /ST { STnoshfill } BD }\n"
              "ifelse\n");
 
  gl2psPrintf("end\n"
              "%%%%EndProlog\n"
              "%%%%BeginSetup\n"
              "/DeviceRGB setcolorspace\n"
              "gl2psdict begin\n"
              "%%%%EndSetup\n"
              "%%%%Page: 1 1\n"
              "%%%%BeginPageSetup\n");
 
  if(gl2ps->options & GL2PS_LANDSCAPE){
    gl2psPrintf("%d 0 translate 90 rotate\n",
                (int)gl2ps->viewport[3]);
  }
 
  gl2psPrintf("%%%%EndPageSetup\n"
              "mark\n"
              "gsave\n"
              "1.0 1.0 scale\n");
 
  if(gl2ps->options & GL2PS_DRAW_BACKGROUND){
    gl2psPrintf("%g %g %g C\n"
                "newpath %d %d moveto %d %d lineto %d %d lineto %d %d lineto\n"
                "closepath fill\n",
                gl2ps->bgcolor[0], gl2ps->bgcolor[1], gl2ps->bgcolor[2],
                (int)gl2ps->viewport[0], (int)gl2ps->viewport[1], (int)gl2ps->viewport[2],
                (int)gl2ps->viewport[1], (int)gl2ps->viewport[2], (int)gl2ps->viewport[3],
                (int)gl2ps->viewport[0], (int)gl2ps->viewport[3]);
  }
}

gl2psPrintPostScriptImagemap()

void gl2psPrintPostScriptImagemap ( GLfloat x, GLfloat y, GLsizei width, GLsizei height, const unsigned char * imagemap )

static

Definition at line 2623 of file gl2ps.cxx.

                                                                       {
  int i, size;
 
  if((width <= 0) || (height <= 0)) return;
 
  size = height + height * (width - 1) / 8;
 
  gl2psPrintf("gsave\n");
  gl2psPrintf("%.2f %.2f translate\n", x, y);
  gl2psPrintf("%d %d scale\n%d %d\ntrue\n", width, height,width, height);
  gl2psPrintf("[ %d 0 0 -%d 0 %d ] {<", width, height);
  for(i = 0; i < size; i++){
    gl2psWriteByte(*imagemap);
    imagemap++;
  }
  gl2psPrintf(">} imagemask\ngrestore\n");
}

gl2psPrintPostScriptPixmap()

void gl2psPrintPostScriptPixmap ( GLfloat x, GLfloat y, GL2PSimage * im )

static

Definition at line 2415 of file gl2ps.cxx.

{
  GLuint nbhex, nbyte, nrgb, nbits;
  GLuint row, col, ibyte, icase;
  GLfloat dr, dg, db, fgrey;
  unsigned char red = 0, green = 0, blue = 0, b, grey;
  GLuint width = (GLuint)im->width;
  GLuint height = (GLuint)im->height;
 
  /* FIXME: should we define an option for these? Or just keep the
     8-bit per component case? */
 
  //TK: coverity does not like how we hardcode some options here but
  //keep the code below. But since this is some complex code lifted
  //from somewhere else, we want to keep it that way at the moment:
 
  const int greyscale = 0; /* set to 1 to output greyscale image */
  const int nbit = 8; /* number of bits per color compoment (2, 4 or 8) */
 
  if((width <= 0) || (height <= 0)) return;
 
  gl2psPrintf("gsave\n");
  gl2psPrintf("%.2f %.2f translate\n", x, y);
  gl2psPrintf("%d %d scale\n", width, height);
 
  if(greyscale){ /* greyscale */
    //coverity[DEADCODE]
    gl2psPrintf("/picstr %d string def\n", width);
    gl2psPrintf("%d %d %d\n", width, height, 8);
    gl2psPrintf("[ %d 0 0 -%d 0 %d ]\n", width, height, height);
    gl2psPrintf("{ currentfile picstr readhexstring pop }\n");
    gl2psPrintf("image\n");
    for(row = 0; row < height; row++){
      for(col = 0; col < width; col++){
        gl2psGetRGB(im, col, row, &dr, &dg, &db);
        fgrey = (0.30F * dr + 0.59F * dg + 0.11F * db);
        grey = (unsigned char)(255. * fgrey);
        gl2psWriteByte(grey);
      }
      gl2psPrintf("\n");
    }
    nbhex = width * height * 2;
    gl2psPrintf("%%%% nbhex digit          :%d\n", nbhex);
  }
  else if(nbit == 2){ /* color, 2 bits for r and g and b; rgbs following each other */
    //coverity[DEADCODE]
    nrgb = width  * 3;
    nbits = nrgb * nbit;
    nbyte = nbits / 8;
    if((nbyte * 8) != nbits) nbyte++;
    gl2psPrintf("/rgbstr %d string def\n", nbyte);
    gl2psPrintf("%d %d %d\n", width, height, nbit);
    gl2psPrintf("[ %d 0 0 -%d 0 %d ]\n", width, height, height);
    gl2psPrintf("{ currentfile rgbstr readhexstring pop }\n");
    gl2psPrintf("false 3\n");
    gl2psPrintf("colorimage\n");
    for(row = 0; row < height; row++){
      icase = 1;
      col = 0;
      b = 0;
      for(ibyte = 0; ibyte < nbyte; ibyte++){
        if(icase == 1) {
          if(col < width) {
            gl2psGetRGB(im, col, row, &dr, &dg, &db);
          }
          else {
            dr = dg = db = 0;
          }
          col++;
          red = (unsigned char)(3. * dr);
          green = (unsigned char)(3. * dg);
          blue = (unsigned char)(3. * db);
          b = red;
          b = (b<<2) + green;
          b = (b<<2) + blue;
          if(col < width) {
            gl2psGetRGB(im, col, row, &dr, &dg, &db);
          }
          else {
            dr = dg = db = 0;
          }
          col++;
          red = (unsigned char)(3. * dr);
          green = (unsigned char)(3. * dg);
          blue = (unsigned char)(3. * db);
          b = (b<<2) + red;
          gl2psWriteByte(b);
          b = 0;
          icase++;
        }
        else if(icase == 2) {
          b = green;
          b = (b<<2) + blue;
          if(col < width) {
            gl2psGetRGB(im, col, row, &dr, &dg, &db);
          }
          else {
            dr = dg = db = 0;
          }
          col++;
          red = (unsigned char)(3. * dr);
          green = (unsigned char)(3. * dg);
          blue = (unsigned char)(3. * db);
          b = (b<<2) + red;
          b = (b<<2) + green;
          gl2psWriteByte(b);
          b = 0;
          icase++;
        }
        else if(icase == 3) {
          b = blue;
          if(col < width) {
            gl2psGetRGB(im, col, row, &dr, &dg, &db);
          }
          else {
            dr = dg = db = 0;
          }
          col++;
          red = (unsigned char)(3. * dr);
          green = (unsigned char)(3. * dg);
          blue = (unsigned char)(3. * db);
          b = (b<<2) + red;
          b = (b<<2) + green;
          b = (b<<2) + blue;
          gl2psWriteByte(b);
          b = 0;
          icase = 1;
        }
      }
      gl2psPrintf("\n");
    }
  }
  else if(nbit == 4){ /* color, 4 bits for r and g and b; rgbs following each other */
    nrgb = width  * 3;
    nbits = nrgb * nbit;
    nbyte = nbits / 8;
    if((nbyte * 8) != nbits) nbyte++;
    gl2psPrintf("/rgbstr %d string def\n", nbyte);
    gl2psPrintf("%d %d %d\n", width, height, nbit);
    gl2psPrintf("[ %d 0 0 -%d 0 %d ]\n", width, height, height);
    gl2psPrintf("{ currentfile rgbstr readhexstring pop }\n");
    gl2psPrintf("false 3\n");
    gl2psPrintf("colorimage\n");
    for(row = 0; row < height; row++){
      col = 0;
      icase = 1;
      for(ibyte = 0; ibyte < nbyte; ibyte++){
        if(icase == 1) {
          if(col < width) {
            gl2psGetRGB(im, col, row, &dr, &dg, &db);
          }
          else {
            dr = dg = db = 0;
          }
          col++;
          red = (unsigned char)(15. * dr);
          green = (unsigned char)(15. * dg);
          gl2psPrintf("%x%x", red, green);
          icase++;
        }
        else if(icase == 2) {
          blue = (unsigned char)(15. * db);
          if(col < width) {
            gl2psGetRGB(im, col, row, &dr, &dg, &db);
          }
          else {
            dr = dg = db = 0;
          }
          col++;
          red = (unsigned char)(15. * dr);
          gl2psPrintf("%x%x", blue, red);
          icase++;
        }
        else if(icase == 3) {
          green = (unsigned char)(15. * dg);
          blue = (unsigned char)(15. * db);
          gl2psPrintf("%x%x", green, blue);
          icase = 1;
        }
      }
      gl2psPrintf("\n");
    }
  }
  else{ /* 8 bit for r and g and b */
    nbyte = width * 3;
    gl2psPrintf("/rgbstr %d string def\n", nbyte);
    gl2psPrintf("%d %d %d\n", width, height, 8);
    gl2psPrintf("[ %d 0 0 -%d 0 %d ]\n", width, height, height);
    gl2psPrintf("{ currentfile rgbstr readhexstring pop }\n");
    gl2psPrintf("false 3\n");
    gl2psPrintf("colorimage\n");
    for(row = 0; row < height; row++){
      for(col = 0; col < width; col++){
        gl2psGetRGB(im, col, row, &dr, &dg, &db);
        red = (unsigned char)(255. * dr);
        gl2psWriteByte(red);
        green = (unsigned char)(255. * dg);
        gl2psWriteByte(green);
        blue = (unsigned char)(255. * db);
        gl2psWriteByte(blue);
      }
      gl2psPrintf("\n");
    }
  }
 
  gl2psPrintf("grestore\n");
}

gl2psPrintPostScriptPrimitive()

void gl2psPrintPostScriptPrimitive ( void * data )

static

Definition at line 2967 of file gl2ps.cxx.

{
  int newline;
  GL2PSprimitive *prim;
 
  prim = *(GL2PSprimitive**)data;
 
  if((gl2ps->options & GL2PS_OCCLUSION_CULL) && prim->culled) return;
 
  /* Every effort is made to draw lines as connected segments (i.e.,
     using a single PostScript path): this is the only way to get nice
     line joins and to not restart the stippling for every line
     segment. So if the primitive to print is not a line we must first
     finish the current line (if any): */
  if(prim->type != GL2PS_LINE) gl2psEndPostScriptLine();
 
  switch(prim->type){
  case GL2PS_POINT :
    gl2psPrintPostScriptColor(prim->verts[0].rgba);
    gl2psPrintf("%g %g %g P\n",
                prim->verts[0].xyz[0], prim->verts[0].xyz[1], 0.5 * prim->width);
    break;
  case GL2PS_LINE :
    if(!gl2psSamePosition(gl2ps->lastvertex.xyz, prim->verts[0].xyz) ||
       !gl2psSameColor(gl2ps->lastrgba, prim->verts[0].rgba) ||
       gl2ps->lastlinewidth != prim->width ||
       gl2ps->lastpattern != prim->pattern ||
       gl2ps->lastfactor != prim->factor){
      /* End the current line if the new segment does not start where
         the last one ended, or if the color, the width or the
         stippling have changed (multi-stroking lines with changing
         colors is necessary until we use /shfill for lines;
         unfortunately this means that at the moment we can screw up
         line stippling for smooth-shaded lines) */
      gl2psEndPostScriptLine();
      newline = 1;
    }
    else{
      newline = 0;
    }
    if(gl2ps->lastlinewidth != prim->width){
      gl2ps->lastlinewidth = prim->width;
      gl2psPrintf("%g W\n", gl2ps->lastlinewidth);
    }
    gl2psPrintPostScriptDash(prim->pattern, prim->factor, "setdash");
    gl2psPrintPostScriptColor(prim->verts[0].rgba);
    gl2psPrintf("%g %g %s\n", prim->verts[0].xyz[0], prim->verts[0].xyz[1],
                newline ? "LS" : "L");
    gl2ps->lastvertex = prim->verts[1];
    break;
  case GL2PS_TRIANGLE :
    if(!gl2psVertsSameColor(prim)){
      gl2psResetPostScriptColor();
      gl2psPrintf("%g %g %g %g %g %g %g %g %g %g %g %g %g %g %g ST\n",
                  prim->verts[2].xyz[0], prim->verts[2].xyz[1],
                  prim->verts[2].rgba[0], prim->verts[2].rgba[1],
                  prim->verts[2].rgba[2], prim->verts[1].xyz[0],
                  prim->verts[1].xyz[1], prim->verts[1].rgba[0],
                  prim->verts[1].rgba[1], prim->verts[1].rgba[2],
                  prim->verts[0].xyz[0], prim->verts[0].xyz[1],
                  prim->verts[0].rgba[0], prim->verts[0].rgba[1],
                  prim->verts[0].rgba[2]);
    }
    else{
      gl2psPrintPostScriptColor(prim->verts[0].rgba);
      gl2psPrintf("%g %g %g %g %g %g T\n",
                  prim->verts[2].xyz[0], prim->verts[2].xyz[1],
                  prim->verts[1].xyz[0], prim->verts[1].xyz[1],
                  prim->verts[0].xyz[0], prim->verts[0].xyz[1]);
    }
    break;
  case GL2PS_QUADRANGLE :
    gl2psMsg(GL2PS_WARNING, "There should not be any quad left to print");
    break;
  case GL2PS_PIXMAP :
    gl2psPrintPostScriptPixmap(prim->verts[0].xyz[0], prim->verts[0].xyz[1],
                               prim->data.image);
    break;
  case GL2PS_IMAGEMAP :
    if(prim->data.image->type != GL2PS_IMAGEMAP_WRITTEN){
      gl2psPrintPostScriptColor(prim->verts[0].rgba);
      gl2psPrintPostScriptImagemap(prim->data.image->pixels[0],
                                   prim->data.image->pixels[1],
                                   prim->data.image->width, prim->data.image->height,
                                   reinterpret_cast<const unsigned char*>(&(prim->data.image->pixels[2])));
      prim->data.image->type = GL2PS_IMAGEMAP_WRITTEN;
    }
    break;
  case GL2PS_TEXT :
    gl2psPrintPostScriptColor(prim->verts[0].rgba);
    gl2psPrintf("(%s) ", prim->data.text->str);
    if(prim->data.text->angle)
      gl2psPrintf("%g ", prim->data.text->angle);
    gl2psPrintf("%g %g %d /%s ",
                prim->verts[0].xyz[0], prim->verts[0].xyz[1],
                prim->data.text->fontsize, prim->data.text->fontname);
    switch(prim->data.text->alignment){
    case GL2PS_TEXT_C:
      gl2psPrintf(prim->data.text->angle ? "SCCR\n" : "SCC\n");
      break;
    case GL2PS_TEXT_CL:
      gl2psPrintf(prim->data.text->angle ? "SCLR\n" : "SCL\n");
      break;
    case GL2PS_TEXT_CR:
      gl2psPrintf(prim->data.text->angle ? "SCRR\n" : "SCR\n");
      break;
    case GL2PS_TEXT_B:
      gl2psPrintf(prim->data.text->angle ? "SBCR\n" : "SBC\n");
      break;
    case GL2PS_TEXT_BR:
      gl2psPrintf(prim->data.text->angle ? "SBRR\n" : "SBR\n");
      break;
    case GL2PS_TEXT_T:
      gl2psPrintf(prim->data.text->angle ? "STCR\n" : "STC\n");
      break;
    case GL2PS_TEXT_TL:
      gl2psPrintf(prim->data.text->angle ? "STLR\n" : "STL\n");
      break;
    case GL2PS_TEXT_TR:
      gl2psPrintf(prim->data.text->angle ? "STRR\n" : "STR\n");
      break;
    case GL2PS_TEXT_BL:
    default:
      gl2psPrintf(prim->data.text->angle ? "SR\n" : "S\n");
      break;
    }
    break;
  case GL2PS_SPECIAL :
    /* alignment contains the format for which the special output text
       is intended */
    if(prim->data.text->alignment == GL2PS_PS ||
       prim->data.text->alignment == GL2PS_EPS)
      gl2psPrintf("%s\n", prim->data.text->str);
    break;
  default :
    break;
  }
}

gl2psPrintPrimitives()

GLint gl2psPrintPrimitives ( void )

static

Definition at line 5504 of file gl2ps.cxx.

{
  GL2PSbsptree *root;
  GL2PSxyz eye = {0.0F, 0.0F, 100.0F * GL2PS_ZSCALE};
  GLint used;
 
  used = glRenderMode(GL_RENDER);
 
  if(used < 0){
    gl2psMsg(GL2PS_INFO, "OpenGL feedback buffer overflow");
    return GL2PS_OVERFLOW;
  }
 
  if(used > 0)
    gl2psParseFeedbackBuffer(used);
 
  gl2psRescaleAndOffset();
 
  if(gl2ps->header){
    if(gl2psListNbr(gl2ps->primitives) &&
       (gl2ps->options & GL2PS_TIGHT_BOUNDING_BOX)){
      gl2ps->viewport[0] = gl2ps->viewport[1] = 100000;
      gl2ps->viewport[2] = gl2ps->viewport[3] = -100000;
      gl2psListAction(gl2ps->primitives, gl2psComputeTightBoundingBox);
    }
    (gl2psbackends[gl2ps->format]->printHeader)();
    gl2ps->header = GL_FALSE;
  }
 
  if(!gl2psListNbr(gl2ps->primitives)){
    /* empty feedback buffer and/or nothing else to print */
    return GL2PS_NO_FEEDBACK;
  }
 
  switch(gl2ps->sort){
  case GL2PS_NO_SORT :
    gl2psListAction(gl2ps->primitives, gl2psbackends[gl2ps->format]->printPrimitive);
    gl2psListAction(gl2ps->primitives, gl2psFreePrimitive);
    /* reset the primitive list, waiting for the next viewport */
    gl2psListReset(gl2ps->primitives);
    break;
  case GL2PS_SIMPLE_SORT :
    gl2psListSort(gl2ps->primitives, gl2psCompareDepth);
    if(gl2ps->options & GL2PS_OCCLUSION_CULL){
      gl2psListActionInverse(gl2ps->primitives, gl2psAddInImageTree);
      gl2psFreeBspImageTree(&gl2ps->imagetree);
    }
    gl2psListAction(gl2ps->primitives, gl2psbackends[gl2ps->format]->printPrimitive);
    gl2psListAction(gl2ps->primitives, gl2psFreePrimitive);
    /* reset the primitive list, waiting for the next viewport */
    gl2psListReset(gl2ps->primitives);
    break;
  case GL2PS_BSP_SORT :
    root = (GL2PSbsptree*)gl2psMalloc(sizeof(GL2PSbsptree));
    gl2psBuildBspTree(root, gl2ps->primitives);
    if(GL_TRUE == gl2ps->boundary) gl2psBuildPolygonBoundary(root);
    if(gl2ps->options & GL2PS_OCCLUSION_CULL){
      gl2psTraverseBspTree(root, eye, -GL2PS_EPSILON, gl2psLess,
                           gl2psAddInImageTree, 1);
      gl2psFreeBspImageTree(&gl2ps->imagetree);
    }
    gl2psTraverseBspTree(root, eye, GL2PS_EPSILON, gl2psGreater,
                         gl2psbackends[gl2ps->format]->printPrimitive, 0);
    gl2psFreeBspTree(&root);
    /* reallocate the primitive list (it's been deleted by
       gl2psBuildBspTree) in case there is another viewport */
    gl2ps->primitives = gl2psListCreate(500, 500, sizeof(GL2PSprimitive*));
    break;
  }
  gl2psbackends[gl2ps->format]->printFinalPrimitive();
 
  return GL2PS_SUCCESS;
}

gl2psPrintSVGBeginViewport()

void gl2psPrintSVGBeginViewport ( GLint viewport[4] )

static

Definition at line 5172 of file gl2ps.cxx.

{
  GLint index;
  char col[32];
  GLfloat rgba[4];
  int x = viewport[0], y = viewport[1], w = viewport[2], h = viewport[3];
 
  glRenderMode(GL_FEEDBACK);
 
  if(gl2ps->header){
    gl2psPrintSVGHeader();
    gl2ps->header = GL_FALSE;
  }
 
  if(gl2ps->options & GL2PS_DRAW_BACKGROUND){
    if(gl2ps->colormode == GL_RGBA || gl2ps->colorsize == 0){
      glGetFloatv(GL_COLOR_CLEAR_VALUE, rgba);
    }
    else{
      glGetIntegerv(GL_INDEX_CLEAR_VALUE, &index);
      rgba[0] = gl2ps->colormap[index][0];
      rgba[1] = gl2ps->colormap[index][1];
      rgba[2] = gl2ps->colormap[index][2];
      rgba[3] = 1.0F;
    }
    gl2psSVGGetColorString(rgba, col);
    gl2psPrintf("<polygon fill=\"%s\" points=\"%d,%d %d,%d %d,%d %d,%d\"/>\n", col,
                x, gl2ps->viewport[3] - y,
                x + w, gl2ps->viewport[3] - y,
                x + w, gl2ps->viewport[3] - (y + h),
                x, gl2ps->viewport[3] - (y + h));
  }
 
  gl2psPrintf("<clipPath id=\"cp%d%d%d%d\">\n", x, y, w, h);
  gl2psPrintf("  <polygon points=\"%d,%d %d,%d %d,%d %d,%d\"/>\n",
              x, gl2ps->viewport[3] - y,
              x + w, gl2ps->viewport[3] - y,
              x + w, gl2ps->viewport[3] - (y + h),
              x, gl2ps->viewport[3] - (y + h));
  gl2psPrintf("</clipPath>\n");
  gl2psPrintf("<g clip-path=\"url(#cp%d%d%d%d)\">\n", x, y, w, h);
}

gl2psPrintSVGDash()

void gl2psPrintSVGDash ( GLushort pattern, GLint factor )

static

Definition at line 4986 of file gl2ps.cxx.

{
  int i, n, array[10];
 
  if(!pattern || !factor) return; /* solid line */
 
  gl2psParseStipplePattern(pattern, factor, &n, array);
  gl2psPrintf("stroke-dasharray=\"");
  for(i = 0; i < n; i++){
    if(i) gl2psPrintf(",");
    gl2psPrintf("%d", array[i]);
  }
  gl2psPrintf("\" ");
}

gl2psPrintSVGEndViewport()

GLint gl2psPrintSVGEndViewport ( void )

static

Definition at line 5215 of file gl2ps.cxx.

{
  GLint res;
 
  res = gl2psPrintPrimitives();
  gl2psPrintf("</g>\n");
  return res;
}

gl2psPrintSVGFinalPrimitive()

void gl2psPrintSVGFinalPrimitive ( void )

static

Definition at line 5224 of file gl2ps.cxx.

{
  /* End any remaining line, if any */
  gl2psEndSVGLine();
}

gl2psPrintSVGFooter()

void gl2psPrintSVGFooter ( void )

static

Definition at line 5164 of file gl2ps.cxx.

{
  gl2psPrintf("</g>\n");
  gl2psPrintf("</svg>\n");
 
  gl2psPrintGzipFooter();
}

gl2psPrintSVGHeader()

void gl2psPrintSVGHeader ( void )

static

Definition at line 4866 of file gl2ps.cxx.

{
  int x, y, width, height;
  char col[32];
  time_t now;
 
  time(&now);
 
  if (gl2ps->options & GL2PS_LANDSCAPE){
    x = (int)gl2ps->viewport[1];
    y = (int)gl2ps->viewport[0];
    width = (int)gl2ps->viewport[3];
    height = (int)gl2ps->viewport[2];
  }
  else{
    x = (int)gl2ps->viewport[0];
    y = (int)gl2ps->viewport[1];
    width = (int)gl2ps->viewport[2];
    height = (int)gl2ps->viewport[3];
  }
 
  /* Compressed SVG files (.svgz) are simply gzipped SVG files */
  gl2psPrintGzipHeader();
 
  gl2psPrintf("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n");
  gl2psPrintf("<svg xmlns=\"http://www.w3.org/2000/svg\"\n");
  gl2psPrintf("     xmlns:xlink=\"http://www.w3.org/1999/xlink\"\n"
              "     width=\"%dpx\" height=\"%dpx\" viewBox=\"%d %d %d %d\">\n",
              width, height, x, y, width, height);
  gl2psPrintf("<title>%s</title>\n", gl2ps->title);
  gl2psPrintf("<desc>\n");
  gl2psPrintf("Creator: GL2PS %d.%d.%d%s, %s\n"
              "For: %s\n"
              "CreationDate: %s",
              GL2PS_MAJOR_VERSION, GL2PS_MINOR_VERSION, GL2PS_PATCH_VERSION,
              GL2PS_EXTRA_VERSION, GL2PS_COPYRIGHT, gl2ps->producer, ctime(&now));
  gl2psPrintf("</desc>\n");
  gl2psPrintf("<defs>\n");
  gl2psPrintf("</defs>\n");
 
  if(gl2ps->options & GL2PS_DRAW_BACKGROUND){
    gl2psSVGGetColorString(gl2ps->bgcolor, col);
    gl2psPrintf("<polygon fill=\"%s\" points=\"%d,%d %d,%d %d,%d %d,%d\"/>\n", col,
                (int)gl2ps->viewport[0], (int)gl2ps->viewport[1],
                (int)gl2ps->viewport[2], (int)gl2ps->viewport[1],
                (int)gl2ps->viewport[2], (int)gl2ps->viewport[3],
                (int)gl2ps->viewport[0], (int)gl2ps->viewport[3]);
  }
 
  /* group all the primitives and disable antialiasing */
  gl2psPrintf("<g shape-rendering=\"crispEdges\">\n");
}

gl2psPrintSVGPixmap()

void gl2psPrintSVGPixmap ( GLfloat , GLfloat , GL2PSimage *  )

static

Definition at line 5014 of file gl2ps.cxx.

{
#if defined(GL2PS_HAVE_LIBPNG)
  GL2PSlist *png;
  unsigned char c;
  int i;
 
  /* The only image types supported by the SVG standard are JPEG, PNG
     and SVG. Here we choose PNG, and since we want to embed the image
     directly in the SVG stream (and not link to an external image
     file), we need to encode the pixmap into PNG in memory, then
     encode it into base64. */
 
  png = gl2psListCreate(pixmap->width * pixmap->height * 3, 1000,
                        sizeof(unsigned char));
  gl2psConvertPixmapToPNG(pixmap, png);
  gl2psListEncodeBase64(png);
  gl2psPrintf("<image x=\"%g\" y=\"%g\" width=\"%d\" height=\"%d\"\n",
              x, y - pixmap->height, pixmap->width, pixmap->height);
  gl2psPrintf("xlink:href=\"data:image/png;base64,");
  for(i = 0; i < gl2psListNbr(png); i++){
    gl2psListRead(png, i, &c);
    gl2psPrintf("%c", c);
  }
  gl2psPrintf("\"/>\n");
  gl2psListDelete(png);
#else
  gl2psMsg(GL2PS_WARNING, "GL2PS must be compiled with PNG support in "
           "order to embed images in SVG streams");
#endif
}

gl2psPrintSVGPrimitive()

void gl2psPrintSVGPrimitive ( void * data )

static

Definition at line 5053 of file gl2ps.cxx.

{
  GL2PSprimitive *prim;
  GL2PSxyz xyz[4];
  GL2PSrgba rgba[4];
  char col[32];
  int newline;
 
  prim = *(GL2PSprimitive**)data;
 
  if((gl2ps->options & GL2PS_OCCLUSION_CULL) && prim->culled) return;
 
  /* We try to draw connected lines as a single path to get nice line
     joins and correct stippling. So if the primitive to print is not
     a line we must first finish the current line (if any): */
  if(prim->type != GL2PS_LINE) gl2psEndSVGLine();
 
  gl2psSVGGetCoordsAndColors(prim->numverts, prim->verts, xyz, rgba);
 
  switch(prim->type){
  case GL2PS_POINT :
    gl2psSVGGetColorString(rgba[0], col);
    gl2psPrintf("<circle fill=\"%s\" ", col);
    if(rgba[0][3] < 1.0F) gl2psPrintf("fill-opacity=\"%g\" ", rgba[0][3]);
    gl2psPrintf("cx=\"%g\" cy=\"%g\" r=\"%g\"/>\n",
                xyz[0][0], xyz[0][1], 0.5 * prim->width);
    break;
  case GL2PS_LINE :
    if(!gl2psSamePosition(gl2ps->lastvertex.xyz, prim->verts[0].xyz) ||
       !gl2psSameColor(gl2ps->lastrgba, prim->verts[0].rgba) ||
       gl2ps->lastlinewidth != prim->width ||
       gl2ps->lastpattern != prim->pattern ||
       gl2ps->lastfactor != prim->factor){
      /* End the current line if the new segment does not start where
         the last one ended, or if the color, the width or the
         stippling have changed (we will need to use multi-point
         gradients for smooth-shaded lines) */
      gl2psEndSVGLine();
      newline = 1;
    }
    else{
      newline = 0;
    }
    gl2ps->lastvertex = prim->verts[1];
    gl2psSetLastColor(prim->verts[0].rgba);
    gl2ps->lastlinewidth = prim->width;
    gl2ps->lastpattern = prim->pattern;
    gl2ps->lastfactor = prim->factor;
    if(newline){
      gl2psSVGGetColorString(rgba[0], col);
      gl2psPrintf("<polyline fill=\"none\" stroke=\"%s\" stroke-width=\"%g\" ",
                  col, prim->width);
      if(rgba[0][3] < 1.0F) gl2psPrintf("stroke-opacity=\"%g\" ", rgba[0][3]);
      gl2psPrintSVGDash(prim->pattern, prim->factor);
      gl2psPrintf("points=\"%g,%g ", xyz[0][0], xyz[0][1]);
    }
    else{
      gl2psPrintf("%g,%g ", xyz[0][0], xyz[0][1]);
    }
    break;
  case GL2PS_TRIANGLE :
    gl2psPrintSVGSmoothTriangle(xyz, rgba);
    break;
  case GL2PS_QUADRANGLE :
    gl2psMsg(GL2PS_WARNING, "There should not be any quad left to print");
    break;
  case GL2PS_PIXMAP :
    gl2psPrintSVGPixmap(xyz[0][0], xyz[0][1], prim->data.image);
    break;
  case GL2PS_TEXT :
    gl2psSVGGetColorString(prim->verts[0].rgba, col);
    gl2psPrintf("<text fill=\"%s\" x=\"%g\" y=\"%g\" font-size=\"%d\" ",
                col, xyz[0][0], xyz[0][1], prim->data.text->fontsize);
    if(prim->data.text->angle)
      gl2psPrintf("transform=\"rotate(%g, %g, %g)\" ",
                  -prim->data.text->angle, xyz[0][0], xyz[0][1]);
    if(!strcmp(prim->data.text->fontname, "Times-Roman"))
      gl2psPrintf("font-family=\"Times\">");
    else if(!strcmp(prim->data.text->fontname, "Times-Bold"))
      gl2psPrintf("font-family=\"Times\" font-weight=\"bold\">");
    else if(!strcmp(prim->data.text->fontname, "Times-Italic"))
      gl2psPrintf("font-family=\"Times\" font-style=\"italic\">");
    else if(!strcmp(prim->data.text->fontname, "Times-BoldItalic"))
      gl2psPrintf("font-family=\"Times\" font-style=\"italic\" font-weight=\"bold\">");
    else if(!strcmp(prim->data.text->fontname, "Helvetica-Bold"))
      gl2psPrintf("font-family=\"Helvetica\" font-weight=\"bold\">");
    else if(!strcmp(prim->data.text->fontname, "Helvetica-Oblique"))
      gl2psPrintf("font-family=\"Helvetica\" font-style=\"oblique\">");
    else if(!strcmp(prim->data.text->fontname, "Helvetica-BoldOblique"))
      gl2psPrintf("font-family=\"Helvetica\" font-style=\"oblique\" font-weight=\"bold\">");
    else if(!strcmp(prim->data.text->fontname, "Courier-Bold"))
      gl2psPrintf("font-family=\"Courier\" font-weight=\"bold\">");
    else if(!strcmp(prim->data.text->fontname, "Courier-Oblique"))
      gl2psPrintf("font-family=\"Courier\" font-style=\"oblique\">");
    else if(!strcmp(prim->data.text->fontname, "Courier-BoldOblique"))
      gl2psPrintf("font-family=\"Courier\" font-style=\"oblique\" font-weight=\"bold\">");
    else
      gl2psPrintf("font-family=\"%s\">", prim->data.text->fontname);
    gl2psPrintf("%s</text>\n", prim->data.text->str);
    break;
  case GL2PS_SPECIAL :
    /* alignment contains the format for which the special output text
       is intended */
    if(prim->data.text->alignment == GL2PS_SVG)
      gl2psPrintf("%s\n", prim->data.text->str);
    break;
  default :
    break;
  }
}

gl2psPrintSVGSmoothTriangle()

void gl2psPrintSVGSmoothTriangle ( GL2PSxyz xyz[3], GL2PSrgba rgba[3] )

static

Definition at line 4919 of file gl2ps.cxx.

{
  int i;
  GL2PSxyz xyz2[3];
  GL2PSrgba rgba2[3];
  char col[32];
 
  /* Apparently there is no easy way to do Gouraud shading in SVG
     without explicitly pre-defining gradients, so for now we just do
     recursive subdivision */
 
  if(gl2psSameColorThreshold(3, rgba, gl2ps->threshold)){
    gl2psSVGGetColorString(rgba[0], col);
    gl2psPrintf("<polygon fill=\"%s\" ", col);
    if(rgba[0][3] < 1.0F) gl2psPrintf("fill-opacity=\"%g\" ", rgba[0][3]);
    gl2psPrintf("points=\"%g,%g %g,%g %g,%g\"/>\n", xyz[0][0], xyz[0][1],
                xyz[1][0], xyz[1][1], xyz[2][0], xyz[2][1]);
  }
  else{
    /* subdivide into 4 subtriangles */
    for(i = 0; i < 3; i++){
      xyz2[0][i] = xyz[0][i];
      xyz2[1][i] = 0.5F * (xyz[0][i] + xyz[1][i]);
      xyz2[2][i] = 0.5F * (xyz[0][i] + xyz[2][i]);
    }
    for(i = 0; i < 4; i++){
      rgba2[0][i] = rgba[0][i];
      rgba2[1][i] = 0.5F * (rgba[0][i] + rgba[1][i]);
      rgba2[2][i] = 0.5F * (rgba[0][i] + rgba[2][i]);
    }
    gl2psPrintSVGSmoothTriangle(xyz2, rgba2);
    for(i = 0; i < 3; i++){
      xyz2[0][i] = 0.5F * (xyz[0][i] + xyz[1][i]);
      xyz2[1][i] = xyz[1][i];
      xyz2[2][i] = 0.5F * (xyz[1][i] + xyz[2][i]);
    }
    for(i = 0; i < 4; i++){
      rgba2[0][i] = 0.5F * (rgba[0][i] + rgba[1][i]);
      rgba2[1][i] = rgba[1][i];
      rgba2[2][i] = 0.5F * (rgba[1][i] + rgba[2][i]);
    }
    gl2psPrintSVGSmoothTriangle(xyz2, rgba2);
    for(i = 0; i < 3; i++){
      xyz2[0][i] = 0.5F * (xyz[0][i] + xyz[2][i]);
      xyz2[1][i] = xyz[2][i];
      xyz2[2][i] = 0.5F * (xyz[1][i] + xyz[2][i]);
    }
    for(i = 0; i < 4; i++){
      rgba2[0][i] = 0.5F * (rgba[0][i] + rgba[2][i]);
      rgba2[1][i] = rgba[2][i];
      rgba2[2][i] = 0.5F * (rgba[1][i] + rgba[2][i]);
    }
    gl2psPrintSVGSmoothTriangle(xyz2, rgba2);
    for(i = 0; i < 3; i++){
      xyz2[0][i] = 0.5F * (xyz[0][i] + xyz[1][i]);
      xyz2[1][i] = 0.5F * (xyz[1][i] + xyz[2][i]);
      xyz2[2][i] = 0.5F * (xyz[0][i] + xyz[2][i]);
    }
    for(i = 0; i < 4; i++){
      rgba2[0][i] = 0.5F * (rgba[0][i] + rgba[1][i]);
      rgba2[1][i] = 0.5F * (rgba[1][i] + rgba[2][i]);
      rgba2[2][i] = 0.5F * (rgba[0][i] + rgba[2][i]);
    }
    gl2psPrintSVGSmoothTriangle(xyz2, rgba2);
  }
}

gl2psPrintTeXBeginViewport()

void gl2psPrintTeXBeginViewport ( GLint viewport[4] )

static

Definition at line 3313 of file gl2ps.cxx.

{
  GLint a  __attribute__((unused)) = viewport[0];
  glRenderMode(GL_FEEDBACK);
 
  if(gl2ps->header){
    gl2psPrintTeXHeader();
    gl2ps->header = GL_FALSE;
  }
}

gl2psPrintTeXEndViewport()

GLint gl2psPrintTeXEndViewport ( void )

static

Definition at line 3324 of file gl2ps.cxx.

{
  return gl2psPrintPrimitives();
}

gl2psPrintTeXFinalPrimitive()

void gl2psPrintTeXFinalPrimitive ( void )

static

Definition at line 3329 of file gl2ps.cxx.

{
}

gl2psPrintTeXFooter()

void gl2psPrintTeXFooter ( void )

static

Definition at line 3307 of file gl2ps.cxx.

{
  fprintf(gl2ps->stream, "\\end{picture}%s\n",
          (gl2ps->options & GL2PS_LANDSCAPE) ? "}" : "");
}

gl2psPrintTeXHeader()

void gl2psPrintTeXHeader ( void )

static

Definition at line 3204 of file gl2ps.cxx.

{
  char name[256];
  time_t now;
  int i;
 
  if(gl2ps->filename && strlen(gl2ps->filename) < 256){
    for(i = strlen(gl2ps->filename)-1; i >= 0; i--){
      if(gl2ps->filename[i] == '.'){
        strncpy(name, gl2ps->filename, i);
        name[i] = '\0';
        break;
      }
    }
    if(i <= 0) strcpy(name, gl2ps->filename);
  }
  else{
    strcpy(name, "untitled");
  }
 
  time(&now);
 
  fprintf(gl2ps->stream,
          "%% Title: %s\n"
          "%% Creator: GL2PS %d.%d.%d%s, %s\n"
          "%% For: %s\n"
          "%% CreationDate: %s",
          gl2ps->title, GL2PS_MAJOR_VERSION, GL2PS_MINOR_VERSION,
          GL2PS_PATCH_VERSION, GL2PS_EXTRA_VERSION, GL2PS_COPYRIGHT,
          gl2ps->producer, ctime(&now));
 
  fprintf(gl2ps->stream,
          "\\setlength{\\unitlength}{1pt}\n"
          "\\begin{picture}(0,0)\n"
          "\\includegraphics{%s}\n"
          "\\end{picture}%%\n"
          "%s\\begin{picture}(%d,%d)(0,0)\n",
          name, (gl2ps->options & GL2PS_LANDSCAPE) ? "\\rotatebox{90}{" : "",
          (int)gl2ps->viewport[2], (int)gl2ps->viewport[3]);
}

gl2psPrintTeXPrimitive()

void gl2psPrintTeXPrimitive ( void * data )

static

Definition at line 3245 of file gl2ps.cxx.

{
  GL2PSprimitive *prim;
 
  prim = *(GL2PSprimitive**)data;
 
  switch(prim->type){
  case GL2PS_TEXT :
    fprintf(gl2ps->stream, "\\fontsize{%d}{0}\n\\selectfont",
            prim->data.text->fontsize);
    fprintf(gl2ps->stream, "\\put(%g,%g){\\makebox(0,0)",
            prim->verts[0].xyz[0], prim->verts[0].xyz[1]);
    switch(prim->data.text->alignment){
    case GL2PS_TEXT_C:
      fprintf(gl2ps->stream, "{");
      break;
    case GL2PS_TEXT_CL:
      fprintf(gl2ps->stream, "[l]{");
      break;
    case GL2PS_TEXT_CR:
      fprintf(gl2ps->stream, "[r]{");
      break;
    case GL2PS_TEXT_B:
      fprintf(gl2ps->stream, "[b]{");
      break;
    case GL2PS_TEXT_BR:
      fprintf(gl2ps->stream, "[br]{");
      break;
    case GL2PS_TEXT_T:
      fprintf(gl2ps->stream, "[t]{");
      break;
    case GL2PS_TEXT_TL:
      fprintf(gl2ps->stream, "[tl]{");
      break;
    case GL2PS_TEXT_TR:
      fprintf(gl2ps->stream, "[tr]{");
      break;
    case GL2PS_TEXT_BL:
    default:
      fprintf(gl2ps->stream, "[bl]{");
      break;
    }
    if(prim->data.text->angle)
      fprintf(gl2ps->stream, "\\rotatebox{%g}{", prim->data.text->angle);
    fprintf(gl2ps->stream, "\\textcolor[rgb]{%g,%g,%g}{{%s}}",
            prim->verts[0].rgba[0], prim->verts[0].rgba[1], prim->verts[0].rgba[2],
            prim->data.text->str);
    if(prim->data.text->angle)
      fprintf(gl2ps->stream, "}");
    fprintf(gl2ps->stream, "}}\n");
    break;
  case GL2PS_SPECIAL :
    /* alignment contains the format for which the special output text
       is intended */
    if (prim->data.text->alignment == GL2PS_TEX)
      fprintf(gl2ps->stream, "%s\n", prim->data.text->str);
    break;
  default :
    break;
  }
}

gl2psPsca()

GLfloat gl2psPsca ( GLfloat * a, GLfloat * b )

static

Definition at line 1062 of file gl2ps.cxx.

{
  return (a[0]*b[0] + a[1]*b[1] + a[2]*b[2]);
}

gl2psPutPDFImage()

void gl2psPutPDFImage ( GL2PSimage * image, int cnt, GLfloat x, GLfloat y )

static

Definition at line 3432 of file gl2ps.cxx.

{
  gl2ps->streamlength += gl2psPrintf
    ("q\n"
     "%d 0 0 %d %f %f cm\n"
     "/Im%d Do\n"
     "Q\n",
     (int)image->width, (int)image->height, x, y, cnt);
}

gl2psPutPDFText()

void gl2psPutPDFText ( GL2PSstring * text, int cnt, GLfloat x, GLfloat y )

static

Definition at line 3405 of file gl2ps.cxx.

{
  GLfloat rad, crad, srad;
 
  if(text->angle == 0.0F){
    gl2ps->streamlength += gl2psPrintf
      ("BT\n"
       "/F%d %d Tf\n"
       "%f %f Td\n"
       "(%s) Tj\n"
       "ET\n",
       cnt, text->fontsize, x, y, text->str);
  }
  else{
    rad = M_PI * text->angle / 180.0F;
    srad = (GLfloat)sin(rad);
    crad = (GLfloat)cos(rad);
    gl2ps->streamlength += gl2psPrintf
      ("BT\n"
       "/F%d %d Tf\n"
       "%f %f %f %f %f %f Tm\n"
       "(%s) Tj\n"
       "ET\n",
       cnt, text->fontsize, crad, srad, -srad, crad, x, y, text->str);
  }
}

gl2psPvec()

void gl2psPvec ( GLfloat * a, GLfloat * b, GLfloat * c )

static

Definition at line 1067 of file gl2ps.cxx.

{
  c[0] = a[1]*b[2] - a[2]*b[1];
  c[1] = a[2]*b[0] - a[0]*b[2];
  c[2] = a[0]*b[1] - a[1]*b[0];
}

gl2psRealloc()

void * gl2psRealloc ( void * ptr, size_t size )

static

Definition at line 309 of file gl2ps.cxx.

{
  if(!size) return NULL;
  ptr = realloc(ptr, size);
  if(!ptr){
    gl2psMsg(GL2PS_ERROR, "Couldn't reallocate requested memory");
    return NULL;
  }
  return ptr;
}

gl2psRescaleAndOffset()

void gl2psRescaleAndOffset ( )

static

Definition at line 1620 of file gl2ps.cxx.

{
  GL2PSprimitive *prim;
  GLfloat minZ, maxZ, rangeZ, scaleZ;
  GLfloat factor, units, area, dZ, dZdX, dZdY, maxdZ;
  int i, j;
 
  if(!gl2psListNbr(gl2ps->primitives))
    return;
 
  /* get z-buffer range */
  prim = *(GL2PSprimitive**)gl2psListPointer(gl2ps->primitives, 0);
  minZ = maxZ = prim->verts[0].xyz[2];
  for(i = 1; i < prim->numverts; i++){
    if(prim->verts[i].xyz[2] < minZ) minZ = prim->verts[i].xyz[2];
    if(prim->verts[i].xyz[2] > maxZ) maxZ = prim->verts[i].xyz[2];
  }
  for(i = 1; i < gl2psListNbr(gl2ps->primitives); i++){
    prim = *(GL2PSprimitive**)gl2psListPointer(gl2ps->primitives, i);
    for(j = 0; j < prim->numverts; j++){
      if(prim->verts[j].xyz[2] < minZ) minZ = prim->verts[j].xyz[2];
      if(prim->verts[j].xyz[2] > maxZ) maxZ = prim->verts[j].xyz[2];
    }
  }
  rangeZ = (maxZ - minZ);
 
  /* rescale z-buffer coordinate in [0,GL2PS_ZSCALE], to make it of
     the same order of magnitude as the x and y coordinates */
  scaleZ = GL2PS_ZERO(rangeZ) ? GL2PS_ZSCALE : (GL2PS_ZSCALE / rangeZ);
  /* avoid precision loss (we use floats!) */
  if(scaleZ > 100000.F) scaleZ = 100000.F;
 
  /* apply offsets */
  for(i = 0; i < gl2psListNbr(gl2ps->primitives); i++){
    prim = *(GL2PSprimitive**)gl2psListPointer(gl2ps->primitives, i);
    for(j = 0; j < prim->numverts; j++){
      prim->verts[j].xyz[2] = (prim->verts[j].xyz[2] - minZ) * scaleZ;
    }
    if((gl2ps->options & GL2PS_SIMPLE_LINE_OFFSET) &&
       (prim->type == GL2PS_LINE)){
      if(gl2ps->sort == GL2PS_SIMPLE_SORT){
        prim->verts[0].xyz[2] -= GL2PS_ZOFFSET_LARGE;
        prim->verts[1].xyz[2] -= GL2PS_ZOFFSET_LARGE;
      }
      else{
        prim->verts[0].xyz[2] -= GL2PS_ZOFFSET;
        prim->verts[1].xyz[2] -= GL2PS_ZOFFSET;
      }
    }
    else if(prim->offset && (prim->type == GL2PS_TRIANGLE)){
      factor = gl2ps->offset[0];
      units = gl2ps->offset[1];
      area =
        (prim->verts[1].xyz[0] - prim->verts[0].xyz[0]) *
        (prim->verts[2].xyz[1] - prim->verts[1].xyz[1]) -
        (prim->verts[2].xyz[0] - prim->verts[1].xyz[0]) *
        (prim->verts[1].xyz[1] - prim->verts[0].xyz[1]);
      if(!GL2PS_ZERO(area)){
        dZdX =
          ((prim->verts[2].xyz[1] - prim->verts[1].xyz[1]) *
           (prim->verts[1].xyz[2] - prim->verts[0].xyz[2]) -
           (prim->verts[1].xyz[1] - prim->verts[0].xyz[1]) *
           (prim->verts[2].xyz[2] - prim->verts[1].xyz[2])) / area;
        dZdY =
          ((prim->verts[1].xyz[0] - prim->verts[0].xyz[0]) *
           (prim->verts[2].xyz[2] - prim->verts[1].xyz[2]) -
           (prim->verts[2].xyz[0] - prim->verts[1].xyz[0]) *
           (prim->verts[1].xyz[2] - prim->verts[0].xyz[2])) / area;
        maxdZ = (GLfloat)sqrt(dZdX * dZdX + dZdY * dZdY);
      }
      else{
        maxdZ = 0.0F;
      }
      dZ = factor * maxdZ + units;
      prim->verts[0].xyz[2] += dZ;
      prim->verts[1].xyz[2] += dZ;
      prim->verts[2].xyz[2] += dZ;
    }
  }
}

gl2psResetPostScriptColor()

void gl2psResetPostScriptColor ( void )

static

Definition at line 2890 of file gl2ps.cxx.

{
  gl2ps->lastrgba[0] = gl2ps->lastrgba[1] = gl2ps->lastrgba[2] = -1.;
}

gl2psSameColor()

GLboolean gl2psSameColor ( GL2PSrgba rgba1, GL2PSrgba rgba2 )

static

Definition at line 669 of file gl2ps.cxx.

{
  if(!GL2PS_ZERO(rgba1[0] - rgba2[0]) ||
     !GL2PS_ZERO(rgba1[1] - rgba2[1]) ||
     !GL2PS_ZERO(rgba1[2] - rgba2[2]))
    return GL_FALSE;
  return GL_TRUE;
}

gl2psSameColorThreshold()

GLboolean gl2psSameColorThreshold ( int n, GL2PSrgba rgba[], GL2PSrgba threshold )

static

Definition at line 690 of file gl2ps.cxx.

{
  int i;
 
  if(n < 2) return GL_TRUE;
 
  for(i = 1; i < n; i++){
    if(fabs(rgba[0][0] - rgba[i][0]) > threshold[0] ||
       fabs(rgba[0][1] - rgba[i][1]) > threshold[1] ||
       fabs(rgba[0][2] - rgba[i][2]) > threshold[2])
      return GL_FALSE;
  }
 
  return GL_TRUE;
}

gl2psSamePosition()

GLboolean gl2psSamePosition ( GL2PSxyz p1, GL2PSxyz p2 )

static

Definition at line 1039 of file gl2ps.cxx.

{
  if(!GL2PS_ZERO(p1[0] - p2[0]) ||
     !GL2PS_ZERO(p1[1] - p2[1]) ||
     !GL2PS_ZERO(p1[2] - p2[2]))
    return GL_FALSE;
  return GL_TRUE;
}

gl2psSetLastColor()

void gl2psSetLastColor ( GL2PSrgba rgba )

static

Definition at line 707 of file gl2ps.cxx.

{
  int i;
  for(i = 0; i < 3; ++i){
    gl2ps->lastrgba[i] = rgba[i];
  }
}

gl2psSetOptions()

GL2PSDLL_API GLint gl2psSetOptions

(

GLint

options

)

Definition at line 6017 of file gl2ps.cxx.

{
  if(!gl2ps) return GL2PS_UNINITIALIZED;
 
  gl2ps->options = options;
 
  return GL2PS_SUCCESS;
}

gl2psSortOutTrianglePDFgroup()

void gl2psSortOutTrianglePDFgroup ( GL2PSpdfgroup * gro )

static

Definition at line 3562 of file gl2ps.cxx.

{
  GL2PStriangle t;
  GL2PSprimitive *prim = NULL;
 
  if(!gro)
    return;
 
  if(!gl2psListNbr(gro->ptrlist))
    return;
 
  prim = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, 0);
 
  if(prim->type != GL2PS_TRIANGLE)
    return;
 
  gl2psFillTriangleFromPrimitive(&t, prim, GL_TRUE);
 
  if(t.prop & T_CONST_COLOR && t.prop & T_ALPHA_LESS_1){
    gro->gsno = gl2ps->extgs_stack++;
    gro->gsobjno = gl2ps->objects_stack ++;
  }
  else if(t.prop & T_CONST_COLOR && t.prop & T_VAR_ALPHA){
    gro->gsno = gl2ps->extgs_stack++;
    gro->gsobjno = gl2ps->objects_stack++;
    gro->trgroupno = gl2ps->trgroupobjects_stack++;
    gro->trgroupobjno = gl2ps->objects_stack++;
    gro->maskshno = gl2ps->mshader_stack++;
    gro->maskshobjno = gl2ps->objects_stack++;
  }
  else if(t.prop & T_VAR_COLOR && t.prop & T_ALPHA_1){
    gro->shno = gl2ps->shader_stack++;
    gro->shobjno = gl2ps->objects_stack++;
  }
  else if(t.prop & T_VAR_COLOR && t.prop & T_ALPHA_LESS_1){
    gro->gsno = gl2ps->extgs_stack++;
    gro->gsobjno = gl2ps->objects_stack++;
    gro->shno = gl2ps->shader_stack++;
    gro->shobjno = gl2ps->objects_stack++;
  }
  else if(t.prop & T_VAR_COLOR && t.prop & T_VAR_ALPHA){
    gro->gsno = gl2ps->extgs_stack++;
    gro->gsobjno = gl2ps->objects_stack++;
    gro->shno = gl2ps->shader_stack++;
    gro->shobjno = gl2ps->objects_stack++;
    gro->trgroupno = gl2ps->trgroupobjects_stack++;
    gro->trgroupobjno = gl2ps->objects_stack++;
    gro->maskshno = gl2ps->mshader_stack++;
    gro->maskshobjno = gl2ps->objects_stack++;
  }
}

gl2psSpecial()

GL2PSDLL_API GLint gl2psSpecial	(	GLint	format,
		const char *	str )

Definition at line 5812 of file gl2ps.cxx.

{
  return gl2psAddText(GL2PS_SPECIAL, str, "", 0, format, 0.0F);
}

gl2psSplitPrimitive()

GLint gl2psSplitPrimitive ( GL2PSprimitive * prim, GL2PSplane plane, GL2PSprimitive ** front, GL2PSprimitive ** back )

static

Definition at line 1281 of file gl2ps.cxx.

{
  GLshort i(0), j(0), in = 0, out = 0, in0[5], in1[5], out0[5], out1[5];
  for (unsigned k=0;k<5;++k)
    in0[k]=in1[k]=out0[k]=out1[k]=0;
  GLint type;
  GLfloat d[5];
 
  type = GL2PS_COINCIDENT;
 
  for(i = 0; i < prim->numverts; i++){
    d[i] = gl2psComparePointPlane(prim->verts[i].xyz, plane);
  }
 
  switch(prim->type){
  case GL2PS_POINT :
    if(d[0] > GL2PS_EPSILON)       type = GL2PS_IN_BACK_OF;
    else if(d[0] < -GL2PS_EPSILON) type = GL2PS_IN_FRONT_OF;
    else                           type = GL2PS_COINCIDENT;
    break;
  default :
    for(i = 0; i < prim->numverts; i++){
      j = gl2psGetIndex(i, prim->numverts);
      if(d[j] > GL2PS_EPSILON){
        if(type == GL2PS_COINCIDENT)      type = GL2PS_IN_BACK_OF;
        else if(type != GL2PS_IN_BACK_OF) type = GL2PS_SPANNING;
        if(d[i] < -GL2PS_EPSILON){
          gl2psAddIndex(in0, in1, &in, i, j);
          gl2psAddIndex(out0, out1, &out, i, j);
          type = GL2PS_SPANNING;
        }
        gl2psAddIndex(out0, out1, &out, j, -1);
      }
      else if(d[j] < -GL2PS_EPSILON){
        if(type == GL2PS_COINCIDENT)       type = GL2PS_IN_FRONT_OF;
        else if(type != GL2PS_IN_FRONT_OF) type = GL2PS_SPANNING;
        if(d[i] > GL2PS_EPSILON){
          gl2psAddIndex(in0, in1, &in, i, j);
          gl2psAddIndex(out0, out1, &out, i, j);
          type = GL2PS_SPANNING;
        }
        gl2psAddIndex(in0, in1, &in, j, -1);
      }
      else{
        gl2psAddIndex(in0, in1, &in, j, -1);
        gl2psAddIndex(out0, out1, &out, j, -1);
      }
    }
    break;
  }
 
  if(type == GL2PS_SPANNING){
    *back = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive));
    *front = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive));
    gl2psCreateSplitPrimitive(prim, plane, *back, out, out0, out1);
    gl2psCreateSplitPrimitive(prim, plane, *front, in, in0, in1);
  }
 
  return type;
}

gl2psSplitPrimitive2D()

void gl2psSplitPrimitive2D ( GL2PSprimitive * prim, GL2PSplane plane, GL2PSprimitive ** front, GL2PSprimitive ** back )

static

Definition at line 1902 of file gl2ps.cxx.

{
  /* cur will hold the position of the current vertex
     prev will hold the position of the previous vertex
     prev0 will hold the position of the vertex number 0
     v1 and v2 represent the current and previous vertices, respectively
     flag is set if the current vertex should be checked against the plane */
  GLint cur = -1, prev = -1, i, v1 = 0, v2 = 0, flag = 1, prev0 = -1;
 
  /* list of vertices that will go in front and back primitive */
  GL2PSvertex *front_list = NULL, *back_list = NULL;
 
  /* number of vertices in front and back list */
  GLshort front_count = 0, back_count = 0;
 
  for(i = 0; i <= prim->numverts; i++){
    v1 = i;
    if(v1 == prim->numverts){
      if(prim->numverts < 3) break;
      v1 = 0;
      v2 = prim->numverts - 1;
      cur = prev0;
    }
    else if(flag){
      cur = gl2psCheckPoint(prim->verts[v1].xyz, plane);
      if(i == 0){
        prev0 = cur;
      }
    }
    if(((prev == -1) || (prev == cur) || (prev == 0) || (cur == 0)) &&
       (i < prim->numverts)){
      if(cur == GL2PS_POINT_INFRONT){
        front_count++;
        front_list = (GL2PSvertex*)gl2psRealloc(front_list,
                                                sizeof(GL2PSvertex)*front_count);
        front_list[front_count-1] = prim->verts[v1];
      }
      else if(cur == GL2PS_POINT_BACK){
        back_count++;
        back_list = (GL2PSvertex*)gl2psRealloc(back_list,
                                               sizeof(GL2PSvertex)*back_count);
        back_list[back_count-1] = prim->verts[v1];
      }
      else{
        front_count++;
        front_list = (GL2PSvertex*)gl2psRealloc(front_list,
                                                sizeof(GL2PSvertex)*front_count);
        front_list[front_count-1] = prim->verts[v1];
        back_count++;
        back_list = (GL2PSvertex*)gl2psRealloc(back_list,
                                               sizeof(GL2PSvertex)*back_count);
        back_list[back_count-1] = prim->verts[v1];
      }
      flag = 1;
    }
    else if((prev != cur) && (cur != 0) && (prev != 0)){
      if(v1 != 0){
        v2 = v1-1;
        i--;
      }
      front_count++;
      front_list = (GL2PSvertex*)gl2psRealloc(front_list,
                                              sizeof(GL2PSvertex)*front_count);
      gl2psCutEdge(&prim->verts[v2], &prim->verts[v1],
                   plane, &front_list[front_count-1]);
      back_count++;
      back_list = (GL2PSvertex*)gl2psRealloc(back_list,
                                             sizeof(GL2PSvertex)*back_count);
      back_list[back_count-1] = front_list[front_count-1];
      flag = 0;
    }
    prev = cur;
  }
  *front = gl2psCreateSplitPrimitive2D(prim, front_count, front_list);
  *back = gl2psCreateSplitPrimitive2D(prim, back_count, back_list);
  gl2psFree(front_list);
  gl2psFree(back_list);
}

gl2psSupportedBlendMode()

GLboolean gl2psSupportedBlendMode ( GLenum sfactor, GLenum dfactor )

static

Definition at line 913 of file gl2ps.cxx.

{
  /* returns TRUE if gl2ps supports the argument combination: only two
     blending modes have been implemented so far */
 
  if( (sfactor == GL_SRC_ALPHA && dfactor == GL_ONE_MINUS_SRC_ALPHA) ||
      (sfactor == GL_ONE && dfactor == GL_ZERO) )
    return GL_TRUE;
  return GL_FALSE;
}

gl2psSVGGetColorString()

void gl2psSVGGetColorString ( GL2PSrgba rgba, char str[32] )

static

Definition at line 4855 of file gl2ps.cxx.

{
  int r = (int)(255. * rgba[0]);
  int g = (int)(255. * rgba[1]);
  int b = (int)(255. * rgba[2]);
  int rc = (r < 0) ? 0 : (r > 255) ? 255 : r;
  int gc = (g < 0) ? 0 : (g > 255) ? 255 : g;
  int bc = (b < 0) ? 0 : (b > 255) ? 255 : b;
  sprintf(str, "#%2.2x%2.2x%2.2x", rc, gc, bc);
}

gl2psSVGGetCoordsAndColors()

void gl2psSVGGetCoordsAndColors ( int n, GL2PSvertex * verts, GL2PSxyz * xyz, GL2PSrgba * rgba )

static

Definition at line 4841 of file gl2ps.cxx.

{
  int i, j;
 
  for(i = 0; i < n; i++){
    xyz[i][0] = verts[i].xyz[0];
    xyz[i][1] = gl2ps->viewport[3] - verts[i].xyz[1];
    xyz[i][2] = 0.0F;
    for(j = 0; j < 4; j++)
      rgba[i][j] = verts[i].rgba[j];
  }
}

gl2psTestSplitPrimitive()

GLint gl2psTestSplitPrimitive ( GL2PSprimitive * prim, GL2PSplane plane )

static

Definition at line 1250 of file gl2ps.cxx.

{
  GLint type = GL2PS_COINCIDENT;
  GLshort i, j;
  GLfloat d[5];
 
  for(i = 0; i < prim->numverts; i++){
    d[i] = gl2psComparePointPlane(prim->verts[i].xyz, plane);
  }
 
  if(prim->numverts < 2){
    return 0;
  }
  else{
    for(i = 0; i < prim->numverts; i++){
      j = gl2psGetIndex(i, prim->numverts);
      if(d[j] > GL2PS_EPSILON){
        if(type == GL2PS_COINCIDENT)      type = GL2PS_IN_BACK_OF;
        else if(type != GL2PS_IN_BACK_OF) return 1;
        if(d[i] < -GL2PS_EPSILON)         return 1;
      }
      else if(d[j] < -GL2PS_EPSILON){
        if(type == GL2PS_COINCIDENT)       type = GL2PS_IN_FRONT_OF;
        else if(type != GL2PS_IN_FRONT_OF) return 1;
        if(d[i] > GL2PS_EPSILON)           return 1;
      }
    }
  }
  return 0;
}

gl2psText()

GL2PSDLL_API GLint gl2psText	(	const char *	str,
		const char *	fontname,
		GLshort	fontsize )

Definition at line 5807 of file gl2ps.cxx.

{
  return gl2psAddText(GL2PS_TEXT, str, fontname, fontsize, GL2PS_TEXT_BL, 0.0F);
}

gl2psTextOpt()

GL2PSDLL_API GLint gl2psTextOpt	(	const char *	str,
		const char *	fontname,
		GLshort	fontsize,
		GLint	alignment,
		GLfloat	angle )

Definition at line 5801 of file gl2ps.cxx.

{
  return gl2psAddText(GL2PS_TEXT, str, fontname, fontsize, alignment, angle);
}

gl2psTraverseBspTree()

void gl2psTraverseBspTree ( GL2PSbsptree * tree, GL2PSxyz eye, GLfloat epsilon, GLboolean(* compare )(GLfloat f1, GLfloat f2), void(* action )(void *data), int inverse )

static

Definition at line 1584 of file gl2ps.cxx.

{
  GLfloat result;
 
  if(!tree) return;
 
  result = gl2psComparePointPlane(eye, tree->plane);
 
  if(GL_TRUE == compare(result, epsilon)){
    gl2psTraverseBspTree(tree->back, eye, epsilon, compare, action, inverse);
    if(inverse){
      gl2psListActionInverse(tree->primitives, action);
    }
    else{
      gl2psListAction(tree->primitives, action);
    }
    gl2psTraverseBspTree(tree->front, eye, epsilon, compare, action, inverse);
  }
  else if(GL_TRUE == compare(-epsilon, result)){
    gl2psTraverseBspTree(tree->front, eye, epsilon, compare, action, inverse);
    if(inverse){
      gl2psListActionInverse(tree->primitives, action);
    }
    else{
      gl2psListAction(tree->primitives, action);
    }
    gl2psTraverseBspTree(tree->back, eye, epsilon, compare, action, inverse);
  }
  else{
    gl2psTraverseBspTree(tree->front, eye, epsilon, compare, action, inverse);
    gl2psTraverseBspTree(tree->back, eye, epsilon, compare, action, inverse);
  }
}

gl2psTrianglesFirst()

int gl2psTrianglesFirst ( const void * a, const void * b )

static

Definition at line 1398 of file gl2ps.cxx.

{
  GL2PSprimitive *q, *w;
 
  q = *(GL2PSprimitive**)a;
  w = *(GL2PSprimitive**)b;
  return (q->type < w->type ? 1 : -1);
}

gl2psVertsSameColor()

GLboolean gl2psVertsSameColor ( const GL2PSprimitive * prim )

static

Definition at line 678 of file gl2ps.cxx.

{
  int i;
 
  for(i = 1; i < prim->numverts; i++){
    if(!gl2psSameColor(prim->verts[0].rgba, prim->verts[i].rgba)){
      return GL_FALSE;
    }
  }
  return GL_TRUE;
}

gl2psWriteBigEndian()

size_t gl2psWriteBigEndian ( unsigned long data, size_t bytes )

static

Definition at line 326 of file gl2ps.cxx.

{
  size_t i;
  size_t size = sizeof(unsigned long);
  for(i = 1; i <= bytes; ++i){
    fputc(0xff & (data >> (size-i) * 8), gl2ps->stream);
  }
  return bytes;
}

gl2psWriteByte()

void gl2psWriteByte ( unsigned char byte )

static

Definition at line 2408 of file gl2ps.cxx.

{
  unsigned char h = byte / 16;
  unsigned char l = byte % 16;
  gl2psPrintf("%x%x", h, l);
}

Variable Documentation

gl2ps

GL2PScontext* gl2ps = NULL

static

Definition at line 266 of file gl2ps.cxx.

gl2psbackends

GL2PSbackend* gl2psbackends[]

static

Initial value:

= {
  &gl2psPS,  
  &gl2psEPS, 
  &gl2psTEX, 
  &gl2psPDF, 
  &gl2psSVG, 
  &gl2psPGF  
}

Definition at line 5476 of file gl2ps.cxx.

                                       {
  &gl2psPS,  /* 0 */
  &gl2psEPS, /* 1 */
  &gl2psTEX, /* 2 */
  &gl2psPDF, /* 3 */
  &gl2psSVG, /* 4 */
  &gl2psPGF  /* 5 */
};

gl2psEPS

GL2PSbackend gl2psEPS

static

Initial value:

= {
  gl2psPrintPostScriptHeader,
  gl2psPrintPostScriptFooter,
  gl2psPrintPostScriptBeginViewport,
  gl2psPrintPostScriptEndViewport,
  gl2psPrintPostScriptPrimitive,
  gl2psPrintPostScriptFinalPrimitive,
  "eps",
  "Encapsulated Postscript"
}

Definition at line 3187 of file gl2ps.cxx.

                               {
  gl2psPrintPostScriptHeader,
  gl2psPrintPostScriptFooter,
  gl2psPrintPostScriptBeginViewport,
  gl2psPrintPostScriptEndViewport,
  gl2psPrintPostScriptPrimitive,
  gl2psPrintPostScriptFinalPrimitive,
  "eps",
  "Encapsulated Postscript"
};

gl2psPDF

GL2PSbackend gl2psPDF

static

Initial value:

= {
  gl2psPrintPDFHeader,
  gl2psPrintPDFFooter,
  gl2psPrintPDFBeginViewport,
  gl2psPrintPDFEndViewport,
  gl2psPrintPDFPrimitive,
  gl2psPrintPDFFinalPrimitive,
  "pdf",
  "Portable Document Format"
}

Definition at line 4824 of file gl2ps.cxx.

                               {
  gl2psPrintPDFHeader,
  gl2psPrintPDFFooter,
  gl2psPrintPDFBeginViewport,
  gl2psPrintPDFEndViewport,
  gl2psPrintPDFPrimitive,
  gl2psPrintPDFFinalPrimitive,
  "pdf",
  "Portable Document Format"
};

gl2psPGF

GL2PSbackend gl2psPGF

static

Initial value:

= {
  gl2psPrintPGFHeader,
  gl2psPrintPGFFooter,
  gl2psPrintPGFBeginViewport,
  gl2psPrintPGFEndViewport,
  gl2psPrintPGFPrimitive,
  gl2psPrintPGFFinalPrimitive,
  "tex",
  "PGF Latex Graphics"
}

Definition at line 5456 of file gl2ps.cxx.

                               {
  gl2psPrintPGFHeader,
  gl2psPrintPGFFooter,
  gl2psPrintPGFBeginViewport,
  gl2psPrintPGFEndViewport,
  gl2psPrintPGFPrimitive,
  gl2psPrintPGFFinalPrimitive,
  "tex",
  "PGF Latex Graphics"
};

gl2psPS

GL2PSbackend gl2psPS

static

Initial value:

= {
  gl2psPrintPostScriptHeader,
  gl2psPrintPostScriptFooter,
  gl2psPrintPostScriptBeginViewport,
  gl2psPrintPostScriptEndViewport,
  gl2psPrintPostScriptPrimitive,
  gl2psPrintPostScriptFinalPrimitive,
  "ps",
  "Postscript"
}

Definition at line 3176 of file gl2ps.cxx.

                              {
  gl2psPrintPostScriptHeader,
  gl2psPrintPostScriptFooter,
  gl2psPrintPostScriptBeginViewport,
  gl2psPrintPostScriptEndViewport,
  gl2psPrintPostScriptPrimitive,
  gl2psPrintPostScriptFinalPrimitive,
  "ps",
  "Postscript"
};

gl2psSVG

GL2PSbackend gl2psSVG

static

Initial value:

= {
  gl2psPrintSVGHeader,
  gl2psPrintSVGFooter,
  gl2psPrintSVGBeginViewport,
  gl2psPrintSVGEndViewport,
  gl2psPrintSVGPrimitive,
  gl2psPrintSVGFinalPrimitive,
  "svg",
  "Scalable Vector Graphics"
}

Definition at line 5232 of file gl2ps.cxx.

                               {
  gl2psPrintSVGHeader,
  gl2psPrintSVGFooter,
  gl2psPrintSVGBeginViewport,
  gl2psPrintSVGEndViewport,
  gl2psPrintSVGPrimitive,
  gl2psPrintSVGFinalPrimitive,
  "svg",
  "Scalable Vector Graphics"
};

gl2psTEX

GL2PSbackend gl2psTEX

static

Initial value:

= {
  gl2psPrintTeXHeader,
  gl2psPrintTeXFooter,
  gl2psPrintTeXBeginViewport,
  gl2psPrintTeXEndViewport,
  gl2psPrintTeXPrimitive,
  gl2psPrintTeXFinalPrimitive,
  "tex",
  "LaTeX text"
}

Definition at line 3335 of file gl2ps.cxx.

                               {
  gl2psPrintTeXHeader,
  gl2psPrintTeXFooter,
  gl2psPrintTeXBeginViewport,
  gl2psPrintTeXEndViewport,
  gl2psPrintTeXPrimitive,
  gl2psPrintTeXFinalPrimitive,
  "tex",
  "LaTeX text"
};