gl2ps.cc File Reference

#include "Geant4_gl2ps.h"
#include <cmath>
#include <string.h>
#include <sys/types.h>
#include <stdarg.h>
#include <time.h>
#include <float.h>
#include <limits.h>

Go to the source code of this file.

Data Structures
struct	GL2PSbackend
struct	GL2PSbsptree2d_
struct	GL2PSbsptree_
struct	GL2PScompress
struct	GL2PScontext
struct	GL2PSimage
struct	GL2PSimagemap_
struct	GL2PSlist
struct	GL2PSpdfgroup
struct	GL2PSprimitive
struct	GL2PSstring
struct	GL2PStriangle

Macros
#define	GL2PS_BEGIN_BLEND_TOKEN   11
#define	GL2PS_BEGIN_BOUNDARY_TOKEN   3
#define	GL2PS_BEGIN_OFFSET_TOKEN   1
#define	GL2PS_BEGIN_STIPPLE_TOKEN   5
#define	GL2PS_COINCIDENT   1
#define	GL2PS_DRAW_PIXELS_TOKEN   16
#define	GL2PS_DST_BLEND_TOKEN   14
#define	GL2PS_END_BLEND_TOKEN   12
#define	GL2PS_END_BOUNDARY_TOKEN   4
#define	GL2PS_END_OFFSET_TOKEN   2
#define	GL2PS_END_STIPPLE_TOKEN   6
#define	GL2PS_EPSILON   5.0e-3F
#define	GL2PS_IMAGEMAP_TOKEN   15
#define	GL2PS_IN_BACK_OF   3
#define	GL2PS_IN_FRONT_OF   2
#define	GL2PS_LINE_CAP_TOKEN   8
#define	GL2PS_LINE_JOIN_TOKEN   9
#define	GL2PS_LINE_WIDTH_TOKEN   10
#define	GL2PS_POINT_BACK   2
#define	GL2PS_POINT_COINCIDENT   0
#define	GL2PS_POINT_INFRONT   1
#define	GL2PS_POINT_SIZE_TOKEN   7
#define	GL2PS_SPANNING   4
#define	GL2PS_SRC_BLEND_TOKEN   13
#define	GL2PS_TEXT_TOKEN   17
#define	GL2PS_ZERO(arg)   (std::fabs(arg) < 1.e-20)
#define	GL2PS_ZOFFSET   5.0e-2F
#define	GL2PS_ZOFFSET_LARGE   20.0F
#define	GL2PS_ZSCALE   1000.0F

Typedefs
typedef struct GL2PSbsptree_	GL2PSbsptree
typedef struct GL2PSbsptree2d_	GL2PSbsptree2d
typedef struct GL2PSimagemap_	GL2PSimagemap
typedef GLfloat	GL2PSplane[4]

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

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

Macro Definition Documentation

GL2PS_BEGIN_BLEND_TOKEN

#define GL2PS_BEGIN_BLEND_TOKEN   11

Definition at line 120 of file gl2ps.cc.

GL2PS_BEGIN_BOUNDARY_TOKEN

#define GL2PS_BEGIN_BOUNDARY_TOKEN   3

Definition at line 112 of file gl2ps.cc.

GL2PS_BEGIN_OFFSET_TOKEN

#define GL2PS_BEGIN_OFFSET_TOKEN   1

Definition at line 110 of file gl2ps.cc.

GL2PS_BEGIN_STIPPLE_TOKEN

#define GL2PS_BEGIN_STIPPLE_TOKEN   5

Definition at line 114 of file gl2ps.cc.

GL2PS_COINCIDENT

#define GL2PS_COINCIDENT   1

Definition at line 97 of file gl2ps.cc.

GL2PS_DRAW_PIXELS_TOKEN

#define GL2PS_DRAW_PIXELS_TOKEN   16

Definition at line 125 of file gl2ps.cc.

GL2PS_DST_BLEND_TOKEN

#define GL2PS_DST_BLEND_TOKEN   14

Definition at line 123 of file gl2ps.cc.

GL2PS_END_BLEND_TOKEN

#define GL2PS_END_BLEND_TOKEN   12

Definition at line 121 of file gl2ps.cc.

GL2PS_END_BOUNDARY_TOKEN

#define GL2PS_END_BOUNDARY_TOKEN   4

Definition at line 113 of file gl2ps.cc.

GL2PS_END_OFFSET_TOKEN

#define GL2PS_END_OFFSET_TOKEN   2

Definition at line 111 of file gl2ps.cc.

GL2PS_END_STIPPLE_TOKEN

#define GL2PS_END_STIPPLE_TOKEN   6

Definition at line 115 of file gl2ps.cc.

GL2PS_EPSILON

#define GL2PS_EPSILON   5.0e-3F

Definition at line 89 of file gl2ps.cc.

GL2PS_IMAGEMAP_TOKEN

#define GL2PS_IMAGEMAP_TOKEN   15

Definition at line 124 of file gl2ps.cc.

GL2PS_IN_BACK_OF

#define GL2PS_IN_BACK_OF   3

Definition at line 99 of file gl2ps.cc.

GL2PS_IN_FRONT_OF

#define GL2PS_IN_FRONT_OF   2

Definition at line 98 of file gl2ps.cc.

GL2PS_LINE_CAP_TOKEN

#define GL2PS_LINE_CAP_TOKEN   8

Definition at line 117 of file gl2ps.cc.

GL2PS_LINE_JOIN_TOKEN

#define GL2PS_LINE_JOIN_TOKEN   9

Definition at line 118 of file gl2ps.cc.

GL2PS_LINE_WIDTH_TOKEN

#define GL2PS_LINE_WIDTH_TOKEN   10

Definition at line 119 of file gl2ps.cc.

GL2PS_POINT_BACK

#define GL2PS_POINT_BACK   2

Definition at line 106 of file gl2ps.cc.

GL2PS_POINT_COINCIDENT

#define GL2PS_POINT_COINCIDENT   0

Definition at line 104 of file gl2ps.cc.

GL2PS_POINT_INFRONT

#define GL2PS_POINT_INFRONT   1

Definition at line 105 of file gl2ps.cc.

GL2PS_POINT_SIZE_TOKEN

#define GL2PS_POINT_SIZE_TOKEN   7

Definition at line 116 of file gl2ps.cc.

GL2PS_SPANNING

#define GL2PS_SPANNING   4

Definition at line 100 of file gl2ps.cc.

GL2PS_SRC_BLEND_TOKEN

#define GL2PS_SRC_BLEND_TOKEN   13

Definition at line 122 of file gl2ps.cc.

GL2PS_TEXT_TOKEN

#define GL2PS_TEXT_TOKEN   17

Definition at line 126 of file gl2ps.cc.

GL2PS_ZERO

#define GL2PS_ZERO

(

arg

)

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

Definition at line 93 of file gl2ps.cc.

GL2PS_ZOFFSET

#define GL2PS_ZOFFSET   5.0e-2F

Definition at line 91 of file gl2ps.cc.

GL2PS_ZOFFSET_LARGE

#define GL2PS_ZOFFSET_LARGE   20.0F

Definition at line 92 of file gl2ps.cc.

GL2PS_ZSCALE

#define GL2PS_ZSCALE   1000.0F

Definition at line 90 of file gl2ps.cc.

Typedef Documentation

GL2PSbsptree

typedef struct GL2PSbsptree_ GL2PSbsptree

Definition at line 151 of file gl2ps.cc.

GL2PSbsptree2d

typedef struct GL2PSbsptree2d_ GL2PSbsptree2d

Definition at line 139 of file gl2ps.cc.

GL2PSimagemap

typedef struct GL2PSimagemap_ GL2PSimagemap

Definition at line 183 of file gl2ps.cc.

GL2PSplane

typedef GLfloat GL2PSplane[4]

Definition at line 137 of file gl2ps.cc.

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 128 of file gl2ps.cc.

             {
  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()

static void gl2psAdaptVertexForBlending ( GL2PSvertex *  v )

static

Definition at line 1014 of file gl2ps.cc.

{
  /* 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;
  }
}

References GL2PScontext::blendfunc, GL2PScontext::blending, gl2ps, GL2PS_NO_BLENDING, GL2PScontext::options, and GL2PSvertex::rgba.

Referenced by gl2psParseFeedbackBuffer().

gl2psAddBoundaryInList()

static void gl2psAddBoundaryInList ( GL2PSprimitive *  prim, GL2PSlist *  list  )

static

Definition at line 2171 of file gl2ps.cc.

{
  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->ofactor = prim->ofactor;
      b->ounits = prim->ounits;
      b->pattern = prim->pattern;
      b->factor = prim->factor;
      b->culled = prim->culled;
      b->width = prim->width;
      b->linecap = prim->linecap;
      b->linejoin = prim->linejoin;
      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);
    }
  }
 
}

References GL2PSprimitive::boundary, GL2PSprimitive::culled, GL2PSprimitive::factor, GL2PS_LINE, gl2psGetIndex(), gl2psListAdd(), gl2psMalloc(), gl2psNorm(), GL2PSprimitive::linecap, GL2PSprimitive::linejoin, GL2PSprimitive::numverts, GL2PSprimitive::ofactor, GL2PSprimitive::offset, GL2PSprimitive::ounits, GL2PSprimitive::pattern, GL2PSvertex::rgba, GL2PSprimitive::type, GL2PSprimitive::verts, GL2PSprimitive::width, and GL2PSvertex::xyz.

Referenced by gl2psBuildPolygonBoundary().

gl2psAddInBspImageTree()

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

static

Definition at line 2095 of file gl2ps.cc.

{
  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;
}

References gl2ps, GL2PS_COINCIDENT, GL2PS_IMAGEMAP, GL2PS_IN_BACK_OF, GL2PS_IN_FRONT_OF, GL2PS_LINE, GL2PS_PIXMAP, GL2PS_SPANNING, GL2PS_SPECIAL, GL2PS_TEXT, gl2psAddInBspImageTree(), gl2psAddPlanesInBspTreeImage(), gl2psCheckPrimitive(), gl2psFree(), gl2psSplitPrimitive2D(), GL2PScontext::primitivetoadd, GL2PSprimitive::type, GL2PSprimitive::verts, and GL2PScontext::zerosurfacearea.

Referenced by gl2psAddInBspImageTree(), and gl2psAddInImageTree().

gl2psAddIndex()

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

static

Definition at line 1335 of file gl2ps.cc.

{
  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)++;
}

Referenced by gl2psSplitPrimitive().

gl2psAddInImageTree()

static void gl2psAddInImageTree ( void *  data )

static

Definition at line 2154 of file gl2ps.cc.

{
  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;
  }
}

References GL2PSprimitive::culled, GL2PSprimitive::data, GL2PSimage::format, gl2ps, GL2PS_IMAGEMAP, GL2PS_IMAGEMAP_VISIBLE, gl2psAddInBspImageTree(), GL2PSprimitive::image, GL2PScontext::imagetree, GL2PScontext::primitivetoadd, and GL2PSprimitive::type.

Referenced by gl2psPrintPrimitives().

gl2psAddPlanesInBspTreeImage()

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

static

Definition at line 1856 of file gl2ps.cc.

{
  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;
  }
}

References GL2PSbsptree2d_::back, GL2PSbsptree2d_::front, GL2PS_POINT_BACK, GL2PS_POINT_COINCIDENT, GL2PS_POINT_INFRONT, gl2psCheckPoint(), gl2psFree(), gl2psGetPlaneFromPoints(), gl2psMalloc(), GL2PSprimitive::numverts, GL2PSbsptree2d_::plane, GL2PSprimitive::verts, and GL2PSvertex::xyz.

Referenced by gl2psAddInBspImageTree().

gl2psAddPolyPrimitive()

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

Definition at line 2263 of file gl2ps.cc.

{
  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 = (char)offset;
  prim->ofactor = ofactor;
  prim->ounits = ounits;
  prim->pattern = pattern;
  prim->factor = factor;
  prim->width = width;
  prim->linecap = linecap;
  prim->linejoin = linejoin;
  prim->culled = 0;
 
  /* FIXME: here we should have an option to split stretched
     tris/quads to enhance SIMPLE_SORT */
 
  gl2psListAdd(gl2ps->primitives, &prim);
}

References GL2PSprimitive::boundary, GL2PSprimitive::culled, GL2PSprimitive::factor, gl2ps, gl2psListAdd(), gl2psMalloc(), GL2PSprimitive::linecap, GL2PSprimitive::linejoin, GL2PSprimitive::numverts, GL2PSprimitive::ofactor, GL2PSprimitive::offset, GL2PSprimitive::ounits, GL2PSprimitive::pattern, GL2PScontext::primitives, GL2PSprimitive::type, GL2PSprimitive::verts, and GL2PSprimitive::width.

Referenced by gl2psParseFeedbackBuffer().

gl2psAddPrimitiveInList()

static void gl2psAddPrimitiveInList ( GL2PSprimitive *  prim, GL2PSlist *  list  )

static

Definition at line 1586 of file gl2ps.cc.

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

References GL2PS_QUADRANGLE, gl2psDivideQuad(), gl2psFreePrimitive(), gl2psListAdd(), and GL2PSprimitive::type.

Referenced by gl2psBuildBspTree().

gl2psAddText()

static GLint gl2psAddText ( GLint  type, const char *  str, const char *  fontname, GLshort  fontsize, GLint  alignment, GLfloat  angle, GL2PSrgba  color, GLboolean  setblpos, GLfloat  blx, GLfloat  bly  )

static

Definition at line 893 of file gl2ps.cc.

{
  GLfloat pos[4];
  GL2PSprimitive *prim;
  GLboolean valid;
 
  if(!gl2ps || !str || !fontname) return GL2PS_UNINITIALIZED;
 
  if(gl2ps->options & GL2PS_NO_TEXT) return GL2PS_SUCCESS;
 
  if (gl2ps->forcerasterpos) {
    pos[0] = gl2ps->rasterpos.xyz[0];
    pos[1] = gl2ps->rasterpos.xyz[1];
    pos[2] = gl2ps->rasterpos.xyz[2];
    pos[3] = 1.f;
  }
  else {
    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 = (GLshort)type;
  prim->boundary = 0;
  prim->numverts = setblpos ? 2 : 1;
  prim->verts = (GL2PSvertex*)gl2psMalloc(sizeof(GL2PSvertex) * prim->numverts);
  prim->verts[0].xyz[0] = pos[0];
  prim->verts[0].xyz[1] = pos[1];
  prim->verts[0].xyz[2] = pos[2];
  if (setblpos) {
    prim->verts[1].xyz[0] = blx;
    prim->verts[1].xyz[1] = bly;
    prim->verts[1].xyz[2] = 0;
  }
  prim->culled = 0;
  prim->offset = 0;
  prim->ofactor = 0.0;
  prim->ounits = 0.0;
  prim->pattern = 0;
  prim->factor = 0;
  prim->width = 1;
  prim->linecap = 0;
  prim->linejoin = 0;
 
  if (color) {
    memcpy(prim->verts[0].rgba, color, 4 * sizeof(float));
  }
  else {
    if (gl2ps->forcerasterpos) {
      prim->verts[0].rgba[0] = gl2ps->rasterpos.rgba[0];
      prim->verts[0].rgba[1] = gl2ps->rasterpos.rgba[1];
      prim->verts[0].rgba[2] = gl2ps->rasterpos.rgba[2];
      prim->verts[0].rgba[3] = gl2ps->rasterpos.rgba[3];
    }
    else {
      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;
 
  gl2ps->forcerasterpos = GL_FALSE;
 
  /* If no OpenGL context, just add directly to primitives */
  if (gl2ps->options & GL2PS_NO_OPENGL_CONTEXT) {
    gl2psListAdd(gl2ps->primitives, &prim);
  }
  else {
    gl2psListAdd(gl2ps->auxprimitives, &prim);
    glPassThrough(GL2PS_TEXT_TOKEN);
  }
 
  return GL2PS_SUCCESS;
}

References GL2PSstring::alignment, angle, GL2PSstring::angle, GL2PScontext::auxprimitives, GL2PSprimitive::boundary, GL2PSprimitive::culled, GL2PSprimitive::data, GL2PSprimitive::factor, GL2PSstring::fontname, GL2PSstring::fontsize, GL2PScontext::forcerasterpos, gl2ps, GL2PS_NO_OPENGL_CONTEXT, GL2PS_NO_TEXT, GL2PS_SUCCESS, GL2PS_TEXT_TOKEN, GL2PS_UNINITIALIZED, gl2psListAdd(), gl2psMalloc(), GL2PSprimitive::linecap, GL2PSprimitive::linejoin, GL2PSprimitive::numverts, GL2PSprimitive::ofactor, GL2PSprimitive::offset, GL2PScontext::options, GL2PSprimitive::ounits, GL2PSprimitive::pattern, pos, GL2PScontext::primitives, GL2PScontext::rasterpos, GL2PSvertex::rgba, GL2PSstring::str, GL2PSprimitive::text, GL2PSprimitive::type, GL2PSprimitive::verts, GL2PSprimitive::width, and GL2PSvertex::xyz.

Referenced by gl2psSpecial(), gl2psSpecialColor(), gl2psText(), gl2psTextOpt(), gl2psTextOptColor(), and gl2psTextOptColorBL().

gl2psAssignTriangleProperties()

static void gl2psAssignTriangleProperties ( GL2PStriangle *  t )

static

Definition at line 1038 of file gl2ps.cc.

{
  /* 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;
  }
}

References GL2PS_ZERO, GL2PStriangle::prop, GL2PSvertex::rgba, T_ALPHA_1, T_ALPHA_LESS_1, T_VAR_ALPHA, T_VAR_COLOR, and GL2PStriangle::vertex.

Referenced by gl2psFillTriangleFromPrimitive().

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 6002 of file gl2ps.cc.

{
  GLint idx;
  int i;
 
  if(gl2ps){
    gl2psMsg(GL2PS_ERROR, "gl2psBeginPage called in wrong program state");
    return GL2PS_ERROR;
  }
 
  gl2ps = (GL2PScontext*)gl2psMalloc(sizeof(GL2PScontext));
 
  /* Validate options */
  if (gl2psCheckOptions(options, colormode) == GL_FALSE) {
    gl2psFree(gl2ps);
    gl2ps = NULL;
    return GL2PS_ERROR;
  }
 
  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->forcerasterpos = GL_FALSE;
  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->lastlinecap = 0;
  gl2ps->lastlinejoin = 0;
  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) */
  if ((gl2ps->options & GL2PS_NO_BLENDING) == GL2PS_NONE) {
    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]);
  }
  else {
    gl2ps->blending = GL_FALSE;
  }
 
  if(gl2ps->colormode == GL_RGBA){
    gl2ps->colorsize = 0;
    gl2ps->colormap = NULL;
    if ((gl2ps->options & GL2PS_NO_OPENGL_CONTEXT) == GL2PS_NONE) {
      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, &idx);
    gl2ps->bgcolor[0] = gl2ps->colormap[idx][0];
    gl2ps->bgcolor[1] = gl2ps->colormap[idx][1];
    gl2ps->bgcolor[2] = gl2ps->colormap[idx][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*));
 
  if ((gl2ps->options & GL2PS_NO_OPENGL_CONTEXT) == GL2PS_NONE) {
    gl2ps->feedback = (GLfloat*)gl2psMalloc(gl2ps->buffersize * sizeof(GLfloat));
    glFeedbackBuffer(gl2ps->buffersize, GL_3D_COLOR, gl2ps->feedback);
    glRenderMode(GL_FEEDBACK);
  }
  else {
    gl2ps->feedback = NULL;
    gl2ps->buffersize = 0;
  }
 
  gl2ps->tex_scaling = 1.;
 
  return GL2PS_SUCCESS;
}

References GL2PScontext::auxprimitives, GL2PScontext::bgcolor, GL2PScontext::blendfunc, GL2PScontext::blending, GL2PScontext::buffersize, GL2PScontext::colormap, GL2PScontext::colormode, GL2PScontext::colorsize, GL2PScontext::compress, GL2PScontext::feedback, GL2PScontext::filename, GL2PScontext::forcerasterpos, GL2PScontext::format, gl2ps, GL2PS_BSP_SORT, GL2PS_ERROR, GL2PS_NO_BLENDING, GL2PS_NO_OPENGL_CONTEXT, GL2PS_NO_SORT, GL2PS_NONE, GL2PS_SIMPLE_SORT, GL2PS_SUCCESS, GL2PS_SVG, GL2PS_USE_CURRENT_VIEWPORT, gl2psbackends, gl2psCheckOptions(), gl2psFree(), gl2psListCreate(), gl2psMalloc(), gl2psMsg(), GL2PScontext::header, GL2PScontext::imagemap_head, GL2PScontext::imagemap_tail, GL2PScontext::imagetree, GL2PScontext::lastfactor, GL2PScontext::lastlinecap, GL2PScontext::lastlinejoin, GL2PScontext::lastlinewidth, GL2PScontext::lastpattern, GL2PScontext::lastrgba, GL2PScontext::lastvertex, GL2PScontext::maxbestroot, GL2PScontext::options, GL2PScontext::pdfgrouplist, GL2PScontext::pdfprimlist, GL2PScontext::primitives, GL2PScontext::primitivetoadd, GL2PScontext::producer, GL2PSvertex::rgba, GL2PScontext::sort, GL2PScontext::stream, GL2PScontext::tex_scaling, GL2PScontext::threshold, GL2PScontext::title, GL2PScontext::viewport, GL2PScontext::xreflist, GL2PSvertex::xyz, and GL2PScontext::zerosurfacearea.

gl2psBeginViewport()

GL2PSDLL_API GLint gl2psBeginViewport

(

GLint

viewport[4]

)

Definition at line 6223 of file gl2ps.cc.

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

References GL2PSbackend::beginViewport, GL2PScontext::format, gl2ps, GL2PS_SUCCESS, GL2PS_UNINITIALIZED, and gl2psbackends.

gl2psBlendFunc()

GL2PSDLL_API GLint gl2psBlendFunc	(	GLenum	sfactor,
		GLenum	dfactor
	)

Definition at line 6552 of file gl2ps.cc.

{
  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;
}

References gl2ps, GL2PS_DST_BLEND_TOKEN, GL2PS_SRC_BLEND_TOKEN, GL2PS_SUCCESS, GL2PS_UNINITIALIZED, GL2PS_WARNING, and gl2psSupportedBlendMode().

gl2psBuildBspTree()

static void gl2psBuildBspTree ( GL2PSbsptree *  tree, GL2PSlist *  primitives  )

static

Definition at line 1628 of file gl2ps.cc.

{
  GL2PSprimitive *prim = NULL, *frontprim = NULL, *backprim = NULL;
  GL2PSlist *frontlist, *backlist;
  GLint i, idx;
 
  tree->front = NULL;
  tree->back = NULL;
  tree->primitives = gl2psListCreate(1, 2, sizeof(GL2PSprimitive*));
  idx = 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 != idx){
      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);
}

