gl2ps File Reference

#include "gl2ps_begin.icc"
#include <math.h>
#include <string.h>
#include <sys/types.h>
#include <stdarg.h>
#include <time.h>
#include <float.h>
#include "gl2ps_end.icc"

Include dependency graph for gl2ps:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_tools_GL2PSbsptree2d
struct	tools_GL2PSlist
struct	_tools_GL2PSbsptree
struct	tools_GL2PStriangle
struct	tools_GL2PSstring
struct	tools_GL2PSimage
struct	_tools_GL2PSimagemap
struct	tools_GL2PSprimitive
struct	tools_GL2PScompress
struct	tools_GL2PSpdfgroup
struct	tools_GL2PScontext
struct	tools_GL2PSbackend

Macros
#define	tools_gl2ps
#define	TOOLS_GL2PS_EPSILON   5.0e-3F
#define	TOOLS_GL2PS_ZSCALE   1000.0F
#define	TOOLS_GL2PS_ZOFFSET   5.0e-2F
#define	TOOLS_GL2PS_ZOFFSET_LARGE   20.0F
#define	TOOLS_GL2PS_ZERO(arg)   (fabs(arg) < 1.e-20)
#define	TOOLS_GL2PS_COINCIDENT   1
#define	TOOLS_GL2PS_IN_FRONT_OF   2
#define	TOOLS_GL2PS_IN_BACK_OF   3
#define	TOOLS_GL2PS_SPANNING   4
#define	TOOLS_GL2PS_POINT_COINCIDENT   0
#define	TOOLS_GL2PS_POINT_INFRONT   1
#define	TOOLS_GL2PS_POINT_BACK   2
#define	TOOLS_GL2PS_BEGIN_OFFSET_TOKEN   1
#define	TOOLS_GL2PS_END_OFFSET_TOKEN   2
#define	TOOLS_GL2PS_BEGIN_BOUNDARY_TOKEN   3
#define	TOOLS_GL2PS_END_BOUNDARY_TOKEN   4
#define	TOOLS_GL2PS_BEGIN_STIPPLE_TOKEN   5
#define	TOOLS_GL2PS_END_STIPPLE_TOKEN   6
#define	TOOLS_GL2PS_POINT_SIZE_TOKEN   7
#define	TOOLS_GL2PS_LINE_CAP_TOKEN   8
#define	TOOLS_GL2PS_LINE_JOIN_TOKEN   9
#define	TOOLS_GL2PS_LINE_WIDTH_TOKEN   10
#define	TOOLS_GL2PS_BEGIN_BLEND_TOKEN   11
#define	TOOLS_GL2PS_END_BLEND_TOKEN   12
#define	TOOLS_GL2PS_SRC_BLEND_TOKEN   13
#define	TOOLS_GL2PS_DST_BLEND_TOKEN   14
#define	TOOLS_GL2PS_IMAGEMAP_TOKEN   15
#define	TOOLS_GL2PS_DRAW_PIXELS_TOKEN   16
#define	TOOLS_GL2PS_TEXT_TOKEN   17

Typedefs
typedef tools_GLfloat	tools_GL2PSplane[4]
typedef struct _tools_GL2PSbsptree2d	tools_GL2PSbsptree2d
typedef struct _tools_GL2PSbsptree	tools_GL2PSbsptree
typedef struct _tools_GL2PSimagemap	tools_GL2PSimagemap

Enumerations
enum	TOOLS_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
TOOLS_GL2PSDLL_API void	tools_gl2psAddPolyPrimitive (tools_GLshort type, tools_GLshort numverts, tools_GL2PSvertex *verts, tools_GLint offset, tools_GLfloat ofactor, tools_GLfloat ounits, tools_GLushort pattern, tools_GLint factor, tools_GLfloat width, tools_GLint linecap, tools_GLint linejoin, char boundary)
TOOLS_GL2PSDLL_API tools_GLint	tools_gl2psBeginPage (const char *title, const char *producer, tools_GLint viewport[4], tools_GLint format, tools_GLint sort, tools_GLint options, tools_GLint colormode, tools_GLint colorsize, tools_GL2PSrgba *colormap, tools_GLint nr, tools_GLint ng, tools_GLint nb, tools_GLint buffersize, FILE *stream, const char *filename)
TOOLS_GL2PSDLL_API tools_GLint	tools_gl2psEndPage (void)
TOOLS_GL2PSDLL_API tools_GLint	tools_gl2psBeginViewport (tools_GLint viewport[4])
TOOLS_GL2PSDLL_API tools_GLint	tools_gl2psEndViewport (void)
TOOLS_GL2PSDLL_API tools_GLint	tools_tools_gl2psTextOptColor (const char *str, const char *fontname, tools_GLshort fontsize, tools_GLint alignment, tools_GLfloat angle, tools_GL2PSrgba color)
TOOLS_GL2PSDLL_API tools_GLint	tools_tools_gl2psTextOpt (const char *str, const char *fontname, tools_GLshort fontsize, tools_GLint alignment, tools_GLfloat angle)
TOOLS_GL2PSDLL_API tools_GLint	tools_gl2psText (const char *str, const char *fontname, tools_GLshort fontsize)
TOOLS_GL2PSDLL_API tools_GLint	tools_gl2psSpecial (tools_GLint format, const char *str)
TOOLS_GL2PSDLL_API tools_GLint	tools_gl2psSpecialColor (tools_GLint format, const char *str, tools_GL2PSrgba rgba)
TOOLS_GL2PSDLL_API tools_GLint	tools_gl2psDrawPixels (tools_GLsizei width, tools_GLsizei height, tools_GLint xorig, tools_GLint yorig, tools_GLenum format, tools_GLenum type, const void *pixels)
TOOLS_GL2PSDLL_API tools_GLint	tools_gl2psDrawImageMap (tools_GLsizei width, tools_GLsizei height, const tools_GLfloat position[3], const unsigned char *imagemap)
TOOLS_GL2PSDLL_API tools_GLint	tools_gl2psEnable (tools_GLint mode)
TOOLS_GL2PSDLL_API tools_GLint	tools_gl2psDisable (tools_GLint mode)
TOOLS_GL2PSDLL_API tools_GLint	tools_gl2psPointSize (tools_GLfloat value)
TOOLS_GL2PSDLL_API tools_GLint	tools_gl2psLineCap (tools_GLint value)
TOOLS_GL2PSDLL_API tools_GLint	tools_gl2psLineJoin (tools_GLint value)
TOOLS_GL2PSDLL_API tools_GLint	tools_gl2psLineWidth (tools_GLfloat value)
TOOLS_GL2PSDLL_API tools_GLint	tools_gl2psBlendFunc (tools_GLenum sfactor, tools_GLenum dfactor)
TOOLS_GL2PSDLL_API tools_GLint	tools_gl2psSetOptions (tools_GLint options)
TOOLS_GL2PSDLL_API tools_GLint	tools_gl2psGetOptions (tools_GLint *options)
TOOLS_GL2PSDLL_API const char *	tools_gl2psGetFileExtension (tools_GLint format)
TOOLS_GL2PSDLL_API const char *	tools_gl2psGetFormatDescription (tools_GLint format)
TOOLS_GL2PSDLL_API tools_GLint	tools_gl2psGetFileFormat ()
TOOLS_GL2PSDLL_API tools_GLint	tools_gl2psForceRasterPos (tools_GL2PSvertex *vert)

