void Set_Transparency()
{
if (AntiAliasing == 0)
{
gl2psEnable(GL2PS_BLEND);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
glDepthMask(GL_FALSE);
}
void draw_sph_flame(double radius, struct buffer_for_gl *gl_buf,
int iflag_write_ps){
int i, j, k, nd, inum, ierr;
double f_color[4];
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glVertexPointer(ITHREE, GL_FLOAT, IZERO, gl_buf->xyz);
glColorPointer(IFOUR, GL_FLOAT, IZERO, gl_buf->rgba);
glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
glEnable(GL_LINE_STIPPLE);
glLineStipple(1,0x3333);
if (iflag_write_ps == ON) {ierr = gl2psEnable(GL2PS_LINE_STIPPLE);};
set_black_color_c(f_color);
inum = 0;
for(j=0; j<NUM_P+1; j++){
for(i=0; i<N_CURVE; i++){
for (k=0; k<2; k++){
gl_buf->xyz[ITWO*inum+k][0] = (GLfloat) (radius * sin(theta_p_grid[k+i]) * cos(phi_p_grid[j]));
gl_buf->xyz[ITWO*inum+k][1] = (GLfloat) (radius * sin(theta_p_grid[k+i]) * sin(phi_p_grid[j]));
gl_buf->xyz[ITWO*inum+k][2] = (GLfloat) (radius * cos(theta_p_grid[k+i]));
};
inum = inum + 1;
}
}
for(j=0; j<NUM_T-1; j++){
for(i=0; i<N_CURVE; i++){
for (k=0; k<2; k++){
gl_buf->xyz[ITWO*inum+k][0] = (GLfloat) (radius * sin(theta_t_grid[j]) * cos(phi_t_grid[i+k]));
gl_buf->xyz[ITWO*inum+k][1] = (GLfloat) (radius * sin(theta_t_grid[j]) * sin(phi_t_grid[i+k]));
gl_buf->xyz[ITWO*inum+k][2] = (GLfloat) (radius * cos(theta_t_grid[j]));
};
inum = inum + 1;
}
}
for (j=0; j<ITWO*inum; j++) {
for(nd=0;nd<4;nd++){gl_buf->rgba[j][nd] = f_color[nd];}
}
if(inum>0){glDrawArrays(GL_LINES, IZERO, (ITWO*inum));};
if (iflag_write_ps == ON) {ierr = gl2psDisable(GL2PS_LINE_STIPPLE);};
glDisable(GL_LINE_STIPPLE);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
return;
}
void draw_PSF_isoline(struct psf_data *psf_s, struct psf_menu_val *psf_m,
struct buffer_for_gl *gl_buf, int iflag_retina, int iflag_write_ps){
int ierr;
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glVertexPointer(ITHREE, GL_FLOAT, IZERO, gl_buf->xyz);
glColorPointer(IFOUR, GL_FLOAT, IZERO, gl_buf->rgba);
glDisable(GL_CULL_FACE);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
glLineWidth(HALF * ((float) iflag_retina+IONE));
if (iflag_write_ps == ON) {
ierr = gl2psLineWidth(ONE);
};
if(psf_m->draw_psf_grid != 0){
find_start_positive_lines(psf_m);
if(psf_m->ist_positive_line > 1){
glEnable(GL_LINE_STIPPLE);
glLineStipple(1,0x3333);
if (iflag_write_ps == ON) {ierr = gl2psEnable(GL2PS_LINE_STIPPLE);};
draw_isolines_4_psf(IONE, psf_m->ist_positive_line,
psf_s, psf_m, gl_buf);
if (iflag_write_ps == ON) {ierr = gl2psDisable(GL2PS_LINE_STIPPLE);};
glDisable(GL_LINE_STIPPLE);
};
if(psf_m->ist_positive_line < psf_m->n_isoline){
draw_isolines_4_psf(psf_m->ist_positive_line,
psf_m->n_isoline, psf_s, psf_m, gl_buf);
};
};
if(psf_m->draw_psf_zero != 0){
glLineWidth( ((float) iflag_retina+IONE) );
if (iflag_write_ps == ON) {ierr = gl2psLineWidth(TWO);};
draw_zeroline_4_psf(psf_s, psf_m, gl_buf);
glLineWidth(HALF * ((float) iflag_retina+IONE));
if (iflag_write_ps == ON) {ierr = gl2psLineWidth(ONE);};
};
glEnable(GL_CULL_FACE);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
return;
}
static void drawVoronoiDual(std::vector<T*> &elements)
{
glColor4ubv((GLubyte *) & CTX::instance()->color.fg);
glEnable(GL_LINE_STIPPLE);
glLineStipple(1, 0x0F0F);
gl2psEnable(GL2PS_LINE_STIPPLE);
glBegin(GL_LINES);
for(unsigned int i = 0; i < elements.size(); i++){
T *ele = elements[i];
if(!isElementVisible(ele)) continue;
SPoint3 pc = ele->circumcenter();
if(ele->getDim() == 2){
for(int j = 0; j < ele->getNumEdges(); j++){
MEdge e = ele->getEdge(j);
SVector3 p2p1(e.getVertex(1)->x() - e.getVertex(0)->x(),
e.getVertex(1)->y() - e.getVertex(0)->y(),
e.getVertex(1)->z() - e.getVertex(0)->z());
SVector3 pcp1(pc.x() - e.getVertex(0)->x(),
pc.y() - e.getVertex(0)->y(),
pc.z() - e.getVertex(0)->z());
double alpha = dot(pcp1,p2p1) / dot(p2p1,p2p1);
SPoint3 p((1 - alpha)*e.getVertex(0)->x() + alpha * e.getVertex(1)->x(),
(1 - alpha)*e.getVertex(0)->y() + alpha * e.getVertex(1)->y(),
(1 - alpha)*e.getVertex(0)->z() + alpha * e.getVertex(1)->z());
glVertex3d(pc.x(), pc.y(), pc.z());
glVertex3d(p.x(), p.y(), p.z());
}
}
else if(ele->getDim() == 3){
for(int j = 0; j < ele->getNumFaces(); j++){
MFace f = ele->getFace(j);
SPoint3 p = f.barycenter();
glVertex3d(pc.x(), pc.y(), pc.z());
glVertex3d(p.x(), p.y(), p.z());
for(int k = 0; k < f.getNumVertices(); k++){
MEdge e(f.getVertex(k), (k == f.getNumVertices() - 1) ?
f.getVertex(0) : f.getVertex(k + 1));
SPoint3 pe = e.barycenter();
glVertex3d(p.x(), p.y(), p.z());
glVertex3d(pe.x(), pe.y(), pe.z());
}
}
}
}
glEnd();
glDisable(GL_LINE_STIPPLE);
gl2psDisable(GL2PS_LINE_STIPPLE);
}
static void display(void)
{
unsigned int i;
unsigned int N = 50;
const char *help = "Press 's' to save image or 'q' to quit";
glClearColor(0.3, 0.5, 0.8, 0.);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
/* draw a smooth-shaded torus */
glPushMatrix();
glRotatef(-60., 2., 0., 1.);
glEnable(GL_LIGHTING);
/* glutSolidTorus(0.3, 0.6, 30, 30);*/
drawCube(0.5);
glDisable(GL_LIGHTING);
glPopMatrix();
glColor3f(1.,1.,1.);
/* draw a stippled line with many small segments (this tests the
ability of gl2ps to render lines using as few strokes as
possible) */
glEnable(GL_LINE_STIPPLE);
glLineStipple(1, 0x087F);
gl2psEnable(GL2PS_LINE_STIPPLE);
glBegin(GL_LINE_STRIP);
for(i = 0; i < N; i++) glVertex3f(-0.75 + 1.5 * (double)i/(double)(N - 1), 0.75, -0.9);
glEnd();
glDisable(GL_LINE_STIPPLE);
gl2psDisable(GL2PS_LINE_STIPPLE);
/* draw a text string */
glRasterPos2d(-0.9,-0.9);
gl2psText(help, "Times-Roman", 24);
for (i = 0; i < strlen(help); i++)
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, help[i]);
glFlush();
}
void Set_AntiAliasing()
{
if (GetMultisample() > 0)
{
glEnable(GL_MULTISAMPLE);
#ifdef GL_MULTISAMPLE_FILTER_HINT_NV
std::string s = (const char *)glGetString(GL_EXTENSIONS);
if (s.find("GL_NV_multisample_filter_hint") != std::string::npos)
{
glHint(GL_MULTISAMPLE_FILTER_HINT_NV, GL_NICEST);
}
#endif
}
gl2psEnable(GL2PS_BLEND);
glEnable(GL_BLEND);
// glDisable(GL_DEPTH_TEST);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// glBlendFunc (GL_SRC_ALPHA_SATURATE, GL_ONE);
glLineWidth(MS_LineWidth);
// In order for polygon smoothing to work nicely, the polygons need to be
// sorted by depth. Therefore we leave polygon smoothing to multisampling.
if (0)
{
glEnable(GL_POLYGON_SMOOTH);
glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);
}
std::string vendor = (const char *)glGetString(GL_VENDOR);
if (vendor.find("ATI") == std::string::npos || GetMultisample() <= 0)
{
// In order for line smoothing to blend nicely with polygons, we draw
// the lines after the polygons.
glEnable(GL_LINE_SMOOTH);
glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
}
else
{
#ifdef GLVIS_DEBUG
std::cout <<
"Found 'ATI' in the GL vendor string:"
" using line smoothing via multisampling." << std::endl;
#endif
}
glEnable(GL_POINT_SMOOTH);
glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);
/* add fog
glEnable(GL_AUTO_NORMAL);
glEnable(GL_NORMALIZE);
glEnable(GL_FOG);
GLfloat fogColor[4] = {1.0, 1.0, 1.0, 1.0};
GLint fogMode;
fogMode = GL_EXP2;
glFogi (GL_FOG_MODE, fogMode);
glFogfv (GL_FOG_COLOR, fogColor);
glFogf (GL_FOG_DENSITY, 2.0);
glHint (GL_FOG_HINT, GL_NICEST);
*/
AntiAliasing = 1;
}
void draw_flame_4_map(struct buffer_for_gl *gl_buf, int iflag_write_ps){
int i, j, nd, inum, ierr;
double rtp_flame[6], d_map_flame[4], f_color[4];
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glVertexPointer(ITWO, GL_FLOAT, IZERO, gl_buf->xy);
glColorPointer(IFOUR, GL_FLOAT, IZERO, gl_buf->rgba);
glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
glEnable(GL_LINE_STIPPLE);
glLineStipple(1,0x3333);
if (iflag_write_ps == ON) {ierr = gl2psEnable(GL2PS_LINE_STIPPLE);};
set_black_color_c(f_color);
inum = 0;
rtp_flame[0] = ONE;
rtp_flame[3] = ONE;
for(j=0; j<NUM_P+1; j++){
rtp_flame[2] = phi_p_grid[j];
rtp_flame[5] = phi_p_grid[j];
for(i=0; i<N_CURVE; i++){
rtp_flame[1] = theta_p_grid[i];
rtp_flame[4] = theta_p_grid[i+1];
aitoff_c(ITWO, rtp_flame, d_map_flame);
gl_buf->xy[ITWO*inum ][0] = d_map_flame[0];
gl_buf->xy[ITWO*inum ][1] = d_map_flame[1];
gl_buf->xy[ITWO*inum+1][0] = d_map_flame[2];
gl_buf->xy[ITWO*inum+1][1] = d_map_flame[3];
inum = inum + 1;
}
}
for(j=0; j<NUM_T-1; j++){
rtp_flame[1] = theta_t_grid[j] ;
rtp_flame[4] = theta_t_grid[j];
for(i=0; i<N_CURVE; i++){
rtp_flame[2] = phi_t_grid[i];
rtp_flame[5] = phi_t_grid[i+1];
aitoff_c(ITWO, rtp_flame, d_map_flame);
gl_buf->xy[ITWO*inum ][0] = d_map_flame[0];
gl_buf->xy[ITWO*inum ][1] = d_map_flame[1];
gl_buf->xy[ITWO*inum+1][0] = d_map_flame[2];
gl_buf->xy[ITWO*inum+1][1] = d_map_flame[3];
inum = inum + 1;
}
}
for (j=0; j<ITWO*inum; j++) {
for(nd=0;nd<4;nd++){gl_buf->rgba[j][nd] = f_color[nd];}
}
if(inum>0){glDrawArrays(GL_LINES, IZERO, (ITWO*inum));};
if (iflag_write_ps == ON) {ierr = gl2psDisable(GL2PS_LINE_STIPPLE);};
glDisable(GL_LINE_STIPPLE);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
return;
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
printOpenGLError();
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
gluLookAt(m_camera.position.x, m_camera.position.y, m_camera.position.z,
m_camera.lookat.x, m_camera.lookat.y, m_camera.lookat.z,
m_camera.up.x, m_camera.up.y, m_camera.up.z);
printOglError(0,0);
if(true)
{
gl2psEnable(GL2PS_LINE_STIPPLE);
if(!noxyz)
UIHelper::drawXYZ();
glPolygonMode(GL_FRONT_AND_BACK, polygon_mode);
glColor3f(0.1, 0.8, 0);
UIHelper::drawBoundingBox(boxobj2);
{
mat4 rotateMatrix = rotateDeg == 0 ? mat4::Identity : mat4::GetRotate(rotateDeg, rotateAxis);
mat4 translateMatrix = mat4::GetTranslate(translatePos);
mat4 transformMatrix = translateMatrix * rotateMatrix;
{
mat4 indentity = mat4::Identity;
//double tx = 1.51, ty = 0, tz = 0;
double tx = translatePos.x, ty = translatePos.y, tz = translatePos.z;
double m [16] = {
1.0, 0, 0, 0,
0.0, 1.0, 0, 0,
0.0, 0, 1.0, 0,
tx, ty, tz, 1.0
};
{
dtSelectObject(&object1);
dtLoadMatrixd(m);
//dtLoadIdentity();
//dtTranslate(tx, ty, tz);
if(dtTestPair(&object1, &object2))
//if(dtTest() > 0)
glColor3f(1.0, 0, 0);
else
glColor3f(0.1, 0.8, 0);
}
}
}
if(rotateDeg != 0)
glRotatef(rotateDeg, rotateAxis.x, rotateAxis.y, rotateAxis.z);
glTranslatef(translatePos.x, translatePos.y, translatePos.z);
UIHelper::drawBoundingBox(boxobj1);
gl2psDisable(GL2PS_LINE_STIPPLE);
}else
{
glColor3f(1, 0, 1);
glPolygonMode(GL_FRONT_AND_BACK ,GL_LINE);
glLineWidth(1.0);
GLUquadricObj *qobj = gluNewQuadric();
gluSphere(qobj,3,16,16);
glLineWidth(2.0);
UIHelper::drawNormals(normals, 3);
glPointSize(5.0f);
UIHelper::drawPoints(normals);
}
glPopMatrix();
glFlush();
if( finish_without_update )
glFinish();
else
glutSwapBuffers();
}
/**
* Renders the current scene to a file in the format given.
*
* @param filename The name of the target file. It must already contain the correct extension and must be encoded in UTF-8.
* @param format The format of the file to render. Supported are PNG, PDF, PS (postscript) and EPS (encapsulated postscript).
* @param title The titel for the document. Must be ANSI encoded for now.
* @param software A string describing the producer of the document. Must be ANSI encoded for now.
* @param content A set of flags indicating what additional info to render.
* @param zoom The zoom at which render the file.
* @param bounds Position and size of the area to store in the file (currently only for PNG).
* @return True if successful otherwise false.
*/
bool CGenericCanvas::renderToFile(const char* filename, TGCFileFormat format, const char* title, const char* software,
TGCRenderContent content, float zoom, TGCViewport& bounds)
{
bool result = false;
if (!updating())
{
beginUpdate();
try
{
if ((FStates & GC_STATE_PENDING_ACTIVATION) != 0)
{
// A pending activation state always means there is a valid current view.
FStates &= ~GC_STATE_PENDING_ACTIVATION;
FCurrentView->activate();
};
switch (format)
{
case GC_FILE_FORMAT_PDF:
case GC_FILE_FORMAT_PS:
case GC_FILE_FORMAT_EPS:
{
if (FCurrentView != NULL)
{
const int fileTypeMapper[4] = {GL2PS_PDF, GL2PS_PS, GL2PS_EPS, GL2PS_TEX};
FILE *file = openFile(filename, "wb");
GLint bufferSize = 0;
GLint state = GL2PS_OVERFLOW;
char *oldlocale = setlocale(LC_NUMERIC, "C");
while (state == GL2PS_OVERFLOW)
{
bufferSize += 1024 * 1024;
gl2psBeginPage(title, software, NULL, fileTypeMapper[format], GL2PS_NO_SORT, GL2PS_DRAW_BACKGROUND | GL2PS_USE_CURRENT_VIEWPORT |
GL2PS_COMPRESS, GL_RGBA, 0, NULL, 0, 0, 0, bufferSize, file, filename);
gl2psEnable(GL2PS_BLEND);
gl2psBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
clearBuffers();
FCurrentView->render(content);
state = gl2psEndPage();
};
setlocale(LC_NUMERIC, oldlocale);
fclose(file);
result = true;
};
break;
};
case GC_FILE_FORMAT_PNG:
{
if (FCurrentView != NULL)
{
TImage image;
float workspaceWidth;
float workspaceHeight;
FCurrentView->getWorkspace(&workspaceWidth, &workspaceHeight);
image.width = bounds.width;
if (image.width < 0)
image.width = (int) workspaceWidth;
image.height = bounds.height;
if (image.height < 0)
image.height = (int) workspaceHeight;
// If the frame buffer extension is not supported then there is no sense
// to allocate a buffer larger than the current viewport,
// because we cannot render more than this area in this case.
if (!supportsExtension(GC_OE_FRAME_BUFFER_OBJECTS))
{
if (image.height > FCurrentView->viewportGet().height)
image.height = FCurrentView->viewportGet().height;
if (image.width > FCurrentView->viewportGet().width)
image.width = FCurrentView->viewportGet().width;
};
image.colorType = COLOR_TYPE_RGB_ALPHA;
image.data = (unsigned char*) malloc(image.width * image.height * 4);
if (image.data != NULL)
{
FCurrentView->renderToMemory(GC_COLOR_FORMAT_RGBA, content, zoom, bounds, image.data);
image.width = bounds.width;
image.height = bounds.height;
result = savePNG(utf8ToUtf16(filename), &image, true, title, software);
free(image.data);
};
};
break;
};
};
endUpdate();
}
catch(...)
{
endUpdate();
throw;
};
checkError();
};
return result;
}
void extras()
{
glColor3f(1., 0., 0.);
glPointSize(1.);
gl2psPointSize(1.);
glBegin(GL_POINTS);
glVertex3f(-1., 1.0, 0.);
glEnd();
glPointSize(3.);
gl2psPointSize(3.);
glBegin(GL_POINTS);
glVertex3f(-0.8, 1.0, 0.);
glEnd();
glPointSize(5.);
gl2psPointSize(5.);
glBegin(GL_POINTS);
glVertex3f(-0.6, 1.0, 0.);
glEnd();
glPointSize(7.);
gl2psPointSize(7.);
glBegin(GL_POINTS);
glVertex3f(-0.4, 1.0, 0.);
glEnd();
glLineWidth(1.);
gl2psLineWidth(1.);
glBegin(GL_LINES);
glVertex3f(-0.2, 1.05, 0.);
glVertex3f(0.2, 1.05, 0.);
glEnd();
glEnable(GL_LINE_STIPPLE);
glLineStipple(1, 0x087F);
gl2psEnable(GL2PS_LINE_STIPPLE);
glBegin(GL_LINES);
glVertex3f(-0.2, 0.95, 0.);
glVertex3f(0.2, 0.95, 0.);
glEnd();
glDisable(GL_LINE_STIPPLE);
gl2psDisable(GL2PS_LINE_STIPPLE);
glLineWidth(3.);
gl2psLineWidth(3.);
glBegin(GL_LINES);
glVertex3f(0.4, 1.05, 0.);
glVertex3f(0.8, 1.05, 0.);
glEnd();
glEnable(GL_LINE_STIPPLE);
glLineStipple(2, 0x0F0F);
/* glLineStipple(1, 0xAAAA); */
gl2psEnable(GL2PS_LINE_STIPPLE);
glBegin(GL_LINES);
glVertex3f(0.4, 0.95, 0.);
glVertex3f(0.8, 0.95, 0.);
glEnd();
glDisable(GL_LINE_STIPPLE);
gl2psDisable(GL2PS_LINE_STIPPLE);
glPointSize(1);
gl2psPointSize(1);
glLineWidth(1);
gl2psLineWidth(1);
}
static void display(void)
{
unsigned int i;
unsigned int N = 50;
const char *help = "Press 's' to save image or 'q' to quit";
glClearColor(0.3, 0.5, 0.8, 0.);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
/* draw a smooth-shaded torus */
glPushMatrix();
glRotatef(-60., 2., 0., 1.);
glEnable(GL_LIGHTING);
glutSolidTorus(0.3, 0.6, 30, 30);
glDisable(GL_LIGHTING);
glPopMatrix();
/* draw three triangles on the same zplane and use polygon offset
to order the layers: the grey triangle should be drawn on the
middle layer */
glEnable(GL_POLYGON_OFFSET_FILL);
glPolygonOffset(1.0, 1.0);
gl2psEnable(GL2PS_POLYGON_OFFSET_FILL);
glColor3f(0.,0.,0.);
glBegin(GL_TRIANGLES);
glVertex3f(0.6, 0.8, 0);
glVertex3f(0.8, 0.8, 0);
glVertex3f(0.7, 0.92, 0);
glEnd();
glPolygonOffset(2.0, 2.0);
gl2psEnable(GL2PS_POLYGON_OFFSET_FILL);
glColor3f(1.,1.,1.);
glBegin(GL_TRIANGLES);
glVertex3f(0.7, 0.8, 0);
glVertex3f(0.9, 0.8, 0);
glVertex3f(0.8, 0.92, 0);
glEnd();
glPolygonOffset(1.5, 1.5);
gl2psEnable(GL2PS_POLYGON_OFFSET_FILL);
glColor3f(0.5,0.5,0.5);
glBegin(GL_TRIANGLES);
glVertex3f(0.65, 0.86, 0);
glVertex3f(0.85, 0.86, 0);
glVertex3f(0.75, 0.98, 0);
glEnd();
glDisable(GL_POLYGON_OFFSET_FILL);
gl2psDisable(GL2PS_POLYGON_OFFSET_FILL);
glColor3f(0.1,0.1,0.1);
/* draw a stippled line with many small segments (this tests the
ability of gl2ps to render lines using as few strokes as
possible) */
glEnable(GL_LINE_STIPPLE);
glLineStipple(1, 0x087F);
gl2psEnable(GL2PS_LINE_STIPPLE);
glBegin(GL_LINE_STRIP);
for(i = 0; i < N; i++)
glVertex3f(-0.75 + 1.5 * (double)i/(double)(N - 1), 0.75, -0.9);
glEnd();
glDisable(GL_LINE_STIPPLE);
gl2psDisable(GL2PS_LINE_STIPPLE);
/* draw a text string */
glRasterPos2d(-0.9,-0.9);
gl2psText(help, "Times-Roman", 24);
for (i = 0; i < strlen(help); i++)
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, help[i]);
glFlush();
}