References GL2PSbsptree_::back, GL2PSbsptree_::front, GL2PS_COINCIDENT, GL2PS_IN_BACK_OF, GL2PS_IN_FRONT_OF, GL2PS_SPANNING, gl2psAddPrimitiveInList(), gl2psBuildBspTree(), gl2psFindRoot(), gl2psFreePrimitive(), gl2psGetPlane(), gl2psListCreate(), gl2psListDelete(), gl2psListNbr(), gl2psListPointer(), gl2psListSort(), gl2psMalloc(), gl2psSplitPrimitive(), gl2psTrianglesFirst(), GL2PSbsptree_::plane, and GL2PSbsptree_::primitives.

Referenced by gl2psBuildBspTree(), and gl2psPrintPrimitives().

gl2psBuildPolygonBoundary()

static void gl2psBuildPolygonBoundary ( GL2PSbsptree *  tree )

static

Definition at line 2243 of file gl2ps.cc.

{
  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);
}

References GL2PSbsptree_::back, GL2PSprimitive::boundary, GL2PSbsptree_::front, gl2psAddBoundaryInList(), gl2psBuildPolygonBoundary(), gl2psListNbr(), gl2psListPointer(), and GL2PSbsptree_::primitives.

Referenced by gl2psBuildPolygonBoundary(), and gl2psPrintPrimitives().

gl2psCheckOptions()

static GLboolean gl2psCheckOptions ( GLint  options, GLint  colormode  )

static

Definition at line 5968 of file gl2ps.cc.

{
  if (options & GL2PS_NO_OPENGL_CONTEXT) {
    if (options & GL2PS_DRAW_BACKGROUND) {
      gl2psMsg(GL2PS_ERROR, "Options GL2PS_NO_OPENGL_CONTEXT and "
                            "GL2PS_DRAW_BACKGROUND are incompatible.");
      return GL_FALSE;
    }
    if (options & GL2PS_USE_CURRENT_VIEWPORT) {
      gl2psMsg(GL2PS_ERROR, "Options GL2PS_NO_OPENGL_CONTEXT and "
                            "GL2PS_USE_CURRENT_VIEWPORT are incompatible.");
      return GL_FALSE;
    }
    if ((options & GL2PS_NO_BLENDING) == GL2PS_NONE) {
      gl2psMsg(GL2PS_ERROR, "Option GL2PS_NO_OPENGL_CONTEXT requires "
                            "option GL2PS_NO_BLENDING.");
      return GL_FALSE;
    }
    if (colormode != GL_RGBA) {
      gl2psMsg(GL2PS_ERROR, "Option GL2PS_NO_OPENGL_CONTEXT requires colormode "
                            "to be GL_RGBA.");
      return GL_FALSE;
    }
  }
 
  return GL_TRUE;
}

References GL2PS_DRAW_BACKGROUND, GL2PS_ERROR, GL2PS_NO_BLENDING, GL2PS_NO_OPENGL_CONTEXT, GL2PS_NONE, GL2PS_USE_CURRENT_VIEWPORT, and gl2psMsg().

Referenced by gl2psBeginPage(), and gl2psSetOptions().

gl2psCheckPoint()

static GLint gl2psCheckPoint ( GL2PSxyz  point, GL2PSplane  plane  )

static

Definition at line 1846 of file gl2ps.cc.

{
  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;
}

References GL2PS_EPSILON, GL2PS_POINT_BACK, GL2PS_POINT_COINCIDENT, GL2PS_POINT_INFRONT, and gl2psComparePointPlane().

Referenced by gl2psAddPlanesInBspTreeImage(), gl2psCheckPrimitive(), and gl2psSplitPrimitive2D().

gl2psCheckPrimitive()

static GLint gl2psCheckPrimitive ( GL2PSprimitive *  prim, GL2PSplane  plane  )

static

Definition at line 1960 of file gl2ps.cc.

{
  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;
}

References GL2PS_COINCIDENT, GL2PS_IN_BACK_OF, GL2PS_IN_FRONT_OF, GL2PS_POINT_BACK, GL2PS_POINT_INFRONT, GL2PS_SPANNING, gl2psCheckPoint(), GL2PSprimitive::numverts, pos, GL2PSprimitive::verts, and GL2PSvertex::xyz.

Referenced by gl2psAddInBspImageTree().

gl2psClosePDFDataStream()

static int gl2psClosePDFDataStream ( void  )

static

Definition at line 4327 of file gl2ps.cc.

{
  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;
}

References GL2PScontext::compress, gl2ps, GL2PS_COMPRESS, GL2PS_ERROR, gl2psDeflate, gl2psFreeCompress, gl2psMsg(), GL2PScontext::options, GL2PScontext::stream, GL2PScontext::streamlength, and Z_OK.

Referenced by gl2psPrintPDFFooter().

gl2psCompareDepth()

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

static

Definition at line 1473 of file gl2ps.cc.

{
  const GL2PSprimitive *q, *w;
  GLfloat dq = 0.0F, dw = 0.0F, diff;
  int i;
 
  q = *(const GL2PSprimitive* const*)a;
  w = *(const GL2PSprimitive* const*)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{
    /* Ensure that initial ordering is preserved when depths match. */
    return q->sortid < w->sortid ? -1 : 1;
  }
}

References GL2PSprimitive::numverts, GL2PSprimitive::sortid, GL2PSprimitive::verts, and GL2PSvertex::xyz.

Referenced by gl2psPrintPrimitives().

gl2psComparePointPlane()

static GLfloat gl2psComparePointPlane ( GL2PSxyz  point, GL2PSplane  plane  )

static

Definition at line 1154 of file gl2ps.cc.

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

Referenced by gl2psCheckPoint(), gl2psCutEdge(), gl2psSplitPrimitive(), gl2psTestSplitPrimitive(), and gl2psTraverseBspTree().

gl2psComputeTightBoundingBox()

static void gl2psComputeTightBoundingBox ( void *  data )

static

Definition at line 5872 of file gl2ps.cc.

{
  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);
  }
}

References gl2ps, GL2PSprimitive::numverts, GL2PSprimitive::verts, GL2PScontext::viewport, and GL2PSvertex::xyz.

Referenced by gl2psPrintPrimitives().

gl2psCopyPixmap()

static GL2PSimage * gl2psCopyPixmap ( GL2PSimage *  im )

static

Definition at line 790 of file gl2ps.cc.

{
  int size;
  GL2PSimage *image = (GL2PSimage*)gl2psMalloc(sizeof(GL2PSimage));
 
  image->width = im->width;
  image->height = im->height;
  image->format = im->format;
  image->type = im->type;
  image->zoom_x = im->zoom_x;
  image->zoom_y = im->zoom_y;
 
  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;
}

References GL2PSimage::format, gl2psMalloc(), GL2PSimage::height, GL2PSimage::pixels, GL2PSimage::type, GL2PSimage::width, GL2PSimage::zoom_x, and GL2PSimage::zoom_y.

Referenced by gl2psCopyPrimitive().

gl2psCopyPrimitive()

static GL2PSprimitive * gl2psCopyPrimitive ( GL2PSprimitive *  p )

static

Definition at line 1098 of file gl2ps.cc.

{
  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->ofactor = p->ofactor;
  prim->ounits = p->ounits;
  prim->pattern = p->pattern;
  prim->factor = p->factor;
  prim->culled = p->culled;
  prim->width = p->width;
  prim->linecap = p->linecap;
  prim->linejoin = p->linejoin;
  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;
}

References GL2PSprimitive::boundary, GL2PSprimitive::culled, GL2PSprimitive::data, GL2PSprimitive::factor, GL2PS_ERROR, GL2PS_PIXMAP, GL2PS_SPECIAL, GL2PS_TEXT, gl2psCopyPixmap(), gl2psCopyText(), gl2psMalloc(), gl2psMsg(), GL2PSprimitive::image, GL2PSprimitive::linecap, GL2PSprimitive::linejoin, GL2PSprimitive::numverts, GL2PSprimitive::ofactor, GL2PSprimitive::offset, GL2PSprimitive::ounits, GL2PSprimitive::pattern, GL2PSprimitive::text, GL2PSprimitive::type, GL2PSprimitive::verts, and GL2PSprimitive::width.

Referenced by gl2psPrintPDFPrimitive().

gl2psCopyText()

static GL2PSstring * gl2psCopyText ( GL2PSstring *  t )

static

Definition at line 978 of file gl2ps.cc.

{
  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;
}

References GL2PSstring::alignment, GL2PSstring::angle, GL2PSstring::fontname, GL2PSstring::fontsize, gl2psMalloc(), and GL2PSstring::str.

Referenced by gl2psCopyPrimitive().

gl2psCreateSplitPrimitive()

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

static

Definition at line 1287 of file gl2ps.cc.

{
  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->ofactor = parent->ofactor;
  child->ounits = parent->ounits;
  child->pattern = parent->pattern;
  child->factor = parent->factor;
  child->width = parent->width;
  child->linecap = parent->linecap;
  child->linejoin = parent->linejoin;
  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]);
    }
  }
}

References GL2PSprimitive::boundary, GL2PSprimitive::culled, GL2PSprimitive::data, GL2PSprimitive::factor, GL2PS_IMAGEMAP, GL2PS_LINE, GL2PS_NO_TYPE, GL2PS_POINT, GL2PS_QUADRANGLE, GL2PS_TRIANGLE, GL2PS_WARNING, gl2psCutEdge(), gl2psMalloc(), gl2psMsg(), GL2PSprimitive::image, GL2PSprimitive::linecap, GL2PSprimitive::linejoin, GL2PSprimitive::numverts, GL2PSprimitive::ofactor, GL2PSprimitive::offset, GL2PSprimitive::ounits, GL2PSprimitive::pattern, GL2PSprimitive::type, GL2PSprimitive::verts, and GL2PSprimitive::width.

Referenced by gl2psSplitPrimitive().

gl2psCreateSplitPrimitive2D()

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

static

Definition at line 1975 of file gl2ps.cc.

{
  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->ofactor = parent->ofactor;
  child->ounits = parent->ounits;
  child->pattern = parent->pattern;
  child->factor = parent->factor;
  child->width = parent->width;
  child->linecap = parent->linecap;
  child->linejoin = parent->linejoin;
  child->numverts = numverts;
  child->verts = (GL2PSvertex*)gl2psMalloc(numverts * sizeof(GL2PSvertex));
  for(i = 0; i < numverts; i++){
    child->verts[i] = vertx[i];
  }
  return child;
}

References GL2PSprimitive::boundary, GL2PSprimitive::culled, GL2PSprimitive::data, GL2PSprimitive::factor, GL2PS_IMAGEMAP, GL2PS_LINE, GL2PS_NO_TYPE, GL2PS_POINT, GL2PS_QUADRANGLE, GL2PS_TRIANGLE, gl2psMalloc(), GL2PSprimitive::image, GL2PSprimitive::linecap, GL2PSprimitive::linejoin, GL2PSprimitive::numverts, GL2PSprimitive::ofactor, GL2PSprimitive::offset, GL2PSprimitive::ounits, GL2PSprimitive::pattern, GL2PSprimitive::type, GL2PSprimitive::verts, and GL2PSprimitive::width.

Referenced by gl2psSplitPrimitive2D().

gl2psCutEdge()

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

static

Definition at line 1262 of file gl2ps.cc.

{
  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];
}

References GL2PS_ZERO, gl2psComparePointPlane(), gl2psPsca(), GL2PSvertex::rgba, and GL2PSvertex::xyz.

Referenced by gl2psCreateSplitPrimitive(), and gl2psSplitPrimitive2D().

gl2psDisable()

GL2PSDLL_API GLint gl2psDisable

(

GLint

mode

)

Definition at line 6487 of file gl2ps.cc.

{
  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;
}

References gl2ps, GL2PS_BLEND, GL2PS_END_BLEND_TOKEN, GL2PS_END_BOUNDARY_TOKEN, GL2PS_END_OFFSET_TOKEN, GL2PS_END_STIPPLE_TOKEN, GL2PS_LINE_STIPPLE, GL2PS_POLYGON_BOUNDARY, GL2PS_POLYGON_OFFSET_FILL, GL2PS_SUCCESS, GL2PS_UNINITIALIZED, GL2PS_WARNING, and gl2psMsg().

gl2psDivideQuad()

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

static

Definition at line 1445 of file gl2ps.cc.

{
  *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)->ofactor = (*t2)->ofactor = quad->ofactor;
  (*t1)->ounits = (*t2)->ounits = quad->ounits;
  (*t1)->pattern = (*t2)->pattern = quad->pattern;
  (*t1)->factor = (*t2)->factor = quad->factor;
  (*t1)->width = (*t2)->width = quad->width;
  (*t1)->linecap = (*t2)->linecap = quad->linecap;
  (*t1)->linejoin = (*t2)->linejoin = quad->linejoin;
  (*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 & 8) ? 4 : 0);
}

References GL2PSprimitive::boundary, GL2PSprimitive::culled, GL2PSprimitive::factor, GL2PS_TRIANGLE, gl2psMalloc(), GL2PSprimitive::linecap, GL2PSprimitive::linejoin, GL2PSprimitive::ofactor, GL2PSprimitive::offset, GL2PSprimitive::ounits, GL2PSprimitive::pattern, GL2PSprimitive::verts, and GL2PSprimitive::width.

Referenced by gl2psAddPrimitiveInList().

gl2psDrawImageMap()

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

Definition at line 6426 of file gl2ps.cc.

                                                                   {
  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){
    const float *value = (const float*)imagemap;
    glPassThrough(*value);
    imagemap += sizeoffloat;
  }
  return GL2PS_SUCCESS;
}

References gl2ps, GL2PS_ERROR, GL2PS_IMAGEMAP_TOKEN, GL2PS_SUCCESS, and GL2PS_UNINITIALIZED.

gl2psDrawPixels()

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

Definition at line 6312 of file gl2ps.cc.