Macro Definition Documentation

tools_gl2ps

#define tools_gl2ps

Definition at line 2 of file gl2ps.

TOOLS_GL2PS_BEGIN_BLEND_TOKEN

#define TOOLS_GL2PS_BEGIN_BLEND_TOKEN   11

Definition at line 107 of file gl2ps.

TOOLS_GL2PS_BEGIN_BOUNDARY_TOKEN

#define TOOLS_GL2PS_BEGIN_BOUNDARY_TOKEN   3

Definition at line 99 of file gl2ps.

TOOLS_GL2PS_BEGIN_OFFSET_TOKEN

#define TOOLS_GL2PS_BEGIN_OFFSET_TOKEN   1

Definition at line 97 of file gl2ps.

TOOLS_GL2PS_BEGIN_STIPPLE_TOKEN

#define TOOLS_GL2PS_BEGIN_STIPPLE_TOKEN   5

Definition at line 101 of file gl2ps.

TOOLS_GL2PS_COINCIDENT

#define TOOLS_GL2PS_COINCIDENT   1

Definition at line 84 of file gl2ps.

TOOLS_GL2PS_DRAW_PIXELS_TOKEN

#define TOOLS_GL2PS_DRAW_PIXELS_TOKEN   16

Definition at line 112 of file gl2ps.

TOOLS_GL2PS_DST_BLEND_TOKEN

#define TOOLS_GL2PS_DST_BLEND_TOKEN   14

Definition at line 110 of file gl2ps.

TOOLS_GL2PS_END_BLEND_TOKEN

#define TOOLS_GL2PS_END_BLEND_TOKEN   12

Definition at line 108 of file gl2ps.

TOOLS_GL2PS_END_BOUNDARY_TOKEN

#define TOOLS_GL2PS_END_BOUNDARY_TOKEN   4

Definition at line 100 of file gl2ps.

TOOLS_GL2PS_END_OFFSET_TOKEN

#define TOOLS_GL2PS_END_OFFSET_TOKEN   2

Definition at line 98 of file gl2ps.

TOOLS_GL2PS_END_STIPPLE_TOKEN

#define TOOLS_GL2PS_END_STIPPLE_TOKEN   6

Definition at line 102 of file gl2ps.

TOOLS_GL2PS_EPSILON

#define TOOLS_GL2PS_EPSILON   5.0e-3F

Definition at line 76 of file gl2ps.

TOOLS_GL2PS_IMAGEMAP_TOKEN

#define TOOLS_GL2PS_IMAGEMAP_TOKEN   15

Definition at line 111 of file gl2ps.

TOOLS_GL2PS_IN_BACK_OF

#define TOOLS_GL2PS_IN_BACK_OF   3

Definition at line 86 of file gl2ps.

TOOLS_GL2PS_IN_FRONT_OF

#define TOOLS_GL2PS_IN_FRONT_OF   2

Definition at line 85 of file gl2ps.

TOOLS_GL2PS_LINE_CAP_TOKEN

#define TOOLS_GL2PS_LINE_CAP_TOKEN   8

Definition at line 104 of file gl2ps.

TOOLS_GL2PS_LINE_JOIN_TOKEN

#define TOOLS_GL2PS_LINE_JOIN_TOKEN   9

Definition at line 105 of file gl2ps.

TOOLS_GL2PS_LINE_WIDTH_TOKEN

#define TOOLS_GL2PS_LINE_WIDTH_TOKEN   10

Definition at line 106 of file gl2ps.

TOOLS_GL2PS_POINT_BACK

#define TOOLS_GL2PS_POINT_BACK   2

Definition at line 93 of file gl2ps.

TOOLS_GL2PS_POINT_COINCIDENT

#define TOOLS_GL2PS_POINT_COINCIDENT   0

Definition at line 91 of file gl2ps.

TOOLS_GL2PS_POINT_INFRONT

#define TOOLS_GL2PS_POINT_INFRONT   1

Definition at line 92 of file gl2ps.

TOOLS_GL2PS_POINT_SIZE_TOKEN