{
  int size, i;
  const GLfloat *piv;
  GLfloat pos[4], zoom_x, zoom_y;
  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;
  }
 
  if (gl2ps->forcerasterpos) {
    pos[0] = gl2ps->rasterpos.xyz[0];
    pos[1] = gl2ps->rasterpos.xyz[1];
    pos[2] = gl2ps->rasterpos.xyz[2];
    pos[3] = 1.f;
    /* Hardcode zoom factors (for now?) */
    zoom_x = 1.f;
    zoom_y = 1.f;
  }
  else {
    glGetBooleanv(GL_CURRENT_RASTER_POSITION_VALID, &valid);
    if(GL_FALSE == valid) return GL2PS_SUCCESS; /* the primitive is culled */
    glGetFloatv(GL_CURRENT_RASTER_POSITION, pos);
    glGetFloatv(GL_ZOOM_X, &zoom_x);
    glGetFloatv(GL_ZOOM_Y, &zoom_y);
  }
 
  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->ofactor = 0.0;
  prim->ounits = 0.0;
  prim->pattern = 0;
  prim->factor = 0;
  prim->width = 1;
  if (gl2ps->forcerasterpos) {
    prim->verts[0].rgba[0] = gl2ps->rasterpos.rgba[0];
    prim->verts[0].rgba[1] = gl2ps->rasterpos.rgba[1];
    prim->verts[0].rgba[2] = gl2ps->rasterpos.rgba[2];
    prim->verts[0].rgba[3] = gl2ps->rasterpos.rgba[3];
  }
  else {
    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->zoom_x = zoom_x;
  prim->data.image->zoom_y = zoom_y;
  prim->data.image->format = format;
  prim->data.image->type = type;
 
  gl2ps->forcerasterpos = GL_FALSE;
 
  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 = (const 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;
  }
 
  /* If no OpenGL context, just add directly to primitives */
  if ((gl2ps->options & GL2PS_NO_OPENGL_CONTEXT) == GL2PS_NONE) {
    gl2psListAdd(gl2ps->auxprimitives, &prim);
    glPassThrough(GL2PS_DRAW_PIXELS_TOKEN);
  }
  else {
    gl2psListAdd(gl2ps->primitives, &prim);
  }
 
  return GL2PS_SUCCESS;
}

References GL2PScontext::auxprimitives, GL2PScontext::blending, GL2PSprimitive::boundary, GL2PSprimitive::culled, GL2PSprimitive::data, GL2PSprimitive::factor, GL2PScontext::forcerasterpos, GL2PSimage::format, gl2ps, GL2PS_DRAW_PIXELS_TOKEN, GL2PS_ERROR, GL2PS_NO_BLENDING, GL2PS_NO_OPENGL_CONTEXT, GL2PS_NO_PIXMAP, GL2PS_NONE, GL2PS_PIXMAP, GL2PS_SUCCESS, GL2PS_UNINITIALIZED, gl2psListAdd(), gl2psMalloc(), gl2psMsg(), GL2PSimage::height, GL2PSprimitive::image, GL2PSprimitive::numverts, GL2PSprimitive::ofactor, GL2PSprimitive::offset, GL2PScontext::options, GL2PSprimitive::ounits, GL2PSprimitive::pattern, GL2PSimage::pixels, pos, GL2PScontext::primitives, GL2PScontext::rasterpos, GL2PSvertex::rgba, GL2PSimage::type, GL2PSprimitive::type, GL2PSprimitive::verts, GL2PSimage::width, GL2PSprimitive::width, GL2PSvertex::xyz, GL2PSimage::zoom_x, and GL2PSimage::zoom_y.

gl2psEnable()

GL2PSDLL_API GLint gl2psEnable

(

GLint

mode

)

Definition at line 6451 of file gl2ps.cc.

{
  GLint tmp;
  GLfloat tmp2;
 
  if(!gl2ps) return GL2PS_UNINITIALIZED;
 
  switch(mode){
  case GL2PS_POLYGON_OFFSET_FILL :
    glPassThrough(GL2PS_BEGIN_OFFSET_TOKEN);
    glGetFloatv(GL_POLYGON_OFFSET_FACTOR, &tmp2);
    glPassThrough(tmp2);
    glGetFloatv(GL_POLYGON_OFFSET_UNITS, &tmp2);
    glPassThrough(tmp2);
    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;
}

References gl2ps, GL2PS_BEGIN_BLEND_TOKEN, GL2PS_BEGIN_BOUNDARY_TOKEN, GL2PS_BEGIN_OFFSET_TOKEN, GL2PS_BEGIN_STIPPLE_TOKEN, GL2PS_BLEND, GL2PS_LINE_STIPPLE, GL2PS_POLYGON_BOUNDARY, GL2PS_POLYGON_OFFSET_FILL, GL2PS_SUCCESS, GL2PS_UNINITIALIZED, GL2PS_WARNING, and gl2psMsg().

gl2psEndPage()

GL2PSDLL_API GLint gl2psEndPage

(

void

)

Definition at line 6196 of file gl2ps.cc.

{
  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;
}

References GL2PScontext::auxprimitives, GL2PScontext::colormap, GL2PScontext::feedback, GL2PScontext::filename, GL2PScontext::format, gl2ps, GL2PS_OVERFLOW, GL2PS_UNINITIALIZED, gl2psbackends, gl2psFree(), gl2psFreeImagemap(), gl2psListDelete(), gl2psPrintPrimitives(), GL2PScontext::imagemap_head, GL2PScontext::primitives, GL2PSbackend::printFooter, GL2PScontext::producer, GL2PScontext::stream, and GL2PScontext::title.

gl2psEndPostScriptLine()

static void gl2psEndPostScriptLine ( void  )

static

Definition at line 3038 of file gl2ps.cc.

{
  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.;
  }
}

References gl2ps, gl2psPrintf(), GL2PScontext::lastvertex, GL2PSvertex::rgba, and GL2PSvertex::xyz.

Referenced by gl2psPrintPostScriptFinalPrimitive(), and gl2psPrintPostScriptPrimitive().

gl2psEndSVGLine()

static void gl2psEndSVGLine ( void  )

static

Definition at line 5257 of file gl2ps.cc.

{
  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.;
  }
}

References gl2ps, gl2psPrintf(), GL2PScontext::lastvertex, GL2PSvertex::rgba, GL2PScontext::viewport, and GL2PSvertex::xyz.

Referenced by gl2psPrintSVGFinalPrimitive(), and gl2psPrintSVGPrimitive().

gl2psEndViewport()

GL2PSDLL_API GLint gl2psEndViewport

(

void

)

Definition at line 6232 of file gl2ps.cc.

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

References GL2PSbackend::endViewport, GL2PScontext::format, gl2ps, GL2PS_UNINITIALIZED, gl2psbackends, and gl2psResetLineProperties().

gl2psFillTriangleFromPrimitive()

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

static

Definition at line 1071 of file gl2ps.cc.

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

References gl2psAssignTriangleProperties(), GL2PStriangle::vertex, and GL2PSprimitive::verts.

Referenced by gl2psPDFgroupListInit(), gl2psPDFgroupListWriteMainStream(), gl2psPDFgroupListWriteObjects(), and gl2psSortOutTrianglePDFgroup().

gl2psFindRoot()

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

static

Definition at line 1514 of file gl2ps.cc.

{
  GLint i, j, count, best = 1000000, idx = 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;
        idx = i;
        *root = prim1;
        if(!count) return idx;
      }
    }
    /* if(index) gl2psMsg(GL2PS_INFO, "GL2PS_BEST_ROOT was worth it: %d", index); */
    return idx;
  }
  else{
    return 0;
  }
}

References gl2ps, GL2PS_BEST_ROOT, GL2PS_ERROR, gl2psGetPlane(), gl2psListNbr(), gl2psListPointer(), gl2psMsg(), gl2psTestSplitPrimitive(), GL2PScontext::maxbestroot, and GL2PScontext::options.

Referenced by gl2psBuildBspTree().

gl2psForceRasterPos()

GL2PSDLL_API GLint gl2psForceRasterPos

(

GL2PSvertex *

vert

)

Definition at line 6617 of file gl2ps.cc.

{
 
  if(!gl2ps) {
    return GL2PS_UNINITIALIZED;
  }
 
  gl2ps->forcerasterpos = GL_TRUE;
  gl2ps->rasterpos.xyz[0] = vert->xyz[0];
  gl2ps->rasterpos.xyz[1] = vert->xyz[1];
  gl2ps->rasterpos.xyz[2] = vert->xyz[2];
  gl2ps->rasterpos.rgba[0] = vert->rgba[0];
  gl2ps->rasterpos.rgba[1] = vert->rgba[1];
  gl2ps->rasterpos.rgba[2] = vert->rgba[2];
  gl2ps->rasterpos.rgba[3] = vert->rgba[3];
 
  return GL2PS_SUCCESS;
}

References GL2PScontext::forcerasterpos, gl2ps, GL2PS_SUCCESS, GL2PS_UNINITIALIZED, GL2PScontext::rasterpos, GL2PSvertex::rgba, and GL2PSvertex::xyz.

gl2psFree()

static void gl2psFree ( void *  ptr )

static

Definition at line 334 of file gl2ps.cc.

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

References free.

Referenced by gl2psAddInBspImageTree(), gl2psAddPlanesInBspTreeImage(), gl2psBeginPage(), gl2psEndPage(), gl2psFreeBspImageTree(), gl2psFreeBspTree(), gl2psFreeImagemap(), gl2psFreePixmap(), gl2psFreePrimitive(), gl2psFreeText(), gl2psListDelete(), gl2psPDFgroupListWriteObjects(), gl2psPrintf(), gl2psPrintGzipFooter(), gl2psPrintPDFFooter(), gl2psSorting(), and gl2psSplitPrimitive2D().

gl2psFreeBspImageTree()

static void gl2psFreeBspImageTree ( GL2PSbsptree2d **  tree )

static

Definition at line 1836 of file gl2ps.cc.

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

References gl2psFree(), and gl2psFreeBspImageTree().

Referenced by gl2psFreeBspImageTree(), and gl2psPrintPrimitives().

gl2psFreeBspTree()

static void gl2psFreeBspTree ( GL2PSbsptree **  tree )

static

Definition at line 1602 of file gl2ps.cc.

{
  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;
  }
}

References gl2psFree(), gl2psFreeBspTree(), gl2psFreePrimitive(), gl2psListAction(), and gl2psListDelete().

Referenced by gl2psFreeBspTree(), and gl2psPrintPrimitives().

gl2psFreeImagemap()

static void gl2psFreeImagemap ( GL2PSimagemap *  list )

static

Definition at line 1559 of file gl2ps.cc.

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

References gl2psFree(), GL2PSimagemap_::image, GL2PSimagemap_::next, and GL2PSimage::pixels.

Referenced by gl2psEndPage().

gl2psFreePixmap()

static void gl2psFreePixmap ( GL2PSimage *  im )

static

Definition at line 818 of file gl2ps.cc.

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

References gl2psFree(), and GL2PSimage::pixels.

Referenced by gl2psFreePrimitive().

gl2psFreePrimitive()

static void gl2psFreePrimitive ( void *  data )

static

Definition at line 1571 of file gl2ps.cc.

{
  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);
}

References GL2PSprimitive::data, GL2PS_PIXMAP, GL2PS_SPECIAL, GL2PS_TEXT, gl2psFree(), gl2psFreePixmap(), gl2psFreeText(), GL2PSprimitive::image, GL2PSprimitive::text, GL2PSprimitive::type, and GL2PSprimitive::verts.

Referenced by gl2psAddPrimitiveInList(), gl2psBuildBspTree(), gl2psFreeBspTree(), gl2psPrintPDFFooter(), and gl2psPrintPrimitives().

gl2psFreeText()

static void gl2psFreeText ( GL2PSstring *  text )

static

Definition at line 992 of file gl2ps.cc.

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

References GL2PSstring::fontname, gl2psFree(), and GL2PSstring::str.

Referenced by gl2psFreePrimitive().

gl2psGetFileExtension()

GL2PSDLL_API const char * gl2psGetFileExtension

(

GLint

format

)

Definition at line 6592 of file gl2ps.cc.

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

References GL2PSbackend::file_extension, and gl2psbackends.

gl2psGetFileFormat()

GL2PSDLL_API GLint gl2psGetFileFormat

(

)

Definition at line 6608 of file gl2ps.cc.

{
  if(!gl2ps) {
    return GL2PS_UNINITIALIZED;
  }
 
  return gl2ps->format;
}

References GL2PScontext::format, gl2ps, and GL2PS_UNINITIALIZED.

gl2psGetFormatDescription()

GL2PSDLL_API const char * gl2psGetFormatDescription

(

GLint

format

)

Definition at line 6600 of file gl2ps.cc.

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

References GL2PSbackend::description, and gl2psbackends.

gl2psGetIndex()

static GLshort gl2psGetIndex ( GLshort  i, GLshort  num  )

static

Definition at line 1349 of file gl2ps.cc.

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

Referenced by gl2psAddBoundaryInList(), gl2psSplitPrimitive(), and gl2psTestSplitPrimitive().

gl2psGetNormal()

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

static

Definition at line 1179 of file gl2ps.cc.

{
  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;
  }
}

References GL2PS_ZERO, gl2psNorm(), and gl2psPvec().

Referenced by gl2psGetPlane().

gl2psGetOptions()

GL2PSDLL_API GLint gl2psGetOptions

(

GLint *

options

)

Definition at line 6580 of file gl2ps.cc.

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

References gl2ps, GL2PS_SUCCESS, GL2PS_UNINITIALIZED, and GL2PScontext::options.

gl2psGetPlane()

static void gl2psGetPlane ( GL2PSprimitive *  prim, GL2PSplane  plane  )

static

Definition at line 1198 of file gl2ps.cc.

{
  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;
  }
}

References GL2PS_ERROR, GL2PS_IMAGEMAP, GL2PS_LINE, GL2PS_PIXMAP, GL2PS_POINT, GL2PS_QUADRANGLE, GL2PS_SPECIAL, GL2PS_TEXT, GL2PS_TRIANGLE, GL2PS_ZERO, gl2psGetNormal(), gl2psMsg(), GL2PSprimitive::type, GL2PSprimitive::verts, and GL2PSvertex::xyz.

Referenced by gl2psBuildBspTree(), and gl2psFindRoot().

gl2psGetPlaneFromPoints()

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

static

Definition at line 1814 of file gl2ps.cc.

{
  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;
  }
}

References GL2PS_ZERO, and CLHEP::detail::n.

Referenced by gl2psAddPlanesInBspTreeImage().

gl2psGetRGB()

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

static

Definition at line 762 of file gl2ps.cc.

{
 
  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;
}

References GL2PSimage::format, GL2PSimage::height, GL2PSimage::pixels, and GL2PSimage::width.

Referenced by gl2psPrintPDFPixmapStreamData(), and gl2psPrintPostScriptPixmap().

gl2psGetVertex()

static GLint gl2psGetVertex ( GL2PSvertex *  v, GLfloat *  p  )

static

Definition at line 2294 of file gl2ps.cc.

{
  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;
  }
}

References GL2PScontext::colormap, GL2PScontext::colormode, GL2PScontext::colorsize, gl2ps, GL2PSvertex::rgba, and GL2PSvertex::xyz.

Referenced by gl2psParseFeedbackBuffer().

gl2psGreater()

static GLboolean gl2psGreater ( GLfloat  f1, GLfloat  f2  )

static

Definition at line 1616 of file gl2ps.cc.

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

Referenced by gl2psPrintPrimitives().

gl2psInitTriangle()

static void gl2psInitTriangle ( GL2PStriangle *  t )

static

Definition at line 1081 of file gl2ps.cc.

{
  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;
}

References GL2PStriangle::prop, T_UNDEFINED, and GL2PStriangle::vertex.

Referenced by gl2psPDFgroupListInit().

gl2psLess()

static GLboolean gl2psLess ( GLfloat  f1, GLfloat  f2  )

static

Definition at line 1622 of file gl2ps.cc.

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

Referenced by gl2psPrintPrimitives().

gl2psLineCap()

GL2PSDLL_API GLint gl2psLineCap

(

GLint

value

)

Definition at line 6522 of file gl2ps.cc.

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

References gl2ps, GL2PS_LINE_CAP_TOKEN, GL2PS_SUCCESS, and GL2PS_UNINITIALIZED.

gl2psLineJoin()

GL2PSDLL_API GLint gl2psLineJoin

(

GLint

value

)

Definition at line 6532 of file gl2ps.cc.

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

References gl2ps, GL2PS_LINE_JOIN_TOKEN, GL2PS_SUCCESS, and GL2PS_UNINITIALIZED.

gl2psLineWidth()

GL2PSDLL_API GLint gl2psLineWidth

(

GLfloat

value

)

Definition at line 6542 of file gl2ps.cc.

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

References gl2ps, GL2PS_LINE_WIDTH_TOKEN, GL2PS_SUCCESS, and GL2PS_UNINITIALIZED.

gl2psListAction()

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

static

Definition at line 642 of file gl2ps.cc.

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

References gl2psListNbr(), and gl2psListPointer().

Referenced by gl2psFreeBspTree(), gl2psPrintPDFFooter(), gl2psPrintPrimitives(), and gl2psTraverseBspTree().

gl2psListActionInverse()

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

static

Definition at line 651 of file gl2ps.cc.

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

References gl2psListNbr(), and gl2psListPointer().

Referenced by gl2psPrintPrimitives(), and gl2psTraverseBspTree().

gl2psListAdd()

static void gl2psListAdd ( GL2PSlist *  list, void *  data  )

static

Definition at line 594 of file gl2ps.cc.

{
  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);
}

References GL2PSlist::array, GL2PS_ERROR, gl2psListRealloc(), gl2psMsg(), GL2PSlist::n, and GL2PSlist::size.

Referenced by gl2psAddBoundaryInList(), gl2psAddPolyPrimitive(), gl2psAddPrimitiveInList(), gl2psAddText(), gl2psDrawPixels(), gl2psParseFeedbackBuffer(), gl2psPDFgroupListInit(), and gl2psPrintPDFPrimitive().

gl2psListAssignSortIds()

static void gl2psListAssignSortIds ( GL2PSlist *  list )

static

Definition at line 634 of file gl2ps.cc.

{
  GLint i;
  for(i = 0; i < gl2psListNbr(list); i++){
    (*(GL2PSprimitive**)gl2psListPointer(list, i))->sortid = i;
  }
}

References gl2psListNbr(), and gl2psListPointer().

Referenced by gl2psPrintPrimitives().

gl2psListCreate()

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

static

Definition at line 565 of file gl2ps.cc.

{
  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;
}

References GL2PSlist::array, gl2psListRealloc(), gl2psMalloc(), GL2PSlist::incr, CLHEP::detail::n, GL2PSlist::n, GL2PSlist::nmax, and GL2PSlist::size.

Referenced by gl2psBeginPage(), gl2psBuildBspTree(), gl2psPDFgroupListInit(), gl2psPrintPDFHeader(), gl2psPrintPrimitives(), and gl2psPrintSVGPixmap().

gl2psListDelete()

static void gl2psListDelete ( GL2PSlist *  list )

static

Definition at line 587 of file gl2ps.cc.

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

References GL2PSlist::array, and gl2psFree().

Referenced by gl2psBuildBspTree(), gl2psEndPage(), gl2psFreeBspTree(), gl2psPDFgroupListDelete(), gl2psPrintPDFFooter(), and gl2psPrintSVGPixmap().

gl2psListNbr()

static int gl2psListNbr ( GL2PSlist *  list )

static

Definition at line 605 of file gl2ps.cc.

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

References GL2PSlist::n.

Referenced by gl2psBuildBspTree(), gl2psBuildPolygonBoundary(), gl2psFindRoot(), gl2psListAction(), gl2psListActionInverse(), gl2psListAssignSortIds(), gl2psParseFeedbackBuffer(), gl2psPDFgroupListDelete(), gl2psPDFgroupListInit(), gl2psPDFgroupListWriteFontResources(), gl2psPDFgroupListWriteGStateResources(), gl2psPDFgroupListWriteMainStream(), gl2psPDFgroupListWriteObjects(), gl2psPDFgroupListWriteShaderResources(), gl2psPDFgroupListWriteXObjectResources(), gl2psPrintPrimitives(), gl2psPrintSVGPixmap(), gl2psRescaleAndOffset(), and gl2psSortOutTrianglePDFgroup().

gl2psListPointer()

static void * gl2psListPointer ( GL2PSlist *  list, GLint  idx  )

static

Definition at line 612 of file gl2ps.cc.

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

References GL2PSlist::array, GL2PS_ERROR, gl2psMsg(), GL2PSlist::n, and GL2PSlist::size.

Referenced by gl2psBuildBspTree(), gl2psBuildPolygonBoundary(), gl2psFindRoot(), gl2psListAction(), gl2psListActionInverse(), gl2psListAssignSortIds(), gl2psParseFeedbackBuffer(), gl2psPDFgroupListDelete(), gl2psPDFgroupListInit(), gl2psPDFgroupListWriteFontResources(), gl2psPDFgroupListWriteGStateResources(), gl2psPDFgroupListWriteMainStream(), gl2psPDFgroupListWriteObjects(), gl2psPDFgroupListWriteShaderResources(), gl2psPDFgroupListWriteXObjectResources(), gl2psRescaleAndOffset(), and gl2psSortOutTrianglePDFgroup().

gl2psListRealloc()

static void gl2psListRealloc ( GL2PSlist *  list, GLint  n  )

static

Definition at line 545 of file gl2ps.cc.

{
  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);
    }
  }
}

References GL2PSlist::array, GL2PS_ERROR, gl2psMalloc(), gl2psMsg(), gl2psRealloc(), GL2PSlist::incr, CLHEP::detail::n, GL2PSlist::nmax, and GL2PSlist::size.

Referenced by gl2psListAdd(), and gl2psListCreate().

gl2psListReset()

static void gl2psListReset ( GL2PSlist *  list )

static

Definition at line 581 of file gl2ps.cc.

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

References GL2PSlist::n.

Referenced by gl2psParseFeedbackBuffer(), and gl2psPrintPrimitives().

gl2psListSort()

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

static

Definition at line 625 of file gl2ps.cc.

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

References GL2PSlist::array, GL2PSlist::n, and GL2PSlist::size.

Referenced by gl2psBuildBspTree(), and gl2psPrintPrimitives().

gl2psMalloc()

static void * gl2psMalloc ( size_t  size )

static

Definition at line 308 of file gl2ps.cc.

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

References GL2PS_ERROR, and gl2psMsg().

Referenced by gl2psAddBoundaryInList(), gl2psAddPlanesInBspTreeImage(), gl2psAddPolyPrimitive(), gl2psAddText(), gl2psBeginPage(), gl2psBuildBspTree(), gl2psCopyPixmap(), gl2psCopyPrimitive(), gl2psCopyText(), gl2psCreateSplitPrimitive(), gl2psCreateSplitPrimitive2D(), gl2psDivideQuad(), gl2psDrawPixels(), gl2psListCreate(), gl2psListRealloc(), gl2psParseFeedbackBuffer(), gl2psPDFgroupListWriteObjects(), gl2psPrintf(), gl2psPrintPDFHeader(), gl2psPrintPrimitives(), and gl2psSplitPrimitive().

gl2psMsg()

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

static

Definition at line 290 of file gl2ps.cc.

{
  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); */
}

References args, gl2ps, GL2PS_ERROR, GL2PS_INFO, GL2PS_SILENT, GL2PS_WARNING, and GL2PScontext::options.

Referenced by gl2psBeginPage(), gl2psCheckOptions(), gl2psClosePDFDataStream(), gl2psCopyPrimitive(), gl2psCreateSplitPrimitive(), gl2psDisable(), gl2psDrawPixels(), gl2psEnable(), gl2psFindRoot(), gl2psGetPlane(), gl2psListAdd(), gl2psListPointer(), gl2psListRealloc(), gl2psMalloc(), gl2psParseFeedbackBuffer(), gl2psPrintGzipFooter(), gl2psPrintPostScriptPrimitive(), gl2psPrintPrimitives(), gl2psPrintSVGPixmap(), gl2psPrintSVGPrimitive(), gl2psRealloc(), and gl2psSorting().

gl2psNorm()

static GLfloat gl2psNorm ( GLfloat *  a )

static

Definition at line 1174 of file gl2ps.cc.

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

Referenced by gl2psAddBoundaryInList(), and gl2psGetNormal().

gl2psOpenPDFDataStream()

static int gl2psOpenPDFDataStream ( void  )

static

Definition at line 4246 of file gl2ps.cc.

{
  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;
}

References gl2ps, gl2psPrintPDFCompressorType(), and GL2PScontext::stream.

Referenced by gl2psPrintPDFHeader().

gl2psOpenPDFDataStreamWritePreface()

static int gl2psOpenPDFDataStreamWritePreface ( void  )

static

Definition at line 4263 of file gl2ps.cc.

{
  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;
}

References GL2PScontext::bgcolor, gl2ps, GL2PS_DRAW_BACKGROUND, gl2psPrintf(), gl2psPrintPDFFillColor(), GL2PScontext::options, and GL2PScontext::viewport.

Referenced by gl2psPrintPDFHeader().

gl2psParseFeedbackBuffer()

static void gl2psParseFeedbackBuffer ( GLint  used )

static

Definition at line 2319 of file gl2ps.cc.

{
  char flag;
  GLushort pattern = 0;
  GLboolean boundary;
  GLint i, sizeoffloat, count, v, vtot, offset = 0, factor = 0, auxindex = 0;
  GLint lcap = 0, ljoin = 0;
  GLfloat lwidth = 1.0F, psize = 1.0F, ofactor = 0.0F, ounits = 0.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, 0.0, 0.0,
                            pattern, factor, psize, lcap, ljoin, 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, 0.0, 0.0,
                            pattern, factor, lwidth, lcap, ljoin, 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, ofactor,
                                ounits, pattern, factor, 1, lcap, ljoin,
                                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;
        current += 2;
        used -= 2;
        ofactor = current[1];
        current += 2;
        used -= 2;
        ounits = current[1];
        break;
      case GL2PS_END_OFFSET_TOKEN :
        offset = 0;
        ofactor = 0.0;
        ounits = 0.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 = 0; 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_CAP_TOKEN :
        current += 2;
        used -= 2;
        lcap = (GLint)current[1];
        break;
      case GL2PS_LINE_JOIN_TOKEN :
        current += 2;
        used -= 2;
        ljoin = (GLint)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->ofactor = 0.0;
        prim->ounits = 0.0;
        prim->pattern = 0;
        prim->factor = 0;
        prim->width = 1;
 
        node = (GL2PSimagemap*)gl2psMalloc(sizeof(GL2PSimagemap));
        node->image = (GL2PSimage*)gl2psMalloc(sizeof(GL2PSimage));
        node->image->type = 0;
        node->image->format = 0;
        node->image->zoom_x = 1.0F;
        node->image->zoom_y = 1.0F;
        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(&(((char*)(node->image->pixels))[i + v]), &(current[2]), sizeoffloat);
          else
            memcpy(&(((char*)(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);
}

References GL2PScontext::auxprimitives, GL2PScontext::blendfunc, GL2PScontext::blending, GL2PSprimitive::boundary, GL2PScontext::boundary, GL2PSprimitive::culled, GL2PSprimitive::data, GL2PSprimitive::factor, GL2PScontext::feedback, GL2PSimage::format, gl2ps, GL2PS_BEGIN_BLEND_TOKEN, GL2PS_BEGIN_BOUNDARY_TOKEN, GL2PS_BEGIN_OFFSET_TOKEN, GL2PS_BEGIN_STIPPLE_TOKEN, GL2PS_DRAW_PIXELS_TOKEN, GL2PS_DST_BLEND_TOKEN, GL2PS_END_BLEND_TOKEN, GL2PS_END_BOUNDARY_TOKEN, GL2PS_END_OFFSET_TOKEN, GL2PS_END_STIPPLE_TOKEN, GL2PS_ERROR, GL2PS_IMAGEMAP, GL2PS_IMAGEMAP_TOKEN, GL2PS_LINE, GL2PS_LINE_CAP_TOKEN, GL2PS_LINE_JOIN_TOKEN, GL2PS_LINE_WIDTH_TOKEN, GL2PS_POINT, GL2PS_POINT_SIZE_TOKEN, GL2PS_SRC_BLEND_TOKEN, GL2PS_TEXT_TOKEN, GL2PS_TRIANGLE, GL2PS_WARNING, gl2psAdaptVertexForBlending(), gl2psAddPolyPrimitive(), gl2psGetVertex(), gl2psListAdd(), gl2psListNbr(), gl2psListPointer(), gl2psListReset(), gl2psMalloc(), gl2psMsg(), GL2PSimage::height, GL2PSimagemap_::image, GL2PSprimitive::image, GL2PScontext::imagemap_head, GL2PScontext::imagemap_tail, GL2PSimagemap_::next, GL2PSprimitive::numverts, GL2PSprimitive::ofactor, GL2PSprimitive::offset, GL2PSprimitive::ounits, GL2PSprimitive::pattern, GL2PSimage::pixels, GL2PScontext::primitives, GL2PSvertex::rgba, GL2PSimage::type, GL2PSprimitive::type, GL2PSprimitive::verts, GL2PSimage::width, GL2PSprimitive::width, GL2PSvertex::xyz, GL2PSimage::zoom_x, and GL2PSimage::zoom_y.

Referenced by gl2psPrintPrimitives().

gl2psParseStipplePattern()

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

static

Definition at line 3050 of file gl2ps.cc.

{
  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; n--){
    array[(*nb)++] = factor * on[n];
    array[(*nb)++] = factor * off[n];
    if(*nb == 10) break;
  }
}

References CLHEP::detail::n.

Referenced by gl2psPrintPGFDash(), gl2psPrintPostScriptDash(), and gl2psPrintSVGDash().

gl2psPDFgroupListDelete()

static void gl2psPDFgroupListDelete ( void  )

static

Definition at line 4161 of file gl2ps.cc.

{
  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;
}

References gl2ps, gl2psListDelete(), gl2psListNbr(), gl2psListPointer(), GL2PScontext::pdfgrouplist, and GL2PSpdfgroup::ptrlist.

Referenced by gl2psPrintPDFFooter().

gl2psPDFgroupListInit()

static void gl2psPDFgroupListInit ( void  )

static

Definition at line 3692 of file gl2ps.cc.

{
  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;
  GLint lastlinecap = 0;
  GLint lastlinejoin = 0;
  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 ||
         lastlinecap != p->linecap || lastlinejoin != p->linejoin ||
         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;
      lastlinecap = p->linecap;
      lastlinejoin = p->linejoin;
      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;
    case GL2PS_SPECIAL:
      gl2psPDFgroupObjectInit(&gro);
      gro.ptrlist = gl2psListCreate(1, 2, sizeof(GL2PSprimitive*));
      gl2psListAdd(gro.ptrlist, &p);
      gl2psListAdd(gl2ps->pdfgrouplist, &gro);
      break;
    default:
      break;
    }
    lasttype = p->type;
  }
}

References GL2PSprimitive::factor, GL2PScontext::font_stack, GL2PSpdfgroup::fontno, gl2ps, GL2PS_LINE, GL2PS_NO_TYPE, GL2PS_PIXMAP, GL2PS_POINT, GL2PS_SPECIAL, GL2PS_TEXT, GL2PS_TRIANGLE, gl2psFillTriangleFromPrimitive(), gl2psInitTriangle(), gl2psListAdd(), gl2psListCreate(), gl2psListNbr(), gl2psListPointer(), gl2psPDFgroupObjectInit(), gl2psSameColor(), GL2PScontext::im_stack, GL2PSpdfgroup::imno, GL2PSprimitive::linecap, GL2PSprimitive::linejoin, GL2PSprimitive::pattern, GL2PScontext::pdfgrouplist, GL2PScontext::pdfprimlist, GL2PStriangle::prop, GL2PSpdfgroup::ptrlist, GL2PSvertex::rgba, T_ALPHA_1, T_CONST_COLOR, GL2PSprimitive::type, GL2PStriangle::vertex, GL2PSprimitive::verts, and GL2PSprimitive::width.

Referenced by gl2psPrintPDFFooter().

gl2psPDFgroupListWriteFontResources()

static int gl2psPDFgroupListWriteFontResources ( void  )

static

Definition at line 4141 of file gl2ps.cc.

{
  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;
}

References GL2PSpdfgroup::fontno, GL2PSpdfgroup::fontobjno, gl2ps, gl2psListNbr(), gl2psListPointer(), GL2PScontext::objects_stack, GL2PScontext::pdfgrouplist, and GL2PScontext::stream.

Referenced by gl2psPDFgroupListWriteVariableResources().

gl2psPDFgroupListWriteGStateResources()

static int gl2psPDFgroupListWriteGStateResources ( void  )

static

Definition at line 4062 of file gl2ps.cc.

{
  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;
}

References gl2ps, gl2psListNbr(), gl2psListPointer(), GL2PSpdfgroup::gsno, GL2PSpdfgroup::gsobjno, GL2PScontext::pdfgrouplist, and GL2PScontext::stream.

Referenced by gl2psPDFgroupListWriteVariableResources().

gl2psPDFgroupListWriteMainStream()

static void gl2psPDFgroupListWriteMainStream ( void  )

static

Definition at line 3853 of file gl2ps.cc.

{
  int i, j, lastel, count;
  GL2PSprimitive *prim = NULL, *prev = NULL;
  GL2PSpdfgroup *gro;
  GL2PStriangle t;
 
  if(!gl2ps->pdfgrouplist)
    return;
 
  count = gl2psListNbr(gl2ps->pdfgrouplist);
 
  for(i = 0; i < count; ++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 += gl2psPrintPDFLineCap(prim->linecap);
      gl2ps->streamlength += gl2psPrintPDFLineJoin(prim->linejoin);
      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);
        if (prim->numverts == 2) {
          gl2psPutPDFTextBL(prim->data.text, gro->fontno, prim->verts[0].xyz[0],
                            prim->verts[0].xyz[1],
                            prim->verts[1].xyz[0],
                            prim->verts[1].xyz[1]);
        }
        else {
          gl2psPutPDFText(prim->data.text, gro->fontno, prim->verts[0].xyz[0],
                          prim->verts[0].xyz[1]);
        }
      }
      break;
    case GL2PS_SPECIAL:
      lastel = gl2psListNbr(gro->ptrlist) - 1;
      if(lastel < 0)
        continue;
 
      for(j = 0; j <= lastel; ++j){
        prim = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, j);
        gl2psPutPDFSpecial(i, j, prim->data.text);
      }
    default:
      break;
    }
  }
}

References GL2PSprimitive::data, GL2PSprimitive::factor, GL2PSpdfgroup::fontno, gl2ps, GL2PS_LINE, GL2PS_PIXMAP, GL2PS_POINT, GL2PS_SPECIAL, GL2PS_TEXT, GL2PS_TRIANGLE, gl2psFillTriangleFromPrimitive(), gl2psListNbr(), gl2psListPointer(), gl2psPrintf(), gl2psPrintPDFFillColor(), gl2psPrintPDFLineCap(), gl2psPrintPDFLineJoin(), gl2psPrintPDFLineWidth(), gl2psPrintPDFStrokeColor(), gl2psPrintPostScriptDash(), gl2psPutPDFImage(), gl2psPutPDFSpecial(), gl2psPutPDFText(), gl2psPutPDFTextBL(), gl2psSamePosition(), gl2psSortOutTrianglePDFgroup(), GL2PSpdfgroup::gsno, GL2PSprimitive::image, GL2PSpdfgroup::imno, GL2PSprimitive::linecap, GL2PSprimitive::linejoin, GL2PSprimitive::numverts, GL2PSprimitive::pattern, GL2PScontext::pdfgrouplist, GL2PStriangle::prop, GL2PSpdfgroup::ptrlist, GL2PSvertex::rgba, GL2PSpdfgroup::shno, GL2PScontext::streamlength, T_ALPHA_1, T_ALPHA_LESS_1, T_CONST_COLOR, T_VAR_ALPHA, T_VAR_COLOR, GL2PSprimitive::text, GL2PSpdfgroup::trgroupno, GL2PSprimitive::type, GL2PStriangle::vertex, GL2PSprimitive::verts, GL2PSprimitive::width, and GL2PSvertex::xyz.

Referenced by gl2psPrintPDFFooter().

gl2psPDFgroupListWriteObjects()

static int gl2psPDFgroupListWriteObjects ( int  entryoffs )

static

Definition at line 4878 of file gl2ps.cc.

{
  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;
}