#define TOOLS_GL2PS_POINT_SIZE_TOKEN   7

Definition at line 103 of file gl2ps.

TOOLS_GL2PS_SPANNING

#define TOOLS_GL2PS_SPANNING   4

Definition at line 87 of file gl2ps.

TOOLS_GL2PS_SRC_BLEND_TOKEN

#define TOOLS_GL2PS_SRC_BLEND_TOKEN   13

Definition at line 109 of file gl2ps.

TOOLS_GL2PS_TEXT_TOKEN

#define TOOLS_GL2PS_TEXT_TOKEN   17

Definition at line 113 of file gl2ps.

TOOLS_GL2PS_ZERO

#define TOOLS_GL2PS_ZERO

(

arg

)

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

Definition at line 80 of file gl2ps.

TOOLS_GL2PS_ZOFFSET

#define TOOLS_GL2PS_ZOFFSET   5.0e-2F

Definition at line 78 of file gl2ps.

TOOLS_GL2PS_ZOFFSET_LARGE

#define TOOLS_GL2PS_ZOFFSET_LARGE   20.0F

Definition at line 79 of file gl2ps.

TOOLS_GL2PS_ZSCALE

#define TOOLS_GL2PS_ZSCALE   1000.0F

Definition at line 77 of file gl2ps.

Typedef Documentation

tools_GL2PSbsptree

typedef struct _tools_GL2PSbsptree tools_GL2PSbsptree

Definition at line 124 of file gl2ps.

tools_GL2PSbsptree2d

typedef struct _tools_GL2PSbsptree2d tools_GL2PSbsptree2d

Definition at line 124 of file gl2ps.

tools_GL2PSimagemap

typedef struct _tools_GL2PSimagemap tools_GL2PSimagemap

Definition at line 124 of file gl2ps.

tools_GL2PSplane

typedef tools_GLfloat tools_GL2PSplane[4]

Definition at line 124 of file gl2ps.

Enumeration Type Documentation

TOOLS_GL2PS_TRIANGLE_PROPERTY

enum TOOLS_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 115 of file gl2ps.

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

Function Documentation

tools_gl2psAddPolyPrimitive()

TOOLS_GL2PSDLL_API void tools_gl2psAddPolyPrimitive	(	tools_GLshort	type,
		tools_GLshort	numverts,
		tools_GL2PSvertex *	verts,
		tools_GLint	offset,
		tools_GLfloat	ofactor,
		tools_GLfloat	ounits,
		tools_GLushort	pattern,
		tools_GLint	factor,
		tools_GLfloat	width,
		tools_GLint	linecap,
		tools_GLint	linejoin,
		char	boundary
	)

Definition at line 2231 of file gl2ps.