References GL2PSstring::alignment, GL2PSprimitive::data, GL2PSpdfgroup::fontno, GL2PSpdfgroup::fontobjno, GL2PSimage::format, gl2ps, GL2PS_LINE, GL2PS_PDF, GL2PS_PIXMAP, GL2PS_POINT, GL2PS_SPECIAL, GL2PS_TEXT, GL2PS_TRIANGLE, gl2psFillTriangleFromPrimitive(), gl2psFree(), gl2psListNbr(), gl2psListPointer(), gl2psMalloc(), gl2psPrintPDFPixmap(), gl2psPrintPDFShader(), gl2psPrintPDFShaderExtGS(), gl2psPrintPDFShaderMask(), gl2psPrintPDFShaderSimpleExtGS(), gl2psPrintPDFText(), GL2PSpdfgroup::gsobjno, GL2PSprimitive::image, GL2PSpdfgroup::imobjno, GL2PSpdfgroup::maskshno, GL2PSpdfgroup::maskshobjno, GL2PScontext::pdfgrouplist, GL2PSpdfgroup::ptrlist, GL2PSvertex::rgba, GL2PSpdfgroup::shobjno, GL2PSstring::str, GL2PScontext::stream, T_ALPHA_LESS_1, T_VAR_ALPHA, T_VAR_COLOR, GL2PSprimitive::text, GL2PSpdfgroup::trgroupobjno, GL2PSprimitive::type, GL2PStriangle::vertex, and GL2PScontext::xreflist.

Referenced by gl2psPrintPDFFooter().

gl2psPDFgroupListWriteShaderResources()

static int gl2psPDFgroupListWriteShaderResources ( void  )

static

Definition at line 4083 of file gl2ps.cc.

{
  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;
}

References gl2ps, gl2psListNbr(), gl2psListPointer(), GL2PSpdfgroup::maskshno, GL2PSpdfgroup::maskshobjno, GL2PScontext::pdfgrouplist, GL2PSpdfgroup::shno, GL2PSpdfgroup::shobjno, and GL2PScontext::stream.

Referenced by gl2psPDFgroupListWriteVariableResources().

gl2psPDFgroupListWriteVariableResources()

static int gl2psPDFgroupListWriteVariableResources ( void  )

static

Definition at line 4391 of file gl2ps.cc.

{
  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;
}

References gl2ps, gl2psPDFgroupListWriteFontResources(), gl2psPDFgroupListWriteGStateResources(), gl2psPDFgroupListWriteShaderResources(), gl2psPDFgroupListWriteXObjectResources(), and GL2PScontext::stream.

Referenced by gl2psPrintPDFFooter().

gl2psPDFgroupListWriteXObjectResources()

static int gl2psPDFgroupListWriteXObjectResources ( void  )

static

Definition at line 4104 of file gl2ps.cc.

{
  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;
}

References GL2PSprimitive::data, GL2PSimage::format, gl2ps, GL2PS_PIXMAP, GL2PS_TRIANGLE, gl2psListNbr(), gl2psListPointer(), GL2PSprimitive::image, GL2PSpdfgroup::imno, GL2PSpdfgroup::imobjno, GL2PScontext::objects_stack, GL2PScontext::pdfgrouplist, GL2PSpdfgroup::ptrlist, GL2PScontext::stream, GL2PSpdfgroup::trgroupno, GL2PSpdfgroup::trgroupobjno, and GL2PSprimitive::type.

Referenced by gl2psPDFgroupListWriteVariableResources().

gl2psPDFgroupObjectInit()

static void gl2psPDFgroupObjectInit ( GL2PSpdfgroup *  gro )

static

Definition at line 3679 of file gl2ps.cc.

{
  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;
}

References GL2PSpdfgroup::fontno, GL2PSpdfgroup::fontobjno, GL2PSpdfgroup::gsno, GL2PSpdfgroup::gsobjno, GL2PSpdfgroup::imno, GL2PSpdfgroup::imobjno, GL2PSpdfgroup::maskshno, GL2PSpdfgroup::maskshobjno, GL2PSpdfgroup::ptrlist, GL2PSpdfgroup::shno, GL2PSpdfgroup::shobjno, GL2PSpdfgroup::trgroupno, and GL2PSpdfgroup::trgroupobjno.

Referenced by gl2psPDFgroupListInit().

gl2psPDFRectHull()

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

static

Definition at line 4559 of file gl2ps.cc.

{
  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];
    }
  }
}

References GL2PStriangle::vertex, and GL2PSvertex::xyz.

Referenced by gl2psPrintPDFShader().

gl2psPDFstacksInit()

static void gl2psPDFstacksInit ( void  )

static

Definition at line 3668 of file gl2ps.cc.

{
  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;
}

References GL2PScontext::extgs_stack, GL2PScontext::font_stack, gl2ps, GL2PScontext::im_stack, GL2PScontext::mshader_stack, GL2PScontext::objects_stack, GL2PScontext::shader_stack, and GL2PScontext::trgroupobjects_stack.

Referenced by gl2psPrintPDFHeader().

gl2psPGFTextAlignment()

static const char * gl2psPGFTextAlignment ( int  align )

static

Definition at line 5630 of file gl2ps.cc.

{
  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";
  }
}

References GL2PS_TEXT_B, GL2PS_TEXT_BL, GL2PS_TEXT_BR, GL2PS_TEXT_C, GL2PS_TEXT_CL, GL2PS_TEXT_CR, GL2PS_TEXT_T, GL2PS_TEXT_TL, and GL2PS_TEXT_TR.

Referenced by gl2psPrintPGFPrimitive().

gl2psPointSize()

GL2PSDLL_API GLint gl2psPointSize

(

GLfloat

value

)

Definition at line 6512 of file gl2ps.cc.

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

References gl2ps, GL2PS_POINT_SIZE_TOKEN, GL2PS_SUCCESS, and GL2PS_UNINITIALIZED.

gl2psPrintf()

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

static

Definition at line 433 of file gl2ps.cc.

{
  int ret;
  va_list args;
 
#if defined(GL2PS_HAVE_ZLIB)
  static char buf[1024];
  char *bufptr = buf;
  GLboolean freebuf = GL_FALSE;
  unsigned int oldsize = 0;
#if !defined(GL2PS_HAVE_NO_VSNPRINTF)
  /* Try writing the string to a 1024 byte buffer. If it is too small to fit,
     keep trying larger sizes until it does. */
  int bufsize = sizeof(buf);
#endif
  if(gl2ps->options & GL2PS_COMPRESS){
    va_start(args, fmt);
#if defined(GL2PS_HAVE_NO_VSNPRINTF)
    ret = vsprintf(buf, fmt, args);
#else
    ret = vsnprintf(bufptr, bufsize, fmt, args);
#endif
    va_end(args);
#if !defined(GL2PS_HAVE_NO_VSNPRINTF)
    while(ret >= (bufsize - 1) || ret < 0){
      /* Too big. Allocate a new buffer. */
      bufsize *= 2;
      if(freebuf == GL_TRUE) gl2psFree(bufptr);
      bufptr = (char *)gl2psMalloc(bufsize);
      freebuf = GL_TRUE;
      va_start(args, fmt);
      ret = vsnprintf(bufptr, bufsize, fmt, args);
      va_end(args);
    }
#endif
    oldsize = gl2ps->compress->srcLen;
    gl2ps->compress->start = (Bytef*)gl2psReallocCompress(oldsize + ret);
    memcpy(gl2ps->compress->start + oldsize, bufptr, ret);
    if(freebuf == GL_TRUE) gl2psFree(bufptr);
    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;
}

References args, GL2PScontext::compress, gl2ps, GL2PS_COMPRESS, gl2psFree(), gl2psMalloc(), gl2psReallocCompress, GL2PScontext::options, and GL2PScontext::stream.

Referenced by gl2psEndPostScriptLine(), gl2psEndSVGLine(), gl2psOpenPDFDataStreamWritePreface(), gl2psPDFgroupListWriteMainStream(), gl2psPrintPDFBeginViewport(), gl2psPrintPDFEndViewport(), gl2psPrintPDFFillColor(), gl2psPrintPDFLineCap(), gl2psPrintPDFLineJoin(), gl2psPrintPDFLineWidth(), gl2psPrintPDFStrokeColor(), gl2psPrintPostScriptBeginViewport(), gl2psPrintPostScriptColor(), gl2psPrintPostScriptDash(), gl2psPrintPostScriptEndViewport(), gl2psPrintPostScriptFooter(), gl2psPrintPostScriptHeader(), gl2psPrintPostScriptImagemap(), gl2psPrintPostScriptPixmap(), gl2psPrintPostScriptPrimitive(), gl2psPrintSVGBeginViewport(), gl2psPrintSVGDash(), gl2psPrintSVGEndViewport(), gl2psPrintSVGFooter(), gl2psPrintSVGHeader(), gl2psPrintSVGPixmap(), gl2psPrintSVGPrimitive(), gl2psPrintSVGSmoothTriangle(), gl2psPutPDFImage(), gl2psPutPDFSpecial(), gl2psPutPDFText(), gl2psPutPDFTextBL(), and gl2psWriteByte().

gl2psPrintGzipFooter()

static void gl2psPrintGzipFooter ( void  )

static

Definition at line 503 of file gl2ps.cc.

{
#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
}

References GL2PScontext::compress, crc32(), gl2ps, GL2PS_COMPRESS, GL2PS_ERROR, gl2psDeflate, gl2psFree(), gl2psFreeCompress, gl2psMsg(), L, CLHEP::detail::n, GL2PScontext::options, GL2PScontext::stream, and Z_OK.

Referenced by gl2psPrintPostScriptFooter(), and gl2psPrintSVGFooter().

gl2psPrintGzipHeader()

static void gl2psPrintGzipHeader ( void  )

static

Definition at line 485 of file gl2ps.cc.

{
#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
}

References gl2ps, GL2PS_COMPRESS, gl2psSetupCompress, GL2PScontext::options, and GL2PScontext::stream.

Referenced by gl2psPrintPostScriptHeader(), and gl2psPrintSVGHeader().

gl2psPrintPDFBeginViewport()

static void gl2psPrintPDFBeginViewport ( GLint  viewport[4] )

static

Definition at line 5019 of file gl2ps.cc.

{
  int offs = 0;
  GLint idx;
  GLfloat rgba[4];
  int x = viewport[0], y = viewport[1], w = viewport[2], h = viewport[3];
 
  glRenderMode(GL_FEEDBACK);
 
  gl2psResetLineProperties();
 
  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, &idx);
      rgba[0] = gl2ps->colormap[idx][0];
      rgba[1] = gl2ps->colormap[idx][1];
      rgba[2] = gl2ps->colormap[idx][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;
}

References GL2PScontext::colormap, GL2PScontext::colormode, GL2PScontext::colorsize, gl2ps, GL2PS_DRAW_BACKGROUND, gl2psPrintf(), gl2psPrintPDFFillColor(), gl2psPrintPDFHeader(), gl2psResetLineProperties(), GL2PScontext::header, GL2PScontext::options, and GL2PScontext::streamlength.

gl2psPrintPDFCatalog()

static int gl2psPrintPDFCatalog ( void  )

static

Definition at line 4221 of file gl2ps.cc.

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

References gl2ps, and GL2PScontext::stream.

Referenced by gl2psPrintPDFHeader().

gl2psPrintPDFCompressorType()

static int gl2psPrintPDFCompressorType ( void  )

static

Definition at line 3518 of file gl2ps.cc.

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

References gl2ps, GL2PS_COMPRESS, GL2PScontext::options, and GL2PScontext::stream.

Referenced by gl2psOpenPDFDataStream(), gl2psPrintPDFPixmap(), and gl2psPrintPDFShader().

gl2psPrintPDFDataStreamLength()

static int gl2psPrintPDFDataStreamLength ( int  val )

static

Definition at line 4352 of file gl2ps.cc.

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

References gl2ps, and GL2PScontext::stream.

Referenced by gl2psPrintPDFFooter().

gl2psPrintPDFEndViewport()

static GLint gl2psPrintPDFEndViewport ( void  )

static

Definition at line 5064 of file gl2ps.cc.

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

References gl2ps, gl2psPrintf(), gl2psPrintPrimitives(), and GL2PScontext::streamlength.

gl2psPrintPDFFillColor()

static int gl2psPrintPDFFillColor ( GL2PSrgba  rgba )

static

Definition at line 3545 of file gl2ps.cc.

{
  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;
}

References e6, GL2PS_ZERO, and gl2psPrintf().

Referenced by gl2psOpenPDFDataStreamWritePreface(), gl2psPDFgroupListWriteMainStream(), and gl2psPrintPDFBeginViewport().

gl2psPrintPDFFinalPrimitive()

static void gl2psPrintPDFFinalPrimitive ( void  )

static

Definition at line 5073 of file gl2ps.cc.

{
}

gl2psPrintPDFFooter()

static void gl2psPrintPDFFooter ( void  )

static

Definition at line 4954 of file gl2ps.cc.

{
  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
}

References GL2PScontext::compress, gl2ps, GL2PS_COMPRESS, gl2psClosePDFDataStream(), gl2psFree(), gl2psFreeCompress, gl2psFreePrimitive(), gl2psListAction(), gl2psListDelete(), gl2psPDFgroupListDelete(), gl2psPDFgroupListInit(), gl2psPDFgroupListWriteMainStream(), gl2psPDFgroupListWriteObjects(), gl2psPDFgroupListWriteVariableResources(), gl2psPrintPDFDataStreamLength(), gl2psPrintPDFGSObject(), gl2psPrintPDFOpenPage(), gl2psRealloc(), GL2PScontext::objects_stack, GL2PScontext::options, GL2PScontext::pdfprimlist, GL2PScontext::stream, GL2PScontext::streamlength, and GL2PScontext::xreflist.

gl2psPrintPDFGSObject()

static int gl2psPrintPDFGSObject ( void  )

static

Definition at line 4417 of file gl2ps.cc.

{
  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");
}

References gl2ps, and GL2PScontext::stream.

Referenced by gl2psPrintPDFFooter().

gl2psPrintPDFHeader()

static void gl2psPrintPDFHeader ( void  )

static

Definition at line 4281 of file gl2ps.cc.

{
  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();
}

References gl2ps, GL2PS_COMPRESS, gl2psListCreate(), gl2psMalloc(), gl2psOpenPDFDataStream(), gl2psOpenPDFDataStreamWritePreface(), gl2psPDFstacksInit(), gl2psPrintPDFCatalog(), gl2psPrintPDFInfo(), gl2psPrintPDFPages(), gl2psSetupCompress, GL2PScontext::objects_stack, GL2PScontext::options, GL2PScontext::pdfprimlist, GL2PScontext::stream, GL2PScontext::streamlength, and GL2PScontext::xreflist.

Referenced by gl2psPrintPDFBeginViewport().

gl2psPrintPDFInfo()

static int gl2psPrintPDFInfo ( void  )

static

Definition at line 4180 of file gl2ps.cc.

{
  int offs;
  time_t now;
  struct tm *newtime;
 
  time(&now);
  newtime = gmtime(&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(!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;
}

References gl2ps, GL2PS_COPYRIGHT, GL2PS_EXTRA_VERSION, GL2PS_MAJOR_VERSION, GL2PS_MINOR_VERSION, GL2PS_PATCH_VERSION, GL2PScontext::producer, GL2PScontext::stream, GL2PScontext::title, and G4InuclParticleNames::tm.

Referenced by gl2psPrintPDFHeader().

gl2psPrintPDFLineCap()

static int gl2psPrintPDFLineCap ( GLint  lc )

static

Definition at line 3571 of file gl2ps.cc.

{
  if(gl2ps->lastlinecap == lc)
    return 0;
  else
    return gl2psPrintf("%d J\n", lc);
}

References gl2ps, gl2psPrintf(), GL2PScontext::lastlinecap, and g4zmq::lc().

Referenced by gl2psPDFgroupListWriteMainStream().

gl2psPrintPDFLineJoin()

static int gl2psPrintPDFLineJoin ( GLint  lj )

static

Definition at line 3579 of file gl2ps.cc.

{
  if(gl2ps->lastlinejoin == lj)
    return 0;
  else
    return gl2psPrintf("%d j\n", lj);
}

References gl2ps, gl2psPrintf(), and GL2PScontext::lastlinejoin.

Referenced by gl2psPDFgroupListWriteMainStream().

gl2psPrintPDFLineWidth()

static int gl2psPrintPDFLineWidth ( GLfloat  lw )

static

Definition at line 3561 of file gl2ps.cc.

{
  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);
}

References e6, GL2PS_ZERO, and gl2psPrintf().

Referenced by gl2psPDFgroupListWriteMainStream().

gl2psPrintPDFOpenPage()

static int gl2psPrintPDFOpenPage ( void  )

static

Definition at line 4362 of file gl2ps.cc.

{
  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() */
}

References gl2ps, GL2PS_LANDSCAPE, GL2PScontext::options, GL2PScontext::stream, and GL2PScontext::viewport.

Referenced by gl2psPrintPDFFooter().

gl2psPrintPDFPages()

static int gl2psPrintPDFPages ( void  )

static

Definition at line 4232 of file gl2ps.cc.

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

References gl2ps, and GL2PScontext::stream.

Referenced by gl2psPrintPDFHeader().

gl2psPrintPDFPixmap()

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

static

Definition at line 4791 of file gl2ps.cc.

{
  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;
}

References GL2PScontext::compress, GL2PSimage::format, gl2ps, GL2PS_COMPRESS, gl2psAllocCompress, gl2psDeflate, gl2psFreeCompress, gl2psPrintPDFCompressorType(), gl2psPrintPDFPixmapStreamData(), gl2psWriteBigEndian(), gl2psWriteBigEndianCompress, gray, GL2PSimage::height, GL2PScontext::options, GL2PScontext::stream, GL2PSimage::width, and Z_OK.

Referenced by gl2psPDFgroupListWriteObjects().

gl2psPrintPDFPixmapStreamData()

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

static

Definition at line 4752 of file gl2ps.cc.

{
  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;
  }
}

References GL2PSimage::format, g, gl2psGetRGB(), gray, GL2PSimage::height, and GL2PSimage::width.

Referenced by gl2psPrintPDFPixmap().

gl2psPrintPDFPrimitive()

static void gl2psPrintPDFPrimitive ( void *  data )

static

Definition at line 4314 of file gl2ps.cc.

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

References GL2PSprimitive::culled, gl2ps, GL2PS_OCCLUSION_CULL, gl2psCopyPrimitive(), gl2psListAdd(), GL2PScontext::options, and GL2PScontext::pdfprimlist.

gl2psPrintPDFShader()

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

static

Definition at line 4589 of file gl2ps.cc.

{
  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;
}

References GL2PScontext::compress, gl2ps, GL2PS_COMPRESS, gl2psAllocCompress, gl2psDeflate, gl2psFreeCompress, gl2psPDFRectHull(), gl2psPrintPDFCompressorType(), gl2psPrintPDFShaderStreamData(), gl2psWriteBigEndian(), gl2psWriteBigEndianCompress, gray, GL2PScontext::options, GL2PScontext::stream, and Z_OK.

Referenced by gl2psPDFgroupListWriteObjects().

gl2psPrintPDFShaderExtGS()

static int gl2psPrintPDFShaderExtGS ( int  obj, int  childobj  )

static

Definition at line 4715 of file gl2ps.cc.

{
  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;
}

References gl2ps, and GL2PScontext::stream.

Referenced by gl2psPDFgroupListWriteObjects().

gl2psPrintPDFShaderMask()

static int gl2psPrintPDFShaderMask ( int  obj, int  childobj  )

static

Definition at line 4676 of file gl2ps.cc.

{
  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)
    ? (int)strlen("/TrSh sh\n") + (int)log10((double)childobj)+1
    : (int)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;
}

References gl2ps, GL2PScontext::stream, and GL2PScontext::viewport.

Referenced by gl2psPDFgroupListWriteObjects().

gl2psPrintPDFShaderSimpleExtGS()

static int gl2psPrintPDFShaderSimpleExtGS ( int  obj, GLfloat  alpha  )

static

Definition at line 4736 of file gl2ps.cc.

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

References alpha, gl2ps, and GL2PScontext::stream.

Referenced by gl2psPDFgroupListWriteObjects().

gl2psPrintPDFShaderStreamData()

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

static

Definition at line 4532 of file gl2ps.cc.

{
  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;
}

References geant4_check_module_cycles::action, gl2psPrintPDFShaderStreamDataAlpha(), gl2psPrintPDFShaderStreamDataCoord(), gl2psPrintPDFShaderStreamDataRGB(), gray, and GL2PStriangle::vertex.

Referenced by gl2psPrintPDFShader().

gl2psPrintPDFShaderStreamDataAlpha()

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

static

Definition at line 4507 of file gl2ps.cc.

{
  int offs = 0;
  unsigned long imap;
  double dmax = (double) ULONG_MAX;
 
  /* 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;
}

References GL2PSvertex::rgba.

Referenced by gl2psPrintPDFShaderStreamData().

gl2psPrintPDFShaderStreamDataCoord()

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

static

Definition at line 4437 of file gl2ps.cc.

{
  int offs = 0;
  unsigned long imap;
  GLfloat diff;
  double dmax = (double) ULONG_MAX;
  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;
}

References GL2PS_ZERO, and GL2PSvertex::xyz.

Referenced by gl2psPrintPDFShaderStreamData().

gl2psPrintPDFShaderStreamDataRGB()

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

static

Definition at line 4483 of file gl2ps.cc.

{
  int offs = 0;
  unsigned long imap;
  double dmax = (double) ULONG_MAX;
 
  /* 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;
}

References GL2PSvertex::rgba.

Referenced by gl2psPrintPDFShaderStreamData().

gl2psPrintPDFStrokeColor()

static int gl2psPrintPDFStrokeColor ( GL2PSrgba  rgba )

static

Definition at line 3528 of file gl2ps.cc.

{
  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;
}

References e6, GL2PS_ZERO, gl2psPrintf(), and gl2psSetLastColor().

Referenced by gl2psPDFgroupListWriteMainStream().

gl2psPrintPDFText()

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

static

Definition at line 4858 of file gl2ps.cc.

{
  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;
}

References gl2ps, s, and GL2PScontext::stream.

Referenced by gl2psPDFgroupListWriteObjects().

gl2psPrintPGFBeginViewport()

static void gl2psPrintPGFBeginViewport ( GLint  viewport[4] )

static

Definition at line 5787 of file gl2ps.cc.

{
  GLint idx;
  GLfloat rgba[4];
  int x = viewport[0], y = viewport[1], w = viewport[2], h = viewport[3];
 
  glRenderMode(GL_FEEDBACK);
 
  gl2psResetLineProperties();
 
  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, &idx);
      rgba[0] = gl2ps->colormap[idx][0];
      rgba[1] = gl2ps->colormap[idx][1];
      rgba[2] = gl2ps->colormap[idx][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);
}

References GL2PScontext::colormap, GL2PScontext::colormode, GL2PScontext::colorsize, gl2ps, GL2PS_DRAW_BACKGROUND, gl2psPrintPGFColor(), gl2psPrintPGFHeader(), gl2psResetLineProperties(), GL2PScontext::header, GL2PScontext::options, and GL2PScontext::stream.

gl2psPrintPGFColor()

static void gl2psPrintPGFColor ( GL2PSrgba  rgba )

static

Definition at line 5573 of file gl2ps.cc.

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

References gl2ps, gl2psSameColor(), gl2psSetLastColor(), GL2PScontext::lastrgba, and GL2PScontext::stream.

Referenced by gl2psPrintPGFBeginViewport(), gl2psPrintPGFHeader(), and gl2psPrintPGFPrimitive().

gl2psPrintPGFDash()

static void gl2psPrintPGFDash ( GLushort  pattern, GLint  factor  )

static

Definition at line 5608 of file gl2ps.cc.

{
  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");
  }
}

References gl2ps, gl2psParseStipplePattern(), GL2PScontext::lastfactor, GL2PScontext::lastpattern, CLHEP::detail::n, and GL2PScontext::stream.

Referenced by gl2psPrintPGFPrimitive().

gl2psPrintPGFEndViewport()

static GLint gl2psPrintPGFEndViewport ( void  )

static

Definition at line 5829 of file gl2ps.cc.

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

References gl2ps, gl2psPrintPrimitives(), and GL2PScontext::stream.

gl2psPrintPGFFinalPrimitive()

static void gl2psPrintPGFFinalPrimitive ( void  )

static

Definition at line 5837 of file gl2ps.cc.

{
}

gl2psPrintPGFFooter()

static void gl2psPrintPGFFooter ( void  )

static

Definition at line 5782 of file gl2ps.cc.

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

References gl2ps, and GL2PScontext::stream.

gl2psPrintPGFHeader()

static void gl2psPrintPGFHeader ( void  )

static

Definition at line 5581 of file gl2ps.cc.

{
  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]);
  }
}

References GL2PScontext::bgcolor, gl2ps, GL2PS_COPYRIGHT, GL2PS_DRAW_BACKGROUND, GL2PS_EXTRA_VERSION, GL2PS_MAJOR_VERSION, GL2PS_MINOR_VERSION, GL2PS_PATCH_VERSION, gl2psPrintPGFColor(), GL2PScontext::options, GL2PScontext::producer, GL2PScontext::stream, GL2PScontext::title, and GL2PScontext::viewport.

Referenced by gl2psPrintPGFBeginViewport().

gl2psPrintPGFPrimitive()

static void gl2psPrintPGFPrimitive ( void *  data )

static

Definition at line 5646 of file gl2ps.cc.

{
  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);
    }
    if(gl2ps->lastlinecap != prim->linecap){
      gl2ps->lastlinecap = prim->linecap;
      switch (prim->linecap){
      case GL2PS_LINE_CAP_BUTT:
        fprintf(gl2ps->stream, "\\pgfset%s\n", "buttcap");
        break;
      case GL2PS_LINE_CAP_ROUND:
        fprintf(gl2ps->stream, "\\pgfset%s\n", "roundcap");
        break;
      case GL2PS_LINE_CAP_SQUARE:
        fprintf(gl2ps->stream, "\\pgfset%s\n", "rectcap");
        break;
      }
    }
    if(gl2ps->lastlinejoin != prim->linejoin){
      gl2ps->lastlinejoin = prim->linejoin;
      switch (prim->linejoin){
      case GL2PS_LINE_JOIN_MITER:
        fprintf(gl2ps->stream, "\\pgfset%s\n", "miterjoin");
        break;
      case GL2PS_LINE_JOIN_ROUND:
        fprintf(gl2ps->stream, "\\pgfset%s\n", "roundjoin");
        break;
      case GL2PS_LINE_JOIN_BEVEL:
        fprintf(gl2ps->stream, "\\pgfset%s\n", "beveljoin");
        break;
      }
    }
    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");
    }
    if(gl2ps->lastlinecap != prim->linecap){
      gl2ps->lastlinecap = prim->linecap;
      switch (prim->linecap){
      case GL2PS_LINE_CAP_BUTT:
        fprintf(gl2ps->stream, "\\pgfset%s\n", "buttcap");
        break;
      case GL2PS_LINE_CAP_ROUND:
        fprintf(gl2ps->stream, "\\pgfset%s\n", "roundcap");
        break;
      case GL2PS_LINE_CAP_SQUARE:
        fprintf(gl2ps->stream, "\\pgfset%s\n", "rectcap");
        break;
      }
    }
    if(gl2ps->lastlinejoin != prim->linejoin){
      gl2ps->lastlinejoin = prim->linejoin;
      switch (prim->linejoin){
      case GL2PS_LINE_JOIN_MITER:
        fprintf(gl2ps->stream, "\\pgfset%s\n", "miterjoin");
        break;
      case GL2PS_LINE_JOIN_ROUND:
        fprintf(gl2ps->stream, "\\pgfset%s\n", "roundjoin");
        break;
      case GL2PS_LINE_JOIN_BEVEL:
        fprintf(gl2ps->stream, "\\pgfset%s\n", "beveljoin");
        break;
      }
    }
    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}}");
 
    if(prim->data.text->angle)
       fprintf(gl2ps->stream, "}");
 
    fprintf(gl2ps->stream, "\n}\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;
  }
}

References GL2PSstring::alignment, GL2PSstring::angle, GL2PSprimitive::data, GL2PSprimitive::factor, GL2PSstring::fontsize, gl2ps, GL2PS_LINE, GL2PS_LINE_CAP_BUTT, GL2PS_LINE_CAP_ROUND, GL2PS_LINE_CAP_SQUARE, GL2PS_LINE_JOIN_BEVEL, GL2PS_LINE_JOIN_MITER, GL2PS_LINE_JOIN_ROUND, GL2PS_PGF, GL2PS_POINT, GL2PS_SPECIAL, GL2PS_TEXT, GL2PS_TRIANGLE, gl2psPGFTextAlignment(), gl2psPrintPGFColor(), gl2psPrintPGFDash(), GL2PScontext::lastlinecap, GL2PScontext::lastlinejoin, GL2PScontext::lastlinewidth, GL2PSprimitive::linecap, GL2PSprimitive::linejoin, GL2PSprimitive::pattern, GL2PSvertex::rgba, GL2PSstring::str, GL2PScontext::stream, GL2PSprimitive::text, GL2PSprimitive::type, GL2PSprimitive::verts, GL2PSprimitive::width, and GL2PSvertex::xyz.

gl2psPrintPostScriptBeginViewport()

static void gl2psPrintPostScriptBeginViewport ( GLint  viewport[4] )

static

Definition at line 3273 of file gl2ps.cc.

{
  GLint idx;
  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;
  }
 
  gl2psResetPostScriptColor();
  gl2psResetLineProperties();
 
  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, &idx);
      rgba[0] = gl2ps->colormap[idx][0];
      rgba[1] = gl2ps->colormap[idx][1];
      rgba[2] = gl2ps->colormap[idx][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);
 
}

References GL2PScontext::colormap, GL2PScontext::colormode, GL2PScontext::colorsize, gl2ps, GL2PS_DRAW_BACKGROUND, gl2psPrintf(), gl2psPrintPostScriptHeader(), gl2psResetLineProperties(), gl2psResetPostScriptColor(), GL2PScontext::header, and GL2PScontext::options.

gl2psPrintPostScriptColor()

static void gl2psPrintPostScriptColor ( GL2PSrgba  rgba )

static

Definition at line 3025 of file gl2ps.cc.

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

References gl2ps, gl2psPrintf(), gl2psSameColor(), gl2psSetLastColor(), and GL2PScontext::lastrgba.

Referenced by gl2psPrintPostScriptPrimitive().

gl2psPrintPostScriptDash()

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

static

Definition at line 3084 of file gl2ps.cc.

{
  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;
}

References gl2ps, gl2psParseStipplePattern(), gl2psPrintf(), GL2PScontext::lastfactor, GL2PScontext::lastpattern, and CLHEP::detail::n.

Referenced by gl2psPDFgroupListWriteMainStream(), and gl2psPrintPostScriptPrimitive().

gl2psPrintPostScriptEndViewport()

static GLint gl2psPrintPostScriptEndViewport ( void  )

static

Definition at line 3316 of file gl2ps.cc.

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

References gl2psPrintf(), and gl2psPrintPrimitives().

gl2psPrintPostScriptFinalPrimitive()

static void gl2psPrintPostScriptFinalPrimitive ( void  )

static

Definition at line 3325 of file gl2ps.cc.

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

References gl2psEndPostScriptLine().

gl2psPrintPostScriptFooter()

static void gl2psPrintPostScriptFooter ( void  )

static

Definition at line 3260 of file gl2ps.cc.

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

References gl2psPrintf(), and gl2psPrintGzipFooter().

gl2psPrintPostScriptHeader()

static void gl2psPrintPostScriptHeader ( void  )

static

Definition at line 2785 of file gl2ps.cc.

{
  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"
              "/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"
              "/LC  { setlinecap } BD\n"
              "/LJ  { setlinejoin } 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]);
  }
}

References GL2PScontext::bgcolor, GL2PScontext::format, gl2ps, GL2PS_COPYRIGHT, GL2PS_DRAW_BACKGROUND, GL2PS_EXTRA_VERSION, GL2PS_LANDSCAPE, GL2PS_MAJOR_VERSION, GL2PS_MINOR_VERSION, GL2PS_NO_PS3_SHADING, GL2PS_PATCH_VERSION, GL2PS_PS, gl2psPrintf(), gl2psPrintGzipHeader(), GL2PScontext::options, GL2PScontext::producer, GL2PScontext::threshold, GL2PScontext::title, and GL2PScontext::viewport.

Referenced by gl2psPrintPostScriptBeginViewport().

gl2psPrintPostScriptImagemap()

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

static

Definition at line 2765 of file gl2ps.cc.

                                                                       {
  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");
}

References gl2psPrintf(), and gl2psWriteByte().

Referenced by gl2psPrintPostScriptPrimitive().

gl2psPrintPostScriptPixmap()

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

static

Definition at line 2564 of file gl2ps.cc.

{
  GLuint nbhex, nbyte, nrgb, nbits;
  GLuint row, col, ibyte, icase;
  GLfloat dr = 0., dg = 0., db = 0., 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? */
  int greyscale = 0; /* set to 1 to output greyscale image */
  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("%.2f %.2f scale\n", width * im->zoom_x, height * im->zoom_y);
 
  if(greyscale){ /* greyscale */
    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 */
    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");
}

References gl2psGetRGB(), gl2psPrintf(), gl2psWriteByte(), GL2PSimage::height, GL2PSimage::width, GL2PSimage::zoom_x, and GL2PSimage::zoom_y.

Referenced by gl2psPrintPostScriptPrimitive().

gl2psPrintPostScriptPrimitive()

static void gl2psPrintPostScriptPrimitive ( void *  data )

static

Definition at line 3111 of file gl2ps.cc.

{
  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->lastlinecap != prim->linecap ||
       gl2ps->lastlinejoin != prim->linejoin ||
       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);
    }
    if(gl2ps->lastlinecap != prim->linecap){
      gl2ps->lastlinecap = prim->linecap;
      gl2psPrintf("%d LC\n", gl2ps->lastlinecap);
    }
    if(gl2ps->lastlinejoin != prim->linejoin){
      gl2ps->lastlinejoin = prim->linejoin;
      gl2psPrintf("%d LJ\n", gl2ps->lastlinejoin);
    }
    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,
                                   (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;
  }
}

References GL2PSstring::alignment, GL2PSstring::angle, GL2PSprimitive::culled, GL2PSprimitive::data, GL2PSprimitive::factor, GL2PSstring::fontname, GL2PSstring::fontsize, gl2ps, GL2PS_EPS, GL2PS_IMAGEMAP, GL2PS_IMAGEMAP_WRITTEN, GL2PS_LINE, GL2PS_OCCLUSION_CULL, GL2PS_PIXMAP, GL2PS_POINT, GL2PS_PS, GL2PS_QUADRANGLE, GL2PS_SPECIAL, GL2PS_TEXT, GL2PS_TEXT_B, GL2PS_TEXT_BL, GL2PS_TEXT_BR, GL2PS_TEXT_C, GL2PS_TEXT_CL, GL2PS_TEXT_CR, GL2PS_TEXT_T, GL2PS_TEXT_TL, GL2PS_TEXT_TR, GL2PS_TRIANGLE, GL2PS_WARNING, gl2psEndPostScriptLine(), gl2psMsg(), gl2psPrintf(), gl2psPrintPostScriptColor(), gl2psPrintPostScriptDash(), gl2psPrintPostScriptImagemap(), gl2psPrintPostScriptPixmap(), gl2psResetPostScriptColor(), gl2psSameColor(), gl2psSamePosition(), gl2psVertsSameColor(), GL2PSimage::height, GL2PSprimitive::image, GL2PScontext::lastfactor, GL2PScontext::lastlinecap, GL2PScontext::lastlinejoin, GL2PScontext::lastlinewidth, GL2PScontext::lastpattern, GL2PScontext::lastrgba, GL2PScontext::lastvertex, GL2PSprimitive::linecap, GL2PSprimitive::linejoin, GL2PScontext::options, GL2PSprimitive::pattern, GL2PSimage::pixels, GL2PSvertex::rgba, GL2PSstring::str, GL2PSprimitive::text, GL2PSimage::type, GL2PSprimitive::type, GL2PSprimitive::verts, GL2PSimage::width, GL2PSprimitive::width, and GL2PSvertex::xyz.

gl2psPrintPrimitives()

static GLint gl2psPrintPrimitives ( void  )

static

Definition at line 5891 of file gl2ps.cc.