{
  tools_GL2PSprimitive *prim;
 
  prim = (tools_GL2PSprimitive*)tools_gl2psMalloc(sizeof(tools_GL2PSprimitive));
  prim->type = type;
  prim->numverts = numverts;
  prim->verts = (tools_GL2PSvertex*)tools_gl2psMalloc(numverts * sizeof(tools_GL2PSvertex));
  memcpy(prim->verts, verts, numverts * sizeof(tools_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 */
 
  tools_gl2psListAdd(tools_gl2ps_context->primitives, &prim);
}

tools_gl2psBeginPage()

TOOLS_GL2PSDLL_API tools_GLint tools_gl2psBeginPage	(	const char *	title,
		const char *	producer,
		tools_GLint	viewport[4],
		tools_GLint	format,
		tools_GLint	sort,
		tools_GLint	options,
		tools_GLint	colormode,
		tools_GLint	colorsize,
		tools_GL2PSrgba *	colormap,
		tools_GLint	nr,
		tools_GLint	ng,
		tools_GLint	nb,
		tools_GLint	buffersize,
		FILE *	stream,
		const char *	filename
	)

Definition at line 5927 of file gl2ps.

{
  tools_GLint idx;
  int i;
 
  if(tools_gl2ps_context){
    tools_gl2psMsg(TOOLS_GL2PS_ERROR, "tools_gl2psBeginPage called in wrong program state");
    return TOOLS_GL2PS_ERROR;
  }
 
  tools_gl2ps_context = (tools_GL2PScontext*)tools_gl2psMalloc(sizeof(tools_GL2PScontext));
 
  /* Validate options */
  if (tools_gl2psCheckOptions(options, colormode) == TOOLS_GL_FALSE) {
    tools_gl2psFree(tools_gl2ps_context);
    tools_gl2ps_context = NULL;
    return TOOLS_GL2PS_ERROR;
  }
 
  if(format >= 0 && format < (tools_GLint)(sizeof(tools_gl2psbackends) / sizeof(tools_gl2psbackends[0]))){
    tools_gl2ps_context->format = format;
  }
  else {
    tools_gl2psMsg(TOOLS_GL2PS_ERROR, "Unknown output format: %d", format);
    tools_gl2psFree(tools_gl2ps_context);
    tools_gl2ps_context = NULL;
    return TOOLS_GL2PS_ERROR;
  }
 
  switch(sort){
  case TOOLS_GL2PS_NO_SORT :
  case TOOLS_GL2PS_SIMPLE_SORT :
  case TOOLS_GL2PS_BSP_SORT :
    tools_gl2ps_context->sort = sort;
    break;
  default :
    tools_gl2psMsg(TOOLS_GL2PS_ERROR, "Unknown sorting algorithm: %d", sort);
    tools_gl2psFree(tools_gl2ps_context);
    tools_gl2ps_context = NULL;
    return TOOLS_GL2PS_ERROR;
  }
 
  if(stream){
    tools_gl2ps_context->stream = stream;
  }
  else{
    tools_gl2psMsg(TOOLS_GL2PS_ERROR, "Bad file pointer");
    tools_gl2psFree(tools_gl2ps_context);
    tools_gl2ps_context = NULL;
    return TOOLS_GL2PS_ERROR;
  }
 
  tools_gl2ps_context->header = TOOLS_GL_TRUE;
  tools_gl2ps_context->forcerasterpos = TOOLS_GL_FALSE;
  tools_gl2ps_context->maxbestroot = 10;
  tools_gl2ps_context->options = options;
  tools_gl2ps_context->compress = NULL;
  tools_gl2ps_context->imagemap_head = NULL;
  tools_gl2ps_context->imagemap_tail = NULL;
 
  if(tools_gl2ps_context->options & TOOLS_GL2PS_USE_CURRENT_VIEWPORT){
    tools_glGetIntegerv(TOOLS_GL_VIEWPORT, tools_gl2ps_context->viewport);
  }
  else{
    for(i = 0; i < 4; i++){
      tools_gl2ps_context->viewport[i] = viewport[i];
    }
  }
 
  if(!tools_gl2ps_context->viewport[2] || !tools_gl2ps_context->viewport[3]){
    tools_gl2psMsg(TOOLS_GL2PS_ERROR, "Incorrect viewport (x=%d, y=%d, width=%d, height=%d)",
             tools_gl2ps_context->viewport[0], tools_gl2ps_context->viewport[1],
             tools_gl2ps_context->viewport[2], tools_gl2ps_context->viewport[3]);
    tools_gl2psFree(tools_gl2ps_context);
    tools_gl2ps_context = NULL;
    return TOOLS_GL2PS_ERROR;
  }
 
  tools_gl2ps_context->threshold[0] = nr ? 1.0F / (tools_GLfloat)nr : 0.064F;
  tools_gl2ps_context->threshold[1] = ng ? 1.0F / (tools_GLfloat)ng : 0.034F;
  tools_gl2ps_context->threshold[2] = nb ? 1.0F / (tools_GLfloat)nb : 0.100F;
  tools_gl2ps_context->colormode = colormode;
  tools_gl2ps_context->buffersize = buffersize > 0 ? buffersize : 2048 * 2048;
  for(i = 0; i < 3; i++){
    tools_gl2ps_context->lastvertex.xyz[i] = -1.0F;
  }
  for(i = 0; i < 4; i++){
    tools_gl2ps_context->lastvertex.rgba[i] = -1.0F;
    tools_gl2ps_context->lastrgba[i] = -1.0F;
  }
  tools_gl2ps_context->lastlinewidth = -1.0F;
  tools_gl2ps_context->lastlinecap = 0;
  tools_gl2ps_context->lastlinejoin = 0;
  tools_gl2ps_context->lastpattern = 0;
  tools_gl2ps_context->lastfactor = 0;
  tools_gl2ps_context->imagetree = NULL;
  tools_gl2ps_context->primitivetoadd = NULL;
  tools_gl2ps_context->zerosurfacearea = TOOLS_GL_FALSE;
  tools_gl2ps_context->pdfprimlist = NULL;
  tools_gl2ps_context->pdfgrouplist = NULL;
  tools_gl2ps_context->xreflist = NULL;
 
  /* get default blending mode from current OpenGL state (enabled by
     default for SVG) */
  if ((tools_gl2ps_context->options & TOOLS_GL2PS_NO_BLENDING) == TOOLS_GL2PS_NONE) {
    tools_gl2ps_context->blending = (tools_gl2ps_context->format == TOOLS_GL2PS_SVG) ? TOOLS_GL_TRUE
                                                   : tools_glIsEnabled(TOOLS_GL_BLEND);
    tools_glGetIntegerv(TOOLS_GL_BLEND_SRC, &tools_gl2ps_context->blendfunc[0]);
    tools_glGetIntegerv(TOOLS_GL_BLEND_DST, &tools_gl2ps_context->blendfunc[1]);
  }
  else {
    tools_gl2ps_context->blending = TOOLS_GL_FALSE;
  }
 
  if(tools_gl2ps_context->colormode == TOOLS_GL_RGBA){
    tools_gl2ps_context->colorsize = 0;
    tools_gl2ps_context->colormap = NULL;
    if ((tools_gl2ps_context->options & TOOLS_GL2PS_NO_OPENGL_CONTEXT) == TOOLS_GL2PS_NONE) {
      tools_glGetFloatv(TOOLS_GL_COLOR_CLEAR_VALUE, tools_gl2ps_context->bgcolor);
    }
  }
  else if(tools_gl2ps_context->colormode == TOOLS_GL_COLOR_INDEX){
    if(!colorsize || !colormap){
      tools_gl2psMsg(TOOLS_GL2PS_ERROR, "Missing colormap for TOOLS_GL_COLOR_INDEX rendering");
      tools_gl2psFree(tools_gl2ps_context);
      tools_gl2ps_context = NULL;
      return TOOLS_GL2PS_ERROR;
    }
    tools_gl2ps_context->colorsize = colorsize;
    tools_gl2ps_context->colormap = (tools_GL2PSrgba*)tools_gl2psMalloc(tools_gl2ps_context->colorsize * sizeof(tools_GL2PSrgba));
    memcpy(tools_gl2ps_context->colormap, colormap, tools_gl2ps_context->colorsize * sizeof(tools_GL2PSrgba));
    tools_glGetIntegerv(TOOLS_GL_INDEX_CLEAR_VALUE, &idx);
    tools_gl2ps_context->bgcolor[0] = tools_gl2ps_context->colormap[idx][0];
    tools_gl2ps_context->bgcolor[1] = tools_gl2ps_context->colormap[idx][1];
    tools_gl2ps_context->bgcolor[2] = tools_gl2ps_context->colormap[idx][2];
    tools_gl2ps_context->bgcolor[3] = 1.0F;
  }
  else{
    tools_gl2psMsg(TOOLS_GL2PS_ERROR, "Unknown color mode in tools_gl2psBeginPage");
    tools_gl2psFree(tools_gl2ps_context);
    tools_gl2ps_context = NULL;
    return TOOLS_GL2PS_ERROR;
  }
 
  if(!title){
    tools_gl2ps_context->title = (char*)tools_gl2psMalloc(sizeof(char));
    tools_gl2ps_context->title[0] = '\0';
  }
  else{
    tools_gl2ps_context->title = (char*)tools_gl2psMalloc((strlen(title)+1)*sizeof(char));
    strcpy(tools_gl2ps_context->title, title);
  }
 
  if(!producer){
    tools_gl2ps_context->producer = (char*)tools_gl2psMalloc(sizeof(char));
    tools_gl2ps_context->producer[0] = '\0';
  }
  else{
    tools_gl2ps_context->producer = (char*)tools_gl2psMalloc((strlen(producer)+1)*sizeof(char));
    strcpy(tools_gl2ps_context->producer, producer);
  }
 
  if(!filename){
    tools_gl2ps_context->filename = (char*)tools_gl2psMalloc(sizeof(char));
    tools_gl2ps_context->filename[0] = '\0';
  }
  else{
    tools_gl2ps_context->filename = (char*)tools_gl2psMalloc((strlen(filename)+1)*sizeof(char));
    strcpy(tools_gl2ps_context->filename, filename);
  }
 
  tools_gl2ps_context->primitives = tools_gl2psListCreate(500, 500, sizeof(tools_GL2PSprimitive*));
  tools_gl2ps_context->auxprimitives = tools_gl2psListCreate(100, 100, sizeof(tools_GL2PSprimitive*));
 
  if ((tools_gl2ps_context->options & TOOLS_GL2PS_NO_OPENGL_CONTEXT) == TOOLS_GL2PS_NONE) {
    tools_gl2ps_context->feedback = (tools_GLfloat*)tools_gl2psMalloc(tools_gl2ps_context->buffersize * sizeof(tools_GLfloat));
    tools_glFeedbackBuffer(tools_gl2ps_context->buffersize, TOOLS_GL_3D_COLOR, tools_gl2ps_context->feedback);
    tools_glRenderMode(TOOLS_GL_FEEDBACK);
  }
  else {
    tools_gl2ps_context->feedback = NULL;
    tools_gl2ps_context->buffersize = 0;
  }
 
  return TOOLS_GL2PS_SUCCESS;
}

tools_gl2psBeginViewport()

TOOLS_GL2PSDLL_API tools_GLint tools_gl2psBeginViewport

(

tools_GLint

viewport[4]

)

Definition at line 6146 of file gl2ps.

{
  if(!tools_gl2ps_context) return TOOLS_GL2PS_UNINITIALIZED;
 
  (tools_gl2psbackends[tools_gl2ps_context->format]->beginViewport)(viewport);
 
  return TOOLS_GL2PS_SUCCESS;
}

tools_gl2psBlendFunc()

TOOLS_GL2PSDLL_API tools_GLint tools_gl2psBlendFunc	(	tools_GLenum	sfactor,
		tools_GLenum	dfactor
	)

Definition at line 6439 of file gl2ps.

{
  if(!tools_gl2ps_context) return TOOLS_GL2PS_UNINITIALIZED;
 
  if(TOOLS_GL_FALSE == tools_gl2psSupportedBlendMode(sfactor, dfactor))
    return TOOLS_GL2PS_WARNING;
 
  tools_glPassThrough(TOOLS_GL2PS_SRC_BLEND_TOKEN);
  tools_glPassThrough((tools_GLfloat)sfactor);
  tools_glPassThrough(TOOLS_GL2PS_DST_BLEND_TOKEN);
  tools_glPassThrough((tools_GLfloat)dfactor);
 
  return TOOLS_GL2PS_SUCCESS;
}

tools_gl2psDisable()

TOOLS_GL2PSDLL_API tools_GLint tools_gl2psDisable

(

tools_GLint

mode

)

Definition at line 6374 of file gl2ps.

{
  if(!tools_gl2ps_context) return TOOLS_GL2PS_UNINITIALIZED;
 
  switch(mode){
  case TOOLS_GL2PS_POLYGON_OFFSET_FILL :
    tools_glPassThrough(TOOLS_GL2PS_END_OFFSET_TOKEN);
    break;
  case TOOLS_GL2PS_POLYGON_BOUNDARY :
    tools_glPassThrough(TOOLS_GL2PS_END_BOUNDARY_TOKEN);
    break;
  case TOOLS_GL2PS_LINE_STIPPLE :
    tools_glPassThrough(TOOLS_GL2PS_END_STIPPLE_TOKEN);
    break;
  case TOOLS_GL2PS_BLEND :
    tools_glPassThrough(TOOLS_GL2PS_END_BLEND_TOKEN);
    break;
  default :
    tools_gl2psMsg(TOOLS_GL2PS_WARNING, "Unknown mode in tools_gl2psDisable: %d", mode);
    return TOOLS_GL2PS_WARNING;
  }
 
  return TOOLS_GL2PS_SUCCESS;
}

tools_gl2psDrawImageMap()

TOOLS_GL2PSDLL_API tools_GLint tools_gl2psDrawImageMap	(	tools_GLsizei	width,
		tools_GLsizei	height,
		const tools_GLfloat	position[3],
		const unsigned char *	imagemap
	)

Definition at line 6313 of file gl2ps.

                                                                   {
  int size, i;
  int sizeoffloat = sizeof(tools_GLfloat);
 
  if(!tools_gl2ps_context || !imagemap) return TOOLS_GL2PS_UNINITIALIZED;
 
  if((width <= 0) || (height <= 0)) return TOOLS_GL2PS_ERROR;
 
  size = height + height * ((width - 1) / 8);
  tools_glPassThrough(TOOLS_GL2PS_IMAGEMAP_TOKEN);
  tools_glBegin(TOOLS_GL_POINTS);
  tools_glVertex3f(position[0], position[1],position[2]);
  tools_glEnd();
  tools_glPassThrough((tools_GLfloat)width);
  tools_glPassThrough((tools_GLfloat)height);
  for(i = 0; i < size; i += sizeoffloat){
    const float *value = (const float*)imagemap;
    tools_glPassThrough(*value);
    imagemap += sizeoffloat;
  }
  return TOOLS_GL2PS_SUCCESS;
}

tools_gl2psDrawPixels()

TOOLS_GL2PSDLL_API tools_GLint tools_gl2psDrawPixels	(	tools_GLsizei	width,
		tools_GLsizei	height,
		tools_GLint	xorig,
		tools_GLint	yorig,
		tools_GLenum	format,
		tools_GLenum	type,
		const void *	pixels
	)

Definition at line 6199 of file gl2ps.

{
  int size, i;
  const tools_GLfloat *piv;
  tools_GLfloat pos[4], zoom_x, zoom_y;
  tools_GL2PSprimitive *prim;
  tools_GLboolean valid;
 
  if(!tools_gl2ps_context || !pixels) return TOOLS_GL2PS_UNINITIALIZED;
 
  if((width <= 0) || (height <= 0)) return TOOLS_GL2PS_ERROR;
 
  if(tools_gl2ps_context->options & TOOLS_GL2PS_NO_PIXMAP) return TOOLS_GL2PS_SUCCESS;
 
  if((format != TOOLS_GL_RGB && format != TOOLS_GL_RGBA) || type != TOOLS_GL_FLOAT){
    tools_gl2psMsg(TOOLS_GL2PS_ERROR, "tools_gl2psDrawPixels only implemented for "
             "TOOLS_GL_RGB/TOOLS_GL_RGBA, TOOLS_GL_FLOAT pixels");
    return TOOLS_GL2PS_ERROR;
  }
 
  if (tools_gl2ps_context->forcerasterpos) {
    pos[0] = tools_gl2ps_context->rasterpos.xyz[0];
    pos[1] = tools_gl2ps_context->rasterpos.xyz[1];
    pos[2] = tools_gl2ps_context->rasterpos.xyz[2];
    pos[3] = 1.f;
    /* Hardcode zoom factors (for now?) */
    zoom_x = 1.f;
    zoom_y = 1.f;
  }
  else {
    tools_glGetBooleanv(TOOLS_GL_CURRENT_RASTER_POSITION_VALID, &valid);
    if(TOOLS_GL_FALSE == valid) return TOOLS_GL2PS_SUCCESS; /* the primitive is culled */
    tools_glGetFloatv(TOOLS_GL_CURRENT_RASTER_POSITION, pos);
    tools_glGetFloatv(TOOLS_GL_ZOOM_X, &zoom_x);
    tools_glGetFloatv(TOOLS_GL_ZOOM_Y, &zoom_y);
  }
 
  prim = (tools_GL2PSprimitive*)tools_gl2psMalloc(sizeof(tools_GL2PSprimitive));
  prim->type = TOOLS_GL2PS_PIXMAP;
  prim->boundary = 0;
  prim->numverts = 1;
  prim->verts = (tools_GL2PSvertex*)tools_gl2psMalloc(sizeof(tools_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 (tools_gl2ps_context->forcerasterpos) {
    prim->verts[0].rgba[0] = tools_gl2ps_context->rasterpos.rgba[0];
    prim->verts[0].rgba[1] = tools_gl2ps_context->rasterpos.rgba[1];
    prim->verts[0].rgba[2] = tools_gl2ps_context->rasterpos.rgba[2];
    prim->verts[0].rgba[3] = tools_gl2ps_context->rasterpos.rgba[3];
  }
  else {
    tools_glGetFloatv(TOOLS_GL_CURRENT_RASTER_COLOR, prim->verts[0].rgba);
  }
  prim->data.image = (tools_GL2PSimage*)tools_gl2psMalloc(sizeof(tools_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;
 
  tools_gl2ps_context->forcerasterpos = TOOLS_GL_FALSE;
 
  switch(format){
  case TOOLS_GL_RGBA:
    if(tools_gl2ps_context->options & TOOLS_GL2PS_NO_BLENDING || !tools_gl2ps_context->blending){
      /* special case: blending turned off */
      prim->data.image->format = TOOLS_GL_RGB;
      size = height * width * 3;
      prim->data.image->pixels = (tools_GLfloat*)tools_gl2psMalloc(size * sizeof(tools_GLfloat));
      piv = (const tools_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 = (tools_GLfloat*)tools_gl2psMalloc(size * sizeof(tools_GLfloat));
      memcpy(prim->data.image->pixels, pixels, size * sizeof(tools_GLfloat));
    }
    break;
  case TOOLS_GL_RGB:
  default:
    size = height * width * 3;
    prim->data.image->pixels = (tools_GLfloat*)tools_gl2psMalloc(size * sizeof(tools_GLfloat));
    memcpy(prim->data.image->pixels, pixels, size * sizeof(tools_GLfloat));
    break;
  }
 
  /* If no OpenGL context, just add directly to primitives */
  if ((tools_gl2ps_context->options & TOOLS_GL2PS_NO_OPENGL_CONTEXT) == TOOLS_GL2PS_NONE) {
    tools_gl2psListAdd(tools_gl2ps_context->auxprimitives, &prim);
    tools_glPassThrough(TOOLS_GL2PS_DRAW_PIXELS_TOKEN);
  }
  else {
    tools_gl2psListAdd(tools_gl2ps_context->primitives, &prim);
  }
 
  return TOOLS_GL2PS_SUCCESS;
}

tools_gl2psEnable()

TOOLS_GL2PSDLL_API tools_GLint tools_gl2psEnable

(

tools_GLint

mode

)

Definition at line 6338 of file gl2ps.

{
  tools_GLint tmp;
  tools_GLfloat tmp2;
 
  if(!tools_gl2ps_context) return TOOLS_GL2PS_UNINITIALIZED;
 
  switch(mode){
  case TOOLS_GL2PS_POLYGON_OFFSET_FILL :
    tools_glPassThrough(TOOLS_GL2PS_BEGIN_OFFSET_TOKEN);
    tools_glGetFloatv(TOOLS_GL_POLYGON_OFFSET_FACTOR, &tmp2);
    tools_glPassThrough(tmp2);
    tools_glGetFloatv(TOOLS_GL_POLYGON_OFFSET_UNITS, &tmp2);
    tools_glPassThrough(tmp2);
    break;
  case TOOLS_GL2PS_POLYGON_BOUNDARY :
    tools_glPassThrough(TOOLS_GL2PS_BEGIN_BOUNDARY_TOKEN);
    break;
  case TOOLS_GL2PS_LINE_STIPPLE :
    tools_glPassThrough(TOOLS_GL2PS_BEGIN_STIPPLE_TOKEN);
    tools_glGetIntegerv(TOOLS_GL_LINE_STIPPLE_PATTERN, &tmp);
    tools_glPassThrough((tools_GLfloat)tmp);
    tools_glGetIntegerv(TOOLS_GL_LINE_STIPPLE_REPEAT, &tmp);
    tools_glPassThrough((tools_GLfloat)tmp);
    break;
  case TOOLS_GL2PS_BLEND :
    tools_glPassThrough(TOOLS_GL2PS_BEGIN_BLEND_TOKEN);
    break;
  default :
    tools_gl2psMsg(TOOLS_GL2PS_WARNING, "Unknown mode in tools_gl2psEnable: %d", mode);
    return TOOLS_GL2PS_WARNING;
  }
 
  return TOOLS_GL2PS_SUCCESS;
}

tools_gl2psEndPage()

TOOLS_GL2PSDLL_API tools_GLint tools_gl2psEndPage

(

void

)

Definition at line 6119 of file gl2ps.

{
  tools_GLint res;
 
  if(!tools_gl2ps_context) return TOOLS_GL2PS_UNINITIALIZED;
 
  res = tools_gl2psPrintPrimitives();
 
  if(res != TOOLS_GL2PS_OVERFLOW)
    (tools_gl2psbackends[tools_gl2ps_context->format]->printFooter)();
 
  fflush(tools_gl2ps_context->stream);
 
  tools_gl2psListDelete(tools_gl2ps_context->primitives);
  tools_gl2psListDelete(tools_gl2ps_context->auxprimitives);
  tools_tools_gl2psFreeImagemap(tools_gl2ps_context->imagemap_head);
  tools_gl2psFree(tools_gl2ps_context->colormap);
  tools_gl2psFree(tools_gl2ps_context->title);
  tools_gl2psFree(tools_gl2ps_context->producer);
  tools_gl2psFree(tools_gl2ps_context->filename);
  tools_gl2psFree(tools_gl2ps_context->feedback);
  tools_gl2psFree(tools_gl2ps_context);
  tools_gl2ps_context = NULL;
 
  return res;
}

tools_gl2psEndViewport()

TOOLS_GL2PSDLL_API tools_GLint tools_gl2psEndViewport

(

void

)

Definition at line 6155 of file gl2ps.

{
  tools_GLint res;
 
  if(!tools_gl2ps_context) return TOOLS_GL2PS_UNINITIALIZED;
 
  res = (tools_gl2psbackends[tools_gl2ps_context->format]->endViewport)();
 
  /* reset last used colors, line widths */
  tools_gl2psResetLineProperties();
 
  return res;
}

tools_gl2psForceRasterPos()

TOOLS_GL2PSDLL_API tools_GLint tools_gl2psForceRasterPos

(

tools_GL2PSvertex *

vert

)

Definition at line 6500 of file gl2ps.

{
 
  if(!tools_gl2ps_context) {
    return TOOLS_GL2PS_UNINITIALIZED;
  }
 
  tools_gl2ps_context->forcerasterpos = TOOLS_GL_TRUE;
  tools_gl2ps_context->rasterpos.xyz[0] = vert->xyz[0];
  tools_gl2ps_context->rasterpos.xyz[1] = vert->xyz[1];
  tools_gl2ps_context->rasterpos.xyz[2] = vert->xyz[2];
  tools_gl2ps_context->rasterpos.rgba[0] = vert->rgba[0];
  tools_gl2ps_context->rasterpos.rgba[1] = vert->rgba[1];
  tools_gl2ps_context->rasterpos.rgba[2] = vert->rgba[2];
  tools_gl2ps_context->rasterpos.rgba[3] = vert->rgba[3];
 
  return TOOLS_GL2PS_SUCCESS;
}

tools_gl2psGetFileExtension()

TOOLS_GL2PSDLL_API const char* tools_gl2psGetFileExtension

(

tools_GLint

format

)

Definition at line 6479 of file gl2ps.

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

tools_gl2psGetFileFormat()

TOOLS_GL2PSDLL_API tools_GLint tools_gl2psGetFileFormat

(

)

Definition at line 6495 of file gl2ps.

{
  return tools_gl2ps_context->format;
}

tools_gl2psGetFormatDescription()

TOOLS_GL2PSDLL_API const char* tools_gl2psGetFormatDescription

(

tools_GLint

format

)

Definition at line 6487 of file gl2ps.

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

tools_gl2psGetOptions()

TOOLS_GL2PSDLL_API tools_GLint tools_gl2psGetOptions

(

tools_GLint *

options

)

Definition at line 6467 of file gl2ps.

{
  if(!tools_gl2ps_context) {
    *options = 0;
    return TOOLS_GL2PS_UNINITIALIZED;
  }
 
  *options = tools_gl2ps_context->options;
 
  return TOOLS_GL2PS_SUCCESS;
}

tools_gl2psLineCap()

TOOLS_GL2PSDLL_API tools_GLint tools_gl2psLineCap

(

tools_GLint

value

)

Definition at line 6409 of file gl2ps.

{
  if(!tools_gl2ps_context) return TOOLS_GL2PS_UNINITIALIZED;
 
  tools_glPassThrough(TOOLS_GL2PS_LINE_CAP_TOKEN);
  tools_glPassThrough(value);
 
  return TOOLS_GL2PS_SUCCESS;
}

tools_gl2psLineJoin()

TOOLS_GL2PSDLL_API tools_GLint tools_gl2psLineJoin

(

tools_GLint

value

)

Definition at line 6419 of file gl2ps.

{
  if(!tools_gl2ps_context) return TOOLS_GL2PS_UNINITIALIZED;
 
  tools_glPassThrough(TOOLS_GL2PS_LINE_JOIN_TOKEN);
  tools_glPassThrough((tools_GLfloat)value);  //G.Barrand : _MSC_VER : cast.
 
  return TOOLS_GL2PS_SUCCESS;
}

tools_gl2psLineWidth()

TOOLS_GL2PSDLL_API tools_GLint tools_gl2psLineWidth

(

tools_GLfloat

value

)

Definition at line 6429 of file gl2ps.

{
  if(!tools_gl2ps_context) return TOOLS_GL2PS_UNINITIALIZED;
 
  tools_glPassThrough(TOOLS_GL2PS_LINE_WIDTH_TOKEN);
  tools_glPassThrough((tools_GLfloat)value);  //G.Barrand : _MSC_VER : cast.
 
  return TOOLS_GL2PS_SUCCESS;
}

tools_gl2psPointSize()

TOOLS_GL2PSDLL_API tools_GLint tools_gl2psPointSize

(

tools_GLfloat

value

)

Definition at line 6399 of file gl2ps.

{
  if(!tools_gl2ps_context) return TOOLS_GL2PS_UNINITIALIZED;
 
  tools_glPassThrough(TOOLS_GL2PS_POINT_SIZE_TOKEN);
  tools_glPassThrough(value);
 
  return TOOLS_GL2PS_SUCCESS;
}

tools_gl2psSetOptions()

TOOLS_GL2PSDLL_API tools_GLint tools_gl2psSetOptions

(

tools_GLint

options

)

Definition at line 6454 of file gl2ps.

{
  if(!tools_gl2ps_context) return TOOLS_GL2PS_UNINITIALIZED;
 
  if(tools_gl2psCheckOptions(options, tools_gl2ps_context->colormode) == TOOLS_GL_FALSE) {
    return TOOLS_GL2PS_ERROR;
  }
 
  tools_gl2ps_context->options = options;
 
  return TOOLS_GL2PS_SUCCESS;
}

tools_gl2psSpecial()

TOOLS_GL2PSDLL_API tools_GLint tools_gl2psSpecial	(	tools_GLint	format,
		const char *	str
	)

Definition at line 6189 of file gl2ps.

{
  return tools_gl2psAddText(TOOLS_GL2PS_SPECIAL, str, "", 0, format, 0.0F, NULL);
}

tools_gl2psSpecialColor()

TOOLS_GL2PSDLL_API tools_GLint tools_gl2psSpecialColor	(	tools_GLint	format,
		const char *	str,
		tools_GL2PSrgba	rgba
	)

Definition at line 6194 of file gl2ps.

{
  return tools_gl2psAddText(TOOLS_GL2PS_SPECIAL, str, "", 0, format, 0.0F, rgba);
}

tools_gl2psText()

TOOLS_GL2PSDLL_API tools_GLint tools_gl2psText	(	const char *	str,
		const char *	fontname,
		tools_GLshort	fontsize
	)

Definition at line 6183 of file gl2ps.

{
  return tools_gl2psAddText(TOOLS_GL2PS_TEXT, str, fontname, fontsize, TOOLS_GL2PS_TEXT_BL, 0.0F,
                      NULL);
}

tools_tools_gl2psTextOpt()

TOOLS_GL2PSDLL_API tools_GLint tools_tools_gl2psTextOpt	(	const char *	str,
		const char *	fontname,
		tools_GLshort	fontsize,
		tools_GLint	alignment,
		tools_GLfloat	angle
	)

Definition at line 6177 of file gl2ps.

{
  return tools_gl2psAddText(TOOLS_GL2PS_TEXT, str, fontname, fontsize, alignment, angle, NULL);
}

tools_tools_gl2psTextOptColor()

TOOLS_GL2PSDLL_API tools_GLint tools_tools_gl2psTextOptColor	(	const char *	str,
		const char *	fontname,
		tools_GLshort	fontsize,
		tools_GLint	alignment,
		tools_GLfloat	angle,
		tools_GL2PSrgba	color
	)

Definition at line 6169 of file gl2ps.

{
  return tools_gl2psAddText(TOOLS_GL2PS_TEXT, str, fontname, fontsize, alignment, angle,
                      color);
}