{
  GL2PSbsptree *root;
  GL2PSxyz eye = {0.0F, 0.0F, 100.0F * GL2PS_ZSCALE};
  GLint used = 0;
 
  if ((gl2ps->options & GL2PS_NO_OPENGL_CONTEXT) == GL2PS_NONE) {
    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 :
    gl2psListAssignSortIds(gl2ps->primitives);
    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;
}

References GL2PScontext::boundary, GL2PScontext::format, gl2ps, GL2PS_BSP_SORT, GL2PS_EPSILON, GL2PS_INFO, GL2PS_NO_FEEDBACK, GL2PS_NO_OPENGL_CONTEXT, GL2PS_NO_SORT, GL2PS_NONE, GL2PS_OCCLUSION_CULL, GL2PS_OVERFLOW, GL2PS_SIMPLE_SORT, GL2PS_SUCCESS, GL2PS_TIGHT_BOUNDING_BOX, GL2PS_ZSCALE, gl2psAddInImageTree(), gl2psbackends, gl2psBuildBspTree(), gl2psBuildPolygonBoundary(), gl2psCompareDepth(), gl2psComputeTightBoundingBox(), gl2psFreeBspImageTree(), gl2psFreeBspTree(), gl2psFreePrimitive(), gl2psGreater(), gl2psLess(), gl2psListAction(), gl2psListActionInverse(), gl2psListAssignSortIds(), gl2psListCreate(), gl2psListNbr(), gl2psListReset(), gl2psListSort(), gl2psMalloc(), gl2psMsg(), gl2psParseFeedbackBuffer(), gl2psRescaleAndOffset(), gl2psTraverseBspTree(), GL2PScontext::header, GL2PScontext::imagetree, GL2PScontext::options, GL2PScontext::primitives, GL2PSbackend::printFinalPrimitive, GL2PSbackend::printHeader, GL2PSbackend::printPrimitive, GL2PScontext::sort, and GL2PScontext::viewport.

Referenced by gl2psEndPage(), gl2psPrintPDFEndViewport(), gl2psPrintPGFEndViewport(), gl2psPrintPostScriptEndViewport(), gl2psPrintSVGEndViewport(), and gl2psPrintTeXEndViewport().

gl2psPrintSVGBeginViewport()

static void gl2psPrintSVGBeginViewport ( GLint  viewport[4] )

static

Definition at line 5493 of file gl2ps.cc.

{
  GLint idx;
  char col[32];
  GLfloat rgba[4];
  int x = viewport[0], y = viewport[1], w = viewport[2], h = viewport[3];
 
  glRenderMode(GL_FEEDBACK);
 
  gl2psResetLineProperties();
 
  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, &idx);
      rgba[0] = gl2ps->colormap[idx][0];
      rgba[1] = gl2ps->colormap[idx][1];
      rgba[2] = gl2ps->colormap[idx][2];
      rgba[3] = 1.0F;
    }
    gl2psSVGGetColorString(rgba, col);
    gl2psPrintf("<polygon fill=\"%s\" points=\"%d,%d %d,%d %d,%d %d,%d\" ", 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("shape-rendering=\"crispEdges\"/>\n");
  }
 
  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);
}

References GL2PScontext::colormap, GL2PScontext::colormode, GL2PScontext::colorsize, gl2ps, GL2PS_DRAW_BACKGROUND, gl2psPrintf(), gl2psPrintSVGHeader(), gl2psResetLineProperties(), gl2psSVGGetColorString(), GL2PScontext::header, GL2PScontext::options, and GL2PScontext::viewport.

gl2psPrintSVGDash()

static void gl2psPrintSVGDash ( GLushort  pattern, GLint  factor  )

static

Definition at line 5242 of file gl2ps.cc.

{
  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("\" ");
}

References gl2psParseStipplePattern(), gl2psPrintf(), and CLHEP::detail::n.

Referenced by gl2psPrintSVGPrimitive().

gl2psPrintSVGEndViewport()

static GLint gl2psPrintSVGEndViewport ( void  )

static

Definition at line 5539 of file gl2ps.cc.

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

References gl2psPrintf(), and gl2psPrintPrimitives().

gl2psPrintSVGFinalPrimitive()

static void gl2psPrintSVGFinalPrimitive ( void  )

static

Definition at line 5548 of file gl2ps.cc.

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

References gl2psEndSVGLine().

gl2psPrintSVGFooter()

static void gl2psPrintSVGFooter ( void  )

static

Definition at line 5485 of file gl2ps.cc.

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

References gl2psPrintf(), and gl2psPrintGzipFooter().

gl2psPrintSVGHeader()

static void gl2psPrintSVGHeader ( void  )

static

Definition at line 5121 of file gl2ps.cc.

{
  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=\"%dpt\" height=\"%dpt\" 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>\n");
}

References GL2PScontext::bgcolor, gl2ps, GL2PS_COPYRIGHT, GL2PS_DRAW_BACKGROUND, GL2PS_EXTRA_VERSION, GL2PS_LANDSCAPE, GL2PS_MAJOR_VERSION, GL2PS_MINOR_VERSION, GL2PS_PATCH_VERSION, gl2psPrintf(), gl2psPrintGzipHeader(), gl2psSVGGetColorString(), GL2PScontext::options, GL2PScontext::producer, GL2PScontext::title, and GL2PScontext::viewport.

Referenced by gl2psPrintSVGBeginViewport().

gl2psPrintSVGPixmap()

static void gl2psPrintSVGPixmap ( GLfloat  x, GLfloat  y, GL2PSimage *  pixmap  )

static

Definition at line 5270 of file gl2ps.cc.

{
#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);
 
  /* Use "transform" attribute to scale and translate the image from
     the coordinates origin (0,0) */
  y -= pixmap->zoom_y * (GLfloat)pixmap->height;
  gl2psPrintf("<image x=\"%g\" y=\"%g\" width=\"%d\" height=\"%d\"\n",
              0., 0., pixmap->width, pixmap->height);
  gl2psPrintf("transform=\"matrix(%g,0,0,%g,%g,%g)\"\n",
              pixmap->zoom_x, pixmap->zoom_y, x, y);
  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
  (void) x; (void) y; (void) pixmap;  /* not used */
  gl2psMsg(GL2PS_WARNING, "GL2PS must be compiled with PNG support in "
           "order to embed images in SVG streams");
#endif
}

References GL2PS_WARNING, gl2psConvertPixmapToPNG, gl2psListCreate(), gl2psListDelete(), gl2psListEncodeBase64, gl2psListNbr(), gl2psListRead, gl2psMsg(), gl2psPrintf(), GL2PSimage::height, GL2PSimage::width, GL2PSimage::zoom_x, and GL2PSimage::zoom_y.

Referenced by gl2psPrintSVGPrimitive().

gl2psPrintSVGPrimitive()

static void gl2psPrintSVGPrimitive ( void *  data )

static

Definition at line 5309 of file gl2ps.cc.

{
  GL2PSprimitive *prim;
  GL2PSxyz xyz[4];
  GL2PSrgba rgba[4];
  char col[32];
  char lcap[7], ljoin[7];
  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->lastlinecap != prim->linecap ||
       gl2ps->lastlinejoin != prim->linejoin ||
       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->lastlinecap = prim->linecap;
    gl2ps->lastlinejoin = prim->linejoin;
    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);
      switch (prim->linecap){
      case GL2PS_LINE_CAP_BUTT:
        sprintf (lcap, "%s", "butt");
        break;
      case GL2PS_LINE_CAP_ROUND:
        sprintf (lcap, "%s", "round");
        break;
      case GL2PS_LINE_CAP_SQUARE:
        sprintf (lcap, "%s", "square");
        break;
      }
      switch (prim->linejoin){
      case GL2PS_LINE_JOIN_MITER:
        sprintf (ljoin, "%s", "miter");
        break;
      case GL2PS_LINE_JOIN_ROUND:
        sprintf (ljoin, "%s", "round");
        break;
      case GL2PS_LINE_JOIN_BEVEL:
        sprintf (ljoin, "%s", "bevel");
        break;
      }
      gl2psPrintf("stroke-linecap=\"%s\" stroke-linejoin=\"%s\" ",
                  lcap, ljoin);
      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]);
    switch(prim->data.text->alignment){
    case GL2PS_TEXT_C:
      gl2psPrintf("text-anchor=\"middle\" dy=\"%d\" ",
                  prim->data.text->fontsize / 2);
      break;
    case GL2PS_TEXT_CL:
      gl2psPrintf("text-anchor=\"start\" dy=\"%d\" ",
                  prim->data.text->fontsize / 2);
      break;
    case GL2PS_TEXT_CR:
      gl2psPrintf("text-anchor=\"end\" dy=\"%d\" ",
                  prim->data.text->fontsize / 2);
      break;
    case GL2PS_TEXT_B:
      gl2psPrintf("text-anchor=\"middle\" dy=\"0\" ");
      break;
    case GL2PS_TEXT_BR:
      gl2psPrintf("text-anchor=\"end\" dy=\"0\" ");
      break;
    case GL2PS_TEXT_T:
      gl2psPrintf("text-anchor=\"middle\" dy=\"%d\" ",
                  prim->data.text->fontsize);
      break;
    case GL2PS_TEXT_TL:
      gl2psPrintf("text-anchor=\"start\" dy=\"%d\" ",
                  prim->data.text->fontsize);
      break;
    case GL2PS_TEXT_TR:
      gl2psPrintf("text-anchor=\"end\" dy=\"%d\" ",
                  prim->data.text->fontsize);
      break;
    case GL2PS_TEXT_BL:
    default: /* same as GL2PS_TEXT_BL */
      gl2psPrintf("text-anchor=\"start\" dy=\"0\" ");
      break;
    }
    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;
  }
}

References GL2PSstring::alignment, GL2PSstring::angle, GL2PSprimitive::culled, GL2PSprimitive::data, GL2PSprimitive::factor, GL2PSstring::fontname, GL2PSstring::fontsize, gl2ps, GL2PS_LINE, GL2PS_LINE_CAP_BUTT, GL2PS_LINE_CAP_ROUND, GL2PS_LINE_CAP_SQUARE, GL2PS_LINE_JOIN_BEVEL, GL2PS_LINE_JOIN_MITER, GL2PS_LINE_JOIN_ROUND, GL2PS_OCCLUSION_CULL, GL2PS_PIXMAP, GL2PS_POINT, GL2PS_QUADRANGLE, GL2PS_SPECIAL, GL2PS_SVG, GL2PS_TEXT, GL2PS_TEXT_B, GL2PS_TEXT_BL, GL2PS_TEXT_BR, GL2PS_TEXT_C, GL2PS_TEXT_CL, GL2PS_TEXT_CR, GL2PS_TEXT_T, GL2PS_TEXT_TL, GL2PS_TEXT_TR, GL2PS_TRIANGLE, GL2PS_WARNING, gl2psEndSVGLine(), gl2psMsg(), gl2psPrintf(), gl2psPrintSVGDash(), gl2psPrintSVGPixmap(), gl2psPrintSVGSmoothTriangle(), gl2psSameColor(), gl2psSamePosition(), gl2psSetLastColor(), gl2psSVGGetColorString(), gl2psSVGGetCoordsAndColors(), GL2PSprimitive::image, GL2PScontext::lastfactor, GL2PScontext::lastlinecap, GL2PScontext::lastlinejoin, GL2PScontext::lastlinewidth, GL2PScontext::lastpattern, GL2PScontext::lastrgba, GL2PScontext::lastvertex, GL2PSprimitive::linecap, GL2PSprimitive::linejoin, GL2PSprimitive::numverts, GL2PScontext::options, GL2PSprimitive::pattern, GL2PSvertex::rgba, GL2PSstring::str, GL2PSprimitive::text, GL2PSprimitive::type, GL2PSprimitive::verts, GL2PSprimitive::width, and GL2PSvertex::xyz.

gl2psPrintSVGSmoothTriangle()

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

static

Definition at line 5174 of file gl2ps.cc.

{
  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("shape-rendering=\"crispEdges\" ");
    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);
  }
}

References gl2ps, gl2psPrintf(), gl2psPrintSVGSmoothTriangle(), gl2psSameColorThreshold(), gl2psSVGGetColorString(), and GL2PScontext::threshold.

Referenced by gl2psPrintSVGPrimitive(), and gl2psPrintSVGSmoothTriangle().

gl2psPrintTeXBeginViewport()

static void gl2psPrintTeXBeginViewport ( GLint  viewport[4] )

static

Definition at line 3477 of file gl2ps.cc.

{
  (void) viewport;  /* not used */
  glRenderMode(GL_FEEDBACK);
 
  gl2psResetLineProperties();
 
  if(gl2ps->header){
    gl2psPrintTeXHeader();
    gl2ps->header = GL_FALSE;
  }
}

References gl2ps, gl2psPrintTeXHeader(), gl2psResetLineProperties(), and GL2PScontext::header.

gl2psPrintTeXEndViewport()

static GLint gl2psPrintTeXEndViewport ( void  )

static

Definition at line 3490 of file gl2ps.cc.

{
  return gl2psPrintPrimitives();
}

References gl2psPrintPrimitives().

gl2psPrintTeXFinalPrimitive()

static void gl2psPrintTeXFinalPrimitive ( void  )

static

Definition at line 3495 of file gl2ps.cc.

{
}

gl2psPrintTeXFooter()

static void gl2psPrintTeXFooter ( void  )

static

Definition at line 3471 of file gl2ps.cc.

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

References gl2ps, GL2PS_LANDSCAPE, GL2PScontext::options, and GL2PScontext::stream.

gl2psPrintTeXHeader()

static void gl2psPrintTeXHeader ( void  )

static

Definition at line 3361 of file gl2ps.cc.

{
  char name[256];
  time_t now;
  int i;
  GLfloat s;
 
  if(gl2ps->filename && strlen(gl2ps->filename) < 256){
    for(i = (int)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));
 
  s = gl2ps->tex_scaling;
  if(s <= 0.) s = 1.;
  fprintf(gl2ps->stream,
          "\\setlength{\\unitlength}{%gpt}\n"
          "\\begin{picture}(0,0)\n"
          "\\includegraphics[scale=%g]{%s}\n"
          "\\end{picture}%%\n"
          "%s\\begin{picture}(%d,%d)(0,0)\n",
          s, s, name,
          (gl2ps->options & GL2PS_LANDSCAPE) ? "\\rotatebox{90}{" : "",
          (int)(gl2ps->viewport[2]), (int)(gl2ps->viewport[3]));
}

References GL2PScontext::filename, gl2ps, GL2PS_COPYRIGHT, GL2PS_EXTRA_VERSION, GL2PS_LANDSCAPE, GL2PS_MAJOR_VERSION, GL2PS_MINOR_VERSION, GL2PS_PATCH_VERSION, G4InuclParticleNames::name(), GL2PScontext::options, GL2PScontext::producer, s, GL2PScontext::stream, GL2PScontext::tex_scaling, GL2PScontext::title, and GL2PScontext::viewport.

Referenced by gl2psPrintTeXBeginViewport().

gl2psPrintTeXPrimitive()

static void gl2psPrintTeXPrimitive ( void *  data )

static

Definition at line 3406 of file gl2ps.cc.

{
  GL2PSprimitive *prim;
 
  prim = *(GL2PSprimitive**)data;
 
  switch(prim->type){
  case GL2PS_TEXT :
    if(!(gl2ps->options & GL2PS_NO_TEX_FONTSIZE))
      fprintf(gl2ps->stream, "\\fontsize{%d}{0}\\selectfont",
              prim->data.text->fontsize);
    fprintf(gl2ps->stream, "\\put(%g,%g)",
            prim->verts[0].xyz[0],
            prim->verts[0].xyz[1]);
    if(prim->data.text->angle)
      fprintf(gl2ps->stream, "{\\rotatebox{%g}", prim->data.text->angle);
    fprintf(gl2ps->stream, "{\\makebox(0,0)");
    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;
    }
    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;
  }
}

References GL2PSstring::alignment, GL2PSstring::angle, GL2PSprimitive::data, GL2PSstring::fontsize, gl2ps, GL2PS_NO_TEX_FONTSIZE, GL2PS_SPECIAL, GL2PS_TEX, GL2PS_TEXT, GL2PS_TEXT_B, GL2PS_TEXT_BL, GL2PS_TEXT_BR, GL2PS_TEXT_C, GL2PS_TEXT_CL, GL2PS_TEXT_CR, GL2PS_TEXT_T, GL2PS_TEXT_TL, GL2PS_TEXT_TR, GL2PScontext::options, GL2PSvertex::rgba, GL2PSstring::str, GL2PScontext::stream, GL2PSprimitive::text, GL2PSprimitive::type, GL2PSprimitive::verts, and GL2PSvertex::xyz.

gl2psPsca()

static GLfloat gl2psPsca ( GLfloat *  a, GLfloat *  b  )

static

Definition at line 1162 of file gl2ps.cc.

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

Referenced by gl2psCutEdge().

gl2psPutPDFImage()

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

static

Definition at line 3657 of file gl2ps.cc.

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

References gl2ps, gl2psPrintf(), GL2PSimage::height, GL2PScontext::streamlength, GL2PSimage::width, GL2PSimage::zoom_x, and GL2PSimage::zoom_y.

Referenced by gl2psPDFgroupListWriteMainStream().

gl2psPutPDFSpecial()

static void gl2psPutPDFSpecial ( int  prim, int  sec, GL2PSstring *  text  )

static

Definition at line 3651 of file gl2ps.cc.

{
  gl2ps->streamlength += gl2psPrintf("/GS%d%d gs\n", prim, sec);
  gl2ps->streamlength += gl2psPrintf("%s\n", text->str);
}

References gl2ps, gl2psPrintf(), GL2PSstring::str, and GL2PScontext::streamlength.

Referenced by gl2psPDFgroupListWriteMainStream().

gl2psPutPDFText()

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

static

Definition at line 3587 of file gl2ps.cc.

{
  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 = (GLfloat)(3.141593F * 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);
  }
}

References GL2PSstring::angle, GL2PSstring::fontsize, gl2ps, gl2psPrintf(), rad, GL2PSstring::str, and GL2PScontext::streamlength.

Referenced by gl2psPDFgroupListWriteMainStream().

gl2psPutPDFTextBL()

static void gl2psPutPDFTextBL ( GL2PSstring *  text, int  cnt, GLfloat  x, GLfloat  y, GLfloat  xbl, GLfloat  ybl  )

static

Definition at line 3618 of file gl2ps.cc.

{
  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, xbl, ybl, text->str);
  }
  else{
    GLfloat a, ca, sa;
    GLfloat pi = 3.141593F;
    GLfloat i = std::atan2(y - ybl, x - xbl);
    GLfloat r = std::sqrt((y - ybl) * (y - ybl) + (x - xbl) * (x - xbl));
 
    a = (GLfloat)(pi * text->angle / 180.0F);
    sa = (GLfloat)sin(a);
    ca = (GLfloat)cos(a);
    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,
       ca, sa, -sa, ca,
       xbl + r * (std::cos(i) - std::cos(i + a)), ybl + r * (std::sin(i) - std::sin(i+a)), text->str);
  }
}

References GL2PSstring::angle, GL2PSstring::fontsize, gl2ps, gl2psPrintf(), pi, GL2PSstring::str, and GL2PScontext::streamlength.

Referenced by gl2psPDFgroupListWriteMainStream().

gl2psPvec()

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

static

Definition at line 1167 of file gl2ps.cc.

{
  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];
}

Referenced by gl2psGetNormal().

gl2psRealloc()

static void * gl2psRealloc ( void *  ptr, size_t  size  )

static

Definition at line 321 of file gl2ps.cc.

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

References free, GL2PS_ERROR, and gl2psMsg().

Referenced by gl2psListRealloc(), gl2psPrintPDFFooter(), and gl2psSplitPrimitive2D().

gl2psRescaleAndOffset()

static void gl2psRescaleAndOffset ( void  )

static

Definition at line 1727 of file gl2ps.cc.

{
  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 = prim->ofactor;
      units = prim->ounits;
      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;
    }
  }
}

References gl2ps, GL2PS_LINE, GL2PS_SIMPLE_LINE_OFFSET, GL2PS_SIMPLE_SORT, GL2PS_TRIANGLE, GL2PS_ZERO, GL2PS_ZOFFSET, GL2PS_ZOFFSET_LARGE, GL2PS_ZSCALE, gl2psListNbr(), gl2psListPointer(), maxZ, GL2PSprimitive::numverts, GL2PSprimitive::ofactor, GL2PSprimitive::offset, GL2PScontext::options, GL2PSprimitive::ounits, GL2PScontext::primitives, GL2PScontext::sort, GL2PSprimitive::type, GL2PSprimitive::verts, and GL2PSvertex::xyz.

Referenced by gl2psPrintPrimitives().

gl2psResetLineProperties()

static void gl2psResetLineProperties ( void  )

static

Definition at line 1092 of file gl2ps.cc.

{
  gl2ps->lastlinewidth = 0.;
  gl2ps->lastlinecap = gl2ps->lastlinejoin = 0;
}

References gl2ps, GL2PScontext::lastlinecap, GL2PScontext::lastlinejoin, and GL2PScontext::lastlinewidth.

Referenced by gl2psEndViewport(), gl2psPrintPDFBeginViewport(), gl2psPrintPGFBeginViewport(), gl2psPrintPostScriptBeginViewport(), gl2psPrintSVGBeginViewport(), and gl2psPrintTeXBeginViewport().

gl2psResetPostScriptColor()

static void gl2psResetPostScriptColor ( void  )

static

Definition at line 3033 of file gl2ps.cc.

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

References gl2ps, and GL2PScontext::lastrgba.

Referenced by gl2psPrintPostScriptBeginViewport(), and gl2psPrintPostScriptPrimitive().

gl2psSameColor()

static GLboolean gl2psSameColor ( GL2PSrgba  rgba1, GL2PSrgba  rgba2  )

static

Definition at line 716 of file gl2ps.cc.

{
  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;
}

References GL2PS_ZERO.

Referenced by gl2psPDFgroupListInit(), gl2psPrintPGFColor(), gl2psPrintPostScriptColor(), gl2psPrintPostScriptPrimitive(), gl2psPrintSVGPrimitive(), and gl2psVertsSameColor().

gl2psSameColorThreshold()

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

static

Definition at line 737 of file gl2ps.cc.

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

References CLHEP::detail::n.

Referenced by gl2psPrintSVGSmoothTriangle().

gl2psSamePosition()

static GLboolean gl2psSamePosition ( GL2PSxyz  p1, GL2PSxyz  p2  )

static

Definition at line 1139 of file gl2ps.cc.

{
  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;
}

References GL2PS_ZERO.

Referenced by gl2psPDFgroupListWriteMainStream(), gl2psPrintPostScriptPrimitive(), and gl2psPrintSVGPrimitive().

gl2psSetLastColor()

static void gl2psSetLastColor ( GL2PSrgba  rgba )

static

Definition at line 754 of file gl2ps.cc.

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

References gl2ps, and GL2PScontext::lastrgba.

Referenced by gl2psPrintPDFStrokeColor(), gl2psPrintPGFColor(), gl2psPrintPostScriptColor(), and gl2psPrintSVGPrimitive().

gl2psSetOptions()

GL2PSDLL_API GLint gl2psSetOptions

(

GLint

options

)

Definition at line 6567 of file gl2ps.cc.

{
  if(!gl2ps) return GL2PS_UNINITIALIZED;
 
  if(gl2psCheckOptions(options, gl2ps->colormode) == GL_FALSE) {
    return GL2PS_ERROR;
  }
 
  gl2ps->options = options;
 
  return GL2PS_SUCCESS;
}

References GL2PScontext::colormode, gl2ps, GL2PS_ERROR, GL2PS_SUCCESS, GL2PS_UNINITIALIZED, gl2psCheckOptions(), and GL2PScontext::options.

gl2psSetTexScaling()

GL2PSDLL_API GLint gl2psSetTexScaling

(

GLfloat

scaling

)

Definition at line 6636 of file gl2ps.cc.

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

References gl2ps, GL2PS_SUCCESS, GL2PS_UNINITIALIZED, and GL2PScontext::tex_scaling.

gl2psSorting()

GL2PSDLL_API GLint gl2psSorting

(

GLint

mode

)

Definition at line 6246 of file gl2ps.cc.

{
  GLint res;
 
  if(!gl2ps) return GL2PS_UNINITIALIZED;
 
  switch(mode){
  case GL2PS_NO_SORT :
  case GL2PS_SIMPLE_SORT :
  case GL2PS_BSP_SORT :
    gl2ps->sort = mode;
    res = GL2PS_SUCCESS;
    break;
  default :
    gl2psMsg(GL2PS_ERROR, "Unknown sorting algorithm: %d", mode);
    gl2psFree(gl2ps);
    gl2ps = NULL;
    res = GL2PS_ERROR;
  }
 
  return res;
}

References gl2ps, GL2PS_BSP_SORT, GL2PS_ERROR, GL2PS_NO_SORT, GL2PS_SIMPLE_SORT, GL2PS_SUCCESS, GL2PS_UNINITIALIZED, gl2psFree(), gl2psMsg(), and GL2PScontext::sort.

gl2psSortOutTrianglePDFgroup()

static void gl2psSortOutTrianglePDFgroup ( GL2PSpdfgroup *  gro )

static

Definition at line 3799 of file gl2ps.cc.

{
  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++;
  }
}

References GL2PScontext::extgs_stack, gl2ps, GL2PS_TRIANGLE, gl2psFillTriangleFromPrimitive(), gl2psListNbr(), gl2psListPointer(), GL2PSpdfgroup::gsno, GL2PSpdfgroup::gsobjno, GL2PSpdfgroup::maskshno, GL2PSpdfgroup::maskshobjno, GL2PScontext::mshader_stack, GL2PScontext::objects_stack, GL2PStriangle::prop, GL2PSpdfgroup::ptrlist, GL2PScontext::shader_stack, GL2PSpdfgroup::shno, GL2PSpdfgroup::shobjno, T_ALPHA_1, T_ALPHA_LESS_1, T_CONST_COLOR, T_VAR_ALPHA, T_VAR_COLOR, GL2PSpdfgroup::trgroupno, GL2PScontext::trgroupobjects_stack, GL2PSpdfgroup::trgroupobjno, and GL2PSprimitive::type.

Referenced by gl2psPDFgroupListWriteMainStream().

gl2psSpecial()

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

Definition at line 6302 of file gl2ps.cc.

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

References GL2PS_SPECIAL, and gl2psAddText().

gl2psSpecialColor()

GL2PSDLL_API GLint gl2psSpecialColor	(	GLint	format,
		const char *	str,
		GL2PSrgba	rgba
	)

Definition at line 6307 of file gl2ps.cc.

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

References GL2PS_SPECIAL, and gl2psAddText().

gl2psSplitPrimitive()

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

static

Definition at line 1385 of file gl2ps.cc.

{
  GLshort i, j, in = 0, out = 0, in0[5], in1[5], out0[5], out1[5];
  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;
}

References GL2PS_COINCIDENT, GL2PS_EPSILON, GL2PS_IN_BACK_OF, GL2PS_IN_FRONT_OF, GL2PS_POINT, GL2PS_SPANNING, gl2psAddIndex(), gl2psComparePointPlane(), gl2psCreateSplitPrimitive(), gl2psGetIndex(), gl2psMalloc(), GL2PSprimitive::numverts, GL2PSprimitive::type, GL2PSprimitive::verts, and GL2PSvertex::xyz.

Referenced by gl2psBuildBspTree().

gl2psSplitPrimitive2D()

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

static

Definition at line 2013 of file gl2ps.cc.

{
  /* 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);
}

References GL2PS_POINT_BACK, GL2PS_POINT_INFRONT, gl2psCheckPoint(), gl2psCreateSplitPrimitive2D(), gl2psCutEdge(), gl2psFree(), gl2psRealloc(), GL2PSprimitive::numverts, GL2PSprimitive::verts, and GL2PSvertex::xyz.

Referenced by gl2psAddInBspImageTree().

gl2psSupportedBlendMode()

static GLboolean gl2psSupportedBlendMode ( GLenum  sfactor, GLenum  dfactor  )

static

Definition at line 1003 of file gl2ps.cc.

{
  /* 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;
}

Referenced by gl2psBlendFunc().

gl2psSVGGetColorString()

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

static

Definition at line 5110 of file gl2ps.cc.

{
  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);
}

References g.

Referenced by gl2psPrintSVGBeginViewport(), gl2psPrintSVGHeader(), gl2psPrintSVGPrimitive(), and gl2psPrintSVGSmoothTriangle().

gl2psSVGGetCoordsAndColors()

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

static

Definition at line 5096 of file gl2ps.cc.

{
  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];
  }
}

References gl2ps, CLHEP::detail::n, GL2PScontext::viewport, and GL2PSvertex::xyz.

Referenced by gl2psPrintSVGPrimitive().

gl2psTestSplitPrimitive()

static GLint gl2psTestSplitPrimitive ( GL2PSprimitive *  prim, GL2PSplane  plane  )

static

Definition at line 1354 of file gl2ps.cc.

{
  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;
}

References GL2PS_COINCIDENT, GL2PS_EPSILON, GL2PS_IN_BACK_OF, GL2PS_IN_FRONT_OF, gl2psComparePointPlane(), gl2psGetIndex(), GL2PSprimitive::numverts, GL2PSprimitive::verts, and GL2PSvertex::xyz.

Referenced by gl2psFindRoot().

gl2psText()

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

Definition at line 6296 of file gl2ps.cc.

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

References GL2PS_TEXT, GL2PS_TEXT_BL, and gl2psAddText().

gl2psTextOpt()

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

Definition at line 6290 of file gl2ps.cc.

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

References angle, GL2PS_TEXT, and gl2psAddText().

gl2psTextOptColor()

GL2PSDLL_API GLint gl2psTextOptColor	(	const char *	str,
		const char *	fontname,
		GLshort	fontsize,
		GLint	alignment,
		GLfloat	angle,
		GL2PSrgba	color
	)

Definition at line 6269 of file gl2ps.cc.

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

References angle, GL2PS_TEXT, and gl2psAddText().

gl2psTextOptColorBL()

GL2PSDLL_API GLint gl2psTextOptColorBL	(	const char *	str,
		const char *	fontname,
		GLshort	fontsize,
		GLint	alignment,
		GLfloat	angle,
		GL2PSrgba	color,
		GLfloat	blx,
		GLfloat	bly
	)

This version of gl2psTextOptColor is used to go around the fact that PDF does not support text alignment. The extra parameters (blx, bly) represent the bottom left corner of the text bounding box.

Definition at line 6282 of file gl2ps.cc.

{
  return gl2psAddText(GL2PS_TEXT, str, fontname, fontsize, alignment, angle,
                      color, GL_TRUE, blx, bly);
}

References angle, GL2PS_TEXT, and gl2psAddText().

gl2psTraverseBspTree()

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

static

Definition at line 1691 of file gl2ps.cc.

{
  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);
  }
}

References geant4_check_module_cycles::action, GL2PSbsptree_::back, epsilon(), GL2PSbsptree_::front, gl2psComparePointPlane(), gl2psListAction(), gl2psListActionInverse(), gl2psTraverseBspTree(), GL2PSbsptree_::plane, and GL2PSbsptree_::primitives.

Referenced by gl2psPrintPrimitives(), and gl2psTraverseBspTree().

gl2psTrianglesFirst()

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

static

Definition at line 1505 of file gl2ps.cc.

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

References GL2PSprimitive::type.

Referenced by gl2psBuildBspTree().

gl2psVertsSameColor()

static GLboolean gl2psVertsSameColor ( const GL2PSprimitive *  prim )

static

Definition at line 725 of file gl2ps.cc.

{
  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;
}

References gl2psSameColor(), GL2PSprimitive::numverts, GL2PSvertex::rgba, and GL2PSprimitive::verts.

Referenced by gl2psPrintPostScriptPrimitive().

gl2psWriteBigEndian()

static int gl2psWriteBigEndian ( unsigned long  data, int  bytes  )

static

Definition at line 340 of file gl2ps.cc.

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

References gl2ps, and GL2PScontext::stream.

Referenced by gl2psPrintPDFPixmap(), and gl2psPrintPDFShader().

gl2psWriteByte()

static void gl2psWriteByte ( unsigned char  byte )

static

Definition at line 2557 of file gl2ps.cc.

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

References gl2psPrintf().

Referenced by gl2psPrintPostScriptImagemap(), and gl2psPrintPostScriptPixmap().

Variable Documentation

gl2ps

GL2PScontext* gl2ps = NULL

static

Definition at line 278 of file gl2ps.cc.

Referenced by gl2psAdaptVertexForBlending(), gl2psAddInBspImageTree(), gl2psAddInImageTree(), gl2psAddPolyPrimitive(), gl2psAddText(), gl2psBeginPage(), gl2psBeginViewport(), gl2psBlendFunc(), gl2psClosePDFDataStream(), gl2psComputeTightBoundingBox(), gl2psDisable(), gl2psDrawImageMap(), gl2psDrawPixels(), gl2psEnable(), gl2psEndPage(), gl2psEndPostScriptLine(), gl2psEndSVGLine(), gl2psEndViewport(), gl2psFindRoot(), gl2psForceRasterPos(), gl2psGetFileFormat(), gl2psGetOptions(), gl2psGetVertex(), gl2psLineCap(), gl2psLineJoin(), gl2psLineWidth(), gl2psMsg(), gl2psOpenPDFDataStream(), gl2psOpenPDFDataStreamWritePreface(), gl2psParseFeedbackBuffer(), gl2psPDFgroupListDelete(), gl2psPDFgroupListInit(), gl2psPDFgroupListWriteFontResources(), gl2psPDFgroupListWriteGStateResources(), gl2psPDFgroupListWriteMainStream(), gl2psPDFgroupListWriteObjects(), gl2psPDFgroupListWriteShaderResources(), gl2psPDFgroupListWriteVariableResources(), gl2psPDFgroupListWriteXObjectResources(), gl2psPDFstacksInit(), gl2psPointSize(), gl2psPrintf(), gl2psPrintGzipFooter(), gl2psPrintGzipHeader(), gl2psPrintPDFBeginViewport(), gl2psPrintPDFCatalog(), gl2psPrintPDFCompressorType(), gl2psPrintPDFDataStreamLength(), gl2psPrintPDFEndViewport(), gl2psPrintPDFFooter(), gl2psPrintPDFGSObject(), gl2psPrintPDFHeader(), gl2psPrintPDFInfo(), gl2psPrintPDFLineCap(), gl2psPrintPDFLineJoin(), gl2psPrintPDFOpenPage(), gl2psPrintPDFPages(), gl2psPrintPDFPixmap(), gl2psPrintPDFPrimitive(), gl2psPrintPDFShader(), gl2psPrintPDFShaderExtGS(), gl2psPrintPDFShaderMask(), gl2psPrintPDFShaderSimpleExtGS(), gl2psPrintPDFText(), gl2psPrintPGFBeginViewport(), gl2psPrintPGFColor(), gl2psPrintPGFDash(), gl2psPrintPGFEndViewport(), gl2psPrintPGFFooter(), gl2psPrintPGFHeader(), gl2psPrintPGFPrimitive(), gl2psPrintPostScriptBeginViewport(), gl2psPrintPostScriptColor(), gl2psPrintPostScriptDash(), gl2psPrintPostScriptHeader(), gl2psPrintPostScriptPrimitive(), gl2psPrintPrimitives(), gl2psPrintSVGBeginViewport(), gl2psPrintSVGHeader(), gl2psPrintSVGPrimitive(), gl2psPrintSVGSmoothTriangle(), gl2psPrintTeXBeginViewport(), gl2psPrintTeXFooter(), gl2psPrintTeXHeader(), gl2psPrintTeXPrimitive(), gl2psPutPDFImage(), gl2psPutPDFSpecial(), gl2psPutPDFText(), gl2psPutPDFTextBL(), gl2psRescaleAndOffset(), gl2psResetLineProperties(), gl2psResetPostScriptColor(), gl2psSetLastColor(), gl2psSetOptions(), gl2psSetTexScaling(), gl2psSorting(), gl2psSortOutTrianglePDFgroup(), gl2psSVGGetCoordsAndColors(), and gl2psWriteBigEndian().

gl2psbackends

GL2PSbackend* gl2psbackends[]

static

Initial value:

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

Definition at line 5863 of file gl2ps.cc.

Referenced by gl2psBeginPage(), gl2psBeginViewport(), gl2psEndPage(), gl2psEndViewport(), gl2psGetFileExtension(), gl2psGetFormatDescription(), and gl2psPrintPrimitives().

gl2psEPS

GL2PSbackend gl2psEPS

static

Initial value:

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

Definition at line 3344 of file gl2ps.cc.

gl2psPDF

GL2PSbackend gl2psPDF

static

Initial value:

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

Definition at line 5079 of file gl2ps.cc.

gl2psPGF

GL2PSbackend gl2psPGF

static

Initial value:

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

Definition at line 5843 of file gl2ps.cc.

gl2psPS

GL2PSbackend gl2psPS

static

Initial value:

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

Definition at line 3333 of file gl2ps.cc.

gl2psSVG

GL2PSbackend gl2psSVG

static

Initial value:

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

Definition at line 5556 of file gl2ps.cc.

gl2psTEX

GL2PSbackend gl2psTEX

static

Initial value:

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

Definition at line 3501 of file gl2ps.cc.