Author: matt
Date: 2011-08-25 03:51:10 -0700 (Thu, 25 Aug 2011)
New Revision: 9008
Log:
Moving OpenGL support around
Added:
branches/branch-3.0/include/fltk3gl/GlWindow.h
branches/branch-3.0/include/fltk3gl/all.h
branches/branch-3.0/include/fltk3gl/fltk3gl.h
branches/branch-3.0/include/fltk3gl/gl.h
branches/branch-3.0/include/fltk3gl/gl2opengl.h
branches/branch-3.0/include/fltk3gl/glDraw.h
branches/branch-3.0/include/fltk3gl/glu.h
branches/branch-3.0/include/fltk3gl/glut.h
branches/branch-3.0/src/fltk3gl/GlChoice.cxx
branches/branch-3.0/src/fltk3gl/GlChoice.h
branches/branch-3.0/src/fltk3gl/GlDevicePlugin.cxx
branches/branch-3.0/src/fltk3gl/GlOverlay.cxx
branches/branch-3.0/src/fltk3gl/GlWindow.cxx
branches/branch-3.0/src/fltk3gl/freeglut_geometry.cxx
branches/branch-3.0/src/fltk3gl/freeglut_stroke_mono_roman.cxx
branches/branch-3.0/src/fltk3gl/freeglut_stroke_roman.cxx
branches/branch-3.0/src/fltk3gl/freeglut_teapot.cxx
Removed:
branches/branch-3.0/include/fltk3/GlWindow.h
branches/branch-3.0/include/fltk3/gl.h
branches/branch-3.0/include/fltk3/gl2opengl.h
branches/branch-3.0/include/fltk3/glDraw.h
branches/branch-3.0/include/fltk3/glu.h
branches/branch-3.0/include/fltk3/glut.h
branches/branch-3.0/src/core/Fl_Gl_Choice.H
branches/branch-3.0/src/core/Fl_Gl_Choice.cxx
branches/branch-3.0/src/core/Fl_Gl_Device_Plugin.cxx
branches/branch-3.0/src/core/Fl_Gl_Overlay.cxx
branches/branch-3.0/src/core/Fl_Gl_Window.cxx
branches/branch-3.0/src/core/freeglut_geometry.cxx
branches/branch-3.0/src/core/freeglut_stroke_mono_roman.cxx
branches/branch-3.0/src/core/freeglut_stroke_roman.cxx
branches/branch-3.0/src/core/freeglut_teapot.cxx
Deleted: branches/branch-3.0/include/fltk3/GlWindow.h
Deleted: branches/branch-3.0/include/fltk3/gl.h
Deleted: branches/branch-3.0/include/fltk3/gl2opengl.h
Deleted: branches/branch-3.0/include/fltk3/glDraw.h
Deleted: branches/branch-3.0/include/fltk3/glu.h
Deleted: branches/branch-3.0/include/fltk3/glut.h
Copied: branches/branch-3.0/include/fltk3gl/GlWindow.h (from rev 9002, branches/branch-3.0/include/fltk3/GlWindow.h)
===================================================================
--- branches/branch-3.0/include/fltk3gl/GlWindow.h (rev 0)
+++ branches/branch-3.0/include/fltk3gl/GlWindow.h 2011-08-25 10:51:10 UTC (rev 9008)
@@ -0,0 +1,248 @@
+//
+// "$Id: GlWindow.h 8157 2011-01-01 14:01:53Z AlbrechtS $"
+//
+// OpenGL header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+// USA.
+//
+// Please report all bugs and problems on the following page:
+//
+// http://www.fltk.org/str.php
+//
+
+/* \file
+ fltk3::GlWindow widget . */
+
+#ifndef Fltk3_Gl_Window_H
+#define Fltk3_Gl_Window_H
+
+#include "Window.h"
+
+#ifndef GLContext
+/**
+ Opaque pointer type to hide system specific implementation.
+ */
+typedef void* GLContext; // actually a GLXContext or HGLDC
+#endif
+
+class Fl_Gl_Window;
+
+namespace fltk3 {
+
+ class GlChoice; // structure to hold result of glXChooseVisual
+
+ /**
+ The fltk3::GlWindow widget sets things up so OpenGL works.
+
+ It also keeps an OpenGL "context" for that window, so that changes to the
+ lighting and projection may be reused between redraws. fltk3::GlWindow
+ also flushes the OpenGL streams and swaps buffers after draw() returns.
+
+ OpenGL hardware typically provides some overlay bit planes, which
+ are very useful for drawing UI controls atop your 3D graphics. If the
+ overlay hardware is not provided, FLTK tries to simulate the overlay.
+ This works pretty well if your graphics are double buffered, but not
+ very well for single-buffered.
+
+ Please note that the FLTK drawing and clipping functions
+ will not work inside an fltk3::GlWindow. All drawing
+ should be done using OpenGL calls exclusively.
+ Even though fltk3::GlWindow is derived from fltk3::Group,
+ it is not useful to add other FLTK Widgets as children,
+ unless those widgets are modified to draw using OpenGL calls.
+ */
+ class FLTK3_EXPORT GlWindow : public fltk3::Window {
+
+ friend class ::Fl_Gl_Window;
+
+ int mode_;
+ const int *alist;
+ GlChoice *g;
+ GLContext context_;
+ char valid_f_;
+ char damage1_; // damage() of back buffer
+ virtual void draw_overlay();
+ void init();
+
+ void *overlay;
+ void make_overlay();
+ friend class _Fl_Gl_Overlay;
+
+ static int can_do(int, const int *);
+ int mode(int, const int *);
+
+ public:
+
+ void show();
+ void show(int a, char **b) {Window::show(a,b);}
+ void flush();
+ void hide();
+ void resize(int,int,int,int);
+ int handle(int);
+
+ /**
+ Is turned off when FLTK creates a new context for this window or
+ when the window resizes, and is turned on \e after draw() is called.
+ You can use this inside your draw() method to avoid unnecessarily
+ initializing the OpenGL context. Just do this:
+ \code
+ void mywindow::draw() {
+ if (!valid()) {
+ glViewport(0,0,w(),h());
+ glFrustum(...);
+ ...other initialization...
+ }
+ if (!context_valid()) {
+ ...load textures, etc. ...
+ }
+ ... draw your geometry here ...
+ }
+ \endcode
+
+ You can turn valid() on by calling valid(1). You
+ should only do this after fixing the transformation inside a draw()
+ or after make_current(). This is done automatically after
+ draw() returns.
+ */
+ char valid() const {return valid_f_ & 1;}
+ /**
+ See char fltk3::GlWindow::valid() const
+ */
+ void valid(char v) {if (v) valid_f_ |= 1; else valid_f_ &= 0xfe;}
+ void invalidate();
+
+ /**
+ Will only be set if the
+ OpenGL context is created or recreated. It differs from
+ fltk3::GlWindow::valid() which is also set whenever the context
+ changes size.
+ */
+ char context_valid() const {return valid_f_ & 2;}
+ /**
+ See char fltk3::GlWindow::context_valid() const
+ */
+ void context_valid(char v) {if (v) valid_f_ |= 2; else valid_f_ &= 0xfd;}
+
+ /** Returns non-zero if the hardware supports the given or current OpenGL mode. */
+ static int can_do(int m) {return can_do(m,0);}
+ /** Returns non-zero if the hardware supports the given or current OpenGL mode. */
+ static int can_do(const int *m) {return can_do(0, m);}
+ /** Returns non-zero if the hardware supports the given or current OpenGL mode. */
+ int can_do() {return can_do(mode_,alist);}
+ /**
+ Set or change the OpenGL capabilites of the window. The value can be
+ any of the following OR'd together:
+
+ - \c fltk3::RGB - RGB color (not indexed)
+ - \c fltk3::RGB8 - RGB color with at least 8 bits of each color
+ - \c fltk3::INDEX - Indexed mode
+ - \c fltk3::SINGLE - not double buffered
+ - \c fltk3::DOUBLE - double buffered
+ - \c fltk3::ACCUM - accumulation buffer
+ - \c fltk3::ALPHA - alpha channel in color
+ - \c fltk3::DEPTH - depth buffer
+ - \c fltk3::STENCIL - stencil buffer
+ - \c fltk3::MULTISAMPLE - multisample antialiasing
+
+ fltk3::RGB and fltk3::SINGLE have a value of zero, so they
+ are "on" unless you give fltk3::INDEX or fltk3::DOUBLE.
+
+ If the desired combination cannot be done, FLTK will try turning off
+ fltk3::MULTISAMPLE. If this also fails the show() will call
+ fltk3::error() and not show the window.
+
+ You can change the mode while the window is displayed. This is most
+ useful for turning double-buffering on and off. Under X this will
+ cause the old X window to be destroyed and a new one to be created. If
+ this is a top-level window this will unfortunately also cause the
+ window to blink, raise to the top, and be de-iconized, and the xid()
+ will change, possibly breaking other code. It is best to make the GL
+ window a child of another window if you wish to do this!
+
+ mode() must not be called within draw() since it
+ changes the current context.
+ */
+ fltk3::Mode mode() const {return (fltk3::Mode)mode_;}
+ /** See fltk3::Mode mode() const */
+ int mode(int a) {return mode(a,0);}
+ /** See fltk3::Mode mode() const */
+ int mode(const int *a) {return mode(0, a);}
+ /** void See void context(void* v, int destroy_flag) */
+ void* context() const {return context_;}
+ void context(void*, int destroy_flag = 0);
+ void make_current();
+ void swap_buffers();
+ void ortho();
+
+ /**
+ Returns true if the hardware overlay is possible. If this is false,
+ FLTK will try to simulate the overlay, with significant loss of update
+ speed. Calling this will cause FLTK to open the display.
+ */
+ int can_do_overlay();
+ /**
+ This method causes draw_overlay() to be called at a later time.
+ Initially the overlay is clear. If you want the window to display
+ something in the overlay when it first appears, you must call this
+ immediately after you show() your window.
+ */
+ void redraw_overlay();
+ void hide_overlay();
+ /**
+ The make_overlay_current() method selects the OpenGL context
+ for the widget's overlay. It is called automatically prior to the
+ draw_overlay() method being called and can also be used to
+ implement feedback and/or selection within the handle()
+ method.
+ */
+ void make_overlay_current();
+
+ // Note: Doxygen docs in Widget.h to avoid redundancy.
+ virtual fltk3::GlWindow* as_gl_window() {return this;}
+
+ ~GlWindow();
+ /**
+ Creates a new fltk3::GlWindow widget using the given size, and label string.
+ The default boxtype is fltk3::NO_BOX. The default mode is fltk3::RGB|fltk3::DOUBLE|fltk3::DEPTH.
+ */
+ GlWindow(int W, int H, const char *l=0) : fltk3::Window(W,H,l) {init();}
+ /**
+ Creates a new fltk3::GlWindow widget using the given position,
+ size, and label string. The default boxtype is fltk3::NO_BOX. The
+ default mode is fltk3::RGB|fltk3::DOUBLE|fltk3::DEPTH.
+ */
+
+ GlWindow(int X, int Y, int W, int H, const char *l=0)
+ : fltk3::Window(X,Y,W,H,l) {init();}
+
+ protected:
+ /**
+ Draws the fltk3::GlWindow.
+
+ You \e \b must override the draw() method.
+ */
+ virtual void draw();
+ };
+
+}
+
+#endif
+
+//
+// End of "$Id: GlWindow.h 8157 2011-01-01 14:01:53Z AlbrechtS $".
+//
Copied: branches/branch-3.0/include/fltk3gl/all.h (from rev 9002, branches/branch-3.0/include/fltk3/gl.h)
===================================================================
--- branches/branch-3.0/include/fltk3gl/all.h (rev 0)
+++ branches/branch-3.0/include/fltk3gl/all.h 2011-08-25 10:51:10 UTC (rev 9008)
@@ -0,0 +1,41 @@
+//
+// "$Id: all.h 8623 2011-04-24 17:09:41Z AlbrechtS $"
+//
+// OpenGL header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2011 by Bill Spitzak and others.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+// USA.
+//
+// Please report all bugs and problems on the following page:
+//
+// http://www.fltk.org/str.php
+//
+
+#ifndef FLTK3GL_ALL_H
+#define FLTK3GL_ALL_H
+
+#include "gl.h"
+#include "glu.h"
+#include "glut.h"
+#include "GlWindow.h"
+#include "glDraw.h"
+
+#endif // !FLTK3GLALL_H
+
+//
+// End of "$Id: gl.h 8623 2011-04-24 17:09:41Z AlbrechtS $".
+//
Copied: branches/branch-3.0/include/fltk3gl/fltk3gl.h (from rev 9002, branches/branch-3.0/include/fltk3/gl.h)
===================================================================
--- branches/branch-3.0/include/fltk3gl/fltk3gl.h (rev 0)
+++ branches/branch-3.0/include/fltk3gl/fltk3gl.h 2011-08-25 10:51:10 UTC (rev 9008)
@@ -0,0 +1,37 @@
+//
+// "$Id: all.h 8623 2011-04-24 17:09:41Z AlbrechtS $"
+//
+// OpenGL header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2011 by Bill Spitzak and others.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+// USA.
+//
+// Please report all bugs and problems on the following page:
+//
+// http://www.fltk.org/str.php
+//
+
+#ifndef FLTK3GL_FLTK3GL_H
+#define FLTK3GL_FLTK3ALL_H
+
+#include "all.h"
+
+#endif // !FLTK3GL_FLTK3GL_H
+
+//
+// End of "$Id: gl.h 8623 2011-04-24 17:09:41Z AlbrechtS $".
+//
Copied: branches/branch-3.0/include/fltk3gl/gl.h (from rev 9002, branches/branch-3.0/include/fltk3/gl.h)
===================================================================
--- branches/branch-3.0/include/fltk3gl/gl.h (rev 0)
+++ branches/branch-3.0/include/fltk3gl/gl.h 2011-08-25 10:51:10 UTC (rev 9008)
@@ -0,0 +1,113 @@
+//
+// "$Id: gl.h 8623 2011-04-24 17:09:41Z AlbrechtS $"
+//
+// OpenGL header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2011 by Bill Spitzak and others.
+//
+// You must include this instead of GL/gl.h to get the Microsoft
+// APIENTRY stuff included (from <windows.h>) prior to the OpenGL
+// header files.
+//
+// This file also provides "missing" OpenGL functions, and
+// gl_start() and gl_finish() to allow OpenGL to be used in any window
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+// USA.
+//
+// Please report all bugs and problems on the following page:
+//
+// http://www.fltk.org/str.php
+//
+
+/** \file gl.h
+ * This file defines wrapper functions for OpenGL in FLTK
+ *
+ * To use OpenGL from within an FLTK application you MUST use gl_visual()
+ * to select the default visual before doing show() on any windows. Mesa
+ * will crash if yoy try to use a visual not returned by glxChooseVidual.
+ *
+ * This does not work with fltk3::DoubleWindow's! It will try to draw
+ * into the front buffer. Depending on the system this will either
+ * crash or do nothing (when pixmaps are being used as back buffer
+ * and GL is being done by hardware), work correctly (when GL is done
+ * with software, such as Mesa), or draw into the front buffer and
+ * be erased when the buffers are swapped (when double buffer hardware
+ * is being used)
+ */
+
+#ifndef FLtk3_gl_H
+# define FLtk3_gl_H
+
+# include "enumerations.h" // for color names
+# ifdef WIN32
+# include <windows.h>
+# endif
+# ifndef APIENTRY
+# if defined(__CYGWIN__)
+# define APIENTRY __attribute__ ((__stdcall__))
+# else
+# define APIENTRY
+# endif
+# endif
+
+# ifdef __APPLE__
+# include <OpenGL/gl.h>
+# else
+# include <GL/gl.h>
+# endif
+
+//FLTK3_EXPORT // FIXME: 123 - keeping this in when compiling with VisualC 2010 we will get an error.
+ void gl_start();
+FLTK3_EXPORT void gl_finish();
+
+FLTK3_EXPORT void gl_color(fltk3::Color i);
+/** back compatibility */
+inline void gl_color(int c) {gl_color((fltk3::Color)c);}
+
+FLTK3_EXPORT void gl_rect(int x,int y,int w,int h);
+/**
+ Fills the given rectangle with the current color.
+ \see gl_rect(int x, int y, int w, int h)
+ */
+inline void gl_rectf(int x,int y,int w,int h) {glRecti(x,y,x+w,y+h);}
+
+FLTK3_EXPORT void gl_font(int fontid, int size);
+FLTK3_EXPORT int gl_height();
+FLTK3_EXPORT int gl_descent();
+FLTK3_EXPORT double gl_width(const char *);
+FLTK3_EXPORT double gl_width(const char *, int n);
+FLTK3_EXPORT double gl_width(uchar);
+
+FLTK3_EXPORT void gl_draw(const char*);
+FLTK3_EXPORT void gl_draw(const char*, int n);
+FLTK3_EXPORT void gl_draw(const char*, int x, int y);
+FLTK3_EXPORT void gl_draw(const char*, float x, float y);
+FLTK3_EXPORT void gl_draw(const char*, int n, int x, int y);
+FLTK3_EXPORT void gl_draw(const char*, int n, float x, float y);
+FLTK3_EXPORT void gl_draw(const char*, int x, int y, int w, int h, fltk3::Align);
+FLTK3_EXPORT void gl_measure(const char*, int& x, int& y);
+#ifdef __APPLE__
+extern FLTK3_EXPORT void gl_texture_pile_height(int max);
+extern FLTK3_EXPORT int gl_texture_pile_height();
+#endif
+
+FLTK3_EXPORT void gl_draw_image(const uchar *, int x,int y,int w,int h, int d=3, int ld=0);
+
+#endif // !FLtk3_gl_H
+
+//
+// End of "$Id: gl.h 8623 2011-04-24 17:09:41Z AlbrechtS $".
+//
Copied: branches/branch-3.0/include/fltk3gl/gl2opengl.h (from rev 9002, branches/branch-3.0/include/fltk3/gl2opengl.h)
===================================================================
--- branches/branch-3.0/include/fltk3gl/gl2opengl.h (rev 0)
+++ branches/branch-3.0/include/fltk3gl/gl2opengl.h 2011-08-25 10:51:10 UTC (rev 9008)
@@ -0,0 +1,35 @@
+/* gl.h
+
+ GL to OpenGL translator.
+ If you include this, you might be able to port old GL programs.
+ There are also much better emulators available on the net.
+
+*/
+
+#include <fltk3/gl.h>
+#include "glDraw.h"
+
+inline void clear() {glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);}
+#define RGBcolor(r,g,b) glColor3ub(r,g,b)
+#define bgnline() glBegin(GL_LINE_STRIP)
+#define bgnpolygon() glBegin(GL_POLYGON)
+#define bgnclosedline() glBegin(GL_LINE_LOOP)
+#define endline() glEnd()
+#define endpolygon() glEnd()
+#define endclosedline() glEnd()
+#define v2f(v) glVertex2fv(v)
+#define v2s(v) glVertex2sv(v)
+#define cmov(x,y,z) glRasterPos3f(x,y,z)
+#define charstr(s) gl_draw(s)
+#define fmprstr(s) gl_draw(s)
+typedef float Matrix[4][4];
+inline void pushmatrix() {glPushMatrix();}
+inline void popmatrix() {glPopMatrix();}
+inline void multmatrix(Matrix m) {glMultMatrixf((float *)m);}
+inline void color(int n) {glIndexi(n);}
+inline void rect(int x,int y,int r,int t) {gl_rect(x,y,r-x,t-y);}
+inline void rectf(int x,int y,int r,int t) {glRectf(x,y,r+1,t+1);}
+inline void recti(int x,int y,int r,int t) {gl_rect(x,y,r-x,t-y);}
+inline void rectfi(int x,int y,int r,int t) {glRecti(x,y,r+1,t+1);}
+inline void rects(int x,int y,int r,int t) {gl_rect(x,y,r-x,t-y);}
+inline void rectfs(int x,int y,int r,int t) {glRects(x,y,r+1,t+1);}
Copied: branches/branch-3.0/include/fltk3gl/glDraw.h (from rev 9002, branches/branch-3.0/include/fltk3/glDraw.h)
===================================================================
--- branches/branch-3.0/include/fltk3gl/glDraw.h (rev 0)
+++ branches/branch-3.0/include/fltk3gl/glDraw.h 2011-08-25 10:51:10 UTC (rev 9008)
@@ -0,0 +1,35 @@
+//
+// "$Id: glDraw.h 7903 2010-11-28 21:06:39Z matt $"
+//
+// OpenGL header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+// USA.
+//
+// Please report all bugs and problems on the following page:
+//
+// http://www.fltk.org/str.php
+//
+
+#include "gl.h"
+
+extern FLTK3_EXPORT void gl_remove_displaylist_fonts();
+
+
+//
+// End of "$Id: glDraw.h 7903 2010-11-28 21:06:39Z matt $".
+//
Copied: branches/branch-3.0/include/fltk3gl/glu.h (from rev 9002, branches/branch-3.0/include/fltk3/glu.h)
===================================================================
--- branches/branch-3.0/include/fltk3gl/glu.h (rev 0)
+++ branches/branch-3.0/include/fltk3gl/glu.h 2011-08-25 10:51:10 UTC (rev 9008)
@@ -0,0 +1,60 @@
+//
+// "$Id: glu.h 7903 2010-11-28 21:06:39Z matt $"
+//
+// GLu header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// You must include this instead of GL/gl.h to get the Microsoft
+// APIENTRY stuff included (from <windows.h>) prior to the OpenGL
+// header files.
+//
+// This file also provides "missing" OpenGL functions, and
+// gl_start() and gl_finish() to allow OpenGL to be used in any window
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+// USA.
+//
+// Please report all bugs and problems on the following page:
+//
+// http://www.fltk.org/str.php
+//
+
+#ifndef FLtk3_glu_H
+# define FLtk3_glu_H
+
+# include "enumerations.h" // for color names
+# ifdef WIN32
+# include <windows.h>
+# endif
+# ifndef APIENTRY
+# if defined(__CYGWIN__)
+# define APIENTRY __attribute__ ((__stdcall__))
+# else
+# define APIENTRY
+# endif
+# endif
+
+# ifdef __APPLE__
+# include <OpenGL/glu.h>
+# else
+# include <GL/glu.h>
+# endif
+
+#endif // !FLtk3_glu_H
+
+//
+// End of "$Id: glu.h 7903 2010-11-28 21:06:39Z matt $".
+//
Copied: branches/branch-3.0/include/fltk3gl/glut.h (from rev 9002, branches/branch-3.0/include/fltk3/glut.h)
===================================================================
--- branches/branch-3.0/include/fltk3gl/glut.h (rev 0)
+++ branches/branch-3.0/include/fltk3gl/glut.h 2011-08-25 10:51:10 UTC (rev 9008)
@@ -0,0 +1,499 @@
+//
+// "$Id: glut.h 8623 2011-04-24 17:09:41Z AlbrechtS $"
+//
+// GLUT emulation header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2011 by Bill Spitzak and others.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+// USA.
+//
+// Please report all bugs and problems on the following page:
+//
+// http://www.fltk.org/str.php
+//
+
+// Emulation of GLUT using fltk.
+
+// GLUT is Copyright (c) Mark J. Kilgard, 1994, 1995, 1996:
+// "This program is freely distributable without licensing fees and is
+// provided without guarantee or warrantee expressed or implied. This
+// program is -not- in the public domain."
+
+// Although I have copied the GLUT API, none of my code is based on
+// any GLUT implementation details and is therefore covered by the LGPL.
+
+// Commented out lines indicate parts of GLUT that are not emulated.
+
+#ifndef Fltk3_glut_H
+#define Fltk3_glut_H
+
+#include "gl.h"
+
+#include "run.h"
+#include "GlWindow.h"
+
+class Fl_Glut_Window;
+
+namespace fltk3 {
+
+ /**
+ GLUT is emulated using this window class and these static variables
+ (plus several more static variables hidden in glut_compatability.cxx):
+ */
+ class FLTK3_EXPORT GlutWindow : public GlWindow {
+
+ friend class ::Fl_Glut_Window;
+
+ void _init();
+ int mouse_down;
+ protected:
+ void draw();
+ void draw_overlay();
+ int handle(int);
+ public: // so the inline functions work
+ int number;
+ int menu[3];
+ void make_current();
+ void (*display)();
+ void (*overlaydisplay)();
+ void (*reshape)(int w, int h);
+ void (*keyboard)(uchar, int x, int y);
+ void (*mouse)(int b, int state, int x, int y);
+ void (*motion)(int x, int y);
+ void (*passivemotion)(int x, int y);
+ void (*entry)(int);
+ void (*visibility)(int);
+ void (*special)(int, int x, int y);
+ GlutWindow(int w, int h, const char *);
+ GlutWindow(int x, int y, int w, int h, const char *);
+ ~GlutWindow();
+ };
+
+}
+
+extern FLTK3_EXPORT fltk3::GlutWindow *glut_window; // the current window
+extern FLTK3_EXPORT int glut_menu; // the current menu
+
+// function pointers that are not per-window:
+extern FLTK3_EXPORT void (*glut_idle_function)();
+extern FLTK3_EXPORT void (*glut_menustate_function)(int);
+extern FLTK3_EXPORT void (*glut_menustatus_function)(int,int,int);
+
+////////////////////////////////////////////////////////////////
+
+//# define GLUT_API_VERSION This does not match any version of GLUT exactly...
+
+FLTK3_EXPORT void glutInit(int *argcp, char **argv); // creates first window
+
+FLTK3_EXPORT void glutInitDisplayMode(unsigned int mode);
+// the fltk3 symbols have the same value as the GLUT ones:
+# define GLUT_RGB fltk3::RGB
+# define GLUT_RGBA fltk3::RGB
+# define GLUT_INDEX fltk3::INDEX
+# define GLUT_SINGLE fltk3::SINGLE
+# define GLUT_DOUBLE fltk3::DOUBLE
+# define GLUT_ACCUM fltk3::ACCUM
+# define GLUT_ALPHA fltk3::ALPHA
+# define GLUT_DEPTH fltk3::DEPTH
+# define GLUT_STENCIL fltk3::STENCIL
+# define GLUT_MULTISAMPLE fltk3::MULTISAMPLE
+# define GLUT_STEREO fltk3::STEREO
+// # define GLUT_LUMINANCE 512
+
+FLTK3_EXPORT void glutInitWindowPosition(int x, int y);
+
+FLTK3_EXPORT void glutInitWindowSize(int w, int h);
+
+FLTK3_EXPORT void glutMainLoop();
+
+FLTK3_EXPORT int glutCreateWindow(char *title);
+FLTK3_EXPORT int glutCreateWindow(const char *title);
+
+FLTK3_EXPORT int glutCreateSubWindow(int win, int x, int y, int width, int height);
+
+FLTK3_EXPORT void glutDestroyWindow(int win);
+
+inline void glutPostRedisplay() {glut_window->redraw();}
+
+FLTK3_EXPORT void glutPostWindowRedisplay(int win);
+
+FLTK3_EXPORT void glutSwapBuffers();
+
+inline int glutGetWindow() {return glut_window->number;}
+
+FLTK3_EXPORT void glutSetWindow(int win);
+
+inline void glutSetWindowTitle(char *t) {glut_window->label(t);}
+
+inline void glutSetIconTitle(char *t) {glut_window->iconlabel(t);}
+
+inline void glutPositionWindow(int x, int y) {glut_window->position(x,y);}
+
+inline void glutReshapeWindow(int w, int h) {glut_window->size(w,h);}
+
+inline void glutPopWindow() {glut_window->show();}
+
+inline void glutPushWindow() { /* do nothing */ }
+
+inline void glutIconifyWindow() {glut_window->iconize();}
+
+inline void glutShowWindow() {glut_window->show();}
+
+inline void glutHideWindow() {glut_window->hide();}
+
+inline void glutFullScreen() {glut_window->fullscreen();}
+
+inline void glutSetCursor(fltk3::Cursor cursor) {glut_window->cursor(cursor);}
+// notice that the numeric values are different than glut:
+# define GLUT_CURSOR_RIGHT_ARROW ((fltk3::Cursor)2)
+# define GLUT_CURSOR_LEFT_ARROW ((fltk3::Cursor)67)
+# define GLUT_CURSOR_INFO fltk3::CURSOR_HAND
+# define GLUT_CURSOR_DESTROY ((fltk3::Cursor)45)
+# define GLUT_CURSOR_HELP fltk3::CURSOR_HELP
+# define GLUT_CURSOR_CYCLE ((fltk3::Cursor)26)
+# define GLUT_CURSOR_SPRAY ((fltk3::Cursor)63)
+# define GLUT_CURSOR_WAIT fltk3::CURSOR_WAIT
+# define GLUT_CURSOR_TEXT fltk3::CURSOR_INSERT
+# define GLUT_CURSOR_CROSSHAIR fltk3::CURSOR_CROSS
+# define GLUT_CURSOR_UP_DOWN fltk3::CURSOR_NS
+# define GLUT_CURSOR_LEFT_RIGHT fltk3::CURSOR_WE
+# define GLUT_CURSOR_TOP_SIDE fltk3::CURSOR_N
+# define GLUT_CURSOR_BOTTOM_SIDE fltk3::CURSOR_S
+# define GLUT_CURSOR_LEFT_SIDE fltk3::CURSOR_W
+# define GLUT_CURSOR_RIGHT_SIDE fltk3::CURSOR_E
+# define GLUT_CURSOR_TOP_LEFT_CORNER fltk3::CURSOR_NW
+# define GLUT_CURSOR_TOP_RIGHT_CORNER fltk3::CURSOR_NE
+# define GLUT_CURSOR_BOTTOM_RIGHT_CORNER fltk3::CURSOR_SE
+# define GLUT_CURSOR_BOTTOM_LEFT_CORNER fltk3::CURSOR_SW
+# define GLUT_CURSOR_INHERIT fltk3::CURSOR_DEFAULT
+# define GLUT_CURSOR_NONE fltk3::CURSOR_NONE
+# define GLUT_CURSOR_FULL_CROSSHAIR fltk3::CURSOR_CROSS
+
+inline void glutWarpPointer(int, int) { /* do nothing */ }
+
+inline void glutEstablishOverlay() {glut_window->make_overlay_current();}
+
+inline void glutRemoveOverlay() {glut_window->hide_overlay();}
+
+inline void glutUseLayer(GLenum layer) {
+ layer ? glut_window->make_overlay_current() : glut_window->make_current();}
+enum {GLUT_NORMAL, GLUT_OVERLAY};
+
+inline void glutPostOverlayRedisplay() {glut_window->redraw_overlay();}
+
+inline void glutShowOverlay() {glut_window->redraw_overlay();}
+
+inline void glutHideOverlay() {glut_window->hide_overlay();}
+
+FLTK3_EXPORT int glutCreateMenu(void (*)(int));
+
+FLTK3_EXPORT void glutDestroyMenu(int menu);
+
+inline int glutGetMenu() {return glut_menu;}
+
+inline void glutSetMenu(int m) {glut_menu = m;}
+
+FLTK3_EXPORT void glutAddMenuEntry(char *label, int value);
+
+FLTK3_EXPORT void glutAddSubMenu(char *label, int submenu);
+
+FLTK3_EXPORT void glutChangeToMenuEntry(int item, char *labela, int value);
+
+FLTK3_EXPORT void glutChangeToSubMenu(int item, char *label, int submenu);
+
+FLTK3_EXPORT void glutRemoveMenuItem(int item);
+
+inline void glutAttachMenu(int b) {glut_window->menu[b] = glut_menu;}
+
+inline void glutDetachMenu(int b) {glut_window->menu[b] = 0;}
+
+inline void glutDisplayFunc(void (*f)()) {glut_window->display = f;}
+
+inline void glutReshapeFunc(void (*f)(int w, int h)) {glut_window->reshape=f;}
+
+inline void glutKeyboardFunc(void (*f)(uchar key, int x, int y)) {
+ glut_window->keyboard = f;}
+
+inline void glutMouseFunc(void (*f)(int b, int state, int x, int y)) {
+ glut_window->mouse = f;}
+# define GLUT_LEFT_BUTTON 0
+# define GLUT_MIDDLE_BUTTON 1
+# define GLUT_RIGHT_BUTTON 2
+# define GLUT_DOWN 0
+# define GLUT_UP 1
+
+inline void glutMotionFunc(void (*f)(int x, int y)) {glut_window->motion= f;}
+
+inline void glutPassiveMotionFunc(void (*f)(int x, int y)) {
+ glut_window->passivemotion= f;}
+
+inline void glutEntryFunc(void (*f)(int s)) {glut_window->entry = f;}
+enum {GLUT_LEFT, GLUT_ENTERED};
+
+inline void glutVisibilityFunc(void (*f)(int s)) {glut_window->visibility=f;}
+enum {GLUT_NOT_VISIBLE, GLUT_VISIBLE};
+
+FLTK3_EXPORT void glutIdleFunc(void (*f)());
+
+// Warning: this cast may not work on all machines:
+inline void glutTimerFunc(unsigned int msec, void (*f)(int), int value) {
+ fltk3::add_timeout(msec*.001, (void (*)(void *))f, (void *)value);
+}
+
+inline void glutMenuStateFunc(void (*f)(int state)) {
+ glut_menustate_function = f;}
+
+inline void glutMenuStatusFunc(void (*f)(int status, int x, int y)) {
+ glut_menustatus_function = f;}
+enum {GLUT_MENU_NOT_IN_USE, GLUT_MENU_IN_USE};
+
+inline void glutSpecialFunc(void (*f)(int key, int x, int y)) {
+ glut_window->special = f;}
+# define GLUT_KEY_F1 1
+# define GLUT_KEY_F2 2
+# define GLUT_KEY_F3 3
+# define GLUT_KEY_F4 4
+# define GLUT_KEY_F5 5
+# define GLUT_KEY_F6 6
+# define GLUT_KEY_F7 7
+# define GLUT_KEY_F8 8
+# define GLUT_KEY_F9 9
+# define GLUT_KEY_F10 10
+# define GLUT_KEY_F11 11
+# define GLUT_KEY_F12 12
+// WARNING: Different values than GLUT uses:
+# define GLUT_KEY_LEFT fltk3::LeftKey
+# define GLUT_KEY_UP fltk3::UpKey
+# define GLUT_KEY_RIGHT fltk3::RightKey
+# define GLUT_KEY_DOWN fltk3::DownKey
+# define GLUT_KEY_PAGE_UP fltk3::PageUpKey
+# define GLUT_KEY_PAGE_DOWN fltk3::PageDownKey
+# define GLUT_KEY_HOME fltk3::HomeKey
+# define GLUT_KEY_END fltk3::EndKey
+# define GLUT_KEY_INSERT fltk3::InsertKey
+
+//inline void glutSpaceballMotionFunc(void (*)(int x, int y, int z));
+
+//inline void glutSpaceballRotateFunc(void (*)(int x, int y, int z));
+
+//inline void glutSpaceballButtonFunc(void (*)(int button, int state));
+
+//inline void glutButtonBoxFunc(void (*)(int button, int state));
+
+//inline void glutDialsFunc(void (*)(int dial, int value));
+
+//inline void glutTabletMotionFunc(void (*)(int x, int y));
+
+//inline void glutTabletButtonFunc(void (*)(int button, int state, int x, int y));
+
+inline void glutOverlayDisplayFunc(void (*f)()) {
+ glut_window->overlaydisplay = f;}
+
+//inline void glutWindowStatusFunc(void (*)(int state));
+//enum {GLUT_HIDDEN, GLUT_FULLY_RETAINED, GLUT_PARTIALLY_RETAINED,
+// GLUT_FULLY_COVERED};
+
+//inline void glutSetColor(int, GLfloat red, GLfloat green, GLfloat blue);
+
+//inline GLfloat glutGetColor(int ndx, int component);
+//#define GLUT_RED 0
+//#define GLUT_GREEN 1
+//#define GLUT_BLUE 2
+
+//inline void glutCopyColormap(int win);
+
+// Warning: values are changed from GLUT!
+// Also relies on the GL_ symbols having values greater than 100
+FLTK3_EXPORT int glutGet(GLenum type);
+enum {
+ GLUT_RETURN_ZERO = 0,
+ GLUT_WINDOW_X,
+ GLUT_WINDOW_Y,
+ GLUT_WINDOW_WIDTH,
+ GLUT_WINDOW_HEIGHT,
+ GLUT_WINDOW_PARENT,
+ GLUT_SCREEN_WIDTH,
+ GLUT_SCREEN_HEIGHT,
+ GLUT_MENU_NUM_ITEMS,
+ GLUT_DISPLAY_MODE_POSSIBLE,
+ GLUT_INIT_WINDOW_X,
+ GLUT_INIT_WINDOW_Y,
+ GLUT_INIT_WINDOW_WIDTH,
+ GLUT_INIT_WINDOW_HEIGHT,
+ GLUT_INIT_DISPLAY_MODE,
+ GLUT_WINDOW_BUFFER_SIZE,
+ GLUT_VERSION
+ //GLUT_WINDOW_NUM_CHILDREN,
+ //GLUT_WINDOW_CURSOR,
+ //GLUT_SCREEN_WIDTH_MM,
+ //GLUT_SCREEN_HEIGHT_MM,
+ //GLUT_ELAPSED_TIME,
+};
+
+# define GLUT_WINDOW_STENCIL_SIZE GL_STENCIL_BITS
+# define GLUT_WINDOW_DEPTH_SIZE GL_DEPTH_BITS
+# define GLUT_WINDOW_RED_SIZE GL_RED_BITS
+# define GLUT_WINDOW_GREEN_SIZE GL_GREEN_BITS
+# define GLUT_WINDOW_BLUE_SIZE GL_BLUE_BITS
+# define GLUT_WINDOW_ALPHA_SIZE GL_ALPHA_BITS
+# define GLUT_WINDOW_ACCUM_RED_SIZE GL_ACCUM_RED_BITS
+# define GLUT_WINDOW_ACCUM_GREEN_SIZE GL_ACCUM_GREEN_BITS
+# define GLUT_WINDOW_ACCUM_BLUE_SIZE GL_ACCUM_BLUE_BITS
+# define GLUT_WINDOW_ACCUM_ALPHA_SIZE GL_ACCUM_ALPHA_BITS
+# define GLUT_WINDOW_DOUBLEBUFFER GL_DOUBLEBUFFER
+# define GLUT_WINDOW_RGBA GL_RGBA
+# define GLUT_WINDOW_COLORMAP_SIZE GL_INDEX_BITS
+# ifdef GL_SAMPLES_SGIS
+# define GLUT_WINDOW_NUM_SAMPLES GL_SAMPLES_SGIS
+# else
+# define GLUT_WINDOW_NUM_SAMPLES GLUT_RETURN_ZERO
+# endif
+# define GLUT_WINDOW_STEREO GL_STEREO
+
+# define GLUT_HAS_KEYBOARD 600
+# define GLUT_HAS_MOUSE 601
+# define GLUT_HAS_SPACEBALL 602
+# define GLUT_HAS_DIAL_AND_BUTTON_BOX 603
+# define GLUT_HAS_TABLET 604
+# define GLUT_NUM_MOUSE_BUTTONS 605
+# define GLUT_NUM_SPACEBALL_BUTTONS 606
+# define GLUT_NUM_BUTTON_BOX_BUTTONS 607
+# define GLUT_NUM_DIALS 608
+# define GLUT_NUM_TABLET_BUTTONS 609
+FLTK3_EXPORT int glutDeviceGet(GLenum type);
+
+// WARNING: these values are different than GLUT uses:
+# define GLUT_ACTIVE_SHIFT fltk3::SHIFT
+# define GLUT_ACTIVE_CTRL fltk3::CTRL
+# define GLUT_ACTIVE_ALT fltk3::ALT
+inline int glutGetModifiers() {return fltk3::event_state() & (GLUT_ACTIVE_SHIFT | GLUT_ACTIVE_CTRL | GLUT_ACTIVE_ALT);}
+
+FLTK3_EXPORT int glutLayerGet(GLenum);
+# define GLUT_OVERLAY_POSSIBLE 800
+//#define GLUT_LAYER_IN_USE 801
+//#define GLUT_HAS_OVERLAY 802
+# define GLUT_TRANSPARENT_INDEX 803
+# define GLUT_NORMAL_DAMAGED 804
+# define GLUT_OVERLAY_DAMAGED 805
+
+extern "C" {
+ typedef void (*GLUTproc)();
+}
+
+FLTK3_EXPORT GLUTproc glutGetProcAddress(const char *procName);
+
+//inline int glutVideoResizeGet(GLenum param);
+//#define GLUT_VIDEO_RESIZE_POSSIBLE 900
+//#define GLUT_VIDEO_RESIZE_IN_USE 901
+//#define GLUT_VIDEO_RESIZE_X_DELTA 902
+//#define GLUT_VIDEO_RESIZE_Y_DELTA 903
+//#define GLUT_VIDEO_RESIZE_WIDTH_DELTA 904
+//#define GLUT_VIDEO_RESIZE_HEIGHT_DELTA 905
+//#define GLUT_VIDEO_RESIZE_X 906
+//#define GLUT_VIDEO_RESIZE_Y 907
+//#define GLUT_VIDEO_RESIZE_WIDTH 908
+//#define GLUT_VIDEO_RESIZE_HEIGHT 909
+
+//inline void glutSetupVideoResizing();
+
+//inline void glutStopVideoResizing();
+
+//inline void glutVideoResize(int x, int y, int width, int height);
+
+//inline void glutVideoPan(int x, int y, int width, int height);
+
+// Font argument must be a void* for compatibility, so...
+/** fltk glut font/size attributes used in the glutXXX functions */
+struct Fl_Glut_Bitmap_Font {fltk3::Font font; fltk3::Fontsize size;};
+
+extern FLTK3_EXPORT struct Fl_Glut_Bitmap_Font
+glutBitmap9By15, glutBitmap8By13, glutBitmapTimesRoman10,
+glutBitmapTimesRoman24, glutBitmapHelvetica10, glutBitmapHelvetica12,
+glutBitmapHelvetica18;
+# define GLUT_BITMAP_9_BY_15 (&glutBitmap9By15)
+# define GLUT_BITMAP_8_BY_13 (&glutBitmap8By13)
+# define GLUT_BITMAP_TIMES_ROMAN_10 (&glutBitmapTimesRoman10)
+# define GLUT_BITMAP_TIMES_ROMAN_24 (&glutBitmapTimesRoman24)
+# define GLUT_BITMAP_HELVETICA_10 (&glutBitmapHelvetica10)
+# define GLUT_BITMAP_HELVETICA_12 (&glutBitmapHelvetica12)
+# define GLUT_BITMAP_HELVETICA_18 (&glutBitmapHelvetica18)
+
+FLTK3_EXPORT void glutBitmapCharacter(void *font, int character);
+FLTK3_EXPORT int glutBitmapHeight(void *font);
+FLTK3_EXPORT int glutBitmapLength(void *font, const unsigned char *string);
+FLTK3_EXPORT void glutBitmapString(void *font, const unsigned char *string);
+FLTK3_EXPORT int glutBitmapWidth(void *font, int character);
+
+FLTK3_EXPORT int glutExtensionSupported(char *name);
+
+/* GLUT stroked font sub-API */
+struct Fl_Glut_StrokeVertex {
+ GLfloat X, Y;
+};
+
+struct Fl_Glut_StrokeStrip {
+ int Number;
+ const Fl_Glut_StrokeVertex* Vertices;
+};
+
+struct Fl_Glut_StrokeChar {
+ GLfloat Right;
+ int Number;
+ const Fl_Glut_StrokeStrip* Strips;
+};
+
+struct Fl_Glut_StrokeFont {
+ char* Name; // The source font name
+ int Quantity; // Number of chars in font
+ GLfloat Height; // Height of the characters
+ const Fl_Glut_StrokeChar** Characters;// The characters mapping
+};
+extern FLTK3_EXPORT Fl_Glut_StrokeFont glutStrokeRoman;
+extern FLTK3_EXPORT Fl_Glut_StrokeFont glutStrokeMonoRoman;
+# define GLUT_STROKE_ROMAN (&glutStrokeRoman)
+# define GLUT_STROKE_MONO_ROMAN (&glutStrokeMonoRoman)
+
+FLTK3_EXPORT void glutStrokeCharacter(void *font, int character);
+FLTK3_EXPORT GLfloat glutStrokeHeight(void *font);
+FLTK3_EXPORT int glutStrokeLength(void *font, const unsigned char *string);
+FLTK3_EXPORT void glutStrokeString(void *font, const unsigned char *string);
+FLTK3_EXPORT int glutStrokeWidth(void *font, int character);
+
+/* GLUT pre-built models sub-API */
+FLTK3_EXPORT void glutWireSphere(GLdouble radius, GLint slices, GLint stacks);
+FLTK3_EXPORT void glutSolidSphere(GLdouble radius, GLint slices, GLint stacks);
+FLTK3_EXPORT void glutWireCone(GLdouble base, GLdouble height, GLint slices, GLint stacks);
+FLTK3_EXPORT void glutSolidCone(GLdouble base, GLdouble height, GLint slices, GLint stacks);
+FLTK3_EXPORT void glutWireCube(GLdouble size);
+FLTK3_EXPORT void glutSolidCube(GLdouble size);
+FLTK3_EXPORT void glutWireTorus(GLdouble innerRadius, GLdouble outerRadius, GLint sides, GLint rings);
+FLTK3_EXPORT void glutSolidTorus(GLdouble innerRadius, GLdouble outerRadius, GLint sides, GLint rings);
+FLTK3_EXPORT void glutWireDodecahedron();
+FLTK3_EXPORT void glutSolidDodecahedron();
+FLTK3_EXPORT void glutWireTeapot(GLdouble size);
+FLTK3_EXPORT void glutSolidTeapot(GLdouble size);
+FLTK3_EXPORT void glutWireOctahedron();
+FLTK3_EXPORT void glutSolidOctahedron();
+FLTK3_EXPORT void glutWireTetrahedron();
+FLTK3_EXPORT void glutSolidTetrahedron();
+FLTK3_EXPORT void glutWireIcosahedron();
+FLTK3_EXPORT void glutSolidIcosahedron();
+
+#endif // !Fltk3_glut_H
+
+//
+// End of "$Id: glut.h 8623 2011-04-24 17:09:41Z AlbrechtS $".
+//
Deleted: branches/branch-3.0/src/core/Fl_Gl_Choice.H
Deleted: branches/branch-3.0/src/core/Fl_Gl_Choice.cxx
Deleted: branches/branch-3.0/src/core/Fl_Gl_Device_Plugin.cxx
Deleted: branches/branch-3.0/src/core/Fl_Gl_Overlay.cxx
Deleted: branches/branch-3.0/src/core/Fl_Gl_Window.cxx
Deleted: branches/branch-3.0/src/core/freeglut_geometry.cxx
Deleted: branches/branch-3.0/src/core/freeglut_stroke_mono_roman.cxx
Deleted: branches/branch-3.0/src/core/freeglut_stroke_roman.cxx
Deleted: branches/branch-3.0/src/core/freeglut_teapot.cxx
Copied: branches/branch-3.0/src/fltk3gl/GlChoice.cxx (from rev 9002, branches/branch-3.0/src/core/Fl_Gl_Choice.cxx)
===================================================================
--- branches/branch-3.0/src/fltk3gl/GlChoice.cxx (rev 0)
+++ branches/branch-3.0/src/fltk3gl/GlChoice.cxx 2011-08-25 10:51:10 UTC (rev 9008)
@@ -0,0 +1,426 @@
+//
+// "$Id$"
+//
+// OpenGL visual selection code for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+// USA.
+//
+// Please report all bugs and problems on the following page:
+//
+// http://www.fltk.org/str.php
+//
+
+#include <config.h>
+#if HAVE_GL
+
+# include <fltk3/run.h>
+# include <fltk3/x.h>
+# include <stdlib.h>
+# include "Fl_Gl_Choice.H"
+# include <fltk3/glDraw.h>
+# include "flstring.h"
+# include <fltk3/utf8.h>
+
+# ifdef __APPLE__
+# include <ApplicationServices/ApplicationServices.h>
+# include <fltk3/Window.h>
+# endif
+
+# ifdef WIN32
+void fl_save_dc(HWND, HDC);
+# endif
+
+static fltk3::GlChoice *first;
+
+// this assumes one of the two arguments is zero:
+// We keep the list system in Win32 to stay compatible and interpret
+// the list later...
+fltk3::GlChoice *fltk3::GlChoice::find(int m, const int *alistp) {
+ fltk3::GlChoice *g;
+
+ for (g = first; g; g = g->next)
+ if (g->mode == m && g->alist == alistp)
+ return g;
+
+#if defined(USE_X11)
+ const int *blist;
+ int list[32];
+
+ if (alistp)
+ blist = alistp;
+ else {
+ int n = 0;
+ if (m & fltk3::INDEX) {
+ list[n++] = GLX_BUFFER_SIZE;
+ list[n++] = 8; // glut tries many sizes, but this should work...
+ } else {
+ list[n++] = GLX_RGBA;
+ list[n++] = GLX_GREEN_SIZE;
+ list[n++] = (m & fltk3::RGB8) ? 8 : 1;
+ if (m & fltk3::ALPHA) {
+ list[n++] = GLX_ALPHA_SIZE;
+ list[n++] = (m & fltk3::RGB8) ? 8 : 1;
+ }
+ if (m & fltk3::ACCUM) {
+ list[n++] = GLX_ACCUM_GREEN_SIZE;
+ list[n++] = 1;
+ if (m & fltk3::ALPHA) {
+ list[n++] = GLX_ACCUM_ALPHA_SIZE;
+ list[n++] = 1;
+ }
+ }
+ }
+ if (m & fltk3::DOUBLE) {
+ list[n++] = GLX_DOUBLEBUFFER;
+ }
+ if (m & fltk3::DEPTH) {
+ list[n++] = GLX_DEPTH_SIZE; list[n++] = 1;
+ }
+ if (m & fltk3::STENCIL) {
+ list[n++] = GLX_STENCIL_SIZE; list[n++] = 1;
+ }
+ if (m & fltk3::STEREO) {
+ list[n++] = GLX_STEREO;
+ }
+# if defined(GLX_VERSION_1_1) && defined(GLX_SGIS_multisample)
+ if (m & fltk3::MULTISAMPLE) {
+ list[n++] = GLX_SAMPLES_SGIS;
+ list[n++] = 4; // value Glut uses
+ }
+# endif
+ list[n] = 0;
+ blist = list;
+ }
+
+ fl_open_display();
+ XVisualInfo *visp = glXChooseVisual(fl_display, fl_screen, (int *)blist);
+ if (!visp) {
+# if defined(GLX_VERSION_1_1) && defined(GLX_SGIS_multisample)
+ if (m&fltk3::MULTISAMPLE) return find(m&~fltk3::MULTISAMPLE,0);
+# endif
+ return 0;
+ }
+
+#elif defined(__APPLE_QUARTZ__)
+ // warning: the Quartz version should probably use Core GL (CGL) instead of AGL
+ const int *blist;
+ int list[32];
+
+ if (alistp)
+ blist = alistp;
+ else {
+ int n = 0;
+ if (m & fltk3::INDEX) {
+ list[n++] = AGL_BUFFER_SIZE;
+ list[n++] = 8; // glut tries many sizes, but this should work...
+ } else {
+ list[n++] = AGL_RGBA;
+ list[n++] = AGL_GREEN_SIZE;
+ list[n++] = (m & fltk3::RGB8) ? 8 : 1;
+ if (m & fltk3::ALPHA) {
+ list[n++] = AGL_ALPHA_SIZE;
+ list[n++] = (m & fltk3::RGB8) ? 8 : 1;
+ }
+ if (m & fltk3::ACCUM) {
+ list[n++] = AGL_ACCUM_GREEN_SIZE;
+ list[n++] = 1;
+ if (m & fltk3::ALPHA) {
+ list[n++] = AGL_ACCUM_ALPHA_SIZE;
+ list[n++] = 1;
+ }
+ }
+ }
+ if (m & fltk3::DOUBLE) {
+ list[n++] = AGL_DOUBLEBUFFER;
+ }
+ if (m & fltk3::DEPTH) {
+ list[n++] = AGL_DEPTH_SIZE; list[n++] = 24;
+ }
+ if (m & fltk3::STENCIL) {
+ list[n++] = AGL_STENCIL_SIZE; list[n++] = 1;
+ }
+# ifdef AGL_STEREO
+ if (m & fltk3::STEREO) {
+ list[n++] = AGL_STEREO;
+ }
+# endif
+ list[n] = AGL_NONE;
+ blist = list;
+ }
+ fl_open_display();
+ AGLPixelFormat fmt = aglChoosePixelFormat(NULL, 0, (GLint*)blist);
+ if (!fmt) return 0;
+
+#elif defined(WIN32)
+
+ // Replacement for ChoosePixelFormat() that finds one with an overlay
+ // if possible:
+ if (!fl_gc) fl_GetDC(0);
+ int pixelformat = 0;
+ PIXELFORMATDESCRIPTOR chosen_pfd;
+ for (int i = 1; ; i++) {
+ PIXELFORMATDESCRIPTOR pfd;
+ if (!DescribePixelFormat(fl_gc, i, sizeof(pfd), &pfd)) break;
+ // continue if it does not satisfy our requirements:
+ if (~pfd.dwFlags & (PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL)) continue;
+ if (pfd.iPixelType != ((m&fltk3::INDEX)?PFD_TYPE_COLORINDEX:PFD_TYPE_RGBA)) continue;
+ if ((m & fltk3::ALPHA) && !pfd.cAlphaBits) continue;
+ if ((m & fltk3::ACCUM) && !pfd.cAccumBits) continue;
+ if ((!(m & fltk3::DOUBLE)) != (!(pfd.dwFlags & PFD_DOUBLEBUFFER))) continue;
+ if ((!(m & fltk3::STEREO)) != (!(pfd.dwFlags & PFD_STEREO))) continue;
+ if ((m & fltk3::DEPTH) && !pfd.cDepthBits) continue;
+ if ((m & fltk3::STENCIL) && !pfd.cStencilBits) continue;
+ // see if better than the one we have already:
+ if (pixelformat) {
+ // offering non-generic rendering is better (read: hardware accelleration)
+ if (!(chosen_pfd.dwFlags & PFD_GENERIC_FORMAT) &&
+ (pfd.dwFlags & PFD_GENERIC_FORMAT)) continue;
+ // offering overlay is better:
+ else if (!(chosen_pfd.bReserved & 15) && (pfd.bReserved & 15)) {}
+ // otherwise more bit planes is better:
+ else if (chosen_pfd.cColorBits > pfd.cColorBits) continue;
+ else if (chosen_pfd.cDepthBits > pfd.cDepthBits) continue;
+ }
+ pixelformat = i;
+ chosen_pfd = pfd;
+ }
+ //printf("Chosen pixel format is %d\n", pixelformat);
+ if (!pixelformat) return 0;
+#else
+# error platform unsupported
+#endif
+
+ g = new fltk3::GlChoice;
+ g->mode = m;
+ g->alist = alistp;
+ g->next = first;
+ first = g;
+
+#if defined(USE_X11)
+ g->vis = visp;
+
+ if (/*MaxCmapsOfScreen(ScreenOfDisplay(fl_display,fl_screen))==1 && */
+ visp->visualid == fl_visual->visualid &&
+ !fltk3::getenv("MESA_PRIVATE_CMAP"))
+ g->colormap = fl_colormap;
+ else
+ g->colormap = XCreateColormap(fl_display, RootWindow(fl_display,fl_screen),
+ visp->visual, AllocNone);
+# elif defined(WIN32)
+ g->pixelformat = pixelformat;
+ g->pfd = chosen_pfd;
+# elif defined(__APPLE_QUARTZ__)
+ // warning: the Quartz version should probably use Core GL (CGL) instead of AGL
+ g->pixelformat = fmt;
+# else
+# error unsupported platform
+# endif
+
+ return g;
+}
+
+static GLContext *context_list = 0;
+static int nContext = 0, NContext = 0;
+
+static void add_context(GLContext ctx) {
+ if (!ctx) return;
+ if (nContext==NContext) {
+ if (!NContext) NContext = 8;
+ NContext *= 2;
+ context_list = (GLContext*)realloc(
+ context_list, NContext*sizeof(GLContext));
+ }
+ context_list[nContext++] = ctx;
+}
+
+static void del_context(GLContext ctx) {
+ int i;
+ for (i=0; i<nContext; i++) {
+ if (context_list[i]==ctx) {
+ memmove(context_list+i, context_list+i+1,
+ (nContext-i-1) * sizeof(GLContext));
+ context_list[--nContext] = 0;
+ break;
+ }
+ }
+ if (!nContext) gl_remove_displaylist_fonts();
+}
+
+#if defined(USE_X11)
+
+GLContext fl_create_gl_context(XVisualInfo* vis) {
+ GLContext shared_ctx = 0;
+ if (context_list && nContext) shared_ctx = context_list[0];
+ GLContext context = glXCreateContext(fl_display, vis, shared_ctx, 1);
+ if (context)
+ add_context(context);
+ return context;
+}
+
+#elif defined(WIN32)
+
+GLContext fl_create_gl_context(fltk3::Window* window, const fltk3::GlChoice* g, int layer) {
+ Fl_X* i = Fl_X::i(window);
+ HDC hdc = i->private_dc;
+ if (!hdc) {
+ hdc = i->private_dc = GetDCEx(i->xid, 0, DCX_CACHE);
+ fl_save_dc(i->xid, hdc);
+ SetPixelFormat(hdc, g->pixelformat, (PIXELFORMATDESCRIPTOR*)(&g->pfd));
+# if USE_COLORMAP
+ if (fl_palette) SelectPalette(hdc, fl_palette, FALSE);
+# endif
+ }
+ GLContext context =
+ layer ? wglCreateLayerContext(hdc, layer) : wglCreateContext(hdc);
+ if (context) {
+ if (context_list && nContext)
+ wglShareLists(context_list[0], context);
+ add_context(context);
+ }
+ return context;
+}
+
+# elif defined(__APPLE_QUARTZ__)
+#if !(MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5 && __LP64__)
+static CGrafPtr fl_GetWindowPort(WindowRef window)
+{
+ typedef CGrafPtr (*wf)(WindowRef);
+ static wf f = NULL;
+ if ( ! f) f = (wf)Fl_X::get_carbon_function("GetWindowPort");
+ return (*f)(window);
+}
+#endif
+
+// warning: the Quartz version should probably use Core GL (CGL) instead of AGL
+GLContext fl_create_gl_context(fltk3::Window* window, const fltk3::GlChoice* g, int layer) {
+ GLContext context, shared_ctx = 0;
+ if (context_list && nContext) shared_ctx = context_list[0];
+ context = aglCreateContext( g->pixelformat, shared_ctx);
+ if (!context) return 0;
+ add_context((GLContext)context);
+ if ( window->parent() ) {
+ int H = window->window()->h();
+ GLint rect[] = { window->x(), H-window->h()-window->y(), window->w(), window->h() };
+ aglSetInteger( (GLContext)context, AGL_BUFFER_RECT, rect );
+ aglEnable( (GLContext)context, AGL_BUFFER_RECT );
+ }
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
+#if __LP64__
+ // 64 bit version
+ aglSetWindowRef(context, Fl_X::i(window)->window_ref() );
+#else
+ // 32 bit version >= 10.5
+ if (aglSetWindowRef != NULL)
+ aglSetWindowRef(context, Fl_X::i(window)->window_ref() );
+ else
+ aglSetDrawable( context, fl_GetWindowPort( Fl_X::i(window)->window_ref() ) );
+#endif
+#else
+ // 32 bit version < 10.5
+ aglSetDrawable( context, fl_GetWindowPort( Fl_X::i(window)->window_ref() ) );
+#endif
+ return (context);
+}
+# else
+# error unsupported platform
+# endif
+
+static GLContext cached_context;
+static fltk3::Window* cached_window;
+
+void fl_set_gl_context(fltk3::Window* w, GLContext context) {
+ if (context != cached_context || w != cached_window) {
+ cached_context = context;
+ cached_window = w;
+# if defined(USE_X11)
+ glXMakeCurrent(fl_display, fl_xid(w), context);
+# elif defined(WIN32)
+ wglMakeCurrent(Fl_X::i(w)->private_dc, context);
+# elif defined(__APPLE_QUARTZ__)
+ // warning: the Quartz version should probably use Core GL (CGL) instead of AGL
+ if ( w->parent() ) { //: resize our GL buffer rectangle
+ int H = w->window()->h();
+ GLint rect[] = { w->x(), H-w->h()-w->y(), w->w(), w->h() };
+ aglSetInteger( context, AGL_BUFFER_RECT, rect );
+ aglEnable( context, AGL_BUFFER_RECT );
+ }
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
+#if __LP64__
+ // 64 bit version
+ aglSetWindowRef(context, Fl_X::i(w)->window_ref() );
+#else
+ // 32 bit version >= 10.5
+ if (aglSetWindowRef != NULL)
+ aglSetWindowRef(context, Fl_X::i(w)->window_ref() );
+ else
+ aglSetDrawable( context, fl_GetWindowPort( Fl_X::i(w)->window_ref() ) );
+#endif
+#else
+ // 32 bit version < 10.5
+ aglSetDrawable( context, fl_GetWindowPort( Fl_X::i(w)->window_ref() ) );
+#endif
+ aglSetCurrentContext(context);
+# else
+# error unsupported platform
+# endif
+ }
+}
+
+void fl_no_gl_context() {
+ cached_context = 0;
+ cached_window = 0;
+# if defined(USE_X11)
+ glXMakeCurrent(fl_display, 0, 0);
+# elif defined(WIN32)
+ wglMakeCurrent(0, 0);
+# elif defined(__APPLE_QUARTZ__)
+ // warning: the Quartz version should probably use Core GL (CGL) instead of AGL
+ AGLContext ctx = aglGetCurrentContext();
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
+ if (aglSetWindowRef != NULL)
+ { if(ctx) aglSetWindowRef(ctx, NULL ); }
+ else
+#endif
+ if(ctx) aglSetDrawable( ctx, NULL );
+ aglSetCurrentContext(0);
+# else
+# error unsupported platform
+# endif
+}
+
+void fl_delete_gl_context(GLContext context) {
+ if (cached_context == context) fl_no_gl_context();
+# if defined(USE_X11)
+ glXDestroyContext(fl_display, context);
+# elif defined(WIN32)
+ wglDeleteContext(context);
+# elif defined(__APPLE_QUARTZ__)
+ // warning: the Quartz version should probably use Core GL (CGL) instead of AGL
+ aglDestroyContext( context );
+# else
+# error unsupported platform
+# endif
+ del_context(context);
+}
+
+#endif // HAVE_GL
+
+
+//
+// End of "$Id$".
+//
Copied: branches/branch-3.0/src/fltk3gl/GlChoice.h (from rev 9002, branches/branch-3.0/src/core/Fl_Gl_Choice.H)
===================================================================
--- branches/branch-3.0/src/fltk3gl/GlChoice.h (rev 0)
+++ branches/branch-3.0/src/fltk3gl/GlChoice.h 2011-08-25 10:51:10 UTC (rev 9008)
@@ -0,0 +1,129 @@
+//
+// "$Id$"
+//
+// OpenGL definitions for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+// USA.
+//
+// Please report all bugs and problems on the following page:
+//
+// http://www.fltk.org/str.php
+//
+
+// Internal interface to set up OpenGL.
+//
+// A "fltk3::GlChoice" is created from an OpenGL mode and holds information
+// necessary to create a window (on X) and to create an OpenGL "context"
+// (on both X and Win32).
+//
+// fl_create_gl_context takes a window (necessary only on Win32) and an
+// fltk3::GlChoice and returns a new OpenGL context. All contexts share
+// display lists with each other.
+//
+// On X another fl_create_gl_context is provided to create it for any
+// X visual.
+//
+// fl_set_gl_context makes the given OpenGL context current and makes
+// it draw into the passed window. It tracks the current one context
+// to avoid calling the context switching code when the same context
+// is used, though it is a mystery to me why the GLX/WGL libraries
+// don't do this themselves...
+//
+// fl_no_gl_context clears that cache so the next fl_set_gl_context is
+// guaranteed to work.
+//
+// fl_delete_gl_context destroys the context.
+//
+// This code is used by fltk3::GlWindow, gl_start(), and gl_visual()
+
+#ifndef Fl_Gl_Choice_H
+#define Fl_Gl_Choice_H
+
+// Warning: whatever GLContext is defined to must take exactly the same
+// space in a structure as a void*!!!
+#ifdef WIN32
+# include <fltk3/gl.h>
+# define GLContext HGLRC
+#elif defined(__APPLE_QUARTZ__)
+// warning: the Quartz version should probably use Core GL (CGL) instead of AGL
+# include <OpenGL/gl.h>
+# include <AGL/agl.h>
+# define GLContext AGLContext
+#else
+# include <GL/glx.h>
+# define GLContext GLXContext
+#endif
+
+namespace fltk3 {
+
+ // Describes crap needed to create a GLContext.
+ class GlChoice {
+ int mode;
+ const int *alist;
+ fltk3::GlChoice *next;
+ public:
+#ifdef WIN32
+ int pixelformat; // the visual to use
+ PIXELFORMATDESCRIPTOR pfd; // some wgl calls need this thing
+#elif defined(__APPLE_QUARTZ__)
+ // warning: the Quartz version should probably use Core GL (CGL) instead of AGL
+ AGLPixelFormat pixelformat;
+#else
+ XVisualInfo *vis; // the visual to use
+ Colormap colormap; // a colormap for that visual
+#endif
+ // Return one of these structures for a given gl mode.
+ // The second argument is a glX attribute list, and is used if mode is
+ // zero. This is not supported on Win32:
+ static fltk3::GlChoice *find(int mode, const int *);
+ };
+
+ class Window;
+
+} // namespace
+
+
+#ifdef WIN32
+
+ GLContext fl_create_gl_context(fltk3::Window*, const fltk3::GlChoice*, int layer=0);
+
+#elif defined(__APPLE_QUARTZ__)
+ // warning: the Quartz version should probably use Core GL (CGL) instead of AGL
+
+ GLContext fl_create_gl_context(fltk3::Window*, const fltk3::GlChoice*, int layer=0);
+
+#else
+
+ GLContext fl_create_gl_context(XVisualInfo* vis);
+
+ static inline
+ GLContext fl_create_gl_context(fltk3::Window*, const fltk3::GlChoice* g) {
+ return fl_create_gl_context(g->vis);
+ }
+
+#endif
+
+ void fl_set_gl_context(fltk3::Window*, GLContext);
+ void fl_no_gl_context();
+ void fl_delete_gl_context(GLContext);
+
+#endif
+
+//
+// End of "$Id$".
+//
Copied: branches/branch-3.0/src/fltk3gl/GlDevicePlugin.cxx (from rev 9002, branches/branch-3.0/src/core/Fl_Gl_Device_Plugin.cxx)
===================================================================
--- branches/branch-3.0/src/fltk3gl/GlDevicePlugin.cxx (rev 0)
+++ branches/branch-3.0/src/fltk3gl/GlDevicePlugin.cxx 2011-08-25 10:51:10 UTC (rev 9008)
@@ -0,0 +1,156 @@
+//
+// "$Id$"
+//
+// implementation of class Fl_Gl_Device_Plugin for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 2010 by Bill Spitzak and others.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+// USA.
+//
+// Please report all bugs and problems to:
+//
+// http://www.fltk.org/str.php
+//
+
+#include <config.h>
+#include <fltk3/Printer.h>
+#include <fltk3/GlWindow.h>
+#include "Fl_Gl_Choice.H"
+#include <fltk3/run.h>
+#ifndef __APPLE__
+#include <fltk3/draw.h>
+#endif
+
+#if defined(__APPLE__)
+static void imgProviderReleaseData (void *info, const void *data, size_t size)
+{
+ free((void *)data);
+}
+#endif
+
+static void print_gl_window(fltk3::GlWindow *glw, int x, int y, int height)
+{
+#ifdef WIN32
+ HDC save_gc = fl_gc;
+ const int bytesperpixel = 3;
+#elif defined(__APPLE__)
+ CGContextRef save_gc = fl_gc;
+ const int bytesperpixel = 4;
+#else
+ _XGC *save_gc = fl_gc;
+ const int bytesperpixel = 3;
+#endif
+ fltk3::SurfaceDevice *save_surface = fltk3::SurfaceDevice::surface();
+ fl_gc = NULL;
+ fltk3::DisplayDevice::display_device()->set_current();
+#ifdef WIN32
+ fltk3::check();
+ fltk3::Window *win = (fltk3::Window*)glw;
+ while( win->window() ) win = win->window();
+ win->redraw();
+ fltk3::check();
+ glw->make_current();
+#else
+ glw->make_current();
+ glw->redraw();
+ glFlush();
+ fltk3::check();
+ glFinish();
+#endif
+ // Read OpenGL context pixels directly.
+ // For extra safety, save & restore OpenGL states that are changed
+ glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
+ glPixelStorei(GL_PACK_ALIGNMENT, 4); /* Force 4-byte alignment */
+ glPixelStorei(GL_PACK_ROW_LENGTH, 0);
+ glPixelStorei(GL_PACK_SKIP_ROWS, 0);
+ glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
+ // Read a block of pixels from the frame buffer
+ int mByteWidth = glw->w() * bytesperpixel;
+ mByteWidth = (mByteWidth + 3) & ~3; // Align to 4 bytes
+ uchar *baseAddress = (uchar*)malloc(mByteWidth * glw->h());
+ glReadPixels(0, 0, glw->w(), glw->h(),
+#ifdef WIN32
+ GL_RGB, GL_UNSIGNED_BYTE,
+#elif defined(__APPLE__)
+ GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV,
+#else // FIXME Linux/Unix
+ GL_RGB, GL_UNSIGNED_BYTE,
+#endif
+ baseAddress);
+ glPopClientAttrib();
+ save_surface->set_current();
+ fl_gc = save_gc;
+#if defined(__APPLE__)
+// kCGBitmapByteOrder32Host and CGBitmapInfo are supposed to arrive with 10.4
+// but some 10.4 don't have kCGBitmapByteOrder32Host, so we play a little #define game
+#if MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_4
+#define kCGBitmapByteOrder32Host 0
+#define CGBitmapInfo CGImageAlphaInfo
+#elif ! defined(kCGBitmapByteOrder32Host)
+#ifdef __BIG_ENDIAN__
+#define kCGBitmapByteOrder32Host (4 << 12)
+#else /* Little endian. */
+#define kCGBitmapByteOrder32Host (2 << 12)
+#endif
+#endif
+ CGColorSpaceRef cSpace = CGColorSpaceCreateDeviceRGB();
+ CGDataProviderRef provider = CGDataProviderCreateWithData(NULL, baseAddress, mByteWidth * glw->h(), imgProviderReleaseData);
+ CGImageRef image = CGImageCreate(glw->w(), glw->h(), 8, 8*bytesperpixel, mByteWidth, cSpace,
+ (CGBitmapInfo)(kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host),
+ provider, NULL, false, kCGRenderingIntentDefault);
+ if(image == NULL) return;
+ CGContextSaveGState(fl_gc);
+ CGContextTranslateCTM(fl_gc, 0, height);
+ CGContextScaleCTM(fl_gc, 1.0f, -1.0f);
+ CGRect rect = { { x, height - y - glw->h() }, { glw->w(), glw->h() } };
+ Fl_X::q_begin_image(rect, 0, 0, glw->w(), glw->h());
+ CGContextDrawImage(fl_gc, rect, image);
+ Fl_X::q_end_image();
+ CGContextRestoreGState(fl_gc);
+ CGImageRelease(image);
+ CGColorSpaceRelease(cSpace);
+ CGDataProviderRelease(provider);
+#else
+ fltk3::draw_image(baseAddress + (glw->h() - 1) * mByteWidth, x, y , glw->w(), glw->h(), bytesperpixel, - mByteWidth);
+ free(baseAddress);
+#endif // __APPLE__
+}
+
+/**
+ This class will make sure that OpenGL printing is available if fltk_gl
+ was linked to the program.
+ */
+class Fl_Gl_Device_Plugin : public fltk3::DevicePlugin {
+public:
+ Fl_Gl_Device_Plugin() : fltk3::DevicePlugin(name()) { }
+ virtual const char *name() { return "opengl.device.fltk.org"; }
+ virtual int print(fltk3::Widget *w, int x, int y, int height) {
+ fltk3::GlWindow *glw = w->as_gl_window();
+ if (!glw) return 0;
+ print_gl_window(glw, x, y, height);
+ return 1;
+ }
+};
+
+static Fl_Gl_Device_Plugin Gl_Device_Plugin;
+
+// The purpose of this variable, used in fltk3::GlWindow.cxx, is only to force this file to be loaded
+// whenever fltk3::GlWindow.cxx is loaded, that is, whenever fltk_gl is.
+FLTK3_EXPORT int fl_gl_load_plugin = 0;
+
+//
+// End of "$Id$".
+//
Copied: branches/branch-3.0/src/fltk3gl/GlOverlay.cxx (from rev 9002, branches/branch-3.0/src/core/Fl_Gl_Overlay.cxx)
===================================================================
--- branches/branch-3.0/src/fltk3gl/GlOverlay.cxx (rev 0)
+++ branches/branch-3.0/src/fltk3gl/GlOverlay.cxx 2011-08-25 10:51:10 UTC (rev 9008)
@@ -0,0 +1,248 @@
+//
+// "$Id$"
+//
+// OpenGL overlay code for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+// USA.
+//
+// Please report all bugs and problems on the following page:
+//
+// http://www.fltk.org/str.php
+//
+
+#include <config.h>
+#if HAVE_GL
+
+#include <fltk3/run.h>
+#include <fltk3/x.h>
+#include "Fl_Gl_Choice.H"
+#include <fltk3/GlWindow.h>
+#include <stdlib.h>
+
+#if !HAVE_GL_OVERLAY
+
+int fltk3::GlWindow::can_do_overlay() {return 0;}
+
+void fltk3::GlWindow::make_overlay() {overlay = this;}
+
+#else
+
+// Methods on fltk3::GlWindow that create an overlay window. Because
+// many programs don't need the overlay, this is separated into this
+// source file so it is not linked in if not used.
+
+// Under X this is done by creating another window, of class _Fl_Gl_Overlay
+// which is a subclass of fltk3::GlWindow except it uses the overlay planes.
+// A pointer to this is stored in the "overlay" pointer of the fltk3::GlWindow.
+
+// Under win32 another GLX context is created to draw into the overlay
+// and it is stored in the "overlay" pointer.
+
+// In both cases if overlay hardware is unavailable, the overlay is
+// "faked" by drawing into the main layers. This is indicated by
+// setting overlay == this.
+
+#ifndef WIN32
+////////////////////////////////////////////////////////////////
+// X version
+
+extern XVisualInfo *fl_find_overlay_visual();
+extern XVisualInfo *fl_overlay_visual;
+extern Colormap fl_overlay_colormap;
+extern unsigned long fl_transparent_pixel;
+extern uchar fl_overlay;
+
+class _Fl_Gl_Overlay : public fltk3::GlWindow {
+ void flush();
+ void draw();
+public:
+ void show();
+ _Fl_Gl_Overlay(int x, int y, int w, int h) :
+ fltk3::GlWindow(x,y,w,h) {
+ set_flag(INACTIVE);
+ }
+};
+
+void _Fl_Gl_Overlay::flush() {
+ make_current();
+#ifdef BOXX_BUGS
+ // The BoXX overlay is broken and you must not call swap-buffers. This
+ // code will make it work, but we lose because machines that do support
+ // double-buffered overlays will blink when they don't have to
+ glDrawBuffer(GL_FRONT);
+ draw();
+#else
+ draw();
+ swap_buffers();
+#endif
+ glFlush();
+ valid(1);
+}
+
+void _Fl_Gl_Overlay::draw() {
+ if (!valid()) glClearIndex((GLfloat)fl_transparent_pixel);
+ if (damage() != fltk3::DAMAGE_EXPOSE) glClear(GL_COLOR_BUFFER_BIT);
+ fltk3::GlWindow *w = (fltk3::GlWindow *)parent();
+ uchar save_valid = w->valid();
+ w->valid(valid());
+ fl_overlay = 1;
+ w->draw_overlay();
+ fl_overlay = 0;
+ valid(w->valid());
+ w->valid(save_valid);
+}
+
+void _Fl_Gl_Overlay::show() {
+ if (!shown()) {
+ fl_background_pixel = int(fl_transparent_pixel);
+ Fl_X::make_xid(this, fl_overlay_visual, fl_overlay_colormap);
+ fl_background_pixel = -1;
+ // find the outermost window to tell wm about the colormap:
+ fltk3::Window *w = window();
+ for (;;) {fltk3::Window *w1 = w->window(); if (!w1) break; w = w1;}
+ XSetWMColormapWindows(fl_display, fl_xid(w), &(Fl_X::i(this)->xid), 1);
+ context(fl_create_gl_context(fl_overlay_visual), 1);
+ valid(0);
+ }
+ fltk3::GlWindow::show();
+}
+
+int fltk3::GlWindow::can_do_overlay() {
+ return fl_find_overlay_visual() != 0;
+}
+
+void fltk3::GlWindow::make_overlay() {
+ if (overlay) return;
+ if (can_do_overlay()) {
+ _Fl_Gl_Overlay* o = new _Fl_Gl_Overlay(0,0,w(),h());
+ overlay = o;
+ add(*o);
+ o->show();
+ } else {
+ overlay = this; // fake the overlay
+ }
+}
+
+#else
+////////////////////////////////////////////////////////////////
+// WIN32 version:
+
+//static COLORREF *palette;
+extern int fl_overlay_depth;
+
+void fltk3::GlWindow::make_overlay() {
+ if (overlay) return;
+
+ GLContext context = fl_create_gl_context(this, g, 1);
+ if (!context) {overlay = this; return;} // fake the overlay
+
+ HDC hdc = Fl_X::i(this)->private_dc;
+ overlay = context;
+ LAYERPLANEDESCRIPTOR pfd;
+ wglDescribeLayerPlane(hdc, g->pixelformat, 1, sizeof(pfd), &pfd);
+ if (!pfd.iPixelType) {
+ ; // full-color overlay
+ } else {
+ fl_overlay_depth = pfd.cColorBits; // used by gl_color()
+ if (fl_overlay_depth > 8) fl_overlay_depth = 8;
+ COLORREF palette[256];
+ int n = (1<<fl_overlay_depth)-1;
+ // copy all colors except #0 into the overlay palette:
+ for (int i = 0; i <= n; i++) {
+ uchar r,g,b; fltk3::get_color((fltk3::Color)i,r,g,b);
+ palette[i] = RGB(r,g,b);
+ }
+ // always provide black & white in the last 2 pixels:
+ if (fl_overlay_depth < 8) {
+ palette[n-1] = RGB(0,0,0);
+ palette[n] = RGB(255,255,255);
+ }
+ // and use it:
+ wglSetLayerPaletteEntries(hdc, 1, 1, n, palette+1);
+ wglRealizeLayerPalette(hdc, 1, TRUE);
+ }
+ valid(0);
+ return;
+}
+
+int fltk3::GlWindow::can_do_overlay() {
+ if (!g) {
+ g = fltk3::GlChoice::find(mode_,alist);
+ if (!g) return 0;
+ }
+ return (g->pfd.bReserved & 15) != 0;
+}
+
+////////////////////////////////////////////////////////////////
+#endif
+
+#endif
+
+void fltk3::GlWindow::redraw_overlay() {
+ if (!shown()) return;
+ make_overlay();
+#ifdef __APPLE__
+ redraw();
+#else
+#ifndef WIN32
+ if (overlay != this)
+ ((fltk3::GlWindow*)overlay)->redraw();
+ else
+#endif
+ damage(fltk3::DAMAGE_OVERLAY);
+#endif
+}
+
+void fltk3::GlWindow::make_overlay_current() {
+ make_overlay();
+#ifdef __APPLE__
+ // this is not very useful, but unfortunately, Apple decided
+ // that front buffer drawing can no longer (OS X 10.4) be
+ // supported on their platforms.
+ make_current();
+#else
+#if HAVE_GL_OVERLAY
+ if (overlay != this) {
+#ifdef WIN32
+ fl_set_gl_context(this, (GLContext)overlay);
+// if (fl_overlay_depth)
+// wglRealizeLayerPalette(Fl_X::i(this)->private_dc, 1, TRUE);
+#else
+ ((fltk3::GlWindow*)overlay)->make_current();
+#endif
+ } else
+#endif
+ glDrawBuffer(GL_FRONT);
+#endif
+}
+/** Hides the window if it is not this window, does nothing in WIN32. */
+void fltk3::GlWindow::hide_overlay() {
+#if HAVE_GL_OVERLAY
+#ifdef WIN32
+ // nothing needs to be done? Or should it be erased?
+#else
+ if (overlay && overlay!=this) ((fltk3::GlWindow*)overlay)->hide();
+#endif
+#endif
+}
+
+#endif
+
+//
+// End of "$Id$".
+//
Copied: branches/branch-3.0/src/fltk3gl/GlWindow.cxx (from rev 9002, branches/branch-3.0/src/core/Fl_Gl_Window.cxx)
===================================================================
--- branches/branch-3.0/src/fltk3gl/GlWindow.cxx (rev 0)
+++ branches/branch-3.0/src/fltk3gl/GlWindow.cxx 2011-08-25 10:51:10 UTC (rev 9008)
@@ -0,0 +1,554 @@
+//
+// "$Id$"
+//
+// OpenGL window code for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+// USA.
+//
+// Please report all bugs and problems on the following page:
+//
+// http://www.fltk.org/str.php
+//
+
+#include "flstring.h"
+#if HAVE_GL
+
+extern int fl_gl_load_plugin;
+
+static int temp = fl_gl_load_plugin;
+
+#include <fltk3/Wrapper.h>
+#include <fltk3/run.h>
+#include <fltk3/x.h>
+#ifdef __APPLE__
+#include <fltk3/gl.h>
+#endif
+#include "Fl_Gl_Choice.H"
+#include <fltk3/GlWindow.h>
+#include <stdlib.h>
+#include <fltk3/utf8.h>
+
+////////////////////////////////////////////////////////////////
+
+// The symbol SWAP_TYPE defines what is in the back buffer after doing
+// a glXSwapBuffers().
+
+// The OpenGl documentation says that the contents of the backbuffer
+// are "undefined" after glXSwapBuffers(). However, if we know what
+// is in the backbuffers then we can save a good deal of time. For
+// this reason you can define some symbols to describe what is left in
+// the back buffer.
+
+// Having not found any way to determine this from glx (or wgl) I have
+// resorted to letting the user specify it with an environment variable,
+// GL_SWAP_TYPE, it should be equal to one of these symbols:
+
+// contents of back buffer after glXSwapBuffers():
+#define UNDEFINED 1 // anything
+#define SWAP 2 // former front buffer (same as unknown)
+#define COPY 3 // unchanged
+#define NODAMAGE 4 // unchanged even by X expose() events
+
+static char SWAP_TYPE = 0 ; // 0 = determine it from environment variable
+
+////////////////////////////////////////////////////////////////
+
+/** Returns non-zero if the hardware supports the given or current OpenGL mode. */
+int fltk3::GlWindow::can_do(int a, const int *b) {
+ return fltk3::GlChoice::find(a,b) != 0;
+}
+
+void fltk3::GlWindow::show() {
+#if defined(__APPLE__)
+ int need_redraw = 0;
+#endif
+ if (!shown()) {
+ if (!g) {
+ g = fltk3::GlChoice::find(mode_,alist);
+
+ if (!g && (mode_ & fltk3::DOUBLE) == fltk3::SINGLE) {
+ g = fltk3::GlChoice::find(mode_ | fltk3::DOUBLE,alist);
+ if (g) mode_ |= fltk3::FAKE_SINGLE;
+ }
+
+ if (!g) {
+ fltk3::error("Insufficient GL support");
+ return;
+ }
+ }
+#if !defined(WIN32) && !defined(__APPLE__)
+ Fl_X::make_xid(this, g->vis, g->colormap);
+ if (overlay && overlay != this) ((fltk3::GlWindow*)overlay)->show();
+#elif defined(__APPLE__)
+ if( ! parent() ) need_redraw=1;
+#endif
+ }
+ Window::show();
+
+#ifdef __APPLE__
+ set_visible();
+ if(need_redraw) redraw();//necessary only after creation of a top-level GL window
+#endif /* __APPLE__ */
+}
+
+/**
+ The invalidate() method turns off valid() and is
+ equivalent to calling value(0).
+*/
+void fltk3::GlWindow::invalidate() {
+ valid(0);
+ context_valid(0);
+#ifndef WIN32
+ if (overlay) {
+ ((fltk3::GlWindow*)overlay)->valid(0);
+ ((fltk3::GlWindow*)overlay)->context_valid(0);
+ }
+#endif
+}
+
+/**
+ See const int fltk3::GlWindow::mode() const
+*/
+int fltk3::GlWindow::mode(int m, const int *a) {
+ if (m == mode_ && a == alist) return 0;
+#ifndef __APPLE__
+ int oldmode = mode_;
+#endif // !__APPLE__
+#if !defined(WIN32) && !defined(__APPLE__)
+ fltk3::GlChoice* oldg = g;
+#endif // !WIN32 && !__APPLE__
+ context(0);
+ mode_ = m; alist = a;
+ if (shown()) {
+ g = fltk3::GlChoice::find(m, a);
+
+#if defined(USE_X11)
+ // under X, if the visual changes we must make a new X window (yuck!):
+ if (!g || g->vis->visualid!=oldg->vis->visualid || (oldmode^m)&fltk3::DOUBLE) {
+ hide();
+ show();
+ }
+#elif defined(WIN32)
+ if (!g || (oldmode^m)&(fltk3::DOUBLE|fltk3::STEREO)) {
+ hide();
+ show();
+ }
+#elif defined(__APPLE_QUARTZ__)
+ // warning: the Quartz version should probably use Core GL (CGL) instead of AGL
+ redraw();
+#else
+# error unsupported platform
+#endif
+ } else {
+ g = 0;
+ }
+ return 1;
+}
+
+#define NON_LOCAL_CONTEXT 0x80000000
+
+/**
+ The make_current() method selects the OpenGL context for the
+ widget. It is called automatically prior to the draw() method
+ being called and can also be used to implement feedback and/or
+ selection within the handle() method.
+*/
+
+void fltk3::GlWindow::make_current() {
+// puts("fltk3::GlWindow::make_current()");
+// printf("make_current: context_=%p\n", context_);
+ if (!context_) {
+ mode_ &= ~NON_LOCAL_CONTEXT;
+ context_ = fl_create_gl_context(this, g);
+ valid(0);
+ context_valid(0);
+ }
+ fl_set_gl_context(this, context_);
+
+#ifdef __APPLE__
+ // Set the buffer rectangle here, since in resize() we won't have the
+ // correct parent window size to work with...
+ GLint xywh[4];
+
+ if (window()) {
+ xywh[0] = x();
+ xywh[1] = window()->h() - y() - h();
+ } else {
+ xywh[0] = 0;
+ xywh[1] = 0;
+ }
+
+ xywh[2] = w();
+ xywh[3] = h();
+
+ aglSetInteger(context_, AGL_BUFFER_RECT, xywh);
+ aglEnable(context_, AGL_BUFFER_RECT);
+// printf("make_current: xywh=[%d %d %d %d]\n", xywh[0], xywh[1], xywh[2], xywh[3]);
+#endif // __APPLE__
+
+#if defined(WIN32) && USE_COLORMAP
+ if (fl_palette) {
+ fl_GetDC(fl_xid(this));
+ SelectPalette(fl_gc, fl_palette, FALSE);
+ RealizePalette(fl_gc);
+ }
+#endif // USE_COLORMAP
+ if (mode_ & fltk3::FAKE_SINGLE) {
+ glDrawBuffer(GL_FRONT);
+ glReadBuffer(GL_FRONT);
+ }
+ current_ = this;
+}
+
+/**
+ Sets the projection so 0,0 is in the lower left of the window and each
+ pixel is 1 unit wide/tall. If you are drawing 2D images, your
+ draw() method may want to call this if valid() is false.
+*/
+void fltk3::GlWindow::ortho() {
+// Alpha NT seems to have a broken OpenGL that does not like negative coords:
+#ifdef _M_ALPHA
+ glLoadIdentity();
+ glViewport(0, 0, w(), h());
+ glOrtho(0, w(), 0, h(), -1, 1);
+#else
+ GLint v[2];
+ glGetIntegerv(GL_MAX_VIEWPORT_DIMS, v);
+ glLoadIdentity();
+ glViewport(w()-v[0], h()-v[1], v[0], v[1]);
+ glOrtho(w()-v[0], w(), h()-v[1], h(), -1, 1);
+#endif
+}
+
+/**
+ The swap_buffers() method swaps the back and front buffers.
+ It is called automatically after the draw() method is called.
+*/
+void fltk3::GlWindow::swap_buffers() {
+#if defined(USE_X11)
+ glXSwapBuffers(fl_display, fl_xid(this));
+#elif defined(WIN32)
+# if HAVE_GL_OVERLAY
+ // Do not swap the overlay, to match GLX:
+ BOOL ret = wglSwapLayerBuffers(Fl_X::i(this)->private_dc, WGL_SWAP_MAIN_PLANE);
+ DWORD err = GetLastError();;
+# else
+ SwapBuffers(Fl_X::i(this)->private_dc);
+# endif
+#elif defined(__APPLE_QUARTZ__)
+ if(overlay != NULL) {
+ //aglSwapBuffers does not work well with overlays under cocoa
+ glReadBuffer(GL_BACK);
+ glDrawBuffer(GL_FRONT);
+ glCopyPixels(0,0,w(),h(),GL_COLOR);
+ }
+ else
+ aglSwapBuffers((AGLContext)context_);
+#else
+# error unsupported platform
+#endif
+}
+
+#if HAVE_GL_OVERLAY && defined(WIN32)
+uchar fl_overlay; // changes how fltk3::color() works
+int fl_overlay_depth = 0;
+#endif
+
+
+void fltk3::GlWindow::flush() {
+ uchar save_valid = valid_f_ & 1;
+#if HAVE_GL_OVERLAY && defined(WIN32)
+ uchar save_valid_f = valid_f_;
+#endif
+
+#if defined(__APPLE_QUARTZ__)
+ // warning: the Quartz version should probably use Core GL (CGL) instead of AGL
+ //: clear previous clipping in this shared port
+#if ! __LP64__
+/*GrafPtr port = GetWindowPort( Fl_X::i(this)->window_ref() );
+ Rect rect; SetRect( &rect, 0, 0, 0x7fff, 0x7fff );
+ GrafPtr old; GetPort( &old );
+ SetPort( port );
+ ClipRect( &rect );
+ SetPort( old );*/
+#endif
+#endif
+
+#if HAVE_GL_OVERLAY && defined(WIN32)
+
+ bool fixcursor = false; // for fixing the SGI 320 bug
+
+ // Draw into hardware overlay planes if they are damaged:
+ if (overlay && overlay != this
+ && (damage()&(fltk3::DAMAGE_OVERLAY|fltk3::DAMAGE_EXPOSE) || !save_valid)) {
+ // SGI 320 messes up overlay with user-defined cursors:
+ if (Fl_X::i(this)->cursor && Fl_X::i(this)->cursor != fl_default_cursor) {
+ fixcursor = true; // make it restore cursor later
+ SetCursor(0);
+ }
+ fl_set_gl_context(this, (GLContext)overlay);
+ if (fl_overlay_depth)
+ wglRealizeLayerPalette(Fl_X::i(this)->private_dc, 1, TRUE);
+ glDisable(GL_SCISSOR_TEST);
+ glClear(GL_COLOR_BUFFER_BIT);
+ fl_overlay = 1;
+ draw_overlay();
+ fl_overlay = 0;
+ valid_f_ = save_valid_f;
+ wglSwapLayerBuffers(Fl_X::i(this)->private_dc, WGL_SWAP_OVERLAY1);
+ // if only the overlay was damaged we are done, leave main layer alone:
+ if (damage() == fltk3::DAMAGE_OVERLAY) {
+ if (fixcursor) SetCursor(Fl_X::i(this)->cursor);
+ return;
+ }
+ }
+#endif
+
+ make_current();
+
+ if (mode_ & fltk3::DOUBLE) {
+
+ glDrawBuffer(GL_BACK);
+
+ if (!SWAP_TYPE) {
+#if defined (__APPLE_QUARTZ__) || defined (USE_X11)
+ SWAP_TYPE = COPY;
+#else
+ SWAP_TYPE = UNDEFINED;
+#endif
+ const char* c = fltk3::getenv("GL_SWAP_TYPE");
+ if (c) {
+ if (!strcmp(c,"COPY")) SWAP_TYPE = COPY;
+ else if (!strcmp(c, "NODAMAGE")) SWAP_TYPE = NODAMAGE;
+ else if (!strcmp(c, "SWAP")) SWAP_TYPE = SWAP;
+ else SWAP_TYPE = UNDEFINED;
+ }
+ }
+
+ if (SWAP_TYPE == NODAMAGE) {
+
+ // don't draw if only overlay damage or expose events:
+ if ((damage()&~(fltk3::DAMAGE_OVERLAY|fltk3::DAMAGE_EXPOSE)) || !save_valid)
+ draw();
+ swap_buffers();
+
+ } else if (SWAP_TYPE == COPY) {
+
+ // don't draw if only the overlay is damaged:
+ if (damage() != fltk3::DAMAGE_OVERLAY || !save_valid) draw();
+ swap_buffers();
+
+ } else if (SWAP_TYPE == SWAP){
+ damage(fltk3::DAMAGE_ALL);
+ draw();
+ if (overlay == this) draw_overlay();
+ swap_buffers();
+ } else if (SWAP_TYPE == UNDEFINED){ // SWAP_TYPE == UNDEFINED
+
+ // If we are faking the overlay, use CopyPixels to act like
+ // SWAP_TYPE == COPY. Otherwise overlay redraw is way too slow.
+ if (overlay == this) {
+ // don't draw if only the overlay is damaged:
+ if (damage1_ || damage() != fltk3::DAMAGE_OVERLAY || !save_valid) draw();
+ // we use a separate context for the copy because rasterpos must be 0
+ // and depth test needs to be off:
+ static GLContext ortho_context = 0;
+ static fltk3::GlWindow* ortho_window = 0;
+ int orthoinit = !ortho_context;
+ if (orthoinit) ortho_context = fl_create_gl_context(this, g);
+ fl_set_gl_context(this, ortho_context);
+ if (orthoinit || !save_valid || ortho_window != this) {
+ glDisable(GL_DEPTH_TEST);
+ glReadBuffer(GL_BACK);
+ glDrawBuffer(GL_FRONT);
+ glLoadIdentity();
+ glViewport(0, 0, w(), h());
+ glOrtho(0, w(), 0, h(), -1, 1);
+ glRasterPos2i(0,0);
+ ortho_window = this;
+ }
+ glCopyPixels(0,0,w(),h(),GL_COLOR);
+ make_current(); // set current context back to draw overlay
+ damage1_ = 0;
+
+ } else {
+ damage1_ = damage();
+ clear_damage(0xff); draw();
+ swap_buffers();
+ }
+
+ }
+
+ if (overlay==this && SWAP_TYPE != SWAP) { // fake overlay in front buffer
+ glDrawBuffer(GL_FRONT);
+ draw_overlay();
+ glDrawBuffer(GL_BACK);
+ glFlush();
+ }
+
+ } else { // single-buffered context is simpler:
+
+ draw();
+ if (overlay == this) draw_overlay();
+ glFlush();
+
+ }
+
+#if HAVE_GL_OVERLAY && defined(WIN32)
+ if (fixcursor) SetCursor(Fl_X::i(this)->cursor);
+#endif
+ valid(1);
+ context_valid(1);
+}
+
+void fltk3::GlWindow::resize(int X,int Y,int W,int H) {
+// printf("fltk3::GlWindow::resize(X=%d, Y=%d, W=%d, H=%d)\n", X, Y, W, H);
+// printf("current: x()=%d, y()=%d, w()=%d, h()=%d\n", x(), y(), w(), h());
+
+ if (W != w() || H != h()) valid(0);
+
+#ifdef __APPLE__
+ if (X != x() || Y != y() || W != w() || H != h()) aglUpdateContext(context_);
+#elif !defined(WIN32)
+ if ((W != w() || H != h()) && !resizable() && overlay && overlay != this) {
+ ((fltk3::GlWindow*)overlay)->resize(0,0,W,H);
+ }
+#endif
+
+ Window::resize(X,Y,W,H);
+}
+
+/**
+ Returns or sets a pointer to the GLContext that this window is
+ using. This is a system-dependent structure, but it is portable to copy
+ the context from one window to another. You can also set it to NULL,
+ which will force FLTK to recreate the context the next time make_current()
+ is called, this is useful for getting around bugs in OpenGL implementations.
+
+ If <i>destroy_flag</i> is true the context will be destroyed by
+ fltk when the window is destroyed, or when the mode() is changed,
+ or the next time context(x) is called.
+*/
+void fltk3::GlWindow::context(void* v, int destroy_flag) {
+ if (context_ && !(mode_&NON_LOCAL_CONTEXT)) fl_delete_gl_context(context_);
+ context_ = (GLContext)v;
+ if (destroy_flag) mode_ &= ~NON_LOCAL_CONTEXT;
+ else mode_ |= NON_LOCAL_CONTEXT;
+}
+
+/**
+ Hides the window and destroys the OpenGL context.
+*/
+void fltk3::GlWindow::hide() {
+ context(0);
+#if HAVE_GL_OVERLAY && defined(WIN32)
+ if (overlay && overlay != this) {
+ fl_delete_gl_context((GLContext)overlay);
+ overlay = 0;
+ }
+#endif
+ Window::hide();
+}
+
+/**
+ The destructor removes the widget and destroys the OpenGL context
+ associated with it.
+*/
+fltk3::GlWindow::~GlWindow() {
+ hide();
+// delete overlay; this is done by ~Fl_Group
+#ifdef __APPLE__
+ // resets the pile of string textures used to draw strings
+ extern void gl_texture_reset();
+ gl_texture_reset();
+#endif
+}
+
+void fltk3::GlWindow::init() {
+ end(); // we probably don't want any children
+ box(fltk3::NO_BOX);
+
+ mode_ = fltk3::RGB | fltk3::DEPTH | fltk3::DOUBLE;
+ alist = 0;
+ context_ = 0;
+ g = 0;
+ overlay = 0;
+ valid_f_ = 0;
+ damage1_ = 0;
+
+#if 0 // This breaks resizing on Linux/X11
+ int H = h();
+ h(1); // Make sure we actually do something in resize()...
+ resize(x(), y(), w(), H);
+#endif // 0
+}
+
+/**
+ You must implement this virtual function if you want to draw into the
+ overlay. The overlay is cleared before this is called. You should
+ draw anything that is not clear using OpenGL. You must use
+ gl_color(i) to choose colors (it allocates them from the colormap
+ using system-specific calls), and remember that you are in an indexed
+ OpenGL mode and drawing anything other than flat-shaded will probably
+ not work.
+
+ Both this function and fltk3::GlWindow::draw() should check
+ fltk3::GlWindow::valid() and set the same transformation. If you
+ don't your code may not work on other systems. Depending on the OS,
+ and on whether overlays are real or simulated, the OpenGL context may
+ be the same or different between the overlay and main window.
+*/
+void fltk3::GlWindow::draw_overlay() {
+ FLTK3_OBJECT_VCALLS_WRAPPER(draw_overlay(), DrawOverlay)
+}
+
+#endif
+
+ /**
+ You \e \b must subclass fltk3::GlWindow and provide an implementation for
+ draw(). You may also provide an implementation of draw_overlay()
+ if you want to draw into the overlay planes. You can avoid
+ reinitializing the viewport and lights and other things by checking
+ valid() at the start of draw() and only doing the
+ initialization if it is false.
+
+ The draw() method can <I>only</I> use OpenGL calls. Do not
+ attempt to call X, any of the functions in <fltk3/draw.h>, or glX
+ directly. Do not call gl_start() or gl_finish().
+
+ If double-buffering is enabled in the window, the back and front
+ buffers are swapped after this function is completed.
+*/
+void fltk3::GlWindow::draw() {
+ FLTK3_OBJECT_VCALLS_WRAPPER(draw(), Draw)
+ fltk3::fatal("fltk3::GlWindow::draw() *must* be overriden. Please refer to the documentation.");
+}
+
+
+/**
+ Handle some FLTK events as needed.
+ */
+int fltk3::GlWindow::handle(int event)
+{
+ FLTK3_OBJECT_VCALLS_WRAPPER_RET(int, handle(event), Handle)
+ return Window::handle(event);
+}
+
+//
+// End of "$Id$".
+//
Copied: branches/branch-3.0/src/fltk3gl/freeglut_geometry.cxx (from rev 9002, branches/branch-3.0/src/core/freeglut_geometry.cxx)
===================================================================
--- branches/branch-3.0/src/fltk3gl/freeglut_geometry.cxx (rev 0)
+++ branches/branch-3.0/src/fltk3gl/freeglut_geometry.cxx 2011-08-25 10:51:10 UTC (rev 9008)
@@ -0,0 +1,1110 @@
+/*
+ * freeglut_geometry.c
+ *
+ * Freeglut geometry rendering methods.
+ *
+ * Copyright (c) 1999-2010 Pawel W. Olszta. All Rights Reserved.
+ * Written by Pawel W. Olszta, <olszta@sourceforge.net>
+ * Creation date: Fri Dec 3 1999
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <fltk3/glut.h>
+#include <fltk3/math.h>
+#include <stdlib.h>
+
+/*
+ * TODO BEFORE THE STABLE RELEASE:
+ *
+ * Following functions have been contributed by Andreas Umbach.
+ *
+ * glutWireCube() -- looks OK
+ * glutSolidCube() -- OK
+ *
+ * Those functions have been implemented by John Fay.
+ *
+ * glutWireTorus() -- looks OK
+ * glutSolidTorus() -- looks OK
+ * glutWireDodecahedron() -- looks OK
+ * glutSolidDodecahedron() -- looks OK
+ * glutWireOctahedron() -- looks OK
+ * glutSolidOctahedron() -- looks OK
+ * glutWireTetrahedron() -- looks OK
+ * glutSolidTetrahedron() -- looks OK
+ * glutWireIcosahedron() -- looks OK
+ * glutSolidIcosahedron() -- looks OK
+ *
+ * The Following functions have been updated by Nigel Stewart, based
+ * on FreeGLUT 2.0.0 implementations:
+ *
+ * glutWireSphere() -- looks OK
+ * glutSolidSphere() -- looks OK
+ * glutWireCone() -- looks OK
+ * glutSolidCone() -- looks OK
+ */
+
+
+/* -- INTERFACE FUNCTIONS -------------------------------------------------- */
+
+/*
+ * Draws a wireframed cube. Code contributed by Andreas Umbach <marvin@dataway.ch>
+ */
+void glutWireCube( GLdouble dSize )
+{
+ double size = dSize * 0.5;
+
+# define V(a,b,c) glVertex3d( a size, b size, c size );
+# define N(a,b,c) glNormal3d( a, b, c );
+
+ /* PWO: I dared to convert the code to use macros... */
+ glBegin( GL_LINE_LOOP ); N( 1.0, 0.0, 0.0); V(+,-,+); V(+,-,-); V(+,+,-); V(+,+,+); glEnd();
+ glBegin( GL_LINE_LOOP ); N( 0.0, 1.0, 0.0); V(+,+,+); V(+,+,-); V(-,+,-); V(-,+,+); glEnd();
+ glBegin( GL_LINE_LOOP ); N( 0.0, 0.0, 1.0); V(+,+,+); V(-,+,+); V(-,-,+); V(+,-,+); glEnd();
+ glBegin( GL_LINE_LOOP ); N(-1.0, 0.0, 0.0); V(-,-,+); V(-,+,+); V(-,+,-); V(-,-,-); glEnd();
+ glBegin( GL_LINE_LOOP ); N( 0.0,-1.0, 0.0); V(-,-,+); V(-,-,-); V(+,-,-); V(+,-,+); glEnd();
+ glBegin( GL_LINE_LOOP ); N( 0.0, 0.0,-1.0); V(-,-,-); V(-,+,-); V(+,+,-); V(+,-,-); glEnd();
+
+# undef V
+# undef N
+}
+
+/*
+ * Draws a solid cube. Code contributed by Andreas Umbach <marvin@dataway.ch>
+ */
+void glutSolidCube( GLdouble dSize )
+{
+ double size = dSize * 0.5;
+
+# define V(a,b,c) glVertex3d( a size, b size, c size );
+# define N(a,b,c) glNormal3d( a, b, c );
+
+ /* PWO: Again, I dared to convert the code to use macros... */
+ glBegin( GL_QUADS );
+ N( 1.0, 0.0, 0.0); V(+,-,+); V(+,-,-); V(+,+,-); V(+,+,+);
+ N( 0.0, 1.0, 0.0); V(+,+,+); V(+,+,-); V(-,+,-); V(-,+,+);
+ N( 0.0, 0.0, 1.0); V(+,+,+); V(-,+,+); V(-,-,+); V(+,-,+);
+ N(-1.0, 0.0, 0.0); V(-,-,+); V(-,+,+); V(-,+,-); V(-,-,-);
+ N( 0.0,-1.0, 0.0); V(-,-,+); V(-,-,-); V(+,-,-); V(+,-,+);
+ N( 0.0, 0.0,-1.0); V(-,-,-); V(-,+,-); V(+,+,-); V(+,-,-);
+ glEnd();
+
+# undef V
+# undef N
+}
+
+/*
+ * Compute lookup table of cos and sin values forming a cirle
+ *
+ * Notes:
+ * It is the responsibility of the caller to free these tables
+ * The size of the table is (n+1) to form a connected loop
+ * The last entry is exactly the same as the first
+ * The sign of n can be flipped to get the reverse loop
+ */
+
+static void fghCircleTable(double **sint,double **cost,const int n)
+{
+ int i;
+
+ /* Table size, the sign of n flips the circle direction */
+
+ const int size = abs(n);
+
+ /* Determine the angle between samples */
+
+ const double angle = 2*M_PI/(double)( ( n == 0 ) ? 1 : n );
+
+ /* Allocate memory for n samples, plus duplicate of first entry at the end */
+
+ *sint = (double *) calloc(sizeof(double), size+1);
+ *cost = (double *) calloc(sizeof(double), size+1);
+
+ /* Bail out if memory allocation fails, fgError never returns */
+
+ if (!(*sint) || !(*cost))
+ {
+ if (*sint) free(*sint);
+ if (*cost) free(*cost);
+ return;
+ }
+
+ /* Compute cos and sin around the circle */
+
+ (*sint)[0] = 0.0;
+ (*cost)[0] = 1.0;
+
+ for (i=1; i<size; i++)
+ {
+ (*sint)[i] = sin(angle*i);
+ (*cost)[i] = cos(angle*i);
+ }
+
+ /* Last sample is duplicate of the first */
+
+ (*sint)[size] = (*sint)[0];
+ (*cost)[size] = (*cost)[0];
+}
+
+/*
+ * Draws a solid sphere
+ */
+void glutSolidSphere(GLdouble radius, GLint slices, GLint stacks)
+{
+ int i,j;
+
+ /* Adjust z and radius as stacks are drawn. */
+
+ double z0,z1;
+ double r0,r1;
+
+ /* Pre-computed circle */
+
+ double *sint1,*cost1;
+ double *sint2,*cost2;
+
+ fghCircleTable(&sint1,&cost1,-slices);
+ fghCircleTable(&sint2,&cost2,stacks*2);
+
+ /* The top stack is covered with a triangle fan */
+
+ z0 = 1.0;
+ z1 = cost2[(stacks>0)?1:0];
+ r0 = 0.0;
+ r1 = sint2[(stacks>0)?1:0];
+
+ glBegin(GL_TRIANGLE_FAN);
+
+ glNormal3d(0,0,1);
+ glVertex3d(0,0,radius);
+
+ for (j=slices; j>=0; j--)
+ {
+ glNormal3d(cost1[j]*r1, sint1[j]*r1, z1 );
+ glVertex3d(cost1[j]*r1*radius, sint1[j]*r1*radius, z1*radius);
+ }
+
+ glEnd();
+
+ /* Cover each stack with a quad strip, except the top and bottom stacks */
+
+ for( i=1; i<stacks-1; i++ )
+ {
+ z0 = z1; z1 = cost2[i+1];
+ r0 = r1; r1 = sint2[i+1];
+
+ glBegin(GL_QUAD_STRIP);
+
+ for(j=0; j<=slices; j++)
+ {
+ glNormal3d(cost1[j]*r1, sint1[j]*r1, z1 );
+ glVertex3d(cost1[j]*r1*radius, sint1[j]*r1*radius, z1*radius);
+ glNormal3d(cost1[j]*r0, sint1[j]*r0, z0 );
+ glVertex3d(cost1[j]*r0*radius, sint1[j]*r0*radius, z0*radius);
+ }
+
+ glEnd();
+ }
+
+ /* The bottom stack is covered with a triangle fan */
+
+ z0 = z1;
+ r0 = r1;
+
+ glBegin(GL_TRIANGLE_FAN);
+
+ glNormal3d(0,0,-1);
+ glVertex3d(0,0,-radius);
+
+ for (j=0; j<=slices; j++)
+ {
+ glNormal3d(cost1[j]*r0, sint1[j]*r0, z0 );
+ glVertex3d(cost1[j]*r0*radius, sint1[j]*r0*radius, z0*radius);
+ }
+
+ glEnd();
+
+ /* Release sin and cos tables */
+
+ free(sint1);
+ free(cost1);
+ free(sint2);
+ free(cost2);
+}
+
+/*
+ * Draws a wire sphere
+ */
+void glutWireSphere(GLdouble radius, GLint slices, GLint stacks)
+{
+ int i,j;
+
+ /* Adjust z and radius as stacks and slices are drawn. */
+
+ double r;
+ double x,y,z;
+
+ /* Pre-computed circle */
+
+ double *sint1,*cost1;
+ double *sint2,*cost2;
+
+ fghCircleTable(&sint1,&cost1,-slices );
+ fghCircleTable(&sint2,&cost2, stacks*2);
+
+ /* Draw a line loop for each stack */
+
+ for (i=1; i<stacks; i++)
+ {
+ z = cost2[i];
+ r = sint2[i];
+
+ glBegin(GL_LINE_LOOP);
+
+ for(j=0; j<=slices; j++)
+ {
+ x = cost1[j];
+ y = sint1[j];
+
+ glNormal3d(x,y,z);
+ glVertex3d(x*r*radius,y*r*radius,z*radius);
+ }
+
+ glEnd();
+ }
+
+ /* Draw a line loop for each slice */
+
+ for (i=0; i<slices; i++)
+ {
+ glBegin(GL_LINE_STRIP);
+
+ for(j=0; j<=stacks; j++)
+ {
+ x = cost1[i]*sint2[j];
+ y = sint1[i]*sint2[j];
+ z = cost2[j];
+
+ glNormal3d(x,y,z);
+ glVertex3d(x*radius,y*radius,z*radius);
+ }
+
+ glEnd();
+ }
+
+ /* Release sin and cos tables */
+
+ free(sint1);
+ free(cost1);
+ free(sint2);
+ free(cost2);
+}
+
+/*
+ * Draws a solid cone
+ */
+void glutSolidCone( GLdouble base, GLdouble height, GLint slices, GLint stacks )
+{
+ int i,j;
+
+ /* Step in z and radius as stacks are drawn. */
+
+ double z0,z1;
+ double r0,r1;
+
+ const double zStep = height / ( ( stacks > 0 ) ? stacks : 1 );
+ const double rStep = base / ( ( stacks > 0 ) ? stacks : 1 );
+
+ /* Scaling factors for vertex normals */
+
+ const double cosn = ( height / sqrt ( height * height + base * base ));
+ const double sinn = ( base / sqrt ( height * height + base * base ));
+
+ /* Pre-computed circle */
+
+ double *sint,*cost;
+
+ fghCircleTable(&sint,&cost,-slices);
+
+ /* Cover the circular base with a triangle fan... */
+
+ z0 = 0.0;
+ z1 = zStep;
+
+ r0 = base;
+ r1 = r0 - rStep;
+
+ glBegin(GL_TRIANGLE_FAN);
+
+ glNormal3d(0.0,0.0,-1.0);
+ glVertex3d(0.0,0.0, z0 );
+
+ for (j=0; j<=slices; j++)
+ glVertex3d(cost[j]*r0, sint[j]*r0, z0);
+
+ glEnd();
+
+ /* Cover each stack with a quad strip, except the top stack */
+
+ for( i=0; i<stacks-1; i++ )
+ {
+ glBegin(GL_QUAD_STRIP);
+
+ for(j=0; j<=slices; j++)
+ {
+ glNormal3d(cost[j]*sinn, sint[j]*sinn, cosn);
+ glVertex3d(cost[j]*r0, sint[j]*r0, z0 );
+ glVertex3d(cost[j]*r1, sint[j]*r1, z1 );
+ }
+
+ z0 = z1; z1 += zStep;
+ r0 = r1; r1 -= rStep;
+
+ glEnd();
+ }
+
+ /* The top stack is covered with individual triangles */
+
+ glBegin(GL_TRIANGLES);
+
+ glNormal3d(cost[0]*sinn, sint[0]*sinn, cosn);
+
+ for (j=0; j<slices; j++)
+ {
+ glVertex3d(cost[j+0]*r0, sint[j+0]*r0, z0 );
+ glVertex3d(0, 0, height);
+ glNormal3d(cost[j+1]*sinn, sint[j+1]*sinn, cosn );
+ glVertex3d(cost[j+1]*r0, sint[j+1]*r0, z0 );
+ }
+
+ glEnd();
+
+ /* Release sin and cos tables */
+
+ free(sint);
+ free(cost);
+}
+
+/*
+ * Draws a wire cone
+ */
+void glutWireCone( GLdouble base, GLdouble height, GLint slices, GLint stacks)
+{
+ int i,j;
+
+ /* Step in z and radius as stacks are drawn. */
+
+ double z = 0.0;
+ double r = base;
+
+ const double zStep = height / ( ( stacks > 0 ) ? stacks : 1 );
+ const double rStep = base / ( ( stacks > 0 ) ? stacks : 1 );
+
+ /* Scaling factors for vertex normals */
+
+ const double cosn = ( height / sqrt ( height * height + base * base ));
+ const double sinn = ( base / sqrt ( height * height + base * base ));
+
+ /* Pre-computed circle */
+
+ double *sint,*cost;
+
+ fghCircleTable(&sint,&cost,-slices);
+
+ /* Draw the stacks... */
+
+ for (i=0; i<stacks; i++)
+ {
+ glBegin(GL_LINE_LOOP);
+
+ for( j=0; j<slices; j++ )
+ {
+ glNormal3d(cost[j]*sinn, sint[j]*sinn, cosn);
+ glVertex3d(cost[j]*r, sint[j]*r, z );
+ }
+
+ glEnd();
+
+ z += zStep;
+ r -= rStep;
+ }
+
+ /* Draw the slices */
+
+ r = base;
+
+ glBegin(GL_LINES);
+
+ for (j=0; j<slices; j++)
+ {
+ glNormal3d(cost[j]*sinn, sint[j]*sinn, cosn );
+ glVertex3d(cost[j]*r, sint[j]*r, 0.0 );
+ glVertex3d(0.0, 0.0, height);
+ }
+
+ glEnd();
+
+ /* Release sin and cos tables */
+
+ free(sint);
+ free(cost);
+}
+
+
+/*
+ * Draws a solid cylinder
+ */
+void glutSolidCylinder(GLdouble radius, GLdouble height, GLint slices, GLint stacks)
+{
+ int i,j;
+
+ /* Step in z and radius as stacks are drawn. */
+
+ double z0,z1;
+ const double zStep = height / ( ( stacks > 0 ) ? stacks : 1 );
+
+ /* Pre-computed circle */
+
+ double *sint,*cost;
+
+ fghCircleTable(&sint,&cost,-slices);
+
+ /* Cover the base and top */
+
+ glBegin(GL_TRIANGLE_FAN);
+ glNormal3d(0.0, 0.0, -1.0 );
+ glVertex3d(0.0, 0.0, 0.0 );
+ for (j=0; j<=slices; j++)
+ glVertex3d(cost[j]*radius, sint[j]*radius, 0.0);
+ glEnd();
+
+ glBegin(GL_TRIANGLE_FAN);
+ glNormal3d(0.0, 0.0, 1.0 );
+ glVertex3d(0.0, 0.0, height);
+ for (j=slices; j>=0; j--)
+ glVertex3d(cost[j]*radius, sint[j]*radius, height);
+ glEnd();
+
+ /* Do the stacks */
+
+ z0 = 0.0;
+ z1 = zStep;
+
+ for (i=1; i<=stacks; i++)
+ {
+ if (i==stacks)
+ z1 = height;
+
+ glBegin(GL_QUAD_STRIP);
+ for (j=0; j<=slices; j++ )
+ {
+ glNormal3d(cost[j], sint[j], 0.0 );
+ glVertex3d(cost[j]*radius, sint[j]*radius, z0 );
+ glVertex3d(cost[j]*radius, sint[j]*radius, z1 );
+ }
+ glEnd();
+
+ z0 = z1; z1 += zStep;
+ }
+
+ /* Release sin and cos tables */
+
+ free(sint);
+ free(cost);
+}
+
+/*
+ * Draws a wire cylinder
+ */
+void glutWireCylinder(GLdouble radius, GLdouble height, GLint slices, GLint stacks)
+{
+ int i,j;
+
+ /* Step in z and radius as stacks are drawn. */
+
+ double z = 0.0;
+ const double zStep = height / ( ( stacks > 0 ) ? stacks : 1 );
+
+ /* Pre-computed circle */
+
+ double *sint,*cost;
+
+ fghCircleTable(&sint,&cost,-slices);
+
+ /* Draw the stacks... */
+
+ for (i=0; i<=stacks; i++)
+ {
+ if (i==stacks)
+ z = height;
+
+ glBegin(GL_LINE_LOOP);
+
+ for( j=0; j<slices; j++ )
+ {
+ glNormal3d(cost[j], sint[j], 0.0);
+ glVertex3d(cost[j]*radius, sint[j]*radius, z );
+ }
+
+ glEnd();
+
+ z += zStep;
+ }
+
+ /* Draw the slices */
+
+ glBegin(GL_LINES);
+
+ for (j=0; j<slices; j++)
+ {
+ glNormal3d(cost[j], sint[j], 0.0 );
+ glVertex3d(cost[j]*radius, sint[j]*radius, 0.0 );
+ glVertex3d(cost[j]*radius, sint[j]*radius, height);
+ }
+
+ glEnd();
+
+ /* Release sin and cos tables */
+
+ free(sint);
+ free(cost);
+}
+
+/*
+ * Draws a wire torus
+ */
+void glutWireTorus( GLdouble dInnerRadius, GLdouble dOuterRadius, GLint nSides, GLint nRings )
+{
+ double iradius = dInnerRadius, oradius = dOuterRadius, phi, psi, dpsi, dphi;
+ double *vertex, *normal;
+ int i, j;
+ double spsi, cpsi, sphi, cphi ;
+
+ if ( nSides < 1 ) nSides = 1;
+ if ( nRings < 1 ) nRings = 1;
+
+ /* Allocate the vertices array */
+ vertex = (double *)calloc( sizeof(double), 3 * nSides * nRings );
+ normal = (double *)calloc( sizeof(double), 3 * nSides * nRings );
+
+ glPushMatrix();
+
+ dpsi = 2.0 * M_PI / (double)nRings ;
+ dphi = -2.0 * M_PI / (double)nSides ;
+ psi = 0.0;
+
+ for( j=0; j<nRings; j++ )
+ {
+ cpsi = cos ( psi ) ;
+ spsi = sin ( psi ) ;
+ phi = 0.0;
+
+ for( i=0; i<nSides; i++ )
+ {
+ int offset = 3 * ( j * nSides + i ) ;
+ cphi = cos ( phi ) ;
+ sphi = sin ( phi ) ;
+ *(vertex + offset + 0) = cpsi * ( oradius + cphi * iradius ) ;
+ *(vertex + offset + 1) = spsi * ( oradius + cphi * iradius ) ;
+ *(vertex + offset + 2) = sphi * iradius ;
+ *(normal + offset + 0) = cpsi * cphi ;
+ *(normal + offset + 1) = spsi * cphi ;
+ *(normal + offset + 2) = sphi ;
+ phi += dphi;
+ }
+
+ psi += dpsi;
+ }
+
+ for( i=0; i<nSides; i++ )
+ {
+ glBegin( GL_LINE_LOOP );
+
+ for( j=0; j<nRings; j++ )
+ {
+ int offset = 3 * ( j * nSides + i ) ;
+ glNormal3dv( normal + offset );
+ glVertex3dv( vertex + offset );
+ }
+
+ glEnd();
+ }
+
+ for( j=0; j<nRings; j++ )
+ {
+ glBegin(GL_LINE_LOOP);
+
+ for( i=0; i<nSides; i++ )
+ {
+ int offset = 3 * ( j * nSides + i ) ;
+ glNormal3dv( normal + offset );
+ glVertex3dv( vertex + offset );
+ }
+
+ glEnd();
+ }
+
+ free ( vertex ) ;
+ free ( normal ) ;
+ glPopMatrix();
+}
+
+/*
+ * Draws a solid torus
+ */
+void glutSolidTorus( GLdouble dInnerRadius, GLdouble dOuterRadius, GLint nSides, GLint nRings )
+{
+ double iradius = dInnerRadius, oradius = dOuterRadius, phi, psi, dpsi, dphi;
+ double *vertex, *normal;
+ int i, j;
+ double spsi, cpsi, sphi, cphi ;
+
+ if ( nSides < 1 ) nSides = 1;
+ if ( nRings < 1 ) nRings = 1;
+
+ /* Increment the number of sides and rings to allow for one more point than surface */
+ nSides ++ ;
+ nRings ++ ;
+
+ /* Allocate the vertices array */
+ vertex = (double *)calloc( sizeof(double), 3 * nSides * nRings );
+ normal = (double *)calloc( sizeof(double), 3 * nSides * nRings );
+
+ glPushMatrix();
+
+ dpsi = 2.0 * M_PI / (double)(nRings - 1) ;
+ dphi = -2.0 * M_PI / (double)(nSides - 1) ;
+ psi = 0.0;
+
+ for( j=0; j<nRings; j++ )
+ {
+ cpsi = cos ( psi ) ;
+ spsi = sin ( psi ) ;
+ phi = 0.0;
+
+ for( i=0; i<nSides; i++ )
+ {
+ int offset = 3 * ( j * nSides + i ) ;
+ cphi = cos ( phi ) ;
+ sphi = sin ( phi ) ;
+ *(vertex + offset + 0) = cpsi * ( oradius + cphi * iradius ) ;
+ *(vertex + offset + 1) = spsi * ( oradius + cphi * iradius ) ;
+ *(vertex + offset + 2) = sphi * iradius ;
+ *(normal + offset + 0) = cpsi * cphi ;
+ *(normal + offset + 1) = spsi * cphi ;
+ *(normal + offset + 2) = sphi ;
+ phi += dphi;
+ }
+
+ psi += dpsi;
+ }
+
+ glBegin( GL_QUADS );
+ for( i=0; i<nSides-1; i++ )
+ {
+ for( j=0; j<nRings-1; j++ )
+ {
+ int offset = 3 * ( j * nSides + i ) ;
+ glNormal3dv( normal + offset );
+ glVertex3dv( vertex + offset );
+ glNormal3dv( normal + offset + 3 );
+ glVertex3dv( vertex + offset + 3 );
+ glNormal3dv( normal + offset + 3 * nSides + 3 );
+ glVertex3dv( vertex + offset + 3 * nSides + 3 );
+ glNormal3dv( normal + offset + 3 * nSides );
+ glVertex3dv( vertex + offset + 3 * nSides );
+ }
+ }
+
+ glEnd();
+
+ free ( vertex ) ;
+ free ( normal ) ;
+ glPopMatrix();
+}
+
+/*
+ *
+ */
+void glutWireDodecahedron( void )
+{
+ /* Magic Numbers: It is possible to create a dodecahedron by attaching two pentagons to each face of
+ * of a cube. The coordinates of the points are:
+ * (+-x,0, z); (+-1, 1, 1); (0, z, x )
+ * where x = (-1 + sqrt(5))/2, z = (1 + sqrt(5))/2 or
+ * x = 0.61803398875 and z = 1.61803398875.
+ */
+ glBegin ( GL_LINE_LOOP ) ;
+ glNormal3d ( 0.0, 0.525731112119, 0.850650808354 ) ; glVertex3d ( 0.0, 1.61803398875, 0.61803398875 ) ; glVertex3d ( -1.0, 1.0, 1.0 ) ; glVertex3d ( -0.61803398875, 0.0, 1.61803398875 ) ; glVertex3d ( 0.61803398875, 0.0, 1.61803398875 ) ; glVertex3d ( 1.0, 1.0, 1.0 ) ;
+ glEnd () ;
+ glBegin ( GL_LINE_LOOP ) ;
+ glNormal3d ( 0.0, 0.525731112119, -0.850650808354 ) ; glVertex3d ( 0.0, 1.61803398875, -0.61803398875 ) ; glVertex3d ( 1.0, 1.0, -1.0 ) ; glVertex3d ( 0.61803398875, 0.0, -1.61803398875 ) ; glVertex3d ( -0.61803398875, 0.0, -1.61803398875 ) ; glVertex3d ( -1.0, 1.0, -1.0 ) ;
+ glEnd () ;
+ glBegin ( GL_LINE_LOOP ) ;
+ glNormal3d ( 0.0, -0.525731112119, 0.850650808354 ) ; glVertex3d ( 0.0, -1.61803398875, 0.61803398875 ) ; glVertex3d ( 1.0, -1.0, 1.0 ) ; glVertex3d ( 0.61803398875, 0.0, 1.61803398875 ) ; glVertex3d ( -0.61803398875, 0.0, 1.61803398875 ) ; glVertex3d ( -1.0, -1.0, 1.0 ) ;
+ glEnd () ;
+ glBegin ( GL_LINE_LOOP ) ;
+ glNormal3d ( 0.0, -0.525731112119, -0.850650808354 ) ; glVertex3d ( 0.0, -1.61803398875, -0.61803398875 ) ; glVertex3d ( -1.0, -1.0, -1.0 ) ; glVertex3d ( -0.61803398875, 0.0, -1.61803398875 ) ; glVertex3d ( 0.61803398875, 0.0, -1.61803398875 ) ; glVertex3d ( 1.0, -1.0, -1.0 ) ;
+ glEnd () ;
+
+ glBegin ( GL_LINE_LOOP ) ;
+ glNormal3d ( 0.850650808354, 0.0, 0.525731112119 ) ; glVertex3d ( 0.61803398875, 0.0, 1.61803398875 ) ; glVertex3d ( 1.0, -1.0, 1.0 ) ; glVertex3d ( 1.61803398875, -0.61803398875, 0.0 ) ; glVertex3d ( 1.61803398875, 0.61803398875, 0.0 ) ; glVertex3d ( 1.0, 1.0, 1.0 ) ;
+ glEnd () ;
+ glBegin ( GL_LINE_LOOP ) ;
+ glNormal3d ( -0.850650808354, 0.0, 0.525731112119 ) ; glVertex3d ( -0.61803398875, 0.0, 1.61803398875 ) ; glVertex3d ( -1.0, 1.0, 1.0 ) ; glVertex3d ( -1.61803398875, 0.61803398875, 0.0 ) ; glVertex3d ( -1.61803398875, -0.61803398875, 0.0 ) ; glVertex3d ( -1.0, -1.0, 1.0 ) ;
+ glEnd () ;
+ glBegin ( GL_LINE_LOOP ) ;
+ glNormal3d ( 0.850650808354, 0.0, -0.525731112119 ) ; glVertex3d ( 0.61803398875, 0.0, -1.61803398875 ) ; glVertex3d ( 1.0, 1.0, -1.0 ) ; glVertex3d ( 1.61803398875, 0.61803398875, 0.0 ) ; glVertex3d ( 1.61803398875, -0.61803398875, 0.0 ) ; glVertex3d ( 1.0, -1.0, -1.0 ) ;
+ glEnd () ;
+ glBegin ( GL_LINE_LOOP ) ;
+ glNormal3d ( -0.850650808354, 0.0, -0.525731112119 ) ; glVertex3d ( -0.61803398875, 0.0, -1.61803398875 ) ; glVertex3d ( -1.0, -1.0, -1.0 ) ; glVertex3d ( -1.61803398875, -0.61803398875, 0.0 ) ; glVertex3d ( -1.61803398875, 0.61803398875, 0.0 ) ; glVertex3d ( -1.0, 1.0, -1.0 ) ;
+ glEnd () ;
+
+ glBegin ( GL_LINE_LOOP ) ;
+ glNormal3d ( 0.525731112119, 0.850650808354, 0.0 ) ; glVertex3d ( 1.61803398875, 0.61803398875, 0.0 ) ; glVertex3d ( 1.0, 1.0, -1.0 ) ; glVertex3d ( 0.0, 1.61803398875, -0.61803398875 ) ; glVertex3d ( 0.0, 1.61803398875, 0.61803398875 ) ; glVertex3d ( 1.0, 1.0, 1.0 ) ;
+ glEnd () ;
+ glBegin ( GL_LINE_LOOP ) ;
+ glNormal3d ( 0.525731112119, -0.850650808354, 0.0 ) ; glVertex3d ( 1.61803398875, -0.61803398875, 0.0 ) ; glVertex3d ( 1.0, -1.0, 1.0 ) ; glVertex3d ( 0.0, -1.61803398875, 0.61803398875 ) ; glVertex3d ( 0.0, -1.61803398875, -0.61803398875 ) ; glVertex3d ( 1.0, -1.0, -1.0 ) ;
+ glEnd () ;
+ glBegin ( GL_LINE_LOOP ) ;
+ glNormal3d ( -0.525731112119, 0.850650808354, 0.0 ) ; glVertex3d ( -1.61803398875, 0.61803398875, 0.0 ) ; glVertex3d ( -1.0, 1.0, 1.0 ) ; glVertex3d ( 0.0, 1.61803398875, 0.61803398875 ) ; glVertex3d ( 0.0, 1.61803398875, -0.61803398875 ) ; glVertex3d ( -1.0, 1.0, -1.0 ) ;
+ glEnd () ;
+ glBegin ( GL_LINE_LOOP ) ;
+ glNormal3d ( -0.525731112119, -0.850650808354, 0.0 ) ; glVertex3d ( -1.61803398875, -0.61803398875, 0.0 ) ; glVertex3d ( -1.0, -1.0, -1.0 ) ; glVertex3d ( 0.0, -1.61803398875, -0.61803398875 ) ; glVertex3d ( 0.0, -1.61803398875, 0.61803398875 ) ; glVertex3d ( -1.0, -1.0, 1.0 ) ;
+ glEnd () ;
+}
+
+/*
+ *
+ */
+void glutSolidDodecahedron( void )
+{
+ /* Magic Numbers: It is possible to create a dodecahedron by attaching two pentagons to each face of
+ * of a cube. The coordinates of the points are:
+ * (+-x,0, z); (+-1, 1, 1); (0, z, x )
+ * where x = (-1 + sqrt(5))/2, z = (1 + sqrt(5))/2 or
+ * x = 0.61803398875 and z = 1.61803398875.
+ */
+ glBegin ( GL_POLYGON ) ;
+ glNormal3d ( 0.0, 0.525731112119, 0.850650808354 ) ; glVertex3d ( 0.0, 1.61803398875, 0.61803398875 ) ; glVertex3d ( -1.0, 1.0, 1.0 ) ; glVertex3d ( -0.61803398875, 0.0, 1.61803398875 ) ; glVertex3d ( 0.61803398875, 0.0, 1.61803398875 ) ; glVertex3d ( 1.0, 1.0, 1.0 ) ;
+ glEnd () ;
+ glBegin ( GL_POLYGON ) ;
+ glNormal3d ( 0.0, 0.525731112119, -0.850650808354 ) ; glVertex3d ( 0.0, 1.61803398875, -0.61803398875 ) ; glVertex3d ( 1.0, 1.0, -1.0 ) ; glVertex3d ( 0.61803398875, 0.0, -1.61803398875 ) ; glVertex3d ( -0.61803398875, 0.0, -1.61803398875 ) ; glVertex3d ( -1.0, 1.0, -1.0 ) ;
+ glEnd () ;
+ glBegin ( GL_POLYGON ) ;
+ glNormal3d ( 0.0, -0.525731112119, 0.850650808354 ) ; glVertex3d ( 0.0, -1.61803398875, 0.61803398875 ) ; glVertex3d ( 1.0, -1.0, 1.0 ) ; glVertex3d ( 0.61803398875, 0.0, 1.61803398875 ) ; glVertex3d ( -0.61803398875, 0.0, 1.61803398875 ) ; glVertex3d ( -1.0, -1.0, 1.0 ) ;
+ glEnd () ;
+ glBegin ( GL_POLYGON ) ;
+ glNormal3d ( 0.0, -0.525731112119, -0.850650808354 ) ; glVertex3d ( 0.0, -1.61803398875, -0.61803398875 ) ; glVertex3d ( -1.0, -1.0, -1.0 ) ; glVertex3d ( -0.61803398875, 0.0, -1.61803398875 ) ; glVertex3d ( 0.61803398875, 0.0, -1.61803398875 ) ; glVertex3d ( 1.0, -1.0, -1.0 ) ;
+ glEnd () ;
+
+ glBegin ( GL_POLYGON ) ;
+ glNormal3d ( 0.850650808354, 0.0, 0.525731112119 ) ; glVertex3d ( 0.61803398875, 0.0, 1.61803398875 ) ; glVertex3d ( 1.0, -1.0, 1.0 ) ; glVertex3d ( 1.61803398875, -0.61803398875, 0.0 ) ; glVertex3d ( 1.61803398875, 0.61803398875, 0.0 ) ; glVertex3d ( 1.0, 1.0, 1.0 ) ;
+ glEnd () ;
+ glBegin ( GL_POLYGON ) ;
+ glNormal3d ( -0.850650808354, 0.0, 0.525731112119 ) ; glVertex3d ( -0.61803398875, 0.0, 1.61803398875 ) ; glVertex3d ( -1.0, 1.0, 1.0 ) ; glVertex3d ( -1.61803398875, 0.61803398875, 0.0 ) ; glVertex3d ( -1.61803398875, -0.61803398875, 0.0 ) ; glVertex3d ( -1.0, -1.0, 1.0 ) ;
+ glEnd () ;
+ glBegin ( GL_POLYGON ) ;
+ glNormal3d ( 0.850650808354, 0.0, -0.525731112119 ) ; glVertex3d ( 0.61803398875, 0.0, -1.61803398875 ) ; glVertex3d ( 1.0, 1.0, -1.0 ) ; glVertex3d ( 1.61803398875, 0.61803398875, 0.0 ) ; glVertex3d ( 1.61803398875, -0.61803398875, 0.0 ) ; glVertex3d ( 1.0, -1.0, -1.0 ) ;
+ glEnd () ;
+ glBegin ( GL_POLYGON ) ;
+ glNormal3d ( -0.850650808354, 0.0, -0.525731112119 ) ; glVertex3d ( -0.61803398875, 0.0, -1.61803398875 ) ; glVertex3d ( -1.0, -1.0, -1.0 ) ; glVertex3d ( -1.61803398875, -0.61803398875, 0.0 ) ; glVertex3d ( -1.61803398875, 0.61803398875, 0.0 ) ; glVertex3d ( -1.0, 1.0, -1.0 ) ;
+ glEnd () ;
+
+ glBegin ( GL_POLYGON ) ;
+ glNormal3d ( 0.525731112119, 0.850650808354, 0.0 ) ; glVertex3d ( 1.61803398875, 0.61803398875, 0.0 ) ; glVertex3d ( 1.0, 1.0, -1.0 ) ; glVertex3d ( 0.0, 1.61803398875, -0.61803398875 ) ; glVertex3d ( 0.0, 1.61803398875, 0.61803398875 ) ; glVertex3d ( 1.0, 1.0, 1.0 ) ;
+ glEnd () ;
+ glBegin ( GL_POLYGON ) ;
+ glNormal3d ( 0.525731112119, -0.850650808354, 0.0 ) ; glVertex3d ( 1.61803398875, -0.61803398875, 0.0 ) ; glVertex3d ( 1.0, -1.0, 1.0 ) ; glVertex3d ( 0.0, -1.61803398875, 0.61803398875 ) ; glVertex3d ( 0.0, -1.61803398875, -0.61803398875 ) ; glVertex3d ( 1.0, -1.0, -1.0 ) ;
+ glEnd () ;
+ glBegin ( GL_POLYGON ) ;
+ glNormal3d ( -0.525731112119, 0.850650808354, 0.0 ) ; glVertex3d ( -1.61803398875, 0.61803398875, 0.0 ) ; glVertex3d ( -1.0, 1.0, 1.0 ) ; glVertex3d ( 0.0, 1.61803398875, 0.61803398875 ) ; glVertex3d ( 0.0, 1.61803398875, -0.61803398875 ) ; glVertex3d ( -1.0, 1.0, -1.0 ) ;
+ glEnd () ;
+ glBegin ( GL_POLYGON ) ;
+ glNormal3d ( -0.525731112119, -0.850650808354, 0.0 ) ; glVertex3d ( -1.61803398875, -0.61803398875, 0.0 ) ; glVertex3d ( -1.0, -1.0, -1.0 ) ; glVertex3d ( 0.0, -1.61803398875, -0.61803398875 ) ; glVertex3d ( 0.0, -1.61803398875, 0.61803398875 ) ; glVertex3d ( -1.0, -1.0, 1.0 ) ;
+ glEnd () ;
+}
+
+/*
+ *
+ */
+void glutWireOctahedron( void )
+{
+#define RADIUS 1.0f
+ glBegin( GL_LINE_LOOP );
+ glNormal3d( 0.577350269189, 0.577350269189, 0.577350269189); glVertex3d( RADIUS, 0.0, 0.0 ); glVertex3d( 0.0, RADIUS, 0.0 ); glVertex3d( 0.0, 0.0, RADIUS );
+ glNormal3d( 0.577350269189, 0.577350269189,-0.577350269189); glVertex3d( RADIUS, 0.0, 0.0 ); glVertex3d( 0.0, 0.0,-RADIUS ); glVertex3d( 0.0, RADIUS, 0.0 );
+ glNormal3d( 0.577350269189,-0.577350269189, 0.577350269189); glVertex3d( RADIUS, 0.0, 0.0 ); glVertex3d( 0.0, 0.0, RADIUS ); glVertex3d( 0.0,-RADIUS, 0.0 );
+ glNormal3d( 0.577350269189,-0.577350269189,-0.577350269189); glVertex3d( RADIUS, 0.0, 0.0 ); glVertex3d( 0.0,-RADIUS, 0.0 ); glVertex3d( 0.0, 0.0,-RADIUS );
+ glNormal3d(-0.577350269189, 0.577350269189, 0.577350269189); glVertex3d(-RADIUS, 0.0, 0.0 ); glVertex3d( 0.0, 0.0, RADIUS ); glVertex3d( 0.0, RADIUS, 0.0 );
+ glNormal3d(-0.577350269189, 0.577350269189,-0.577350269189); glVertex3d(-RADIUS, 0.0, 0.0 ); glVertex3d( 0.0, RADIUS, 0.0 ); glVertex3d( 0.0, 0.0,-RADIUS );
+ glNormal3d(-0.577350269189,-0.577350269189, 0.577350269189); glVertex3d(-RADIUS, 0.0, 0.0 ); glVertex3d( 0.0,-RADIUS, 0.0 ); glVertex3d( 0.0, 0.0, RADIUS );
+ glNormal3d(-0.577350269189,-0.577350269189,-0.577350269189); glVertex3d(-RADIUS, 0.0, 0.0 ); glVertex3d( 0.0, 0.0,-RADIUS ); glVertex3d( 0.0,-RADIUS, 0.0 );
+ glEnd();
+#undef RADIUS
+}
+
+/*
+ *
+ */
+void glutSolidOctahedron( void )
+{
+#define RADIUS 1.0f
+ glBegin( GL_TRIANGLES );
+ glNormal3d( 0.577350269189, 0.577350269189, 0.577350269189); glVertex3d( RADIUS, 0.0, 0.0 ); glVertex3d( 0.0, RADIUS, 0.0 ); glVertex3d( 0.0, 0.0, RADIUS );
+ glNormal3d( 0.577350269189, 0.577350269189,-0.577350269189); glVertex3d( RADIUS, 0.0, 0.0 ); glVertex3d( 0.0, 0.0,-RADIUS ); glVertex3d( 0.0, RADIUS, 0.0 );
+ glNormal3d( 0.577350269189,-0.577350269189, 0.577350269189); glVertex3d( RADIUS, 0.0, 0.0 ); glVertex3d( 0.0, 0.0, RADIUS ); glVertex3d( 0.0,-RADIUS, 0.0 );
+ glNormal3d( 0.577350269189,-0.577350269189,-0.577350269189); glVertex3d( RADIUS, 0.0, 0.0 ); glVertex3d( 0.0,-RADIUS, 0.0 ); glVertex3d( 0.0, 0.0,-RADIUS );
+ glNormal3d(-0.577350269189, 0.577350269189, 0.577350269189); glVertex3d(-RADIUS, 0.0, 0.0 ); glVertex3d( 0.0, 0.0, RADIUS ); glVertex3d( 0.0, RADIUS, 0.0 );
+ glNormal3d(-0.577350269189, 0.577350269189,-0.577350269189); glVertex3d(-RADIUS, 0.0, 0.0 ); glVertex3d( 0.0, RADIUS, 0.0 ); glVertex3d( 0.0, 0.0,-RADIUS );
+ glNormal3d(-0.577350269189,-0.577350269189, 0.577350269189); glVertex3d(-RADIUS, 0.0, 0.0 ); glVertex3d( 0.0,-RADIUS, 0.0 ); glVertex3d( 0.0, 0.0, RADIUS );
+ glNormal3d(-0.577350269189,-0.577350269189,-0.577350269189); glVertex3d(-RADIUS, 0.0, 0.0 ); glVertex3d( 0.0, 0.0,-RADIUS ); glVertex3d( 0.0,-RADIUS, 0.0 );
+ glEnd();
+#undef RADIUS
+}
+
+/* Magic Numbers: r0 = ( 1, 0, 0 )
+ * r1 = ( -1/3, 2 sqrt(2) / 3, 0 )
+ * r2 = ( -1/3, -sqrt(2) / 3, sqrt(6) / 3 )
+ * r3 = ( -1/3, -sqrt(2) / 3, -sqrt(6) / 3 )
+ * |r0| = |r1| = |r2| = |r3| = 1
+ * Distance between any two points is 2 sqrt(6) / 3
+ *
+ * Normals: The unit normals are simply the negative of the coordinates of the point not on the surface.
+ */
+
+#define NUM_TETR_FACES 4
+
+static GLdouble tet_r[4][3] = { { 1.0, 0.0, 0.0 },
+ { -0.333333333333, 0.942809041582, 0.0 },
+ { -0.333333333333, -0.471404520791, 0.816496580928 },
+ { -0.333333333333, -0.471404520791, -0.816496580928 } } ;
+
+static GLint tet_i[4][3] = /* Vertex indices */
+{
+ { 1, 3, 2 }, { 0, 2, 3 }, { 0, 3, 1 }, { 0, 1, 2 }
+} ;
+
+/*
+ *
+ */
+void glutWireTetrahedron( void )
+{
+ glBegin( GL_LINE_LOOP ) ;
+ glNormal3d ( -tet_r[0][0], -tet_r[0][1], -tet_r[0][2] ) ; glVertex3dv ( tet_r[1] ) ; glVertex3dv ( tet_r[3] ) ; glVertex3dv ( tet_r[2] ) ;
+ glNormal3d ( -tet_r[1][0], -tet_r[1][1], -tet_r[1][2] ) ; glVertex3dv ( tet_r[0] ) ; glVertex3dv ( tet_r[2] ) ; glVertex3dv ( tet_r[3] ) ;
+ glNormal3d ( -tet_r[2][0], -tet_r[2][1], -tet_r[2][2] ) ; glVertex3dv ( tet_r[0] ) ; glVertex3dv ( tet_r[3] ) ; glVertex3dv ( tet_r[1] ) ;
+ glNormal3d ( -tet_r[3][0], -tet_r[3][1], -tet_r[3][2] ) ; glVertex3dv ( tet_r[0] ) ; glVertex3dv ( tet_r[1] ) ; glVertex3dv ( tet_r[2] ) ;
+ glEnd() ;
+}
+
+/*
+ *
+ */
+void glutSolidTetrahedron( void )
+{
+ glBegin( GL_TRIANGLES ) ;
+ glNormal3d ( -tet_r[0][0], -tet_r[0][1], -tet_r[0][2] ) ; glVertex3dv ( tet_r[1] ) ; glVertex3dv ( tet_r[3] ) ; glVertex3dv ( tet_r[2] ) ;
+ glNormal3d ( -tet_r[1][0], -tet_r[1][1], -tet_r[1][2] ) ; glVertex3dv ( tet_r[0] ) ; glVertex3dv ( tet_r[2] ) ; glVertex3dv ( tet_r[3] ) ;
+ glNormal3d ( -tet_r[2][0], -tet_r[2][1], -tet_r[2][2] ) ; glVertex3dv ( tet_r[0] ) ; glVertex3dv ( tet_r[3] ) ; glVertex3dv ( tet_r[1] ) ;
+ glNormal3d ( -tet_r[3][0], -tet_r[3][1], -tet_r[3][2] ) ; glVertex3dv ( tet_r[0] ) ; glVertex3dv ( tet_r[1] ) ; glVertex3dv ( tet_r[2] ) ;
+ glEnd() ;
+}
+
+/*
+ *
+ */
+double icos_r[12][3] = { { 1.0, 0.0, 0.0 },
+ { 0.447213595500, 0.894427191000, 0.0 }, { 0.447213595500, 0.276393202252, 0.850650808354 }, { 0.447213595500, -0.723606797748, 0.525731112119 }, { 0.447213595500, -0.723606797748, -0.525731112119 }, { 0.447213595500, 0.276393202252, -0.850650808354 },
+ { -0.447213595500, -0.894427191000, 0.0 }, { -0.447213595500, -0.276393202252, 0.850650808354 }, { -0.447213595500, 0.723606797748, 0.525731112119 }, { -0.447213595500, 0.723606797748, -0.525731112119 }, { -0.447213595500, -0.276393202252, -0.850650808354 },
+ { -1.0, 0.0, 0.0 } } ;
+int icos_v [20][3] = { { 0, 1, 2 }, { 0, 2, 3 }, { 0, 3, 4 }, { 0, 4, 5 }, { 0, 5, 1 },
+ { 1, 8, 2 }, { 2, 7, 3 }, { 3, 6, 4 }, { 4, 10, 5 }, { 5, 9, 1 },
+ { 1, 9, 8 }, { 2, 8, 7 }, { 3, 7, 6 }, { 4, 6, 10 }, { 5, 10, 9 },
+ { 11, 9, 10 }, { 11, 8, 9 }, { 11, 7, 8 }, { 11, 6, 7 }, { 11, 10, 6 } } ;
+
+void glutWireIcosahedron( void )
+{
+ int i ;
+
+ for ( i = 0; i < 20; i++ )
+ {
+ double normal[3] ;
+ normal[0] = ( icos_r[icos_v[i][1]][1] - icos_r[icos_v[i][0]][1] ) * ( icos_r[icos_v[i][2]][2] - icos_r[icos_v[i][0]][2] ) - ( icos_r[icos_v[i][1]][2] - icos_r[icos_v[i][0]][2] ) * ( icos_r[icos_v[i][2]][1] - icos_r[icos_v[i][0]][1] ) ;
+ normal[1] = ( icos_r[icos_v[i][1]][2] - icos_r[icos_v[i][0]][2] ) * ( icos_r[icos_v[i][2]][0] - icos_r[icos_v[i][0]][0] ) - ( icos_r[icos_v[i][1]][0] - icos_r[icos_v[i][0]][0] ) * ( icos_r[icos_v[i][2]][2] - icos_r[icos_v[i][0]][2] ) ;
+ normal[2] = ( icos_r[icos_v[i][1]][0] - icos_r[icos_v[i][0]][0] ) * ( icos_r[icos_v[i][2]][1] - icos_r[icos_v[i][0]][1] ) - ( icos_r[icos_v[i][1]][1] - icos_r[icos_v[i][0]][1] ) * ( icos_r[icos_v[i][2]][0] - icos_r[icos_v[i][0]][0] ) ;
+ glBegin ( GL_LINE_LOOP ) ;
+ glNormal3dv ( normal ) ;
+ glVertex3dv ( icos_r[icos_v[i][0]] ) ;
+ glVertex3dv ( icos_r[icos_v[i][1]] ) ;
+ glVertex3dv ( icos_r[icos_v[i][2]] ) ;
+ glEnd () ;
+ }
+}
+
+/*
+ *
+ */
+void glutSolidIcosahedron( void )
+{
+ int i ;
+
+ glBegin ( GL_TRIANGLES ) ;
+ for ( i = 0; i < 20; i++ )
+ {
+ double normal[3] ;
+ normal[0] = ( icos_r[icos_v[i][1]][1] - icos_r[icos_v[i][0]][1] ) * ( icos_r[icos_v[i][2]][2] - icos_r[icos_v[i][0]][2] ) - ( icos_r[icos_v[i][1]][2] - icos_r[icos_v[i][0]][2] ) * ( icos_r[icos_v[i][2]][1] - icos_r[icos_v[i][0]][1] ) ;
+ normal[1] = ( icos_r[icos_v[i][1]][2] - icos_r[icos_v[i][0]][2] ) * ( icos_r[icos_v[i][2]][0] - icos_r[icos_v[i][0]][0] ) - ( icos_r[icos_v[i][1]][0] - icos_r[icos_v[i][0]][0] ) * ( icos_r[icos_v[i][2]][2] - icos_r[icos_v[i][0]][2] ) ;
+ normal[2] = ( icos_r[icos_v[i][1]][0] - icos_r[icos_v[i][0]][0] ) * ( icos_r[icos_v[i][2]][1] - icos_r[icos_v[i][0]][1] ) - ( icos_r[icos_v[i][1]][1] - icos_r[icos_v[i][0]][1] ) * ( icos_r[icos_v[i][2]][0] - icos_r[icos_v[i][0]][0] ) ;
+ glNormal3dv ( normal ) ;
+ glVertex3dv ( icos_r[icos_v[i][0]] ) ;
+ glVertex3dv ( icos_r[icos_v[i][1]] ) ;
+ glVertex3dv ( icos_r[icos_v[i][2]] ) ;
+ }
+
+ glEnd () ;
+}
+
+/*
+ *
+ */
+double rdod_r[14][3] = { { 0.0, 0.0, 1.0 },
+ { 0.707106781187, 0.000000000000, 0.5 }, { 0.000000000000, 0.707106781187, 0.5 }, { -0.707106781187, 0.000000000000, 0.5 }, { 0.000000000000, -0.707106781187, 0.5 },
+ { 0.707106781187, 0.707106781187, 0.0 }, { -0.707106781187, 0.707106781187, 0.0 }, { -0.707106781187, -0.707106781187, 0.0 }, { 0.707106781187, -0.707106781187, 0.0 },
+ { 0.707106781187, 0.000000000000, -0.5 }, { 0.000000000000, 0.707106781187, -0.5 }, { -0.707106781187, 0.000000000000, -0.5 }, { 0.000000000000, -0.707106781187, -0.5 },
+ { 0.0, 0.0, -1.0 } } ;
+int rdod_v [12][4] = { { 0, 1, 5, 2 }, { 0, 2, 6, 3 }, { 0, 3, 7, 4 }, { 0, 4, 8, 1 },
+ { 5, 10, 6, 2 }, { 6, 11, 7, 3 }, { 7, 12, 8, 4 }, { 8, 9, 5, 1 },
+ { 5, 9, 13, 10 }, { 6, 10, 13, 11 }, { 7, 11, 13, 12 }, { 8, 12, 13, 9 } } ;
+double rdod_n[12][3] = {
+ { 0.353553390594, 0.353553390594, 0.5 }, { -0.353553390594, 0.353553390594, 0.5 }, { -0.353553390594, -0.353553390594, 0.5 }, { 0.353553390594, -0.353553390594, 0.5 },
+ { 0.000000000000, 1.000000000000, 0.0 }, { -1.000000000000, 0.000000000000, 0.0 }, { 0.000000000000, -1.000000000000, 0.0 }, { 1.000000000000, 0.000000000000, 0.0 },
+ { 0.353553390594, 0.353553390594, -0.5 }, { -0.353553390594, 0.353553390594, -0.5 }, { -0.353553390594, -0.353553390594, -0.5 }, { 0.353553390594, -0.353553390594, -0.5 }
+ } ;
+
+void glutWireRhombicDodecahedron( void )
+{
+ int i ;
+
+ for ( i = 0; i < 12; i++ )
+ {
+ glBegin ( GL_LINE_LOOP ) ;
+ glNormal3dv ( rdod_n[i] ) ;
+ glVertex3dv ( rdod_r[rdod_v[i][0]] ) ;
+ glVertex3dv ( rdod_r[rdod_v[i][1]] ) ;
+ glVertex3dv ( rdod_r[rdod_v[i][2]] ) ;
+ glVertex3dv ( rdod_r[rdod_v[i][3]] ) ;
+ glEnd () ;
+ }
+}
+
+/*
+ *
+ */
+void glutSolidRhombicDodecahedron( void )
+{
+ int i ;
+
+ glBegin ( GL_QUADS ) ;
+ for ( i = 0; i < 12; i++ )
+ {
+ glNormal3dv ( rdod_n[i] ) ;
+ glVertex3dv ( rdod_r[rdod_v[i][0]] ) ;
+ glVertex3dv ( rdod_r[rdod_v[i][1]] ) ;
+ glVertex3dv ( rdod_r[rdod_v[i][2]] ) ;
+ glVertex3dv ( rdod_r[rdod_v[i][3]] ) ;
+ }
+
+ glEnd () ;
+}
+
+void glutWireSierpinskiSponge ( int num_levels, GLdouble offset[3], GLdouble scale )
+{
+ int i, j ;
+
+ if ( num_levels == 0 )
+ {
+
+ for ( i = 0 ; i < NUM_TETR_FACES ; i++ )
+ {
+ glBegin ( GL_LINE_LOOP ) ;
+ glNormal3d ( -tet_r[i][0], -tet_r[i][1], -tet_r[i][2] ) ;
+ for ( j = 0; j < 3; j++ )
+ {
+ double x = offset[0] + scale * tet_r[tet_i[i][j]][0] ;
+ double y = offset[1] + scale * tet_r[tet_i[i][j]][1] ;
+ double z = offset[2] + scale * tet_r[tet_i[i][j]][2] ;
+ glVertex3d ( x, y, z ) ;
+ }
+
+ glEnd () ;
+ }
+ }
+ else
+ {
+ GLdouble local_offset[3] ; /* Use a local variable to avoid buildup of roundoff errors */
+ num_levels -- ;
+ scale /= 2.0 ;
+ for ( i = 0 ; i < NUM_TETR_FACES ; i++ )
+ {
+ local_offset[0] = offset[0] + scale * tet_r[i][0] ;
+ local_offset[1] = offset[1] + scale * tet_r[i][1] ;
+ local_offset[2] = offset[2] + scale * tet_r[i][2] ;
+ glutWireSierpinskiSponge ( num_levels, local_offset, scale ) ;
+ }
+ }
+}
+
+void glutSolidSierpinskiSponge ( int num_levels, GLdouble offset[3], GLdouble scale )
+{
+ int i, j ;
+
+ if ( num_levels == 0 )
+ {
+ glBegin ( GL_TRIANGLES ) ;
+
+ for ( i = 0 ; i < NUM_TETR_FACES ; i++ )
+ {
+ glNormal3d ( -tet_r[i][0], -tet_r[i][1], -tet_r[i][2] ) ;
+ for ( j = 0; j < 3; j++ )
+ {
+ double x = offset[0] + scale * tet_r[tet_i[i][j]][0] ;
+ double y = offset[1] + scale * tet_r[tet_i[i][j]][1] ;
+ double z = offset[2] + scale * tet_r[tet_i[i][j]][2] ;
+ glVertex3d ( x, y, z ) ;
+ }
+ }
+
+ glEnd () ;
+ }
+ else
+ {
+ GLdouble local_offset[3] ; /* Use a local variable to avoid buildup of roundoff errors */
+ num_levels -- ;
+ scale /= 2.0 ;
+ for ( i = 0 ; i < NUM_TETR_FACES ; i++ )
+ {
+ local_offset[0] = offset[0] + scale * tet_r[i][0] ;
+ local_offset[1] = offset[1] + scale * tet_r[i][1] ;
+ local_offset[2] = offset[2] + scale * tet_r[i][2] ;
+ glutSolidSierpinskiSponge ( num_levels, local_offset, scale ) ;
+ }
+ }
+}
+
+/*** END OF FILE ***/
Copied: branches/branch-3.0/src/fltk3gl/freeglut_stroke_mono_roman.cxx (from rev 9002, branches/branch-3.0/src/core/freeglut_stroke_mono_roman.cxx)
===================================================================
--- branches/branch-3.0/src/fltk3gl/freeglut_stroke_mono_roman.cxx (rev 0)
+++ branches/branch-3.0/src/fltk3gl/freeglut_stroke_mono_roman.cxx 2011-08-25 10:51:10 UTC (rev 9008)
@@ -0,0 +1,2848 @@
+/*
+ * freeglut_stroke_mono_roman.c
+ *
+ * freeglut Monospace Roman stroke font definition
+ *
+ * Copyright (c) 1999-2010 Pawel W. Olszta. All Rights Reserved.
+ * Written by Pawel W. Olszta, <olszta@sourceforge.net>
+ * Creation date: Thu Dec 16 1999
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+/* This file has been automatically generated by the genstroke utility. */
+
+#include <fltk3/glut.h>
+
+/* char: 0x20 */
+
+static const Fl_Glut_StrokeStrip ch32st[] =
+{
+ { 0, 0 }
+};
+
+static const Fl_Glut_StrokeChar ch32 = {104.762f,0,ch32st};
+
+/* char: 0x21 */
+
+static const Fl_Glut_StrokeVertex ch33st0[] =
+{
+ {52.381f,100.0f},
+ {52.381f,33.3333f}
+};
+
+static const Fl_Glut_StrokeVertex ch33st1[] =
+{
+ {52.381f,9.5238f},
+ {47.6191f,4.7619f},
+ {52.381f,0.0f},
+ {57.1429f,4.7619f},
+ {52.381f,9.5238f}
+};
+
+static const Fl_Glut_StrokeStrip ch33st[] =
+{
+ {2,ch33st0},
+ {5,ch33st1}
+};
+
+static const Fl_Glut_StrokeChar ch33 = {104.762f,2,ch33st};
+
+/* char: 0x22 */
+
+static const Fl_Glut_StrokeVertex ch34st0[] =
+{
+ {33.3334f,100.0f},
+ {33.3334f,66.6667f}
+};
+
+static const Fl_Glut_StrokeVertex ch34st1[] =
+{
+ {71.4286f,100.0f},
+ {71.4286f,66.6667f}
+};
+
+static const Fl_Glut_StrokeStrip ch34st[] =
+{
+ {2,ch34st0},
+ {2,ch34st1}
+};
+
+static const Fl_Glut_StrokeChar ch34 = {104.762f,2,ch34st};
+
+/* char: 0x23 */
+
+static const Fl_Glut_StrokeVertex ch35st0[] =
+{
+ {54.7619f,119.048f},
+ {21.4286f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeVertex ch35st1[] =
+{
+ {83.3334f,119.048f},
+ {50.0f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeVertex ch35st2[] =
+{
+ {21.4286f,57.1429f},
+ {88.0952f,57.1429f}
+};
+
+static const Fl_Glut_StrokeVertex ch35st3[] =
+{
+ {16.6667f,28.5714f},
+ {83.3334f,28.5714f}
+};
+
+static const Fl_Glut_StrokeStrip ch35st[] =
+{
+ {2,ch35st0},
+ {2,ch35st1},
+ {2,ch35st2},
+ {2,ch35st3}
+};
+
+static const Fl_Glut_StrokeChar ch35 = {104.762f,4,ch35st};
+
+/* char: 0x24 */
+
+static const Fl_Glut_StrokeVertex ch36st0[] =
+{
+ {42.8571f,119.048f},
+ {42.8571f,-19.0476f}
+};
+
+static const Fl_Glut_StrokeVertex ch36st1[] =
+{
+ {61.9047f,119.048f},
+ {61.9047f,-19.0476f}
+};
+
+static const Fl_Glut_StrokeVertex ch36st2[] =
+{
+ {85.7143f,85.7143f},
+ {76.1905f,95.2381f},
+ {61.9047f,100.0f},
+ {42.8571f,100.0f},
+ {28.5714f,95.2381f},
+ {19.0476f,85.7143f},
+ {19.0476f,76.1905f},
+ {23.8095f,66.6667f},
+ {28.5714f,61.9048f},
+ {38.0952f,57.1429f},
+ {66.6666f,47.619f},
+ {76.1905f,42.8571f},
+ {80.9524f,38.0952f},
+ {85.7143f,28.5714f},
+ {85.7143f,14.2857f},
+ {76.1905f,4.7619f},
+ {61.9047f,0.0f},
+ {42.8571f,0.0f},
+ {28.5714f,4.7619f},
+ {19.0476f,14.2857f}
+};
+
+static const Fl_Glut_StrokeStrip ch36st[] =
+{
+ {2,ch36st0},
+ {2,ch36st1},
+ {20,ch36st2}
+};
+
+static const Fl_Glut_StrokeChar ch36 = {104.762f,3,ch36st};
+
+/* char: 0x25 */
+
+static const Fl_Glut_StrokeVertex ch37st0[] =
+{
+ {95.2381f,100.0f},
+ {9.5238f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch37st1[] =
+{
+ {33.3333f,100.0f},
+ {42.8571f,90.4762f},
+ {42.8571f,80.9524f},
+ {38.0952f,71.4286f},
+ {28.5714f,66.6667f},
+ {19.0476f,66.6667f},
+ {9.5238f,76.1905f},
+ {9.5238f,85.7143f},
+ {14.2857f,95.2381f},
+ {23.8095f,100.0f},
+ {33.3333f,100.0f},
+ {42.8571f,95.2381f},
+ {57.1428f,90.4762f},
+ {71.4286f,90.4762f},
+ {85.7143f,95.2381f},
+ {95.2381f,100.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch37st2[] =
+{
+ {76.1905f,33.3333f},
+ {66.6667f,28.5714f},
+ {61.9048f,19.0476f},
+ {61.9048f,9.5238f},
+ {71.4286f,0.0f},
+ {80.9524f,0.0f},
+ {90.4762f,4.7619f},
+ {95.2381f,14.2857f},
+ {95.2381f,23.8095f},
+ {85.7143f,33.3333f},
+ {76.1905f,33.3333f}
+};
+
+static const Fl_Glut_StrokeStrip ch37st[] =
+{
+ {2,ch37st0},
+ {16,ch37st1},
+ {11,ch37st2}
+};
+
+static const Fl_Glut_StrokeChar ch37 = {104.762f,3,ch37st};
+
+/* char: 0x26 */
+
+static const Fl_Glut_StrokeVertex ch38st0[] =
+{
+ {100.0f,57.1429f},
+ {100.0f,61.9048f},
+ {95.2381f,66.6667f},
+ {90.4762f,66.6667f},
+ {85.7143f,61.9048f},
+ {80.9524f,52.381f},
+ {71.4286f,28.5714f},
+ {61.9048f,14.2857f},
+ {52.3809f,4.7619f},
+ {42.8571f,0.0f},
+ {23.8095f,0.0f},
+ {14.2857f,4.7619f},
+ {9.5238f,9.5238f},
+ {4.7619f,19.0476f},
+ {4.7619f,28.5714f},
+ {9.5238f,38.0952f},
+ {14.2857f,42.8571f},
+ {47.619f,61.9048f},
+ {52.3809f,66.6667f},
+ {57.1429f,76.1905f},
+ {57.1429f,85.7143f},
+ {52.3809f,95.2381f},
+ {42.8571f,100.0f},
+ {33.3333f,95.2381f},
+ {28.5714f,85.7143f},
+ {28.5714f,76.1905f},
+ {33.3333f,61.9048f},
+ {42.8571f,47.619f},
+ {66.6667f,14.2857f},
+ {76.1905f,4.7619f},
+ {85.7143f,0.0f},
+ {95.2381f,0.0f},
+ {100.0f,4.7619f},
+ {100.0f,9.5238f}
+};
+
+static const Fl_Glut_StrokeStrip ch38st[] =
+{
+ {34,ch38st0}
+};
+
+static const Fl_Glut_StrokeChar ch38 = {104.762f,1,ch38st};
+
+/* char: 0x27 */
+
+static const Fl_Glut_StrokeVertex ch39st0[] =
+{
+ {52.381f,100.0f},
+ {52.381f,66.6667f}
+};
+
+static const Fl_Glut_StrokeStrip ch39st[] =
+{
+ {2,ch39st0}
+};
+
+static const Fl_Glut_StrokeChar ch39 = {104.762f,1,ch39st};
+
+/* char: 0x28 */
+
+static const Fl_Glut_StrokeVertex ch40st0[] =
+{
+ {69.0476f,119.048f},
+ {59.5238f,109.524f},
+ {50.0f,95.2381f},
+ {40.4762f,76.1905f},
+ {35.7143f,52.381f},
+ {35.7143f,33.3333f},
+ {40.4762f,9.5238f},
+ {50.0f,-9.5238f},
+ {59.5238f,-23.8095f},
+ {69.0476f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeStrip ch40st[] =
+{
+ {10,ch40st0}
+};
+
+static const Fl_Glut_StrokeChar ch40 = {104.762f,1,ch40st};
+
+/* char: 0x29 */
+
+static const Fl_Glut_StrokeVertex ch41st0[] =
+{
+ {35.7143f,119.048f},
+ {45.2381f,109.524f},
+ {54.7619f,95.2381f},
+ {64.2857f,76.1905f},
+ {69.0476f,52.381f},
+ {69.0476f,33.3333f},
+ {64.2857f,9.5238f},
+ {54.7619f,-9.5238f},
+ {45.2381f,-23.8095f},
+ {35.7143f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeStrip ch41st[] =
+{
+ {10,ch41st0}
+};
+
+static const Fl_Glut_StrokeChar ch41 = {104.762f,1,ch41st};
+
+/* char: 0x2a */
+
+static const Fl_Glut_StrokeVertex ch42st0[] =
+{
+ {52.381f,71.4286f},
+ {52.381f,14.2857f}
+};
+
+static const Fl_Glut_StrokeVertex ch42st1[] =
+{
+ {28.5715f,57.1429f},
+ {76.1905f,28.5714f}
+};
+
+static const Fl_Glut_StrokeVertex ch42st2[] =
+{
+ {76.1905f,57.1429f},
+ {28.5715f,28.5714f}
+};
+
+static const Fl_Glut_StrokeStrip ch42st[] =
+{
+ {2,ch42st0},
+ {2,ch42st1},
+ {2,ch42st2}
+};
+
+static const Fl_Glut_StrokeChar ch42 = {104.762f,3,ch42st};
+
+/* char: 0x2b */
+
+static const Fl_Glut_StrokeVertex ch43st0[] =
+{
+ {52.3809f,85.7143f},
+ {52.3809f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch43st1[] =
+{
+ {9.5238f,42.8571f},
+ {95.2381f,42.8571f}
+};
+
+static const Fl_Glut_StrokeStrip ch43st[] =
+{
+ {2,ch43st0},
+ {2,ch43st1}
+};
+
+static const Fl_Glut_StrokeChar ch43 = {104.762f,2,ch43st};
+
+/* char: 0x2c */
+
+static const Fl_Glut_StrokeVertex ch44st0[] =
+{
+ {57.1429f,4.7619f},
+ {52.381f,0.0f},
+ {47.6191f,4.7619f},
+ {52.381f,9.5238f},
+ {57.1429f,4.7619f},
+ {57.1429f,-4.7619f},
+ {52.381f,-14.2857f},
+ {47.6191f,-19.0476f}
+};
+
+static const Fl_Glut_StrokeStrip ch44st[] =
+{
+ {8,ch44st0}
+};
+
+static const Fl_Glut_StrokeChar ch44 = {104.762f,1,ch44st};
+
+/* char: 0x2d */
+
+static const Fl_Glut_StrokeVertex ch45st0[] =
+{
+ {9.5238f,42.8571f},
+ {95.2381f,42.8571f}
+};
+
+static const Fl_Glut_StrokeStrip ch45st[] =
+{
+ {2,ch45st0}
+};
+
+static const Fl_Glut_StrokeChar ch45 = {104.762f,1,ch45st};
+
+/* char: 0x2e */
+
+static const Fl_Glut_StrokeVertex ch46st0[] =
+{
+ {52.381f,9.5238f},
+ {47.6191f,4.7619f},
+ {52.381f,0.0f},
+ {57.1429f,4.7619f},
+ {52.381f,9.5238f}
+};
+
+static const Fl_Glut_StrokeStrip ch46st[] =
+{
+ {5,ch46st0}
+};
+
+static const Fl_Glut_StrokeChar ch46 = {104.762f,1,ch46st};
+
+/* char: 0x2f */
+
+static const Fl_Glut_StrokeVertex ch47st0[] =
+{
+ {19.0476f,-14.2857f},
+ {85.7143f,100.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch47st[] =
+{
+ {2,ch47st0}
+};
+
+static const Fl_Glut_StrokeChar ch47 = {104.762f,1,ch47st};
+
+/* char: 0x30 */
+
+static const Fl_Glut_StrokeVertex ch48st0[] =
+{
+ {47.619f,100.0f},
+ {33.3333f,95.2381f},
+ {23.8095f,80.9524f},
+ {19.0476f,57.1429f},
+ {19.0476f,42.8571f},
+ {23.8095f,19.0476f},
+ {33.3333f,4.7619f},
+ {47.619f,0.0f},
+ {57.1428f,0.0f},
+ {71.4286f,4.7619f},
+ {80.9524f,19.0476f},
+ {85.7143f,42.8571f},
+ {85.7143f,57.1429f},
+ {80.9524f,80.9524f},
+ {71.4286f,95.2381f},
+ {57.1428f,100.0f},
+ {47.619f,100.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch48st[] =
+{
+ {17,ch48st0}
+};
+
+static const Fl_Glut_StrokeChar ch48 = {104.762f,1,ch48st};
+
+/* char: 0x31 */
+
+static const Fl_Glut_StrokeVertex ch49st0[] =
+{
+ {40.4762f,80.9524f},
+ {50.0f,85.7143f},
+ {64.2857f,100.0f},
+ {64.2857f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch49st[] =
+{
+ {4,ch49st0}
+};
+
+static const Fl_Glut_StrokeChar ch49 = {104.762f,1,ch49st};
+
+/* char: 0x32 */
+
+static const Fl_Glut_StrokeVertex ch50st0[] =
+{
+ {23.8095f,76.1905f},
+ {23.8095f,80.9524f},
+ {28.5714f,90.4762f},
+ {33.3333f,95.2381f},
+ {42.8571f,100.0f},
+ {61.9047f,100.0f},
+ {71.4286f,95.2381f},
+ {76.1905f,90.4762f},
+ {80.9524f,80.9524f},
+ {80.9524f,71.4286f},
+ {76.1905f,61.9048f},
+ {66.6666f,47.619f},
+ {19.0476f,0.0f},
+ {85.7143f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch50st[] =
+{
+ {14,ch50st0}
+};
+
+static const Fl_Glut_StrokeChar ch50 = {104.762f,1,ch50st};
+
+/* char: 0x33 */
+
+static const Fl_Glut_StrokeVertex ch51st0[] =
+{
+ {28.5714f,100.0f},
+ {80.9524f,100.0f},
+ {52.3809f,61.9048f},
+ {66.6666f,61.9048f},
+ {76.1905f,57.1429f},
+ {80.9524f,52.381f},
+ {85.7143f,38.0952f},
+ {85.7143f,28.5714f},
+ {80.9524f,14.2857f},
+ {71.4286f,4.7619f},
+ {57.1428f,0.0f},
+ {42.8571f,0.0f},
+ {28.5714f,4.7619f},
+ {23.8095f,9.5238f},
+ {19.0476f,19.0476f}
+};
+
+static const Fl_Glut_StrokeStrip ch51st[] =
+{
+ {15,ch51st0}
+};
+
+static const Fl_Glut_StrokeChar ch51 = {104.762f,1,ch51st};
+
+/* char: 0x34 */
+
+static const Fl_Glut_StrokeVertex ch52st0[] =
+{
+ {64.2857f,100.0f},
+ {16.6667f,33.3333f},
+ {88.0952f,33.3333f}
+};
+
+static const Fl_Glut_StrokeVertex ch52st1[] =
+{
+ {64.2857f,100.0f},
+ {64.2857f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch52st[] =
+{
+ {3,ch52st0},
+ {2,ch52st1}
+};
+
+static const Fl_Glut_StrokeChar ch52 = {104.762f,2,ch52st};
+
+/* char: 0x35 */
+
+static const Fl_Glut_StrokeVertex ch53st0[] =
+{
+ {76.1905f,100.0f},
+ {28.5714f,100.0f},
+ {23.8095f,57.1429f},
+ {28.5714f,61.9048f},
+ {42.8571f,66.6667f},
+ {57.1428f,66.6667f},
+ {71.4286f,61.9048f},
+ {80.9524f,52.381f},
+ {85.7143f,38.0952f},
+ {85.7143f,28.5714f},
+ {80.9524f,14.2857f},
+ {71.4286f,4.7619f},
+ {57.1428f,0.0f},
+ {42.8571f,0.0f},
+ {28.5714f,4.7619f},
+ {23.8095f,9.5238f},
+ {19.0476f,19.0476f}
+};
+
+static const Fl_Glut_StrokeStrip ch53st[] =
+{
+ {17,ch53st0}
+};
+
+static const Fl_Glut_StrokeChar ch53 = {104.762f,1,ch53st};
+
+/* char: 0x36 */
+
+static const Fl_Glut_StrokeVertex ch54st0[] =
+{
+ {78.5714f,85.7143f},
+ {73.8096f,95.2381f},
+ {59.5238f,100.0f},
+ {50.0f,100.0f},
+ {35.7143f,95.2381f},
+ {26.1905f,80.9524f},
+ {21.4286f,57.1429f},
+ {21.4286f,33.3333f},
+ {26.1905f,14.2857f},
+ {35.7143f,4.7619f},
+ {50.0f,0.0f},
+ {54.7619f,0.0f},
+ {69.0476f,4.7619f},
+ {78.5714f,14.2857f},
+ {83.3334f,28.5714f},
+ {83.3334f,33.3333f},
+ {78.5714f,47.619f},
+ {69.0476f,57.1429f},
+ {54.7619f,61.9048f},
+ {50.0f,61.9048f},
+ {35.7143f,57.1429f},
+ {26.1905f,47.619f},
+ {21.4286f,33.3333f}
+};
+
+static const Fl_Glut_StrokeStrip ch54st[] =
+{
+ {23,ch54st0}
+};
+
+static const Fl_Glut_StrokeChar ch54 = {104.762f,1,ch54st};
+
+/* char: 0x37 */
+
+static const Fl_Glut_StrokeVertex ch55st0[] =
+{
+ {85.7143f,100.0f},
+ {38.0952f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch55st1[] =
+{
+ {19.0476f,100.0f},
+ {85.7143f,100.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch55st[] =
+{
+ {2,ch55st0},
+ {2,ch55st1}
+};
+
+static const Fl_Glut_StrokeChar ch55 = {104.762f,2,ch55st};
+
+/* char: 0x38 */
+
+static const Fl_Glut_StrokeVertex ch56st0[] =
+{
+ {42.8571f,100.0f},
+ {28.5714f,95.2381f},
+ {23.8095f,85.7143f},
+ {23.8095f,76.1905f},
+ {28.5714f,66.6667f},
+ {38.0952f,61.9048f},
+ {57.1428f,57.1429f},
+ {71.4286f,52.381f},
+ {80.9524f,42.8571f},
+ {85.7143f,33.3333f},
+ {85.7143f,19.0476f},
+ {80.9524f,9.5238f},
+ {76.1905f,4.7619f},
+ {61.9047f,0.0f},
+ {42.8571f,0.0f},
+ {28.5714f,4.7619f},
+ {23.8095f,9.5238f},
+ {19.0476f,19.0476f},
+ {19.0476f,33.3333f},
+ {23.8095f,42.8571f},
+ {33.3333f,52.381f},
+ {47.619f,57.1429f},
+ {66.6666f,61.9048f},
+ {76.1905f,66.6667f},
+ {80.9524f,76.1905f},
+ {80.9524f,85.7143f},
+ {76.1905f,95.2381f},
+ {61.9047f,100.0f},
+ {42.8571f,100.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch56st[] =
+{
+ {29,ch56st0}
+};
+
+static const Fl_Glut_StrokeChar ch56 = {104.762f,1,ch56st};
+
+/* char: 0x39 */
+
+static const Fl_Glut_StrokeVertex ch57st0[] =
+{
+ {83.3334f,66.6667f},
+ {78.5714f,52.381f},
+ {69.0476f,42.8571f},
+ {54.7619f,38.0952f},
+ {50.0f,38.0952f},
+ {35.7143f,42.8571f},
+ {26.1905f,52.381f},
+ {21.4286f,66.6667f},
+ {21.4286f,71.4286f},
+ {26.1905f,85.7143f},
+ {35.7143f,95.2381f},
+ {50.0f,100.0f},
+ {54.7619f,100.0f},
+ {69.0476f,95.2381f},
+ {78.5714f,85.7143f},
+ {83.3334f,66.6667f},
+ {83.3334f,42.8571f},
+ {78.5714f,19.0476f},
+ {69.0476f,4.7619f},
+ {54.7619f,0.0f},
+ {45.2381f,0.0f},
+ {30.9524f,4.7619f},
+ {26.1905f,14.2857f}
+};
+
+static const Fl_Glut_StrokeStrip ch57st[] =
+{
+ {23,ch57st0}
+};
+
+static const Fl_Glut_StrokeChar ch57 = {104.762f,1,ch57st};
+
+/* char: 0x3a */
+
+static const Fl_Glut_StrokeVertex ch58st0[] =
+{
+ {52.381f,66.6667f},
+ {47.6191f,61.9048f},
+ {52.381f,57.1429f},
+ {57.1429f,61.9048f},
+ {52.381f,66.6667f}
+};
+
+static const Fl_Glut_StrokeVertex ch58st1[] =
+{
+ {52.381f,9.5238f},
+ {47.6191f,4.7619f},
+ {52.381f,0.0f},
+ {57.1429f,4.7619f},
+ {52.381f,9.5238f}
+};
+
+static const Fl_Glut_StrokeStrip ch58st[] =
+{
+ {5,ch58st0},
+ {5,ch58st1}
+};
+
+static const Fl_Glut_StrokeChar ch58 = {104.762f,2,ch58st};
+
+/* char: 0x3b */
+
+static const Fl_Glut_StrokeVertex ch59st0[] =
+{
+ {52.381f,66.6667f},
+ {47.6191f,61.9048f},
+ {52.381f,57.1429f},
+ {57.1429f,61.9048f},
+ {52.381f,66.6667f}
+};
+
+static const Fl_Glut_StrokeVertex ch59st1[] =
+{
+ {57.1429f,4.7619f},
+ {52.381f,0.0f},
+ {47.6191f,4.7619f},
+ {52.381f,9.5238f},
+ {57.1429f,4.7619f},
+ {57.1429f,-4.7619f},
+ {52.381f,-14.2857f},
+ {47.6191f,-19.0476f}
+};
+
+static const Fl_Glut_StrokeStrip ch59st[] =
+{
+ {5,ch59st0},
+ {8,ch59st1}
+};
+
+static const Fl_Glut_StrokeChar ch59 = {104.762f,2,ch59st};
+
+/* char: 0x3c */
+
+static const Fl_Glut_StrokeVertex ch60st0[] =
+{
+ {90.4762f,85.7143f},
+ {14.2857f,42.8571f},
+ {90.4762f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch60st[] =
+{
+ {3,ch60st0}
+};
+
+static const Fl_Glut_StrokeChar ch60 = {104.762f,1,ch60st};
+
+/* char: 0x3d */
+
+static const Fl_Glut_StrokeVertex ch61st0[] =
+{
+ {9.5238f,57.1429f},
+ {95.2381f,57.1429f}
+};
+
+static const Fl_Glut_StrokeVertex ch61st1[] =
+{
+ {9.5238f,28.5714f},
+ {95.2381f,28.5714f}
+};
+
+static const Fl_Glut_StrokeStrip ch61st[] =
+{
+ {2,ch61st0},
+ {2,ch61st1}
+};
+
+static const Fl_Glut_StrokeChar ch61 = {104.762f,2,ch61st};
+
+/* char: 0x3e */
+
+static const Fl_Glut_StrokeVertex ch62st0[] =
+{
+ {14.2857f,85.7143f},
+ {90.4762f,42.8571f},
+ {14.2857f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch62st[] =
+{
+ {3,ch62st0}
+};
+
+static const Fl_Glut_StrokeChar ch62 = {104.762f,1,ch62st};
+
+/* char: 0x3f */
+
+static const Fl_Glut_StrokeVertex ch63st0[] =
+{
+ {23.8095f,76.1905f},
+ {23.8095f,80.9524f},
+ {28.5714f,90.4762f},
+ {33.3333f,95.2381f},
+ {42.8571f,100.0f},
+ {61.9047f,100.0f},
+ {71.4285f,95.2381f},
+ {76.1905f,90.4762f},
+ {80.9524f,80.9524f},
+ {80.9524f,71.4286f},
+ {76.1905f,61.9048f},
+ {71.4285f,57.1429f},
+ {52.3809f,47.619f},
+ {52.3809f,33.3333f}
+};
+
+static const Fl_Glut_StrokeVertex ch63st1[] =
+{
+ {52.3809f,9.5238f},
+ {47.619f,4.7619f},
+ {52.3809f,0.0f},
+ {57.1428f,4.7619f},
+ {52.3809f,9.5238f}
+};
+
+static const Fl_Glut_StrokeStrip ch63st[] =
+{
+ {14,ch63st0},
+ {5,ch63st1}
+};
+
+static const Fl_Glut_StrokeChar ch63 = {104.762f,2,ch63st};
+
+/* char: 0x40 */
+
+static const Fl_Glut_StrokeVertex ch64st0[] =
+{
+ {64.2857f,52.381f},
+ {54.7619f,57.1429f},
+ {45.2381f,57.1429f},
+ {40.4762f,47.619f},
+ {40.4762f,42.8571f},
+ {45.2381f,33.3333f},
+ {54.7619f,33.3333f},
+ {64.2857f,38.0952f}
+};
+
+static const Fl_Glut_StrokeVertex ch64st1[] =
+{
+ {64.2857f,57.1429f},
+ {64.2857f,38.0952f},
+ {69.0476f,33.3333f},
+ {78.5714f,33.3333f},
+ {83.3334f,42.8571f},
+ {83.3334f,47.619f},
+ {78.5714f,61.9048f},
+ {69.0476f,71.4286f},
+ {54.7619f,76.1905f},
+ {50.0f,76.1905f},
+ {35.7143f,71.4286f},
+ {26.1905f,61.9048f},
+ {21.4286f,47.619f},
+ {21.4286f,42.8571f},
+ {26.1905f,28.5714f},
+ {35.7143f,19.0476f},
+ {50.0f,14.2857f},
+ {54.7619f,14.2857f},
+ {69.0476f,19.0476f}
+};
+
+static const Fl_Glut_StrokeStrip ch64st[] =
+{
+ {8,ch64st0},
+ {19,ch64st1}
+};
+
+static const Fl_Glut_StrokeChar ch64 = {104.762f,2,ch64st};
+
+/* char: 0x41 */
+
+static const Fl_Glut_StrokeVertex ch65st0[] =
+{
+ {52.3809f,100.0f},
+ {14.2857f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch65st1[] =
+{
+ {52.3809f,100.0f},
+ {90.4762f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch65st2[] =
+{
+ {28.5714f,33.3333f},
+ {76.1905f,33.3333f}
+};
+
+static const Fl_Glut_StrokeStrip ch65st[] =
+{
+ {2,ch65st0},
+ {2,ch65st1},
+ {2,ch65st2}
+};
+
+static const Fl_Glut_StrokeChar ch65 = {104.762f,3,ch65st};
+
+/* char: 0x42 */
+
+static const Fl_Glut_StrokeVertex ch66st0[] =
+{
+ {19.0476f,100.0f},
+ {19.0476f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch66st1[] =
+{
+ {19.0476f,100.0f},
+ {61.9047f,100.0f},
+ {76.1905f,95.2381f},
+ {80.9524f,90.4762f},
+ {85.7143f,80.9524f},
+ {85.7143f,71.4286f},
+ {80.9524f,61.9048f},
+ {76.1905f,57.1429f},
+ {61.9047f,52.381f}
+};
+
+static const Fl_Glut_StrokeVertex ch66st2[] =
+{
+ {19.0476f,52.381f},
+ {61.9047f,52.381f},
+ {76.1905f,47.619f},
+ {80.9524f,42.8571f},
+ {85.7143f,33.3333f},
+ {85.7143f,19.0476f},
+ {80.9524f,9.5238f},
+ {76.1905f,4.7619f},
+ {61.9047f,0.0f},
+ {19.0476f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch66st[] =
+{
+ {2,ch66st0},
+ {9,ch66st1},
+ {10,ch66st2}
+};
+
+static const Fl_Glut_StrokeChar ch66 = {104.762f,3,ch66st};
+
+/* char: 0x43 */
+
+static const Fl_Glut_StrokeVertex ch67st0[] =
+{
+ {88.0952f,76.1905f},
+ {83.3334f,85.7143f},
+ {73.8096f,95.2381f},
+ {64.2857f,100.0f},
+ {45.2381f,100.0f},
+ {35.7143f,95.2381f},
+ {26.1905f,85.7143f},
+ {21.4286f,76.1905f},
+ {16.6667f,61.9048f},
+ {16.6667f,38.0952f},
+ {21.4286f,23.8095f},
+ {26.1905f,14.2857f},
+ {35.7143f,4.7619f},
+ {45.2381f,0.0f},
+ {64.2857f,0.0f},
+ {73.8096f,4.7619f},
+ {83.3334f,14.2857f},
+ {88.0952f,23.8095f}
+};
+
+static const Fl_Glut_StrokeStrip ch67st[] =
+{
+ {18,ch67st0}
+};
+
+static const Fl_Glut_StrokeChar ch67 = {104.762f,1,ch67st};
+
+/* char: 0x44 */
+
+static const Fl_Glut_StrokeVertex ch68st0[] =
+{
+ {19.0476f,100.0f},
+ {19.0476f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch68st1[] =
+{
+ {19.0476f,100.0f},
+ {52.3809f,100.0f},
+ {66.6666f,95.2381f},
+ {76.1905f,85.7143f},
+ {80.9524f,76.1905f},
+ {85.7143f,61.9048f},
+ {85.7143f,38.0952f},
+ {80.9524f,23.8095f},
+ {76.1905f,14.2857f},
+ {66.6666f,4.7619f},
+ {52.3809f,0.0f},
+ {19.0476f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch68st[] =
+{
+ {2,ch68st0},
+ {12,ch68st1}
+};
+
+static const Fl_Glut_StrokeChar ch68 = {104.762f,2,ch68st};
+
+/* char: 0x45 */
+
+static const Fl_Glut_StrokeVertex ch69st0[] =
+{
+ {21.4286f,100.0f},
+ {21.4286f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch69st1[] =
+{
+ {21.4286f,100.0f},
+ {83.3334f,100.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch69st2[] =
+{
+ {21.4286f,52.381f},
+ {59.5238f,52.381f}
+};
+
+static const Fl_Glut_StrokeVertex ch69st3[] =
+{
+ {21.4286f,0.0f},
+ {83.3334f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch69st[] =
+{
+ {2,ch69st0},
+ {2,ch69st1},
+ {2,ch69st2},
+ {2,ch69st3}
+};
+
+static const Fl_Glut_StrokeChar ch69 = {104.762f,4,ch69st};
+
+/* char: 0x46 */
+
+static const Fl_Glut_StrokeVertex ch70st0[] =
+{
+ {21.4286f,100.0f},
+ {21.4286f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch70st1[] =
+{
+ {21.4286f,100.0f},
+ {83.3334f,100.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch70st2[] =
+{
+ {21.4286f,52.381f},
+ {59.5238f,52.381f}
+};
+
+static const Fl_Glut_StrokeStrip ch70st[] =
+{
+ {2,ch70st0},
+ {2,ch70st1},
+ {2,ch70st2}
+};
+
+static const Fl_Glut_StrokeChar ch70 = {104.762f,3,ch70st};
+
+/* char: 0x47 */
+
+static const Fl_Glut_StrokeVertex ch71st0[] =
+{
+ {88.0952f,76.1905f},
+ {83.3334f,85.7143f},
+ {73.8096f,95.2381f},
+ {64.2857f,100.0f},
+ {45.2381f,100.0f},
+ {35.7143f,95.2381f},
+ {26.1905f,85.7143f},
+ {21.4286f,76.1905f},
+ {16.6667f,61.9048f},
+ {16.6667f,38.0952f},
+ {21.4286f,23.8095f},
+ {26.1905f,14.2857f},
+ {35.7143f,4.7619f},
+ {45.2381f,0.0f},
+ {64.2857f,0.0f},
+ {73.8096f,4.7619f},
+ {83.3334f,14.2857f},
+ {88.0952f,23.8095f},
+ {88.0952f,38.0952f}
+};
+
+static const Fl_Glut_StrokeVertex ch71st1[] =
+{
+ {64.2857f,38.0952f},
+ {88.0952f,38.0952f}
+};
+
+static const Fl_Glut_StrokeStrip ch71st[] =
+{
+ {19,ch71st0},
+ {2,ch71st1}
+};
+
+static const Fl_Glut_StrokeChar ch71 = {104.762f,2,ch71st};
+
+/* char: 0x48 */
+
+static const Fl_Glut_StrokeVertex ch72st0[] =
+{
+ {19.0476f,100.0f},
+ {19.0476f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch72st1[] =
+{
+ {85.7143f,100.0f},
+ {85.7143f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch72st2[] =
+{
+ {19.0476f,52.381f},
+ {85.7143f,52.381f}
+};
+
+static const Fl_Glut_StrokeStrip ch72st[] =
+{
+ {2,ch72st0},
+ {2,ch72st1},
+ {2,ch72st2}
+};
+
+static const Fl_Glut_StrokeChar ch72 = {104.762f,3,ch72st};
+
+/* char: 0x49 */
+
+static const Fl_Glut_StrokeVertex ch73st0[] =
+{
+ {52.381f,100.0f},
+ {52.381f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch73st[] =
+{
+ {2,ch73st0}
+};
+
+static const Fl_Glut_StrokeChar ch73 = {104.762f,1,ch73st};
+
+/* char: 0x4a */
+
+static const Fl_Glut_StrokeVertex ch74st0[] =
+{
+ {76.1905f,100.0f},
+ {76.1905f,23.8095f},
+ {71.4286f,9.5238f},
+ {66.6667f,4.7619f},
+ {57.1429f,0.0f},
+ {47.6191f,0.0f},
+ {38.0953f,4.7619f},
+ {33.3334f,9.5238f},
+ {28.5715f,23.8095f},
+ {28.5715f,33.3333f}
+};
+
+static const Fl_Glut_StrokeStrip ch74st[] =
+{
+ {10,ch74st0}
+};
+
+static const Fl_Glut_StrokeChar ch74 = {104.762f,1,ch74st};
+
+/* char: 0x4b */
+
+static const Fl_Glut_StrokeVertex ch75st0[] =
+{
+ {19.0476f,100.0f},
+ {19.0476f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch75st1[] =
+{
+ {85.7143f,100.0f},
+ {19.0476f,33.3333f}
+};
+
+static const Fl_Glut_StrokeVertex ch75st2[] =
+{
+ {42.8571f,57.1429f},
+ {85.7143f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch75st[] =
+{
+ {2,ch75st0},
+ {2,ch75st1},
+ {2,ch75st2}
+};
+
+static const Fl_Glut_StrokeChar ch75 = {104.762f,3,ch75st};
+
+/* char: 0x4c */
+
+static const Fl_Glut_StrokeVertex ch76st0[] =
+{
+ {23.8095f,100.0f},
+ {23.8095f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch76st1[] =
+{
+ {23.8095f,0.0f},
+ {80.9524f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch76st[] =
+{
+ {2,ch76st0},
+ {2,ch76st1}
+};
+
+static const Fl_Glut_StrokeChar ch76 = {104.762f,2,ch76st};
+
+/* char: 0x4d */
+
+static const Fl_Glut_StrokeVertex ch77st0[] =
+{
+ {14.2857f,100.0f},
+ {14.2857f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch77st1[] =
+{
+ {14.2857f,100.0f},
+ {52.3809f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch77st2[] =
+{
+ {90.4762f,100.0f},
+ {52.3809f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch77st3[] =
+{
+ {90.4762f,100.0f},
+ {90.4762f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch77st[] =
+{
+ {2,ch77st0},
+ {2,ch77st1},
+ {2,ch77st2},
+ {2,ch77st3}
+};
+
+static const Fl_Glut_StrokeChar ch77 = {104.762f,4,ch77st};
+
+/* char: 0x4e */
+
+static const Fl_Glut_StrokeVertex ch78st0[] =
+{
+ {19.0476f,100.0f},
+ {19.0476f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch78st1[] =
+{
+ {19.0476f,100.0f},
+ {85.7143f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch78st2[] =
+{
+ {85.7143f,100.0f},
+ {85.7143f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch78st[] =
+{
+ {2,ch78st0},
+ {2,ch78st1},
+ {2,ch78st2}
+};
+
+static const Fl_Glut_StrokeChar ch78 = {104.762f,3,ch78st};
+
+/* char: 0x4f */
+
+static const Fl_Glut_StrokeVertex ch79st0[] =
+{
+ {42.8571f,100.0f},
+ {33.3333f,95.2381f},
+ {23.8095f,85.7143f},
+ {19.0476f,76.1905f},
+ {14.2857f,61.9048f},
+ {14.2857f,38.0952f},
+ {19.0476f,23.8095f},
+ {23.8095f,14.2857f},
+ {33.3333f,4.7619f},
+ {42.8571f,0.0f},
+ {61.9047f,0.0f},
+ {71.4286f,4.7619f},
+ {80.9524f,14.2857f},
+ {85.7143f,23.8095f},
+ {90.4762f,38.0952f},
+ {90.4762f,61.9048f},
+ {85.7143f,76.1905f},
+ {80.9524f,85.7143f},
+ {71.4286f,95.2381f},
+ {61.9047f,100.0f},
+ {42.8571f,100.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch79st[] =
+{
+ {21,ch79st0}
+};
+
+static const Fl_Glut_StrokeChar ch79 = {104.762f,1,ch79st};
+
+/* char: 0x50 */
+
+static const Fl_Glut_StrokeVertex ch80st0[] =
+{
+ {19.0476f,100.0f},
+ {19.0476f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch80st1[] =
+{
+ {19.0476f,100.0f},
+ {61.9047f,100.0f},
+ {76.1905f,95.2381f},
+ {80.9524f,90.4762f},
+ {85.7143f,80.9524f},
+ {85.7143f,66.6667f},
+ {80.9524f,57.1429f},
+ {76.1905f,52.381f},
+ {61.9047f,47.619f},
+ {19.0476f,47.619f}
+};
+
+static const Fl_Glut_StrokeStrip ch80st[] =
+{
+ {2,ch80st0},
+ {10,ch80st1}
+};
+
+static const Fl_Glut_StrokeChar ch80 = {104.762f,2,ch80st};
+
+/* char: 0x51 */
+
+static const Fl_Glut_StrokeVertex ch81st0[] =
+{
+ {42.8571f,100.0f},
+ {33.3333f,95.2381f},
+ {23.8095f,85.7143f},
+ {19.0476f,76.1905f},
+ {14.2857f,61.9048f},
+ {14.2857f,38.0952f},
+ {19.0476f,23.8095f},
+ {23.8095f,14.2857f},
+ {33.3333f,4.7619f},
+ {42.8571f,0.0f},
+ {61.9047f,0.0f},
+ {71.4286f,4.7619f},
+ {80.9524f,14.2857f},
+ {85.7143f,23.8095f},
+ {90.4762f,38.0952f},
+ {90.4762f,61.9048f},
+ {85.7143f,76.1905f},
+ {80.9524f,85.7143f},
+ {71.4286f,95.2381f},
+ {61.9047f,100.0f},
+ {42.8571f,100.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch81st1[] =
+{
+ {57.1428f,19.0476f},
+ {85.7143f,-9.5238f}
+};
+
+static const Fl_Glut_StrokeStrip ch81st[] =
+{
+ {21,ch81st0},
+ {2,ch81st1}
+};
+
+static const Fl_Glut_StrokeChar ch81 = {104.762f,2,ch81st};
+
+/* char: 0x52 */
+
+static const Fl_Glut_StrokeVertex ch82st0[] =
+{
+ {19.0476f,100.0f},
+ {19.0476f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch82st1[] =
+{
+ {19.0476f,100.0f},
+ {61.9047f,100.0f},
+ {76.1905f,95.2381f},
+ {80.9524f,90.4762f},
+ {85.7143f,80.9524f},
+ {85.7143f,71.4286f},
+ {80.9524f,61.9048f},
+ {76.1905f,57.1429f},
+ {61.9047f,52.381f},
+ {19.0476f,52.381f}
+};
+
+static const Fl_Glut_StrokeVertex ch82st2[] =
+{
+ {52.3809f,52.381f},
+ {85.7143f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch82st[] =
+{
+ {2,ch82st0},
+ {10,ch82st1},
+ {2,ch82st2}
+};
+
+static const Fl_Glut_StrokeChar ch82 = {104.762f,3,ch82st};
+
+/* char: 0x53 */
+
+static const Fl_Glut_StrokeVertex ch83st0[] =
+{
+ {85.7143f,85.7143f},
+ {76.1905f,95.2381f},
+ {61.9047f,100.0f},
+ {42.8571f,100.0f},
+ {28.5714f,95.2381f},
+ {19.0476f,85.7143f},
+ {19.0476f,76.1905f},
+ {23.8095f,66.6667f},
+ {28.5714f,61.9048f},
+ {38.0952f,57.1429f},
+ {66.6666f,47.619f},
+ {76.1905f,42.8571f},
+ {80.9524f,38.0952f},
+ {85.7143f,28.5714f},
+ {85.7143f,14.2857f},
+ {76.1905f,4.7619f},
+ {61.9047f,0.0f},
+ {42.8571f,0.0f},
+ {28.5714f,4.7619f},
+ {19.0476f,14.2857f}
+};
+
+static const Fl_Glut_StrokeStrip ch83st[] =
+{
+ {20,ch83st0}
+};
+
+static const Fl_Glut_StrokeChar ch83 = {104.762f,1,ch83st};
+
+/* char: 0x54 */
+
+static const Fl_Glut_StrokeVertex ch84st0[] =
+{
+ {52.3809f,100.0f},
+ {52.3809f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch84st1[] =
+{
+ {19.0476f,100.0f},
+ {85.7143f,100.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch84st[] =
+{
+ {2,ch84st0},
+ {2,ch84st1}
+};
+
+static const Fl_Glut_StrokeChar ch84 = {104.762f,2,ch84st};
+
+/* char: 0x55 */
+
+static const Fl_Glut_StrokeVertex ch85st0[] =
+{
+ {19.0476f,100.0f},
+ {19.0476f,28.5714f},
+ {23.8095f,14.2857f},
+ {33.3333f,4.7619f},
+ {47.619f,0.0f},
+ {57.1428f,0.0f},
+ {71.4286f,4.7619f},
+ {80.9524f,14.2857f},
+ {85.7143f,28.5714f},
+ {85.7143f,100.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch85st[] =
+{
+ {10,ch85st0}
+};
+
+static const Fl_Glut_StrokeChar ch85 = {104.762f,1,ch85st};
+
+/* char: 0x56 */
+
+static const Fl_Glut_StrokeVertex ch86st0[] =
+{
+ {14.2857f,100.0f},
+ {52.3809f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch86st1[] =
+{
+ {90.4762f,100.0f},
+ {52.3809f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch86st[] =
+{
+ {2,ch86st0},
+ {2,ch86st1}
+};
+
+static const Fl_Glut_StrokeChar ch86 = {104.762f,2,ch86st};
+
+/* char: 0x57 */
+
+static const Fl_Glut_StrokeVertex ch87st0[] =
+{
+ {4.7619f,100.0f},
+ {28.5714f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch87st1[] =
+{
+ {52.3809f,100.0f},
+ {28.5714f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch87st2[] =
+{
+ {52.3809f,100.0f},
+ {76.1905f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch87st3[] =
+{
+ {100.0f,100.0f},
+ {76.1905f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch87st[] =
+{
+ {2,ch87st0},
+ {2,ch87st1},
+ {2,ch87st2},
+ {2,ch87st3}
+};
+
+static const Fl_Glut_StrokeChar ch87 = {104.762f,4,ch87st};
+
+/* char: 0x58 */
+
+static const Fl_Glut_StrokeVertex ch88st0[] =
+{
+ {19.0476f,100.0f},
+ {85.7143f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch88st1[] =
+{
+ {85.7143f,100.0f},
+ {19.0476f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch88st[] =
+{
+ {2,ch88st0},
+ {2,ch88st1}
+};
+
+static const Fl_Glut_StrokeChar ch88 = {104.762f,2,ch88st};
+
+/* char: 0x59 */
+
+static const Fl_Glut_StrokeVertex ch89st0[] =
+{
+ {14.2857f,100.0f},
+ {52.3809f,52.381f},
+ {52.3809f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch89st1[] =
+{
+ {90.4762f,100.0f},
+ {52.3809f,52.381f}
+};
+
+static const Fl_Glut_StrokeStrip ch89st[] =
+{
+ {3,ch89st0},
+ {2,ch89st1}
+};
+
+static const Fl_Glut_StrokeChar ch89 = {104.762f,2,ch89st};
+
+/* char: 0x5a */
+
+static const Fl_Glut_StrokeVertex ch90st0[] =
+{
+ {85.7143f,100.0f},
+ {19.0476f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch90st1[] =
+{
+ {19.0476f,100.0f},
+ {85.7143f,100.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch90st2[] =
+{
+ {19.0476f,0.0f},
+ {85.7143f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch90st[] =
+{
+ {2,ch90st0},
+ {2,ch90st1},
+ {2,ch90st2}
+};
+
+static const Fl_Glut_StrokeChar ch90 = {104.762f,3,ch90st};
+
+/* char: 0x5b */
+
+static const Fl_Glut_StrokeVertex ch91st0[] =
+{
+ {35.7143f,119.048f},
+ {35.7143f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeVertex ch91st1[] =
+{
+ {40.4762f,119.048f},
+ {40.4762f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeVertex ch91st2[] =
+{
+ {35.7143f,119.048f},
+ {69.0476f,119.048f}
+};
+
+static const Fl_Glut_StrokeVertex ch91st3[] =
+{
+ {35.7143f,-33.3333f},
+ {69.0476f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeStrip ch91st[] =
+{
+ {2,ch91st0},
+ {2,ch91st1},
+ {2,ch91st2},
+ {2,ch91st3}
+};
+
+static const Fl_Glut_StrokeChar ch91 = {104.762f,4,ch91st};
+
+/* char: 0x5c */
+
+static const Fl_Glut_StrokeVertex ch92st0[] =
+{
+ {19.0476f,100.0f},
+ {85.7143f,-14.2857f}
+};
+
+static const Fl_Glut_StrokeStrip ch92st[] =
+{
+ {2,ch92st0}
+};
+
+static const Fl_Glut_StrokeChar ch92 = {104.762f,1,ch92st};
+
+/* char: 0x5d */
+
+static const Fl_Glut_StrokeVertex ch93st0[] =
+{
+ {64.2857f,119.048f},
+ {64.2857f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeVertex ch93st1[] =
+{
+ {69.0476f,119.048f},
+ {69.0476f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeVertex ch93st2[] =
+{
+ {35.7143f,119.048f},
+ {69.0476f,119.048f}
+};
+
+static const Fl_Glut_StrokeVertex ch93st3[] =
+{
+ {35.7143f,-33.3333f},
+ {69.0476f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeStrip ch93st[] =
+{
+ {2,ch93st0},
+ {2,ch93st1},
+ {2,ch93st2},
+ {2,ch93st3}
+};
+
+static const Fl_Glut_StrokeChar ch93 = {104.762f,4,ch93st};
+
+/* char: 0x5e */
+
+static const Fl_Glut_StrokeVertex ch94st0[] =
+{
+ {52.3809f,109.524f},
+ {14.2857f,42.8571f}
+};
+
+static const Fl_Glut_StrokeVertex ch94st1[] =
+{
+ {52.3809f,109.524f},
+ {90.4762f,42.8571f}
+};
+
+static const Fl_Glut_StrokeStrip ch94st[] =
+{
+ {2,ch94st0},
+ {2,ch94st1}
+};
+
+static const Fl_Glut_StrokeChar ch94 = {104.762f,2,ch94st};
+
+/* char: 0x5f */
+
+static const Fl_Glut_StrokeVertex ch95st0[] =
+{
+ {0,-33.3333f},
+ {104.762f,-33.3333f},
+ {104.762f,-28.5714f},
+ {0,-28.5714f},
+ {0,-33.3333f}
+};
+
+static const Fl_Glut_StrokeStrip ch95st[] =
+{
+ {5,ch95st0}
+};
+
+static const Fl_Glut_StrokeChar ch95 = {104.762f,1,ch95st};
+
+/* char: 0x60 */
+
+static const Fl_Glut_StrokeVertex ch96st0[] =
+{
+ {42.8572f,100.0f},
+ {66.6667f,71.4286f}
+};
+
+static const Fl_Glut_StrokeVertex ch96st1[] =
+{
+ {42.8572f,100.0f},
+ {38.0953f,95.2381f},
+ {66.6667f,71.4286f}
+};
+
+static const Fl_Glut_StrokeStrip ch96st[] =
+{
+ {2,ch96st0},
+ {3,ch96st1}
+};
+
+static const Fl_Glut_StrokeChar ch96 = {104.762f,2,ch96st};
+
+/* char: 0x61 */
+
+static const Fl_Glut_StrokeVertex ch97st0[] =
+{
+ {80.9524f,66.6667f},
+ {80.9524f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch97st1[] =
+{
+ {80.9524f,52.381f},
+ {71.4285f,61.9048f},
+ {61.9047f,66.6667f},
+ {47.619f,66.6667f},
+ {38.0952f,61.9048f},
+ {28.5714f,52.381f},
+ {23.8095f,38.0952f},
+ {23.8095f,28.5714f},
+ {28.5714f,14.2857f},
+ {38.0952f,4.7619f},
+ {47.619f,0.0f},
+ {61.9047f,0.0f},
+ {71.4285f,4.7619f},
+ {80.9524f,14.2857f}
+};
+
+static const Fl_Glut_StrokeStrip ch97st[] =
+{
+ {2,ch97st0},
+ {14,ch97st1}
+};
+
+static const Fl_Glut_StrokeChar ch97 = {104.762f,2,ch97st};
+
+/* char: 0x62 */
+
+static const Fl_Glut_StrokeVertex ch98st0[] =
+{
+ {23.8095f,100.0f},
+ {23.8095f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch98st1[] =
+{
+ {23.8095f,52.381f},
+ {33.3333f,61.9048f},
+ {42.8571f,66.6667f},
+ {57.1428f,66.6667f},
+ {66.6666f,61.9048f},
+ {76.1905f,52.381f},
+ {80.9524f,38.0952f},
+ {80.9524f,28.5714f},
+ {76.1905f,14.2857f},
+ {66.6666f,4.7619f},
+ {57.1428f,0.0f},
+ {42.8571f,0.0f},
+ {33.3333f,4.7619f},
+ {23.8095f,14.2857f}
+};
+
+static const Fl_Glut_StrokeStrip ch98st[] =
+{
+ {2,ch98st0},
+ {14,ch98st1}
+};
+
+static const Fl_Glut_StrokeChar ch98 = {104.762f,2,ch98st};
+
+/* char: 0x63 */
+
+static const Fl_Glut_StrokeVertex ch99st0[] =
+{
+ {80.9524f,52.381f},
+ {71.4285f,61.9048f},
+ {61.9047f,66.6667f},
+ {47.619f,66.6667f},
+ {38.0952f,61.9048f},
+ {28.5714f,52.381f},
+ {23.8095f,38.0952f},
+ {23.8095f,28.5714f},
+ {28.5714f,14.2857f},
+ {38.0952f,4.7619f},
+ {47.619f,0.0f},
+ {61.9047f,0.0f},
+ {71.4285f,4.7619f},
+ {80.9524f,14.2857f}
+};
+
+static const Fl_Glut_StrokeStrip ch99st[] =
+{
+ {14,ch99st0}
+};
+
+static const Fl_Glut_StrokeChar ch99 = {104.762f,1,ch99st};
+
+/* char: 0x64 */
+
+static const Fl_Glut_StrokeVertex ch100st0[] =
+{
+ {80.9524f,100.0f},
+ {80.9524f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch100st1[] =
+{
+ {80.9524f,52.381f},
+ {71.4285f,61.9048f},
+ {61.9047f,66.6667f},
+ {47.619f,66.6667f},
+ {38.0952f,61.9048f},
+ {28.5714f,52.381f},
+ {23.8095f,38.0952f},
+ {23.8095f,28.5714f},
+ {28.5714f,14.2857f},
+ {38.0952f,4.7619f},
+ {47.619f,0.0f},
+ {61.9047f,0.0f},
+ {71.4285f,4.7619f},
+ {80.9524f,14.2857f}
+};
+
+static const Fl_Glut_StrokeStrip ch100st[] =
+{
+ {2,ch100st0},
+ {14,ch100st1}
+};
+
+static const Fl_Glut_StrokeChar ch100 = {104.762f,2,ch100st};
+
+/* char: 0x65 */
+
+static const Fl_Glut_StrokeVertex ch101st0[] =
+{
+ {23.8095f,38.0952f},
+ {80.9524f,38.0952f},
+ {80.9524f,47.619f},
+ {76.1905f,57.1429f},
+ {71.4285f,61.9048f},
+ {61.9047f,66.6667f},
+ {47.619f,66.6667f},
+ {38.0952f,61.9048f},
+ {28.5714f,52.381f},
+ {23.8095f,38.0952f},
+ {23.8095f,28.5714f},
+ {28.5714f,14.2857f},
+ {38.0952f,4.7619f},
+ {47.619f,0.0f},
+ {61.9047f,0.0f},
+ {71.4285f,4.7619f},
+ {80.9524f,14.2857f}
+};
+
+static const Fl_Glut_StrokeStrip ch101st[] =
+{
+ {17,ch101st0}
+};
+
+static const Fl_Glut_StrokeChar ch101 = {104.762f,1,ch101st};
+
+/* char: 0x66 */
+
+static const Fl_Glut_StrokeVertex ch102st0[] =
+{
+ {71.4286f,100.0f},
+ {61.9048f,100.0f},
+ {52.381f,95.2381f},
+ {47.6191f,80.9524f},
+ {47.6191f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch102st1[] =
+{
+ {33.3334f,66.6667f},
+ {66.6667f,66.6667f}
+};
+
+static const Fl_Glut_StrokeStrip ch102st[] =
+{
+ {5,ch102st0},
+ {2,ch102st1}
+};
+
+static const Fl_Glut_StrokeChar ch102 = {104.762f,2,ch102st};
+
+/* char: 0x67 */
+
+static const Fl_Glut_StrokeVertex ch103st0[] =
+{
+ {80.9524f,66.6667f},
+ {80.9524f,-9.5238f},
+ {76.1905f,-23.8095f},
+ {71.4285f,-28.5714f},
+ {61.9047f,-33.3333f},
+ {47.619f,-33.3333f},
+ {38.0952f,-28.5714f}
+};
+
+static const Fl_Glut_StrokeVertex ch103st1[] =
+{
+ {80.9524f,52.381f},
+ {71.4285f,61.9048f},
+ {61.9047f,66.6667f},
+ {47.619f,66.6667f},
+ {38.0952f,61.9048f},
+ {28.5714f,52.381f},
+ {23.8095f,38.0952f},
+ {23.8095f,28.5714f},
+ {28.5714f,14.2857f},
+ {38.0952f,4.7619f},
+ {47.619f,0.0f},
+ {61.9047f,0.0f},
+ {71.4285f,4.7619f},
+ {80.9524f,14.2857f}
+};
+
+static const Fl_Glut_StrokeStrip ch103st[] =
+{
+ {7,ch103st0},
+ {14,ch103st1}
+};
+
+static const Fl_Glut_StrokeChar ch103 = {104.762f,2,ch103st};
+
+/* char: 0x68 */
+
+static const Fl_Glut_StrokeVertex ch104st0[] =
+{
+ {26.1905f,100.0f},
+ {26.1905f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch104st1[] =
+{
+ {26.1905f,47.619f},
+ {40.4762f,61.9048f},
+ {50.0f,66.6667f},
+ {64.2857f,66.6667f},
+ {73.8095f,61.9048f},
+ {78.5715f,47.619f},
+ {78.5715f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch104st[] =
+{
+ {2,ch104st0},
+ {7,ch104st1}
+};
+
+static const Fl_Glut_StrokeChar ch104 = {104.762f,2,ch104st};
+
+/* char: 0x69 */
+
+static const Fl_Glut_StrokeVertex ch105st0[] =
+{
+ {47.6191f,100.0f},
+ {52.381f,95.2381f},
+ {57.1429f,100.0f},
+ {52.381f,104.762f},
+ {47.6191f,100.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch105st1[] =
+{
+ {52.381f,66.6667f},
+ {52.381f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch105st[] =
+{
+ {5,ch105st0},
+ {2,ch105st1}
+};
+
+static const Fl_Glut_StrokeChar ch105 = {104.762f,2,ch105st};
+
+/* char: 0x6a */
+
+static const Fl_Glut_StrokeVertex ch106st0[] =
+{
+ {57.1429f,100.0f},
+ {61.9048f,95.2381f},
+ {66.6667f,100.0f},
+ {61.9048f,104.762f},
+ {57.1429f,100.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch106st1[] =
+{
+ {61.9048f,66.6667f},
+ {61.9048f,-14.2857f},
+ {57.1429f,-28.5714f},
+ {47.6191f,-33.3333f},
+ {38.0953f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeStrip ch106st[] =
+{
+ {5,ch106st0},
+ {5,ch106st1}
+};
+
+static const Fl_Glut_StrokeChar ch106 = {104.762f,2,ch106st};
+
+/* char: 0x6b */
+
+static const Fl_Glut_StrokeVertex ch107st0[] =
+{
+ {26.1905f,100.0f},
+ {26.1905f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch107st1[] =
+{
+ {73.8095f,66.6667f},
+ {26.1905f,19.0476f}
+};
+
+static const Fl_Glut_StrokeVertex ch107st2[] =
+{
+ {45.2381f,38.0952f},
+ {78.5715f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch107st[] =
+{
+ {2,ch107st0},
+ {2,ch107st1},
+ {2,ch107st2}
+};
+
+static const Fl_Glut_StrokeChar ch107 = {104.762f,3,ch107st};
+
+/* char: 0x6c */
+
+static const Fl_Glut_StrokeVertex ch108st0[] =
+{
+ {52.381f,100.0f},
+ {52.381f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch108st[] =
+{
+ {2,ch108st0}
+};
+
+static const Fl_Glut_StrokeChar ch108 = {104.762f,1,ch108st};
+
+/* char: 0x6d */
+
+static const Fl_Glut_StrokeVertex ch109st0[] =
+{
+ {0,66.6667f},
+ {0,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch109st1[] =
+{
+ {0,47.619f},
+ {14.2857f,61.9048f},
+ {23.8095f,66.6667f},
+ {38.0952f,66.6667f},
+ {47.619f,61.9048f},
+ {52.381f,47.619f},
+ {52.381f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch109st2[] =
+{
+ {52.381f,47.619f},
+ {66.6667f,61.9048f},
+ {76.1905f,66.6667f},
+ {90.4762f,66.6667f},
+ {100.0f,61.9048f},
+ {104.762f,47.619f},
+ {104.762f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch109st[] =
+{
+ {2,ch109st0},
+ {7,ch109st1},
+ {7,ch109st2}
+};
+
+static const Fl_Glut_StrokeChar ch109 = {104.762f,3,ch109st};
+
+/* char: 0x6e */
+
+static const Fl_Glut_StrokeVertex ch110st0[] =
+{
+ {26.1905f,66.6667f},
+ {26.1905f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch110st1[] =
+{
+ {26.1905f,47.619f},
+ {40.4762f,61.9048f},
+ {50.0f,66.6667f},
+ {64.2857f,66.6667f},
+ {73.8095f,61.9048f},
+ {78.5715f,47.619f},
+ {78.5715f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch110st[] =
+{
+ {2,ch110st0},
+ {7,ch110st1}
+};
+
+static const Fl_Glut_StrokeChar ch110 = {104.762f,2,ch110st};
+
+/* char: 0x6f */
+
+static const Fl_Glut_StrokeVertex ch111st0[] =
+{
+ {45.2381f,66.6667f},
+ {35.7143f,61.9048f},
+ {26.1905f,52.381f},
+ {21.4286f,38.0952f},
+ {21.4286f,28.5714f},
+ {26.1905f,14.2857f},
+ {35.7143f,4.7619f},
+ {45.2381f,0.0f},
+ {59.5238f,0.0f},
+ {69.0476f,4.7619f},
+ {78.5714f,14.2857f},
+ {83.3334f,28.5714f},
+ {83.3334f,38.0952f},
+ {78.5714f,52.381f},
+ {69.0476f,61.9048f},
+ {59.5238f,66.6667f},
+ {45.2381f,66.6667f}
+};
+
+static const Fl_Glut_StrokeStrip ch111st[] =
+{
+ {17,ch111st0}
+};
+
+static const Fl_Glut_StrokeChar ch111 = {104.762f,1,ch111st};
+
+/* char: 0x70 */
+
+static const Fl_Glut_StrokeVertex ch112st0[] =
+{
+ {23.8095f,66.6667f},
+ {23.8095f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeVertex ch112st1[] =
+{
+ {23.8095f,52.381f},
+ {33.3333f,61.9048f},
+ {42.8571f,66.6667f},
+ {57.1428f,66.6667f},
+ {66.6666f,61.9048f},
+ {76.1905f,52.381f},
+ {80.9524f,38.0952f},
+ {80.9524f,28.5714f},
+ {76.1905f,14.2857f},
+ {66.6666f,4.7619f},
+ {57.1428f,0.0f},
+ {42.8571f,0.0f},
+ {33.3333f,4.7619f},
+ {23.8095f,14.2857f}
+};
+
+static const Fl_Glut_StrokeStrip ch112st[] =
+{
+ {2,ch112st0},
+ {14,ch112st1}
+};
+
+static const Fl_Glut_StrokeChar ch112 = {104.762f,2,ch112st};
+
+/* char: 0x71 */
+
+static const Fl_Glut_StrokeVertex ch113st0[] =
+{
+ {80.9524f,66.6667f},
+ {80.9524f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeVertex ch113st1[] =
+{
+ {80.9524f,52.381f},
+ {71.4285f,61.9048f},
+ {61.9047f,66.6667f},
+ {47.619f,66.6667f},
+ {38.0952f,61.9048f},
+ {28.5714f,52.381f},
+ {23.8095f,38.0952f},
+ {23.8095f,28.5714f},
+ {28.5714f,14.2857f},
+ {38.0952f,4.7619f},
+ {47.619f,0.0f},
+ {61.9047f,0.0f},
+ {71.4285f,4.7619f},
+ {80.9524f,14.2857f}
+};
+
+static const Fl_Glut_StrokeStrip ch113st[] =
+{
+ {2,ch113st0},
+ {14,ch113st1}
+};
+
+static const Fl_Glut_StrokeChar ch113 = {104.762f,2,ch113st};
+
+/* char: 0x72 */
+
+static const Fl_Glut_StrokeVertex ch114st0[] =
+{
+ {33.3334f,66.6667f},
+ {33.3334f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch114st1[] =
+{
+ {33.3334f,38.0952f},
+ {38.0953f,52.381f},
+ {47.6191f,61.9048f},
+ {57.1429f,66.6667f},
+ {71.4286f,66.6667f}
+};
+
+static const Fl_Glut_StrokeStrip ch114st[] =
+{
+ {2,ch114st0},
+ {5,ch114st1}
+};
+
+static const Fl_Glut_StrokeChar ch114 = {104.762f,2,ch114st};
+
+/* char: 0x73 */
+
+static const Fl_Glut_StrokeVertex ch115st0[] =
+{
+ {78.5715f,52.381f},
+ {73.8095f,61.9048f},
+ {59.5238f,66.6667f},
+ {45.2381f,66.6667f},
+ {30.9524f,61.9048f},
+ {26.1905f,52.381f},
+ {30.9524f,42.8571f},
+ {40.4762f,38.0952f},
+ {64.2857f,33.3333f},
+ {73.8095f,28.5714f},
+ {78.5715f,19.0476f},
+ {78.5715f,14.2857f},
+ {73.8095f,4.7619f},
+ {59.5238f,0.0f},
+ {45.2381f,0.0f},
+ {30.9524f,4.7619f},
+ {26.1905f,14.2857f}
+};
+
+static const Fl_Glut_StrokeStrip ch115st[] =
+{
+ {17,ch115st0}
+};
+
+static const Fl_Glut_StrokeChar ch115 = {104.762f,1,ch115st};
+
+/* char: 0x74 */
+
+static const Fl_Glut_StrokeVertex ch116st0[] =
+{
+ {47.6191f,100.0f},
+ {47.6191f,19.0476f},
+ {52.381f,4.7619f},
+ {61.9048f,0.0f},
+ {71.4286f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch116st1[] =
+{
+ {33.3334f,66.6667f},
+ {66.6667f,66.6667f}
+};
+
+static const Fl_Glut_StrokeStrip ch116st[] =
+{
+ {5,ch116st0},
+ {2,ch116st1}
+};
+
+static const Fl_Glut_StrokeChar ch116 = {104.762f,2,ch116st};
+
+/* char: 0x75 */
+
+static const Fl_Glut_StrokeVertex ch117st0[] =
+{
+ {26.1905f,66.6667f},
+ {26.1905f,19.0476f},
+ {30.9524f,4.7619f},
+ {40.4762f,0.0f},
+ {54.7619f,0.0f},
+ {64.2857f,4.7619f},
+ {78.5715f,19.0476f}
+};
+
+static const Fl_Glut_StrokeVertex ch117st1[] =
+{
+ {78.5715f,66.6667f},
+ {78.5715f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch117st[] =
+{
+ {7,ch117st0},
+ {2,ch117st1}
+};
+
+static const Fl_Glut_StrokeChar ch117 = {104.762f,2,ch117st};
+
+/* char: 0x76 */
+
+static const Fl_Glut_StrokeVertex ch118st0[] =
+{
+ {23.8095f,66.6667f},
+ {52.3809f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch118st1[] =
+{
+ {80.9524f,66.6667f},
+ {52.3809f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch118st[] =
+{
+ {2,ch118st0},
+ {2,ch118st1}
+};
+
+static const Fl_Glut_StrokeChar ch118 = {104.762f,2,ch118st};
+
+/* char: 0x77 */
+
+static const Fl_Glut_StrokeVertex ch119st0[] =
+{
+ {14.2857f,66.6667f},
+ {33.3333f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch119st1[] =
+{
+ {52.3809f,66.6667f},
+ {33.3333f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch119st2[] =
+{
+ {52.3809f,66.6667f},
+ {71.4286f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch119st3[] =
+{
+ {90.4762f,66.6667f},
+ {71.4286f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch119st[] =
+{
+ {2,ch119st0},
+ {2,ch119st1},
+ {2,ch119st2},
+ {2,ch119st3}
+};
+
+static const Fl_Glut_StrokeChar ch119 = {104.762f,4,ch119st};
+
+/* char: 0x78 */
+
+static const Fl_Glut_StrokeVertex ch120st0[] =
+{
+ {26.1905f,66.6667f},
+ {78.5715f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch120st1[] =
+{
+ {78.5715f,66.6667f},
+ {26.1905f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch120st[] =
+{
+ {2,ch120st0},
+ {2,ch120st1}
+};
+
+static const Fl_Glut_StrokeChar ch120 = {104.762f,2,ch120st};
+
+/* char: 0x79 */
+
+static const Fl_Glut_StrokeVertex ch121st0[] =
+{
+ {26.1905f,66.6667f},
+ {54.7619f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch121st1[] =
+{
+ {83.3334f,66.6667f},
+ {54.7619f,0.0f},
+ {45.2381f,-19.0476f},
+ {35.7143f,-28.5714f},
+ {26.1905f,-33.3333f},
+ {21.4286f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeStrip ch121st[] =
+{
+ {2,ch121st0},
+ {6,ch121st1}
+};
+
+static const Fl_Glut_StrokeChar ch121 = {104.762f,2,ch121st};
+
+/* char: 0x7a */
+
+static const Fl_Glut_StrokeVertex ch122st0[] =
+{
+ {78.5715f,66.6667f},
+ {26.1905f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch122st1[] =
+{
+ {26.1905f,66.6667f},
+ {78.5715f,66.6667f}
+};
+
+static const Fl_Glut_StrokeVertex ch122st2[] =
+{
+ {26.1905f,0.0f},
+ {78.5715f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch122st[] =
+{
+ {2,ch122st0},
+ {2,ch122st1},
+ {2,ch122st2}
+};
+
+static const Fl_Glut_StrokeChar ch122 = {104.762f,3,ch122st};
+
+/* char: 0x7b */
+
+static const Fl_Glut_StrokeVertex ch123st0[] =
+{
+ {64.2857f,119.048f},
+ {54.7619f,114.286f},
+ {50.0f,109.524f},
+ {45.2381f,100.0f},
+ {45.2381f,90.4762f},
+ {50.0f,80.9524f},
+ {54.7619f,76.1905f},
+ {59.5238f,66.6667f},
+ {59.5238f,57.1429f},
+ {50.0f,47.619f}
+};
+
+static const Fl_Glut_StrokeVertex ch123st1[] =
+{
+ {54.7619f,114.286f},
+ {50.0f,104.762f},
+ {50.0f,95.2381f},
+ {54.7619f,85.7143f},
+ {59.5238f,80.9524f},
+ {64.2857f,71.4286f},
+ {64.2857f,61.9048f},
+ {59.5238f,52.381f},
+ {40.4762f,42.8571f},
+ {59.5238f,33.3333f},
+ {64.2857f,23.8095f},
+ {64.2857f,14.2857f},
+ {59.5238f,4.7619f},
+ {54.7619f,0.0f},
+ {50.0f,-9.5238f},
+ {50.0f,-19.0476f},
+ {54.7619f,-28.5714f}
+};
+
+static const Fl_Glut_StrokeVertex ch123st2[] =
+{
+ {50.0f,38.0952f},
+ {59.5238f,28.5714f},
+ {59.5238f,19.0476f},
+ {54.7619f,9.5238f},
+ {50.0f,4.7619f},
+ {45.2381f,-4.7619f},
+ {45.2381f,-14.2857f},
+ {50.0f,-23.8095f},
+ {54.7619f,-28.5714f},
+ {64.2857f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeStrip ch123st[] =
+{
+ {10,ch123st0},
+ {17,ch123st1},
+ {10,ch123st2}
+};
+
+static const Fl_Glut_StrokeChar ch123 = {104.762f,3,ch123st};
+
+/* char: 0x7c */
+
+static const Fl_Glut_StrokeVertex ch124st0[] =
+{
+ {52.381f,119.048f},
+ {52.381f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeStrip ch124st[] =
+{
+ {2,ch124st0}
+};
+
+static const Fl_Glut_StrokeChar ch124 = {104.762f,1,ch124st};
+
+/* char: 0x7d */
+
+static const Fl_Glut_StrokeVertex ch125st0[] =
+{
+ {40.4762f,119.048f},
+ {50.0f,114.286f},
+ {54.7619f,109.524f},
+ {59.5238f,100.0f},
+ {59.5238f,90.4762f},
+ {54.7619f,80.9524f},
+ {50.0f,76.1905f},
+ {45.2381f,66.6667f},
+ {45.2381f,57.1429f},
+ {54.7619f,47.619f}
+};
+
+static const Fl_Glut_StrokeVertex ch125st1[] =
+{
+ {50.0f,114.286f},
+ {54.7619f,104.762f},
+ {54.7619f,95.2381f},
+ {50.0f,85.7143f},
+ {45.2381f,80.9524f},
+ {40.4762f,71.4286f},
+ {40.4762f,61.9048f},
+ {45.2381f,52.381f},
+ {64.2857f,42.8571f},
+ {45.2381f,33.3333f},
+ {40.4762f,23.8095f},
+ {40.4762f,14.2857f},
+ {45.2381f,4.7619f},
+ {50.0f,0.0f},
+ {54.7619f,-9.5238f},
+ {54.7619f,-19.0476f},
+ {50.0f,-28.5714f}
+};
+
+static const Fl_Glut_StrokeVertex ch125st2[] =
+{
+ {54.7619f,38.0952f},
+ {45.2381f,28.5714f},
+ {45.2381f,19.0476f},
+ {50.0f,9.5238f},
+ {54.7619f,4.7619f},
+ {59.5238f,-4.7619f},
+ {59.5238f,-14.2857f},
+ {54.7619f,-23.8095f},
+ {50.0f,-28.5714f},
+ {40.4762f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeStrip ch125st[] =
+{
+ {10,ch125st0},
+ {17,ch125st1},
+ {10,ch125st2}
+};
+
+static const Fl_Glut_StrokeChar ch125 = {104.762f,3,ch125st};
+
+/* char: 0x7e */
+
+static const Fl_Glut_StrokeVertex ch126st0[] =
+{
+ {9.5238f,28.5714f},
+ {9.5238f,38.0952f},
+ {14.2857f,52.381f},
+ {23.8095f,57.1429f},
+ {33.3333f,57.1429f},
+ {42.8571f,52.381f},
+ {61.9048f,38.0952f},
+ {71.4286f,33.3333f},
+ {80.9524f,33.3333f},
+ {90.4762f,38.0952f},
+ {95.2381f,47.619f}
+};
+
+static const Fl_Glut_StrokeVertex ch126st1[] =
+{
+ {9.5238f,38.0952f},
+ {14.2857f,47.619f},
+ {23.8095f,52.381f},
+ {33.3333f,52.381f},
+ {42.8571f,47.619f},
+ {61.9048f,33.3333f},
+ {71.4286f,28.5714f},
+ {80.9524f,28.5714f},
+ {90.4762f,33.3333f},
+ {95.2381f,47.619f},
+ {95.2381f,57.1429f}
+};
+
+static const Fl_Glut_StrokeStrip ch126st[] =
+{
+ {11,ch126st0},
+ {11,ch126st1}
+};
+
+static const Fl_Glut_StrokeChar ch126 = {104.762f,2,ch126st};
+
+/* char: 0x7f */
+
+static const Fl_Glut_StrokeVertex ch127st0[] =
+{
+ {71.4286f,100.0f},
+ {33.3333f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeVertex ch127st1[] =
+{
+ {47.619f,66.6667f},
+ {33.3333f,61.9048f},
+ {23.8095f,52.381f},
+ {19.0476f,38.0952f},
+ {19.0476f,23.8095f},
+ {23.8095f,14.2857f},
+ {33.3333f,4.7619f},
+ {47.619f,0.0f},
+ {57.1428f,0.0f},
+ {71.4286f,4.7619f},
+ {80.9524f,14.2857f},
+ {85.7143f,28.5714f},
+ {85.7143f,42.8571f},
+ {80.9524f,52.381f},
+ {71.4286f,61.9048f},
+ {57.1428f,66.6667f},
+ {47.619f,66.6667f}
+};
+
+static const Fl_Glut_StrokeStrip ch127st[] =
+{
+ {2,ch127st0},
+ {17,ch127st1}
+};
+
+static const Fl_Glut_StrokeChar ch127 = {104.762f,2,ch127st};
+
+static const Fl_Glut_StrokeChar *chars[] =
+{
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ &ch32, &ch33, &ch34, &ch35, &ch36, &ch37, &ch38, &ch39,
+ &ch40, &ch41, &ch42, &ch43, &ch44, &ch45, &ch46, &ch47,
+ &ch48, &ch49, &ch50, &ch51, &ch52, &ch53, &ch54, &ch55,
+ &ch56, &ch57, &ch58, &ch59, &ch60, &ch61, &ch62, &ch63,
+ &ch64, &ch65, &ch66, &ch67, &ch68, &ch69, &ch70, &ch71,
+ &ch72, &ch73, &ch74, &ch75, &ch76, &ch77, &ch78, &ch79,
+ &ch80, &ch81, &ch82, &ch83, &ch84, &ch85, &ch86, &ch87,
+ &ch88, &ch89, &ch90, &ch91, &ch92, &ch93, &ch94, &ch95,
+ &ch96, &ch97, &ch98, &ch99, &ch100, &ch101, &ch102, &ch103,
+ &ch104, &ch105, &ch106, &ch107, &ch108, &ch109, &ch110, &ch111,
+ &ch112, &ch113, &ch114, &ch115, &ch116, &ch117, &ch118, &ch119,
+ &ch120, &ch121, &ch122, &ch123, &ch124, &ch125, &ch126, &ch127
+};
+
+Fl_Glut_StrokeFont glutStrokeMonoRoman = {(char *)"MonoRoman",128,152.381f,chars};
Copied: branches/branch-3.0/src/fltk3gl/freeglut_stroke_roman.cxx (from rev 9002, branches/branch-3.0/src/core/freeglut_stroke_roman.cxx)
===================================================================
--- branches/branch-3.0/src/fltk3gl/freeglut_stroke_roman.cxx (rev 0)
+++ branches/branch-3.0/src/fltk3gl/freeglut_stroke_roman.cxx 2011-08-25 10:51:10 UTC (rev 9008)
@@ -0,0 +1,2848 @@
+/*
+ * freeglut_stroke_roman.c
+ *
+ * freeglut Roman stroke font definition
+ *
+ * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.
+ * Written by Pawel W. Olszta, <olszta@sourceforge.net>
+ * Creation date: Thu Dec 16 1999
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+/* This file has been automatically generated by the genstroke utility. */
+
+#include <fltk3/glut.h>
+
+/* char: 0x20 */
+
+static const Fl_Glut_StrokeStrip ch32st[] =
+{
+ { 0, 0 }
+};
+
+static const Fl_Glut_StrokeChar ch32 = {104.762f,0,ch32st};
+
+/* char: 0x21 */
+
+static const Fl_Glut_StrokeVertex ch33st0[] =
+{
+ {13.3819f,100.0f},
+ {13.3819f,33.3333f}
+};
+
+static const Fl_Glut_StrokeVertex ch33st1[] =
+{
+ {13.3819f,9.5238f},
+ {8.62f,4.7619f},
+ {13.3819f,0.0f},
+ {18.1438f,4.7619f},
+ {13.3819f,9.5238f}
+};
+
+static const Fl_Glut_StrokeStrip ch33st[] =
+{
+ {2,ch33st0},
+ {5,ch33st1}
+};
+
+static const Fl_Glut_StrokeChar ch33 = {26.6238f,2,ch33st};
+
+/* char: 0x22 */
+
+static const Fl_Glut_StrokeVertex ch34st0[] =
+{
+ {4.02f,100.0f},
+ {4.02f,66.6667f}
+};
+
+static const Fl_Glut_StrokeVertex ch34st1[] =
+{
+ {42.1152f,100.0f},
+ {42.1152f,66.6667f}
+};
+
+static const Fl_Glut_StrokeStrip ch34st[] =
+{
+ {2,ch34st0},
+ {2,ch34st1}
+};
+
+static const Fl_Glut_StrokeChar ch34 = {51.4352f,2,ch34st};
+
+/* char: 0x23 */
+
+static const Fl_Glut_StrokeVertex ch35st0[] =
+{
+ {41.2952f,119.048f},
+ {7.9619f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeVertex ch35st1[] =
+{
+ {69.8667f,119.048f},
+ {36.5333f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeVertex ch35st2[] =
+{
+ {7.9619f,57.1429f},
+ {74.6286f,57.1429f}
+};
+
+static const Fl_Glut_StrokeVertex ch35st3[] =
+{
+ {3.2f,28.5714f},
+ {69.8667f,28.5714f}
+};
+
+static const Fl_Glut_StrokeStrip ch35st[] =
+{
+ {2,ch35st0},
+ {2,ch35st1},
+ {2,ch35st2},
+ {2,ch35st3}
+};
+
+static const Fl_Glut_StrokeChar ch35 = {79.4886f,4,ch35st};
+
+/* char: 0x24 */
+
+static const Fl_Glut_StrokeVertex ch36st0[] =
+{
+ {28.6295f,119.048f},
+ {28.6295f,-19.0476f}
+};
+
+static const Fl_Glut_StrokeVertex ch36st1[] =
+{
+ {47.6771f,119.048f},
+ {47.6771f,-19.0476f}
+};
+
+static const Fl_Glut_StrokeVertex ch36st2[] =
+{
+ {71.4867f,85.7143f},
+ {61.9629f,95.2381f},
+ {47.6771f,100.0f},
+ {28.6295f,100.0f},
+ {14.3438f,95.2381f},
+ {4.82f,85.7143f},
+ {4.82f,76.1905f},
+ {9.5819f,66.6667f},
+ {14.3438f,61.9048f},
+ {23.8676f,57.1429f},
+ {52.439f,47.619f},
+ {61.9629f,42.8571f},
+ {66.7248f,38.0952f},
+ {71.4867f,28.5714f},
+ {71.4867f,14.2857f},
+ {61.9629f,4.7619f},
+ {47.6771f,0.0f},
+ {28.6295f,0.0f},
+ {14.3438f,4.7619f},
+ {4.82f,14.2857f}
+};
+
+static const Fl_Glut_StrokeStrip ch36st[] =
+{
+ {2,ch36st0},
+ {2,ch36st1},
+ {20,ch36st2}
+};
+
+static const Fl_Glut_StrokeChar ch36 = {76.2067f,3,ch36st};
+
+/* char: 0x25 */
+
+static const Fl_Glut_StrokeVertex ch37st0[] =
+{
+ {92.0743f,100.0f},
+ {6.36f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch37st1[] =
+{
+ {30.1695f,100.0f},
+ {39.6933f,90.4762f},
+ {39.6933f,80.9524f},
+ {34.9314f,71.4286f},
+ {25.4076f,66.6667f},
+ {15.8838f,66.6667f},
+ {6.36f,76.1905f},
+ {6.36f,85.7143f},
+ {11.1219f,95.2381f},
+ {20.6457f,100.0f},
+ {30.1695f,100.0f},
+ {39.6933f,95.2381f},
+ {53.979f,90.4762f},
+ {68.2648f,90.4762f},
+ {82.5505f,95.2381f},
+ {92.0743f,100.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch37st2[] =
+{
+ {73.0267f,33.3333f},
+ {63.5029f,28.5714f},
+ {58.741f,19.0476f},
+ {58.741f,9.5238f},
+ {68.2648f,0.0f},
+ {77.7886f,0.0f},
+ {87.3124f,4.7619f},
+ {92.0743f,14.2857f},
+ {92.0743f,23.8095f},
+ {82.5505f,33.3333f},
+ {73.0267f,33.3333f}
+};
+
+static const Fl_Glut_StrokeStrip ch37st[] =
+{
+ {2,ch37st0},
+ {16,ch37st1},
+ {11,ch37st2}
+};
+
+static const Fl_Glut_StrokeChar ch37 = {96.5743f,3,ch37st};
+
+/* char: 0x26 */
+
+static const Fl_Glut_StrokeVertex ch38st0[] =
+{
+ {101.218f,57.1429f},
+ {101.218f,61.9048f},
+ {96.4562f,66.6667f},
+ {91.6943f,66.6667f},
+ {86.9324f,61.9048f},
+ {82.1705f,52.381f},
+ {72.6467f,28.5714f},
+ {63.1229f,14.2857f},
+ {53.599f,4.7619f},
+ {44.0752f,0.0f},
+ {25.0276f,0.0f},
+ {15.5038f,4.7619f},
+ {10.7419f,9.5238f},
+ {5.98f,19.0476f},
+ {5.98f,28.5714f},
+ {10.7419f,38.0952f},
+ {15.5038f,42.8571f},
+ {48.8371f,61.9048f},
+ {53.599f,66.6667f},
+ {58.361f,76.1905f},
+ {58.361f,85.7143f},
+ {53.599f,95.2381f},
+ {44.0752f,100.0f},
+ {34.5514f,95.2381f},
+ {29.7895f,85.7143f},
+ {29.7895f,76.1905f},
+ {34.5514f,61.9048f},
+ {44.0752f,47.619f},
+ {67.8848f,14.2857f},
+ {77.4086f,4.7619f},
+ {86.9324f,0.0f},
+ {96.4562f,0.0f},
+ {101.218f,4.7619f},
+ {101.218f,9.5238f}
+};
+
+static const Fl_Glut_StrokeStrip ch38st[] =
+{
+ {34,ch38st0}
+};
+
+static const Fl_Glut_StrokeChar ch38 = {101.758f,1,ch38st};
+
+/* char: 0x27 */
+
+static const Fl_Glut_StrokeVertex ch39st0[] =
+{
+ {4.44f,100.0f},
+ {4.44f,66.6667f}
+};
+
+static const Fl_Glut_StrokeStrip ch39st[] =
+{
+ {2,ch39st0}
+};
+
+static const Fl_Glut_StrokeChar ch39 = {13.62f,1,ch39st};
+
+/* char: 0x28 */
+
+static const Fl_Glut_StrokeVertex ch40st0[] =
+{
+ {40.9133f,119.048f},
+ {31.3895f,109.524f},
+ {21.8657f,95.2381f},
+ {12.3419f,76.1905f},
+ {7.58f,52.381f},
+ {7.58f,33.3333f},
+ {12.3419f,9.5238f},
+ {21.8657f,-9.5238f},
+ {31.3895f,-23.8095f},
+ {40.9133f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeStrip ch40st[] =
+{
+ {10,ch40st0}
+};
+
+static const Fl_Glut_StrokeChar ch40 = {47.1733f,1,ch40st};
+
+/* char: 0x29 */
+
+static const Fl_Glut_StrokeVertex ch41st0[] =
+{
+ {5.28f,119.048f},
+ {14.8038f,109.524f},
+ {24.3276f,95.2381f},
+ {33.8514f,76.1905f},
+ {38.6133f,52.381f},
+ {38.6133f,33.3333f},
+ {33.8514f,9.5238f},
+ {24.3276f,-9.5238f},
+ {14.8038f,-23.8095f},
+ {5.28f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeStrip ch41st[] =
+{
+ {10,ch41st0}
+};
+
+static const Fl_Glut_StrokeChar ch41 = {47.5333f,1,ch41st};
+
+/* char: 0x2a */
+
+static const Fl_Glut_StrokeVertex ch42st0[] =
+{
+ {30.7695f,71.4286f},
+ {30.7695f,14.2857f}
+};
+
+static const Fl_Glut_StrokeVertex ch42st1[] =
+{
+ {6.96f,57.1429f},
+ {54.579f,28.5714f}
+};
+
+static const Fl_Glut_StrokeVertex ch42st2[] =
+{
+ {54.579f,57.1429f},
+ {6.96f,28.5714f}
+};
+
+static const Fl_Glut_StrokeStrip ch42st[] =
+{
+ {2,ch42st0},
+ {2,ch42st1},
+ {2,ch42st2}
+};
+
+static const Fl_Glut_StrokeChar ch42 = {59.439f,3,ch42st};
+
+/* char: 0x2b */
+
+static const Fl_Glut_StrokeVertex ch43st0[] =
+{
+ {48.8371f,85.7143f},
+ {48.8371f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch43st1[] =
+{
+ {5.98f,42.8571f},
+ {91.6943f,42.8571f}
+};
+
+static const Fl_Glut_StrokeStrip ch43st[] =
+{
+ {2,ch43st0},
+ {2,ch43st1}
+};
+
+static const Fl_Glut_StrokeChar ch43 = {97.2543f,2,ch43st};
+
+/* char: 0x2c */
+
+static const Fl_Glut_StrokeVertex ch44st0[] =
+{
+ {18.2838f,4.7619f},
+ {13.5219f,0.0f},
+ {8.76f,4.7619f},
+ {13.5219f,9.5238f},
+ {18.2838f,4.7619f},
+ {18.2838f,-4.7619f},
+ {13.5219f,-14.2857f},
+ {8.76f,-19.0476f}
+};
+
+static const Fl_Glut_StrokeStrip ch44st[] =
+{
+ {8,ch44st0}
+};
+
+static const Fl_Glut_StrokeChar ch44 = {26.0638f,1,ch44st};
+
+/* char: 0x2d */
+
+static const Fl_Glut_StrokeVertex ch45st0[] =
+{
+ {7.38f,42.8571f},
+ {93.0943f,42.8571f}
+};
+
+static const Fl_Glut_StrokeStrip ch45st[] =
+{
+ {2,ch45st0}
+};
+
+static const Fl_Glut_StrokeChar ch45 = {100.754f,1,ch45st};
+
+/* char: 0x2e */
+
+static const Fl_Glut_StrokeVertex ch46st0[] =
+{
+ {13.1019f,9.5238f},
+ {8.34f,4.7619f},
+ {13.1019f,0.0f},
+ {17.8638f,4.7619f},
+ {13.1019f,9.5238f}
+};
+
+static const Fl_Glut_StrokeStrip ch46st[] =
+{
+ {5,ch46st0}
+};
+
+static const Fl_Glut_StrokeChar ch46 = {26.4838f,1,ch46st};
+
+/* char: 0x2f */
+
+static const Fl_Glut_StrokeVertex ch47st0[] =
+{
+ {7.24f,-14.2857f},
+ {73.9067f,100.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch47st[] =
+{
+ {2,ch47st0}
+};
+
+static const Fl_Glut_StrokeChar ch47 = {82.1067f,1,ch47st};
+
+/* char: 0x30 */
+
+static const Fl_Glut_StrokeVertex ch48st0[] =
+{
+ {33.5514f,100.0f},
+ {19.2657f,95.2381f},
+ {9.7419f,80.9524f},
+ {4.98f,57.1429f},
+ {4.98f,42.8571f},
+ {9.7419f,19.0476f},
+ {19.2657f,4.7619f},
+ {33.5514f,0.0f},
+ {43.0752f,0.0f},
+ {57.361f,4.7619f},
+ {66.8848f,19.0476f},
+ {71.6467f,42.8571f},
+ {71.6467f,57.1429f},
+ {66.8848f,80.9524f},
+ {57.361f,95.2381f},
+ {43.0752f,100.0f},
+ {33.5514f,100.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch48st[] =
+{
+ {17,ch48st0}
+};
+
+static const Fl_Glut_StrokeChar ch48 = {77.0667f,1,ch48st};
+
+/* char: 0x31 */
+
+static const Fl_Glut_StrokeVertex ch49st0[] =
+{
+ {11.82f,80.9524f},
+ {21.3438f,85.7143f},
+ {35.6295f,100.0f},
+ {35.6295f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch49st[] =
+{
+ {4,ch49st0}
+};
+
+static const Fl_Glut_StrokeChar ch49 = {66.5295f,1,ch49st};
+
+/* char: 0x32 */
+
+static const Fl_Glut_StrokeVertex ch50st0[] =
+{
+ {10.1819f,76.1905f},
+ {10.1819f,80.9524f},
+ {14.9438f,90.4762f},
+ {19.7057f,95.2381f},
+ {29.2295f,100.0f},
+ {48.2771f,100.0f},
+ {57.801f,95.2381f},
+ {62.5629f,90.4762f},
+ {67.3248f,80.9524f},
+ {67.3248f,71.4286f},
+ {62.5629f,61.9048f},
+ {53.039f,47.619f},
+ {5.42f,0.0f},
+ {72.0867f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch50st[] =
+{
+ {14,ch50st0}
+};
+
+static const Fl_Glut_StrokeChar ch50 = {77.6467f,1,ch50st};
+
+/* char: 0x33 */
+
+static const Fl_Glut_StrokeVertex ch51st0[] =
+{
+ {14.5238f,100.0f},
+ {66.9048f,100.0f},
+ {38.3333f,61.9048f},
+ {52.619f,61.9048f},
+ {62.1429f,57.1429f},
+ {66.9048f,52.381f},
+ {71.6667f,38.0952f},
+ {71.6667f,28.5714f},
+ {66.9048f,14.2857f},
+ {57.381f,4.7619f},
+ {43.0952f,0.0f},
+ {28.8095f,0.0f},
+ {14.5238f,4.7619f},
+ {9.7619f,9.5238f},
+ {5.0f,19.0476f}
+};
+
+static const Fl_Glut_StrokeStrip ch51st[] =
+{
+ {15,ch51st0}
+};
+
+static const Fl_Glut_StrokeChar ch51 = {77.0467f,1,ch51st};
+
+/* char: 0x34 */
+
+static const Fl_Glut_StrokeVertex ch52st0[] =
+{
+ {51.499f,100.0f},
+ {3.88f,33.3333f},
+ {75.3086f,33.3333f}
+};
+
+static const Fl_Glut_StrokeVertex ch52st1[] =
+{
+ {51.499f,100.0f},
+ {51.499f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch52st[] =
+{
+ {3,ch52st0},
+ {2,ch52st1}
+};
+
+static const Fl_Glut_StrokeChar ch52 = {80.1686f,2,ch52st};
+
+/* char: 0x35 */
+
+static const Fl_Glut_StrokeVertex ch53st0[] =
+{
+ {62.0029f,100.0f},
+ {14.3838f,100.0f},
+ {9.6219f,57.1429f},
+ {14.3838f,61.9048f},
+ {28.6695f,66.6667f},
+ {42.9552f,66.6667f},
+ {57.241f,61.9048f},
+ {66.7648f,52.381f},
+ {71.5267f,38.0952f},
+ {71.5267f,28.5714f},
+ {66.7648f,14.2857f},
+ {57.241f,4.7619f},
+ {42.9552f,0.0f},
+ {28.6695f,0.0f},
+ {14.3838f,4.7619f},
+ {9.6219f,9.5238f},
+ {4.86f,19.0476f}
+};
+
+static const Fl_Glut_StrokeStrip ch53st[] =
+{
+ {17,ch53st0}
+};
+
+static const Fl_Glut_StrokeChar ch53 = {77.6867f,1,ch53st};
+
+/* char: 0x36 */
+
+static const Fl_Glut_StrokeVertex ch54st0[] =
+{
+ {62.7229f,85.7143f},
+ {57.961f,95.2381f},
+ {43.6752f,100.0f},
+ {34.1514f,100.0f},
+ {19.8657f,95.2381f},
+ {10.3419f,80.9524f},
+ {5.58f,57.1429f},
+ {5.58f,33.3333f},
+ {10.3419f,14.2857f},
+ {19.8657f,4.7619f},
+ {34.1514f,0.0f},
+ {38.9133f,0.0f},
+ {53.199f,4.7619f},
+ {62.7229f,14.2857f},
+ {67.4848f,28.5714f},
+ {67.4848f,33.3333f},
+ {62.7229f,47.619f},
+ {53.199f,57.1429f},
+ {38.9133f,61.9048f},
+ {34.1514f,61.9048f},
+ {19.8657f,57.1429f},
+ {10.3419f,47.619f},
+ {5.58f,33.3333f}
+};
+
+static const Fl_Glut_StrokeStrip ch54st[] =
+{
+ {23,ch54st0}
+};
+
+static const Fl_Glut_StrokeChar ch54 = {73.8048f,1,ch54st};
+
+/* char: 0x37 */
+
+static const Fl_Glut_StrokeVertex ch55st0[] =
+{
+ {72.2267f,100.0f},
+ {24.6076f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch55st1[] =
+{
+ {5.56f,100.0f},
+ {72.2267f,100.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch55st[] =
+{
+ {2,ch55st0},
+ {2,ch55st1}
+};
+
+static const Fl_Glut_StrokeChar ch55 = {77.2267f,2,ch55st};
+
+/* char: 0x38 */
+
+static const Fl_Glut_StrokeVertex ch56st0[] =
+{
+ {29.4095f,100.0f},
+ {15.1238f,95.2381f},
+ {10.3619f,85.7143f},
+ {10.3619f,76.1905f},
+ {15.1238f,66.6667f},
+ {24.6476f,61.9048f},
+ {43.6952f,57.1429f},
+ {57.981f,52.381f},
+ {67.5048f,42.8571f},
+ {72.2667f,33.3333f},
+ {72.2667f,19.0476f},
+ {67.5048f,9.5238f},
+ {62.7429f,4.7619f},
+ {48.4571f,0.0f},
+ {29.4095f,0.0f},
+ {15.1238f,4.7619f},
+ {10.3619f,9.5238f},
+ {5.6f,19.0476f},
+ {5.6f,33.3333f},
+ {10.3619f,42.8571f},
+ {19.8857f,52.381f},
+ {34.1714f,57.1429f},
+ {53.219f,61.9048f},
+ {62.7429f,66.6667f},
+ {67.5048f,76.1905f},
+ {67.5048f,85.7143f},
+ {62.7429f,95.2381f},
+ {48.4571f,100.0f},
+ {29.4095f,100.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch56st[] =
+{
+ {29,ch56st0}
+};
+
+static const Fl_Glut_StrokeChar ch56 = {77.6667f,1,ch56st};
+
+/* char: 0x39 */
+
+static const Fl_Glut_StrokeVertex ch57st0[] =
+{
+ {68.5048f,66.6667f},
+ {63.7429f,52.381f},
+ {54.219f,42.8571f},
+ {39.9333f,38.0952f},
+ {35.1714f,38.0952f},
+ {20.8857f,42.8571f},
+ {11.3619f,52.381f},
+ {6.6f,66.6667f},
+ {6.6f,71.4286f},
+ {11.3619f,85.7143f},
+ {20.8857f,95.2381f},
+ {35.1714f,100.0f},
+ {39.9333f,100.0f},
+ {54.219f,95.2381f},
+ {63.7429f,85.7143f},
+ {68.5048f,66.6667f},
+ {68.5048f,42.8571f},
+ {63.7429f,19.0476f},
+ {54.219f,4.7619f},
+ {39.9333f,0.0f},
+ {30.4095f,0.0f},
+ {16.1238f,4.7619f},
+ {11.3619f,14.2857f}
+};
+
+static const Fl_Glut_StrokeStrip ch57st[] =
+{
+ {23,ch57st0}
+};
+
+static const Fl_Glut_StrokeChar ch57 = {74.0648f,1,ch57st};
+
+/* char: 0x3a */
+
+static const Fl_Glut_StrokeVertex ch58st0[] =
+{
+ {14.0819f,66.6667f},
+ {9.32f,61.9048f},
+ {14.0819f,57.1429f},
+ {18.8438f,61.9048f},
+ {14.0819f,66.6667f}
+};
+
+static const Fl_Glut_StrokeVertex ch58st1[] =
+{
+ {14.0819f,9.5238f},
+ {9.32f,4.7619f},
+ {14.0819f,0.0f},
+ {18.8438f,4.7619f},
+ {14.0819f,9.5238f}
+};
+
+static const Fl_Glut_StrokeStrip ch58st[] =
+{
+ {5,ch58st0},
+ {5,ch58st1}
+};
+
+static const Fl_Glut_StrokeChar ch58 = {26.2238f,2,ch58st};
+
+/* char: 0x3b */
+
+static const Fl_Glut_StrokeVertex ch59st0[] =
+{
+ {12.9619f,66.6667f},
+ {8.2f,61.9048f},
+ {12.9619f,57.1429f},
+ {17.7238f,61.9048f},
+ {12.9619f,66.6667f}
+};
+
+static const Fl_Glut_StrokeVertex ch59st1[] =
+{
+ {17.7238f,4.7619f},
+ {12.9619f,0.0f},
+ {8.2f,4.7619f},
+ {12.9619f,9.5238f},
+ {17.7238f,4.7619f},
+ {17.7238f,-4.7619f},
+ {12.9619f,-14.2857f},
+ {8.2f,-19.0476f}
+};
+
+static const Fl_Glut_StrokeStrip ch59st[] =
+{
+ {5,ch59st0},
+ {8,ch59st1}
+};
+
+static const Fl_Glut_StrokeChar ch59 = {26.3038f,2,ch59st};
+
+/* char: 0x3c */
+
+static const Fl_Glut_StrokeVertex ch60st0[] =
+{
+ {79.2505f,85.7143f},
+ {3.06f,42.8571f},
+ {79.2505f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch60st[] =
+{
+ {3,ch60st0}
+};
+
+static const Fl_Glut_StrokeChar ch60 = {81.6105f,1,ch60st};
+
+/* char: 0x3d */
+
+static const Fl_Glut_StrokeVertex ch61st0[] =
+{
+ {5.7f,57.1429f},
+ {91.4143f,57.1429f}
+};
+
+static const Fl_Glut_StrokeVertex ch61st1[] =
+{
+ {5.7f,28.5714f},
+ {91.4143f,28.5714f}
+};
+
+static const Fl_Glut_StrokeStrip ch61st[] =
+{
+ {2,ch61st0},
+ {2,ch61st1}
+};
+
+static const Fl_Glut_StrokeChar ch61 = {97.2543f,2,ch61st};
+
+/* char: 0x3e */
+
+static const Fl_Glut_StrokeVertex ch62st0[] =
+{
+ {2.78f,85.7143f},
+ {78.9705f,42.8571f},
+ {2.78f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch62st[] =
+{
+ {3,ch62st0}
+};
+
+static const Fl_Glut_StrokeChar ch62 = {81.6105f,1,ch62st};
+
+/* char: 0x3f */
+
+static const Fl_Glut_StrokeVertex ch63st0[] =
+{
+ {8.42f,76.1905f},
+ {8.42f,80.9524f},
+ {13.1819f,90.4762f},
+ {17.9438f,95.2381f},
+ {27.4676f,100.0f},
+ {46.5152f,100.0f},
+ {56.039f,95.2381f},
+ {60.801f,90.4762f},
+ {65.5629f,80.9524f},
+ {65.5629f,71.4286f},
+ {60.801f,61.9048f},
+ {56.039f,57.1429f},
+ {36.9914f,47.619f},
+ {36.9914f,33.3333f}
+};
+
+static const Fl_Glut_StrokeVertex ch63st1[] =
+{
+ {36.9914f,9.5238f},
+ {32.2295f,4.7619f},
+ {36.9914f,0.0f},
+ {41.7533f,4.7619f},
+ {36.9914f,9.5238f}
+};
+
+static const Fl_Glut_StrokeStrip ch63st[] =
+{
+ {14,ch63st0},
+ {5,ch63st1}
+};
+
+static const Fl_Glut_StrokeChar ch63 = {73.9029f,2,ch63st};
+
+/* char: 0x40 */
+
+static const Fl_Glut_StrokeVertex ch64st0[] =
+{
+ {49.2171f,52.381f},
+ {39.6933f,57.1429f},
+ {30.1695f,57.1429f},
+ {25.4076f,47.619f},
+ {25.4076f,42.8571f},
+ {30.1695f,33.3333f},
+ {39.6933f,33.3333f},
+ {49.2171f,38.0952f}
+};
+
+static const Fl_Glut_StrokeVertex ch64st1[] =
+{
+ {49.2171f,57.1429f},
+ {49.2171f,38.0952f},
+ {53.979f,33.3333f},
+ {63.5029f,33.3333f},
+ {68.2648f,42.8571f},
+ {68.2648f,47.619f},
+ {63.5029f,61.9048f},
+ {53.979f,71.4286f},
+ {39.6933f,76.1905f},
+ {34.9314f,76.1905f},
+ {20.6457f,71.4286f},
+ {11.1219f,61.9048f},
+ {6.36f,47.619f},
+ {6.36f,42.8571f},
+ {11.1219f,28.5714f},
+ {20.6457f,19.0476f},
+ {34.9314f,14.2857f},
+ {39.6933f,14.2857f},
+ {53.979f,19.0476f}
+};
+
+static const Fl_Glut_StrokeStrip ch64st[] =
+{
+ {8,ch64st0},
+ {19,ch64st1}
+};
+
+static const Fl_Glut_StrokeChar ch64 = {74.3648f,2,ch64st};
+
+/* char: 0x41 */
+
+static const Fl_Glut_StrokeVertex ch65st0[] =
+{
+ {40.5952f,100.0f},
+ {2.5f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch65st1[] =
+{
+ {40.5952f,100.0f},
+ {78.6905f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch65st2[] =
+{
+ {16.7857f,33.3333f},
+ {64.4048f,33.3333f}
+};
+
+static const Fl_Glut_StrokeStrip ch65st[] =
+{
+ {2,ch65st0},
+ {2,ch65st1},
+ {2,ch65st2}
+};
+
+static const Fl_Glut_StrokeChar ch65 = {80.4905f,3,ch65st};
+
+/* char: 0x42 */
+
+static const Fl_Glut_StrokeVertex ch66st0[] =
+{
+ {11.42f,100.0f},
+ {11.42f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch66st1[] =
+{
+ {11.42f,100.0f},
+ {54.2771f,100.0f},
+ {68.5629f,95.2381f},
+ {73.3248f,90.4762f},
+ {78.0867f,80.9524f},
+ {78.0867f,71.4286f},
+ {73.3248f,61.9048f},
+ {68.5629f,57.1429f},
+ {54.2771f,52.381f}
+};
+
+static const Fl_Glut_StrokeVertex ch66st2[] =
+{
+ {11.42f,52.381f},
+ {54.2771f,52.381f},
+ {68.5629f,47.619f},
+ {73.3248f,42.8571f},
+ {78.0867f,33.3333f},
+ {78.0867f,19.0476f},
+ {73.3248f,9.5238f},
+ {68.5629f,4.7619f},
+ {54.2771f,0.0f},
+ {11.42f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch66st[] =
+{
+ {2,ch66st0},
+ {9,ch66st1},
+ {10,ch66st2}
+};
+
+static const Fl_Glut_StrokeChar ch66 = {83.6267f,3,ch66st};
+
+/* char: 0x43 */
+
+static const Fl_Glut_StrokeVertex ch67st0[] =
+{
+ {78.0886f,76.1905f},
+ {73.3267f,85.7143f},
+ {63.8029f,95.2381f},
+ {54.279f,100.0f},
+ {35.2314f,100.0f},
+ {25.7076f,95.2381f},
+ {16.1838f,85.7143f},
+ {11.4219f,76.1905f},
+ {6.66f,61.9048f},
+ {6.66f,38.0952f},
+ {11.4219f,23.8095f},
+ {16.1838f,14.2857f},
+ {25.7076f,4.7619f},
+ {35.2314f,0.0f},
+ {54.279f,0.0f},
+ {63.8029f,4.7619f},
+ {73.3267f,14.2857f},
+ {78.0886f,23.8095f}
+};
+
+static const Fl_Glut_StrokeStrip ch67st[] =
+{
+ {18,ch67st0}
+};
+
+static const Fl_Glut_StrokeChar ch67 = {84.4886f,1,ch67st};
+
+/* char: 0x44 */
+
+static const Fl_Glut_StrokeVertex ch68st0[] =
+{
+ {11.96f,100.0f},
+ {11.96f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch68st1[] =
+{
+ {11.96f,100.0f},
+ {45.2933f,100.0f},
+ {59.579f,95.2381f},
+ {69.1029f,85.7143f},
+ {73.8648f,76.1905f},
+ {78.6267f,61.9048f},
+ {78.6267f,38.0952f},
+ {73.8648f,23.8095f},
+ {69.1029f,14.2857f},
+ {59.579f,4.7619f},
+ {45.2933f,0.0f},
+ {11.96f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch68st[] =
+{
+ {2,ch68st0},
+ {12,ch68st1}
+};
+
+static const Fl_Glut_StrokeChar ch68 = {85.2867f,2,ch68st};
+
+/* char: 0x45 */
+
+static const Fl_Glut_StrokeVertex ch69st0[] =
+{
+ {11.42f,100.0f},
+ {11.42f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch69st1[] =
+{
+ {11.42f,100.0f},
+ {73.3248f,100.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch69st2[] =
+{
+ {11.42f,52.381f},
+ {49.5152f,52.381f}
+};
+
+static const Fl_Glut_StrokeVertex ch69st3[] =
+{
+ {11.42f,0.0f},
+ {73.3248f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch69st[] =
+{
+ {2,ch69st0},
+ {2,ch69st1},
+ {2,ch69st2},
+ {2,ch69st3}
+};
+
+static const Fl_Glut_StrokeChar ch69 = {78.1848f,4,ch69st};
+
+/* char: 0x46 */
+
+static const Fl_Glut_StrokeVertex ch70st0[] =
+{
+ {11.42f,100.0f},
+ {11.42f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch70st1[] =
+{
+ {11.42f,100.0f},
+ {73.3248f,100.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch70st2[] =
+{
+ {11.42f,52.381f},
+ {49.5152f,52.381f}
+};
+
+static const Fl_Glut_StrokeStrip ch70st[] =
+{
+ {2,ch70st0},
+ {2,ch70st1},
+ {2,ch70st2}
+};
+
+static const Fl_Glut_StrokeChar ch70 = {78.7448f,3,ch70st};
+
+/* char: 0x47 */
+
+static const Fl_Glut_StrokeVertex ch71st0[] =
+{
+ {78.4886f,76.1905f},
+ {73.7267f,85.7143f},
+ {64.2029f,95.2381f},
+ {54.679f,100.0f},
+ {35.6314f,100.0f},
+ {26.1076f,95.2381f},
+ {16.5838f,85.7143f},
+ {11.8219f,76.1905f},
+ {7.06f,61.9048f},
+ {7.06f,38.0952f},
+ {11.8219f,23.8095f},
+ {16.5838f,14.2857f},
+ {26.1076f,4.7619f},
+ {35.6314f,0.0f},
+ {54.679f,0.0f},
+ {64.2029f,4.7619f},
+ {73.7267f,14.2857f},
+ {78.4886f,23.8095f},
+ {78.4886f,38.0952f}
+};
+
+static const Fl_Glut_StrokeVertex ch71st1[] =
+{
+ {54.679f,38.0952f},
+ {78.4886f,38.0952f}
+};
+
+static const Fl_Glut_StrokeStrip ch71st[] =
+{
+ {19,ch71st0},
+ {2,ch71st1}
+};
+
+static const Fl_Glut_StrokeChar ch71 = {89.7686f,2,ch71st};
+
+/* char: 0x48 */
+
+static const Fl_Glut_StrokeVertex ch72st0[] =
+{
+ {11.42f,100.0f},
+ {11.42f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch72st1[] =
+{
+ {78.0867f,100.0f},
+ {78.0867f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch72st2[] =
+{
+ {11.42f,52.381f},
+ {78.0867f,52.381f}
+};
+
+static const Fl_Glut_StrokeStrip ch72st[] =
+{
+ {2,ch72st0},
+ {2,ch72st1},
+ {2,ch72st2}
+};
+
+static const Fl_Glut_StrokeChar ch72 = {89.0867f,3,ch72st};
+
+/* char: 0x49 */
+
+static const Fl_Glut_StrokeVertex ch73st0[] =
+{
+ {10.86f,100.0f},
+ {10.86f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch73st[] =
+{
+ {2,ch73st0}
+};
+
+static const Fl_Glut_StrokeChar ch73 = {21.3f,1,ch73st};
+
+/* char: 0x4a */
+
+static const Fl_Glut_StrokeVertex ch74st0[] =
+{
+ {50.119f,100.0f},
+ {50.119f,23.8095f},
+ {45.3571f,9.5238f},
+ {40.5952f,4.7619f},
+ {31.0714f,0.0f},
+ {21.5476f,0.0f},
+ {12.0238f,4.7619f},
+ {7.2619f,9.5238f},
+ {2.5f,23.8095f},
+ {2.5f,33.3333f}
+};
+
+static const Fl_Glut_StrokeStrip ch74st[] =
+{
+ {10,ch74st0}
+};
+
+static const Fl_Glut_StrokeChar ch74 = {59.999f,1,ch74st};
+
+/* char: 0x4b */
+
+static const Fl_Glut_StrokeVertex ch75st0[] =
+{
+ {11.28f,100.0f},
+ {11.28f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch75st1[] =
+{
+ {77.9467f,100.0f},
+ {11.28f,33.3333f}
+};
+
+static const Fl_Glut_StrokeVertex ch75st2[] =
+{
+ {35.0895f,57.1429f},
+ {77.9467f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch75st[] =
+{
+ {2,ch75st0},
+ {2,ch75st1},
+ {2,ch75st2}
+};
+
+static const Fl_Glut_StrokeChar ch75 = {79.3267f,3,ch75st};
+
+/* char: 0x4c */
+
+static const Fl_Glut_StrokeVertex ch76st0[] =
+{
+ {11.68f,100.0f},
+ {11.68f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch76st1[] =
+{
+ {11.68f,0.0f},
+ {68.8229f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch76st[] =
+{
+ {2,ch76st0},
+ {2,ch76st1}
+};
+
+static const Fl_Glut_StrokeChar ch76 = {71.3229f,2,ch76st};
+
+/* char: 0x4d */
+
+static const Fl_Glut_StrokeVertex ch77st0[] =
+{
+ {10.86f,100.0f},
+ {10.86f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch77st1[] =
+{
+ {10.86f,100.0f},
+ {48.9552f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch77st2[] =
+{
+ {87.0505f,100.0f},
+ {48.9552f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch77st3[] =
+{
+ {87.0505f,100.0f},
+ {87.0505f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch77st[] =
+{
+ {2,ch77st0},
+ {2,ch77st1},
+ {2,ch77st2},
+ {2,ch77st3}
+};
+
+static const Fl_Glut_StrokeChar ch77 = {97.2105f,4,ch77st};
+
+/* char: 0x4e */
+
+static const Fl_Glut_StrokeVertex ch78st0[] =
+{
+ {11.14f,100.0f},
+ {11.14f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch78st1[] =
+{
+ {11.14f,100.0f},
+ {77.8067f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch78st2[] =
+{
+ {77.8067f,100.0f},
+ {77.8067f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch78st[] =
+{
+ {2,ch78st0},
+ {2,ch78st1},
+ {2,ch78st2}
+};
+
+static const Fl_Glut_StrokeChar ch78 = {88.8067f,3,ch78st};
+
+/* char: 0x4f */
+
+static const Fl_Glut_StrokeVertex ch79st0[] =
+{
+ {34.8114f,100.0f},
+ {25.2876f,95.2381f},
+ {15.7638f,85.7143f},
+ {11.0019f,76.1905f},
+ {6.24f,61.9048f},
+ {6.24f,38.0952f},
+ {11.0019f,23.8095f},
+ {15.7638f,14.2857f},
+ {25.2876f,4.7619f},
+ {34.8114f,0.0f},
+ {53.859f,0.0f},
+ {63.3829f,4.7619f},
+ {72.9067f,14.2857f},
+ {77.6686f,23.8095f},
+ {82.4305f,38.0952f},
+ {82.4305f,61.9048f},
+ {77.6686f,76.1905f},
+ {72.9067f,85.7143f},
+ {63.3829f,95.2381f},
+ {53.859f,100.0f},
+ {34.8114f,100.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch79st[] =
+{
+ {21,ch79st0}
+};
+
+static const Fl_Glut_StrokeChar ch79 = {88.8305f,1,ch79st};
+
+/* char: 0x50 */
+
+static const Fl_Glut_StrokeVertex ch80st0[] =
+{
+ {12.1f,100.0f},
+ {12.1f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch80st1[] =
+{
+ {12.1f,100.0f},
+ {54.9571f,100.0f},
+ {69.2429f,95.2381f},
+ {74.0048f,90.4762f},
+ {78.7667f,80.9524f},
+ {78.7667f,66.6667f},
+ {74.0048f,57.1429f},
+ {69.2429f,52.381f},
+ {54.9571f,47.619f},
+ {12.1f,47.619f}
+};
+
+static const Fl_Glut_StrokeStrip ch80st[] =
+{
+ {2,ch80st0},
+ {10,ch80st1}
+};
+
+static const Fl_Glut_StrokeChar ch80 = {85.6667f,2,ch80st};
+
+/* char: 0x51 */
+
+static const Fl_Glut_StrokeVertex ch81st0[] =
+{
+ {33.8714f,100.0f},
+ {24.3476f,95.2381f},
+ {14.8238f,85.7143f},
+ {10.0619f,76.1905f},
+ {5.3f,61.9048f},
+ {5.3f,38.0952f},
+ {10.0619f,23.8095f},
+ {14.8238f,14.2857f},
+ {24.3476f,4.7619f},
+ {33.8714f,0.0f},
+ {52.919f,0.0f},
+ {62.4429f,4.7619f},
+ {71.9667f,14.2857f},
+ {76.7286f,23.8095f},
+ {81.4905f,38.0952f},
+ {81.4905f,61.9048f},
+ {76.7286f,76.1905f},
+ {71.9667f,85.7143f},
+ {62.4429f,95.2381f},
+ {52.919f,100.0f},
+ {33.8714f,100.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch81st1[] =
+{
+ {48.1571f,19.0476f},
+ {76.7286f,-9.5238f}
+};
+
+static const Fl_Glut_StrokeStrip ch81st[] =
+{
+ {21,ch81st0},
+ {2,ch81st1}
+};
+
+static const Fl_Glut_StrokeChar ch81 = {88.0905f,2,ch81st};
+
+/* char: 0x52 */
+
+static const Fl_Glut_StrokeVertex ch82st0[] =
+{
+ {11.68f,100.0f},
+ {11.68f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch82st1[] =
+{
+ {11.68f,100.0f},
+ {54.5371f,100.0f},
+ {68.8229f,95.2381f},
+ {73.5848f,90.4762f},
+ {78.3467f,80.9524f},
+ {78.3467f,71.4286f},
+ {73.5848f,61.9048f},
+ {68.8229f,57.1429f},
+ {54.5371f,52.381f},
+ {11.68f,52.381f}
+};
+
+static const Fl_Glut_StrokeVertex ch82st2[] =
+{
+ {45.0133f,52.381f},
+ {78.3467f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch82st[] =
+{
+ {2,ch82st0},
+ {10,ch82st1},
+ {2,ch82st2}
+};
+
+static const Fl_Glut_StrokeChar ch82 = {82.3667f,3,ch82st};
+
+/* char: 0x53 */
+
+static const Fl_Glut_StrokeVertex ch83st0[] =
+{
+ {74.6667f,85.7143f},
+ {65.1429f,95.2381f},
+ {50.8571f,100.0f},
+ {31.8095f,100.0f},
+ {17.5238f,95.2381f},
+ {8.0f,85.7143f},
+ {8.0f,76.1905f},
+ {12.7619f,66.6667f},
+ {17.5238f,61.9048f},
+ {27.0476f,57.1429f},
+ {55.619f,47.619f},
+ {65.1429f,42.8571f},
+ {69.9048f,38.0952f},
+ {74.6667f,28.5714f},
+ {74.6667f,14.2857f},
+ {65.1429f,4.7619f},
+ {50.8571f,0.0f},
+ {31.8095f,0.0f},
+ {17.5238f,4.7619f},
+ {8.0f,14.2857f}
+};
+
+static const Fl_Glut_StrokeStrip ch83st[] =
+{
+ {20,ch83st0}
+};
+
+static const Fl_Glut_StrokeChar ch83 = {80.8267f,1,ch83st};
+
+/* char: 0x54 */
+
+static const Fl_Glut_StrokeVertex ch84st0[] =
+{
+ {35.6933f,100.0f},
+ {35.6933f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch84st1[] =
+{
+ {2.36f,100.0f},
+ {69.0267f,100.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch84st[] =
+{
+ {2,ch84st0},
+ {2,ch84st1}
+};
+
+static const Fl_Glut_StrokeChar ch84 = {71.9467f,2,ch84st};
+
+/* char: 0x55 */
+
+static const Fl_Glut_StrokeVertex ch85st0[] =
+{
+ {11.54f,100.0f},
+ {11.54f,28.5714f},
+ {16.3019f,14.2857f},
+ {25.8257f,4.7619f},
+ {40.1114f,0.0f},
+ {49.6352f,0.0f},
+ {63.921f,4.7619f},
+ {73.4448f,14.2857f},
+ {78.2067f,28.5714f},
+ {78.2067f,100.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch85st[] =
+{
+ {10,ch85st0}
+};
+
+static const Fl_Glut_StrokeChar ch85 = {89.4867f,1,ch85st};
+
+/* char: 0x56 */
+
+static const Fl_Glut_StrokeVertex ch86st0[] =
+{
+ {2.36f,100.0f},
+ {40.4552f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch86st1[] =
+{
+ {78.5505f,100.0f},
+ {40.4552f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch86st[] =
+{
+ {2,ch86st0},
+ {2,ch86st1}
+};
+
+static const Fl_Glut_StrokeChar ch86 = {81.6105f,2,ch86st};
+
+/* char: 0x57 */
+
+static const Fl_Glut_StrokeVertex ch87st0[] =
+{
+ {2.22f,100.0f},
+ {26.0295f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch87st1[] =
+{
+ {49.839f,100.0f},
+ {26.0295f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch87st2[] =
+{
+ {49.839f,100.0f},
+ {73.6486f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch87st3[] =
+{
+ {97.4581f,100.0f},
+ {73.6486f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch87st[] =
+{
+ {2,ch87st0},
+ {2,ch87st1},
+ {2,ch87st2},
+ {2,ch87st3}
+};
+
+static const Fl_Glut_StrokeChar ch87 = {100.518f,4,ch87st};
+
+/* char: 0x58 */
+
+static const Fl_Glut_StrokeVertex ch88st0[] =
+{
+ {2.5f,100.0f},
+ {69.1667f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch88st1[] =
+{
+ {69.1667f,100.0f},
+ {2.5f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch88st[] =
+{
+ {2,ch88st0},
+ {2,ch88st1}
+};
+
+static const Fl_Glut_StrokeChar ch88 = {72.3667f,2,ch88st};
+
+/* char: 0x59 */
+
+static const Fl_Glut_StrokeVertex ch89st0[] =
+{
+ {1.52f,100.0f},
+ {39.6152f,52.381f},
+ {39.6152f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch89st1[] =
+{
+ {77.7105f,100.0f},
+ {39.6152f,52.381f}
+};
+
+static const Fl_Glut_StrokeStrip ch89st[] =
+{
+ {3,ch89st0},
+ {2,ch89st1}
+};
+
+static const Fl_Glut_StrokeChar ch89 = {79.6505f,2,ch89st};
+
+/* char: 0x5a */
+
+static const Fl_Glut_StrokeVertex ch90st0[] =
+{
+ {69.1667f,100.0f},
+ {2.5f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch90st1[] =
+{
+ {2.5f,100.0f},
+ {69.1667f,100.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch90st2[] =
+{
+ {2.5f,0.0f},
+ {69.1667f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch90st[] =
+{
+ {2,ch90st0},
+ {2,ch90st1},
+ {2,ch90st2}
+};
+
+static const Fl_Glut_StrokeChar ch90 = {73.7467f,3,ch90st};
+
+/* char: 0x5b */
+
+static const Fl_Glut_StrokeVertex ch91st0[] =
+{
+ {7.78f,119.048f},
+ {7.78f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeVertex ch91st1[] =
+{
+ {12.5419f,119.048f},
+ {12.5419f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeVertex ch91st2[] =
+{
+ {7.78f,119.048f},
+ {41.1133f,119.048f}
+};
+
+static const Fl_Glut_StrokeVertex ch91st3[] =
+{
+ {7.78f,-33.3333f},
+ {41.1133f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeStrip ch91st[] =
+{
+ {2,ch91st0},
+ {2,ch91st1},
+ {2,ch91st2},
+ {2,ch91st3}
+};
+
+static const Fl_Glut_StrokeChar ch91 = {46.1133f,4,ch91st};
+
+/* char: 0x5c */
+
+static const Fl_Glut_StrokeVertex ch92st0[] =
+{
+ {5.84f,100.0f},
+ {72.5067f,-14.2857f}
+};
+
+static const Fl_Glut_StrokeStrip ch92st[] =
+{
+ {2,ch92st0}
+};
+
+static const Fl_Glut_StrokeChar ch92 = {78.2067f,1,ch92st};
+
+/* char: 0x5d */
+
+static const Fl_Glut_StrokeVertex ch93st0[] =
+{
+ {33.0114f,119.048f},
+ {33.0114f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeVertex ch93st1[] =
+{
+ {37.7733f,119.048f},
+ {37.7733f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeVertex ch93st2[] =
+{
+ {4.44f,119.048f},
+ {37.7733f,119.048f}
+};
+
+static const Fl_Glut_StrokeVertex ch93st3[] =
+{
+ {4.44f,-33.3333f},
+ {37.7733f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeStrip ch93st[] =
+{
+ {2,ch93st0},
+ {2,ch93st1},
+ {2,ch93st2},
+ {2,ch93st3}
+};
+
+static const Fl_Glut_StrokeChar ch93 = {46.3933f,4,ch93st};
+
+/* char: 0x5e */
+
+static const Fl_Glut_StrokeVertex ch94st0[] =
+{
+ {44.0752f,109.524f},
+ {5.98f,42.8571f}
+};
+
+static const Fl_Glut_StrokeVertex ch94st1[] =
+{
+ {44.0752f,109.524f},
+ {82.1705f,42.8571f}
+};
+
+static const Fl_Glut_StrokeStrip ch94st[] =
+{
+ {2,ch94st0},
+ {2,ch94st1}
+};
+
+static const Fl_Glut_StrokeChar ch94 = {90.2305f,2,ch94st};
+
+/* char: 0x5f */
+
+static const Fl_Glut_StrokeVertex ch95st0[] =
+{
+ {-1.1f,-33.3333f},
+ {103.662f,-33.3333f},
+ {103.662f,-28.5714f},
+ {-1.1f,-28.5714f},
+ {-1.1f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeStrip ch95st[] =
+{
+ {5,ch95st0}
+};
+
+static const Fl_Glut_StrokeChar ch95 = {104.062f,1,ch95st};
+
+/* char: 0x60 */
+
+static const Fl_Glut_StrokeVertex ch96st0[] =
+{
+ {33.0219f,100.0f},
+ {56.8314f,71.4286f}
+};
+
+static const Fl_Glut_StrokeVertex ch96st1[] =
+{
+ {33.0219f,100.0f},
+ {28.26f,95.2381f},
+ {56.8314f,71.4286f}
+};
+
+static const Fl_Glut_StrokeStrip ch96st[] =
+{
+ {2,ch96st0},
+ {3,ch96st1}
+};
+
+static const Fl_Glut_StrokeChar ch96 = {83.5714f,2,ch96st};
+
+/* char: 0x61 */
+
+static const Fl_Glut_StrokeVertex ch97st0[] =
+{
+ {63.8229f,66.6667f},
+ {63.8229f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch97st1[] =
+{
+ {63.8229f,52.381f},
+ {54.299f,61.9048f},
+ {44.7752f,66.6667f},
+ {30.4895f,66.6667f},
+ {20.9657f,61.9048f},
+ {11.4419f,52.381f},
+ {6.68f,38.0952f},
+ {6.68f,28.5714f},
+ {11.4419f,14.2857f},
+ {20.9657f,4.7619f},
+ {30.4895f,0.0f},
+ {44.7752f,0.0f},
+ {54.299f,4.7619f},
+ {63.8229f,14.2857f}
+};
+
+static const Fl_Glut_StrokeStrip ch97st[] =
+{
+ {2,ch97st0},
+ {14,ch97st1}
+};
+
+static const Fl_Glut_StrokeChar ch97 = {66.6029f,2,ch97st};
+
+/* char: 0x62 */
+
+static const Fl_Glut_StrokeVertex ch98st0[] =
+{
+ {8.76f,100.0f},
+ {8.76f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch98st1[] =
+{
+ {8.76f,52.381f},
+ {18.2838f,61.9048f},
+ {27.8076f,66.6667f},
+ {42.0933f,66.6667f},
+ {51.6171f,61.9048f},
+ {61.141f,52.381f},
+ {65.9029f,38.0952f},
+ {65.9029f,28.5714f},
+ {61.141f,14.2857f},
+ {51.6171f,4.7619f},
+ {42.0933f,0.0f},
+ {27.8076f,0.0f},
+ {18.2838f,4.7619f},
+ {8.76f,14.2857f}
+};
+
+static const Fl_Glut_StrokeStrip ch98st[] =
+{
+ {2,ch98st0},
+ {14,ch98st1}
+};
+
+static const Fl_Glut_StrokeChar ch98 = {70.4629f,2,ch98st};
+
+/* char: 0x63 */
+
+static const Fl_Glut_StrokeVertex ch99st0[] =
+{
+ {62.6629f,52.381f},
+ {53.139f,61.9048f},
+ {43.6152f,66.6667f},
+ {29.3295f,66.6667f},
+ {19.8057f,61.9048f},
+ {10.2819f,52.381f},
+ {5.52f,38.0952f},
+ {5.52f,28.5714f},
+ {10.2819f,14.2857f},
+ {19.8057f,4.7619f},
+ {29.3295f,0.0f},
+ {43.6152f,0.0f},
+ {53.139f,4.7619f},
+ {62.6629f,14.2857f}
+};
+
+static const Fl_Glut_StrokeStrip ch99st[] =
+{
+ {14,ch99st0}
+};
+
+static const Fl_Glut_StrokeChar ch99 = {68.9229f,1,ch99st};
+
+/* char: 0x64 */
+
+static const Fl_Glut_StrokeVertex ch100st0[] =
+{
+ {61.7829f,100.0f},
+ {61.7829f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch100st1[] =
+{
+ {61.7829f,52.381f},
+ {52.259f,61.9048f},
+ {42.7352f,66.6667f},
+ {28.4495f,66.6667f},
+ {18.9257f,61.9048f},
+ {9.4019f,52.381f},
+ {4.64f,38.0952f},
+ {4.64f,28.5714f},
+ {9.4019f,14.2857f},
+ {18.9257f,4.7619f},
+ {28.4495f,0.0f},
+ {42.7352f,0.0f},
+ {52.259f,4.7619f},
+ {61.7829f,14.2857f}
+};
+
+static const Fl_Glut_StrokeStrip ch100st[] =
+{
+ {2,ch100st0},
+ {14,ch100st1}
+};
+
+static const Fl_Glut_StrokeChar ch100 = {70.2629f,2,ch100st};
+
+/* char: 0x65 */
+
+static const Fl_Glut_StrokeVertex ch101st0[] =
+{
+ {5.72f,38.0952f},
+ {62.8629f,38.0952f},
+ {62.8629f,47.619f},
+ {58.101f,57.1429f},
+ {53.339f,61.9048f},
+ {43.8152f,66.6667f},
+ {29.5295f,66.6667f},
+ {20.0057f,61.9048f},
+ {10.4819f,52.381f},
+ {5.72f,38.0952f},
+ {5.72f,28.5714f},
+ {10.4819f,14.2857f},
+ {20.0057f,4.7619f},
+ {29.5295f,0.0f},
+ {43.8152f,0.0f},
+ {53.339f,4.7619f},
+ {62.8629f,14.2857f}
+};
+
+static const Fl_Glut_StrokeStrip ch101st[] =
+{
+ {17,ch101st0}
+};
+
+static const Fl_Glut_StrokeChar ch101 = {68.5229f,1,ch101st};
+
+/* char: 0x66 */
+
+static const Fl_Glut_StrokeVertex ch102st0[] =
+{
+ {38.7752f,100.0f},
+ {29.2514f,100.0f},
+ {19.7276f,95.2381f},
+ {14.9657f,80.9524f},
+ {14.9657f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch102st1[] =
+{
+ {0.68f,66.6667f},
+ {34.0133f,66.6667f}
+};
+
+static const Fl_Glut_StrokeStrip ch102st[] =
+{
+ {5,ch102st0},
+ {2,ch102st1}
+};
+
+static const Fl_Glut_StrokeChar ch102 = {38.6552f,2,ch102st};
+
+/* char: 0x67 */
+
+static const Fl_Glut_StrokeVertex ch103st0[] =
+{
+ {62.5029f,66.6667f},
+ {62.5029f,-9.5238f},
+ {57.741f,-23.8095f},
+ {52.979f,-28.5714f},
+ {43.4552f,-33.3333f},
+ {29.1695f,-33.3333f},
+ {19.6457f,-28.5714f}
+};
+
+static const Fl_Glut_StrokeVertex ch103st1[] =
+{
+ {62.5029f,52.381f},
+ {52.979f,61.9048f},
+ {43.4552f,66.6667f},
+ {29.1695f,66.6667f},
+ {19.6457f,61.9048f},
+ {10.1219f,52.381f},
+ {5.36f,38.0952f},
+ {5.36f,28.5714f},
+ {10.1219f,14.2857f},
+ {19.6457f,4.7619f},
+ {29.1695f,0.0f},
+ {43.4552f,0.0f},
+ {52.979f,4.7619f},
+ {62.5029f,14.2857f}
+};
+
+static const Fl_Glut_StrokeStrip ch103st[] =
+{
+ {7,ch103st0},
+ {14,ch103st1}
+};
+
+static const Fl_Glut_StrokeChar ch103 = {70.9829f,2,ch103st};
+
+/* char: 0x68 */
+
+static const Fl_Glut_StrokeVertex ch104st0[] =
+{
+ {9.6f,100.0f},
+ {9.6f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch104st1[] =
+{
+ {9.6f,47.619f},
+ {23.8857f,61.9048f},
+ {33.4095f,66.6667f},
+ {47.6952f,66.6667f},
+ {57.219f,61.9048f},
+ {61.981f,47.619f},
+ {61.981f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch104st[] =
+{
+ {2,ch104st0},
+ {7,ch104st1}
+};
+
+static const Fl_Glut_StrokeChar ch104 = {71.021f,2,ch104st};
+
+/* char: 0x69 */
+
+static const Fl_Glut_StrokeVertex ch105st0[] =
+{
+ {10.02f,100.0f},
+ {14.7819f,95.2381f},
+ {19.5438f,100.0f},
+ {14.7819f,104.762f},
+ {10.02f,100.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch105st1[] =
+{
+ {14.7819f,66.6667f},
+ {14.7819f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch105st[] =
+{
+ {5,ch105st0},
+ {2,ch105st1}
+};
+
+static const Fl_Glut_StrokeChar ch105 = {28.8638f,2,ch105st};
+
+/* char: 0x6a */
+
+static const Fl_Glut_StrokeVertex ch106st0[] =
+{
+ {17.3876f,100.0f},
+ {22.1495f,95.2381f},
+ {26.9114f,100.0f},
+ {22.1495f,104.762f},
+ {17.3876f,100.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch106st1[] =
+{
+ {22.1495f,66.6667f},
+ {22.1495f,-14.2857f},
+ {17.3876f,-28.5714f},
+ {7.8638f,-33.3333f},
+ {-1.66f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeStrip ch106st[] =
+{
+ {5,ch106st0},
+ {5,ch106st1}
+};
+
+static const Fl_Glut_StrokeChar ch106 = {36.2314f,2,ch106st};
+
+/* char: 0x6b */
+
+static const Fl_Glut_StrokeVertex ch107st0[] =
+{
+ {9.6f,100.0f},
+ {9.6f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch107st1[] =
+{
+ {57.219f,66.6667f},
+ {9.6f,19.0476f}
+};
+
+static const Fl_Glut_StrokeVertex ch107st2[] =
+{
+ {28.6476f,38.0952f},
+ {61.981f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch107st[] =
+{
+ {2,ch107st0},
+ {2,ch107st1},
+ {2,ch107st2}
+};
+
+static const Fl_Glut_StrokeChar ch107 = {62.521f,3,ch107st};
+
+/* char: 0x6c */
+
+static const Fl_Glut_StrokeVertex ch108st0[] =
+{
+ {10.02f,100.0f},
+ {10.02f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch108st[] =
+{
+ {2,ch108st0}
+};
+
+static const Fl_Glut_StrokeChar ch108 = {19.34f,1,ch108st};
+
+/* char: 0x6d */
+
+static const Fl_Glut_StrokeVertex ch109st0[] =
+{
+ {9.6f,66.6667f},
+ {9.6f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch109st1[] =
+{
+ {9.6f,47.619f},
+ {23.8857f,61.9048f},
+ {33.4095f,66.6667f},
+ {47.6952f,66.6667f},
+ {57.219f,61.9048f},
+ {61.981f,47.619f},
+ {61.981f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch109st2[] =
+{
+ {61.981f,47.619f},
+ {76.2667f,61.9048f},
+ {85.7905f,66.6667f},
+ {100.076f,66.6667f},
+ {109.6f,61.9048f},
+ {114.362f,47.619f},
+ {114.362f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch109st[] =
+{
+ {2,ch109st0},
+ {7,ch109st1},
+ {7,ch109st2}
+};
+
+static const Fl_Glut_StrokeChar ch109 = {123.962f,3,ch109st};
+
+/* char: 0x6e */
+
+static const Fl_Glut_StrokeVertex ch110st0[] =
+{
+ {9.18f,66.6667f},
+ {9.18f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch110st1[] =
+{
+ {9.18f,47.619f},
+ {23.4657f,61.9048f},
+ {32.9895f,66.6667f},
+ {47.2752f,66.6667f},
+ {56.799f,61.9048f},
+ {61.561f,47.619f},
+ {61.561f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch110st[] =
+{
+ {2,ch110st0},
+ {7,ch110st1}
+};
+
+static const Fl_Glut_StrokeChar ch110 = {70.881f,2,ch110st};
+
+/* char: 0x6f */
+
+static const Fl_Glut_StrokeVertex ch111st0[] =
+{
+ {28.7895f,66.6667f},
+ {19.2657f,61.9048f},
+ {9.7419f,52.381f},
+ {4.98f,38.0952f},
+ {4.98f,28.5714f},
+ {9.7419f,14.2857f},
+ {19.2657f,4.7619f},
+ {28.7895f,0.0f},
+ {43.0752f,0.0f},
+ {52.599f,4.7619f},
+ {62.1229f,14.2857f},
+ {66.8848f,28.5714f},
+ {66.8848f,38.0952f},
+ {62.1229f,52.381f},
+ {52.599f,61.9048f},
+ {43.0752f,66.6667f},
+ {28.7895f,66.6667f}
+};
+
+static const Fl_Glut_StrokeStrip ch111st[] =
+{
+ {17,ch111st0}
+};
+
+static const Fl_Glut_StrokeChar ch111 = {71.7448f,1,ch111st};
+
+/* char: 0x70 */
+
+static const Fl_Glut_StrokeVertex ch112st0[] =
+{
+ {9.46f,66.6667f},
+ {9.46f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeVertex ch112st1[] =
+{
+ {9.46f,52.381f},
+ {18.9838f,61.9048f},
+ {28.5076f,66.6667f},
+ {42.7933f,66.6667f},
+ {52.3171f,61.9048f},
+ {61.841f,52.381f},
+ {66.6029f,38.0952f},
+ {66.6029f,28.5714f},
+ {61.841f,14.2857f},
+ {52.3171f,4.7619f},
+ {42.7933f,0.0f},
+ {28.5076f,0.0f},
+ {18.9838f,4.7619f},
+ {9.46f,14.2857f}
+};
+
+static const Fl_Glut_StrokeStrip ch112st[] =
+{
+ {2,ch112st0},
+ {14,ch112st1}
+};
+
+static const Fl_Glut_StrokeChar ch112 = {70.8029f,2,ch112st};
+
+/* char: 0x71 */
+
+static const Fl_Glut_StrokeVertex ch113st0[] =
+{
+ {61.9829f,66.6667f},
+ {61.9829f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeVertex ch113st1[] =
+{
+ {61.9829f,52.381f},
+ {52.459f,61.9048f},
+ {42.9352f,66.6667f},
+ {28.6495f,66.6667f},
+ {19.1257f,61.9048f},
+ {9.6019f,52.381f},
+ {4.84f,38.0952f},
+ {4.84f,28.5714f},
+ {9.6019f,14.2857f},
+ {19.1257f,4.7619f},
+ {28.6495f,0.0f},
+ {42.9352f,0.0f},
+ {52.459f,4.7619f},
+ {61.9829f,14.2857f}
+};
+
+static const Fl_Glut_StrokeStrip ch113st[] =
+{
+ {2,ch113st0},
+ {14,ch113st1}
+};
+
+static const Fl_Glut_StrokeChar ch113 = {70.7429f,2,ch113st};
+
+/* char: 0x72 */
+
+static const Fl_Glut_StrokeVertex ch114st0[] =
+{
+ {9.46f,66.6667f},
+ {9.46f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch114st1[] =
+{
+ {9.46f,38.0952f},
+ {14.2219f,52.381f},
+ {23.7457f,61.9048f},
+ {33.2695f,66.6667f},
+ {47.5552f,66.6667f}
+};
+
+static const Fl_Glut_StrokeStrip ch114st[] =
+{
+ {2,ch114st0},
+ {5,ch114st1}
+};
+
+static const Fl_Glut_StrokeChar ch114 = {49.4952f,2,ch114st};
+
+/* char: 0x73 */
+
+static const Fl_Glut_StrokeVertex ch115st0[] =
+{
+ {57.081f,52.381f},
+ {52.319f,61.9048f},
+ {38.0333f,66.6667f},
+ {23.7476f,66.6667f},
+ {9.4619f,61.9048f},
+ {4.7f,52.381f},
+ {9.4619f,42.8571f},
+ {18.9857f,38.0952f},
+ {42.7952f,33.3333f},
+ {52.319f,28.5714f},
+ {57.081f,19.0476f},
+ {57.081f,14.2857f},
+ {52.319f,4.7619f},
+ {38.0333f,0.0f},
+ {23.7476f,0.0f},
+ {9.4619f,4.7619f},
+ {4.7f,14.2857f}
+};
+
+static const Fl_Glut_StrokeStrip ch115st[] =
+{
+ {17,ch115st0}
+};
+
+static const Fl_Glut_StrokeChar ch115 = {62.321f,1,ch115st};
+
+/* char: 0x74 */
+
+static const Fl_Glut_StrokeVertex ch116st0[] =
+{
+ {14.8257f,100.0f},
+ {14.8257f,19.0476f},
+ {19.5876f,4.7619f},
+ {29.1114f,0.0f},
+ {38.6352f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch116st1[] =
+{
+ {0.54f,66.6667f},
+ {33.8733f,66.6667f}
+};
+
+static const Fl_Glut_StrokeStrip ch116st[] =
+{
+ {5,ch116st0},
+ {2,ch116st1}
+};
+
+static const Fl_Glut_StrokeChar ch116 = {39.3152f,2,ch116st};
+
+/* char: 0x75 */
+
+static const Fl_Glut_StrokeVertex ch117st0[] =
+{
+ {9.46f,66.6667f},
+ {9.46f,19.0476f},
+ {14.2219f,4.7619f},
+ {23.7457f,0.0f},
+ {38.0314f,0.0f},
+ {47.5552f,4.7619f},
+ {61.841f,19.0476f}
+};
+
+static const Fl_Glut_StrokeVertex ch117st1[] =
+{
+ {61.841f,66.6667f},
+ {61.841f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch117st[] =
+{
+ {7,ch117st0},
+ {2,ch117st1}
+};
+
+static const Fl_Glut_StrokeChar ch117 = {71.161f,2,ch117st};
+
+/* char: 0x76 */
+
+static const Fl_Glut_StrokeVertex ch118st0[] =
+{
+ {1.8f,66.6667f},
+ {30.3714f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch118st1[] =
+{
+ {58.9429f,66.6667f},
+ {30.3714f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch118st[] =
+{
+ {2,ch118st0},
+ {2,ch118st1}
+};
+
+static const Fl_Glut_StrokeChar ch118 = {60.6029f,2,ch118st};
+
+/* char: 0x77 */
+
+static const Fl_Glut_StrokeVertex ch119st0[] =
+{
+ {2.5f,66.6667f},
+ {21.5476f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch119st1[] =
+{
+ {40.5952f,66.6667f},
+ {21.5476f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch119st2[] =
+{
+ {40.5952f,66.6667f},
+ {59.6429f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch119st3[] =
+{
+ {78.6905f,66.6667f},
+ {59.6429f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch119st[] =
+{
+ {2,ch119st0},
+ {2,ch119st1},
+ {2,ch119st2},
+ {2,ch119st3}
+};
+
+static const Fl_Glut_StrokeChar ch119 = {80.4905f,4,ch119st};
+
+/* char: 0x78 */
+
+static const Fl_Glut_StrokeVertex ch120st0[] =
+{
+ {1.66f,66.6667f},
+ {54.041f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch120st1[] =
+{
+ {54.041f,66.6667f},
+ {1.66f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch120st[] =
+{
+ {2,ch120st0},
+ {2,ch120st1}
+};
+
+static const Fl_Glut_StrokeChar ch120 = {56.401f,2,ch120st};
+
+/* char: 0x79 */
+
+static const Fl_Glut_StrokeVertex ch121st0[] =
+{
+ {6.5619f,66.6667f},
+ {35.1333f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch121st1[] =
+{
+ {63.7048f,66.6667f},
+ {35.1333f,0.0f},
+ {25.6095f,-19.0476f},
+ {16.0857f,-28.5714f},
+ {6.5619f,-33.3333f},
+ {1.8f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeStrip ch121st[] =
+{
+ {2,ch121st0},
+ {6,ch121st1}
+};
+
+static const Fl_Glut_StrokeChar ch121 = {66.0648f,2,ch121st};
+
+/* char: 0x7a */
+
+static const Fl_Glut_StrokeVertex ch122st0[] =
+{
+ {56.821f,66.6667f},
+ {4.44f,0.0f}
+};
+
+static const Fl_Glut_StrokeVertex ch122st1[] =
+{
+ {4.44f,66.6667f},
+ {56.821f,66.6667f}
+};
+
+static const Fl_Glut_StrokeVertex ch122st2[] =
+{
+ {4.44f,0.0f},
+ {56.821f,0.0f}
+};
+
+static const Fl_Glut_StrokeStrip ch122st[] =
+{
+ {2,ch122st0},
+ {2,ch122st1},
+ {2,ch122st2}
+};
+
+static const Fl_Glut_StrokeChar ch122 = {61.821f,3,ch122st};
+
+/* char: 0x7b */
+
+static const Fl_Glut_StrokeVertex ch123st0[] =
+{
+ {31.1895f,119.048f},
+ {21.6657f,114.286f},
+ {16.9038f,109.524f},
+ {12.1419f,100.0f},
+ {12.1419f,90.4762f},
+ {16.9038f,80.9524f},
+ {21.6657f,76.1905f},
+ {26.4276f,66.6667f},
+ {26.4276f,57.1429f},
+ {16.9038f,47.619f}
+};
+
+static const Fl_Glut_StrokeVertex ch123st1[] =
+{
+ {21.6657f,114.286f},
+ {16.9038f,104.762f},
+ {16.9038f,95.2381f},
+ {21.6657f,85.7143f},
+ {26.4276f,80.9524f},
+ {31.1895f,71.4286f},
+ {31.1895f,61.9048f},
+ {26.4276f,52.381f},
+ {7.38f,42.8571f},
+ {26.4276f,33.3333f},
+ {31.1895f,23.8095f},
+ {31.1895f,14.2857f},
+ {26.4276f,4.7619f},
+ {21.6657f,0.0f},
+ {16.9038f,-9.5238f},
+ {16.9038f,-19.0476f},
+ {21.6657f,-28.5714f}
+};
+
+static const Fl_Glut_StrokeVertex ch123st2[] =
+{
+ {16.9038f,38.0952f},
+ {26.4276f,28.5714f},
+ {26.4276f,19.0476f},
+ {21.6657f,9.5238f},
+ {16.9038f,4.7619f},
+ {12.1419f,-4.7619f},
+ {12.1419f,-14.2857f},
+ {16.9038f,-23.8095f},
+ {21.6657f,-28.5714f},
+ {31.1895f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeStrip ch123st[] =
+{
+ {10,ch123st0},
+ {17,ch123st1},
+ {10,ch123st2}
+};
+
+static const Fl_Glut_StrokeChar ch123 = {41.6295f,3,ch123st};
+
+/* char: 0x7c */
+
+static const Fl_Glut_StrokeVertex ch124st0[] =
+{
+ {11.54f,119.048f},
+ {11.54f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeStrip ch124st[] =
+{
+ {2,ch124st0}
+};
+
+static const Fl_Glut_StrokeChar ch124 = {23.78f,1,ch124st};
+
+/* char: 0x7d */
+
+static const Fl_Glut_StrokeVertex ch125st0[] =
+{
+ {9.18f,119.048f},
+ {18.7038f,114.286f},
+ {23.4657f,109.524f},
+ {28.2276f,100.0f},
+ {28.2276f,90.4762f},
+ {23.4657f,80.9524f},
+ {18.7038f,76.1905f},
+ {13.9419f,66.6667f},
+ {13.9419f,57.1429f},
+ {23.4657f,47.619f}
+};
+
+static const Fl_Glut_StrokeVertex ch125st1[] =
+{
+ {18.7038f,114.286f},
+ {23.4657f,104.762f},
+ {23.4657f,95.2381f},
+ {18.7038f,85.7143f},
+ {13.9419f,80.9524f},
+ {9.18f,71.4286f},
+ {9.18f,61.9048f},
+ {13.9419f,52.381f},
+ {32.9895f,42.8571f},
+ {13.9419f,33.3333f},
+ {9.18f,23.8095f},
+ {9.18f,14.2857f},
+ {13.9419f,4.7619f},
+ {18.7038f,0.0f},
+ {23.4657f,-9.5238f},
+ {23.4657f,-19.0476f},
+ {18.7038f,-28.5714f}
+};
+
+static const Fl_Glut_StrokeVertex ch125st2[] =
+{
+ {23.4657f,38.0952f},
+ {13.9419f,28.5714f},
+ {13.9419f,19.0476f},
+ {18.7038f,9.5238f},
+ {23.4657f,4.7619f},
+ {28.2276f,-4.7619f},
+ {28.2276f,-14.2857f},
+ {23.4657f,-23.8095f},
+ {18.7038f,-28.5714f},
+ {9.18f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeStrip ch125st[] =
+{
+ {10,ch125st0},
+ {17,ch125st1},
+ {10,ch125st2}
+};
+
+static const Fl_Glut_StrokeChar ch125 = {41.4695f,3,ch125st};
+
+/* char: 0x7e */
+
+static const Fl_Glut_StrokeVertex ch126st0[] =
+{
+ {2.92f,28.5714f},
+ {2.92f,38.0952f},
+ {7.6819f,52.381f},
+ {17.2057f,57.1429f},
+ {26.7295f,57.1429f},
+ {36.2533f,52.381f},
+ {55.301f,38.0952f},
+ {64.8248f,33.3333f},
+ {74.3486f,33.3333f},
+ {83.8724f,38.0952f},
+ {88.6343f,47.619f}
+};
+
+static const Fl_Glut_StrokeVertex ch126st1[] =
+{
+ {2.92f,38.0952f},
+ {7.6819f,47.619f},
+ {17.2057f,52.381f},
+ {26.7295f,52.381f},
+ {36.2533f,47.619f},
+ {55.301f,33.3333f},
+ {64.8248f,28.5714f},
+ {74.3486f,28.5714f},
+ {83.8724f,33.3333f},
+ {88.6343f,47.619f},
+ {88.6343f,57.1429f}
+};
+
+static const Fl_Glut_StrokeStrip ch126st[] =
+{
+ {11,ch126st0},
+ {11,ch126st1}
+};
+
+static const Fl_Glut_StrokeChar ch126 = {91.2743f,2,ch126st};
+
+/* char: 0x7f */
+
+static const Fl_Glut_StrokeVertex ch127st0[] =
+{
+ {52.381f,100.0f},
+ {14.2857f,-33.3333f}
+};
+
+static const Fl_Glut_StrokeVertex ch127st1[] =
+{
+ {28.5714f,66.6667f},
+ {14.2857f,61.9048f},
+ {4.7619f,52.381f},
+ {0.0f,38.0952f},
+ {0.0f,23.8095f},
+ {4.7619f,14.2857f},
+ {14.2857f,4.7619f},
+ {28.5714f,0.0f},
+ {38.0952f,0.0f},
+ {52.381f,4.7619f},
+ {61.9048f,14.2857f},
+ {66.6667f,28.5714f},
+ {66.6667f,42.8571f},
+ {61.9048f,52.381f},
+ {52.381f,61.9048f},
+ {38.0952f,66.6667f},
+ {28.5714f,66.6667f}
+};
+
+static const Fl_Glut_StrokeStrip ch127st[] =
+{
+ {2,ch127st0},
+ {17,ch127st1}
+};
+
+static const Fl_Glut_StrokeChar ch127 = {66.6667f,2,ch127st};
+
+static const Fl_Glut_StrokeChar *chars[] =
+{
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ &ch32, &ch33, &ch34, &ch35, &ch36, &ch37, &ch38, &ch39,
+ &ch40, &ch41, &ch42, &ch43, &ch44, &ch45, &ch46, &ch47,
+ &ch48, &ch49, &ch50, &ch51, &ch52, &ch53, &ch54, &ch55,
+ &ch56, &ch57, &ch58, &ch59, &ch60, &ch61, &ch62, &ch63,
+ &ch64, &ch65, &ch66, &ch67, &ch68, &ch69, &ch70, &ch71,
+ &ch72, &ch73, &ch74, &ch75, &ch76, &ch77, &ch78, &ch79,
+ &ch80, &ch81, &ch82, &ch83, &ch84, &ch85, &ch86, &ch87,
+ &ch88, &ch89, &ch90, &ch91, &ch92, &ch93, &ch94, &ch95,
+ &ch96, &ch97, &ch98, &ch99, &ch100, &ch101, &ch102, &ch103,
+ &ch104, &ch105, &ch106, &ch107, &ch108, &ch109, &ch110, &ch111,
+ &ch112, &ch113, &ch114, &ch115, &ch116, &ch117, &ch118, &ch119,
+ &ch120, &ch121, &ch122, &ch123, &ch124, &ch125, &ch126, &ch127
+};
+
+Fl_Glut_StrokeFont glutStrokeRoman = {(char *)"Roman",128,152.381f,chars};
Copied: branches/branch-3.0/src/fltk3gl/freeglut_teapot.cxx (from rev 9002, branches/branch-3.0/src/core/freeglut_teapot.cxx)
===================================================================
--- branches/branch-3.0/src/fltk3gl/freeglut_teapot.cxx (rev 0)
+++ branches/branch-3.0/src/fltk3gl/freeglut_teapot.cxx 2011-08-25 10:51:10 UTC (rev 9008)
@@ -0,0 +1,164 @@
+/*
+ * freeglut_teapot.c
+ *
+ * Teapot(tm) rendering code.
+ *
+ * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.
+ * Written by Pawel W. Olszta, <olszta@sourceforge.net>
+ * Creation date: Fri Dec 24 1999
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+ * Original teapot code copyright follows:
+ */
+
+/*
+ * (c) Copyright 1993, Silicon Graphics, Inc.
+ *
+ * ALL RIGHTS RESERVED
+ *
+ * Permission to use, copy, modify, and distribute this software
+ * for any purpose and without fee is hereby granted, provided
+ * that the above copyright notice appear in all copies and that
+ * both the copyright notice and this permission notice appear in
+ * supporting documentation, and that the name of Silicon
+ * Graphics, Inc. not be used in advertising or publicity
+ * pertaining to distribution of the software without specific,
+ * written prior permission.
+ *
+ * THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU
+ * "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR
+ * OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
+ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. IN NO
+ * EVENT SHALL SILICON GRAPHICS, INC. BE LIABLE TO YOU OR ANYONE
+ * ELSE FOR ANY DIRECT, SPECIAL, INCIDENTAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER,
+ * INCLUDING WITHOUT LIMITATION, LOSS OF PROFIT, LOSS OF USE,
+ * SAVINGS OR REVENUE, OR THE CLAIMS OF THIRD PARTIES, WHETHER OR
+ * NOT SILICON GRAPHICS, INC. HAS BEEN ADVISED OF THE POSSIBILITY
+ * OF SUCH LOSS, HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * ARISING OUT OF OR IN CONNECTION WITH THE POSSESSION, USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ *
+ * US Government Users Restricted Rights
+ *
+ * Use, duplication, or disclosure by the Government is subject to
+ * restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
+ * (c)(1)(ii) of the Rights in Technical Data and Computer
+ * Software clause at DFARS 252.227-7013 and/or in similar or
+ * successor clauses in the FAR or the DOD or NASA FAR
+ * Supplement. Unpublished-- rights reserved under the copyright
+ * laws of the United States. Contractor/manufacturer is Silicon
+ * Graphics, Inc., 2011 N. Shoreline Blvd., Mountain View, CA
+ * 94039-7311.
+ *
+ * OpenGL(TM) is a trademark of Silicon Graphics, Inc.
+ */
+
+#include <fltk3/glut.h>
+#include "freeglut_teapot_data.h"
+
+/* -- PRIVATE FUNCTIONS ---------------------------------------------------- */
+
+
+static void fghTeapot( GLint grid, GLdouble scale, GLenum type )
+{
+ double p[4][4][3], q[4][4][3], r[4][4][3], s[4][4][3];
+ long i, j, k, l;
+
+ glPushAttrib( GL_ENABLE_BIT | GL_EVAL_BIT );
+ glEnable( GL_AUTO_NORMAL );
+ glEnable( GL_NORMALIZE );
+ glEnable( GL_MAP2_VERTEX_3 );
+ glEnable( GL_MAP2_TEXTURE_COORD_2 );
+
+ glPushMatrix();
+ glRotated( 270.0, 1.0, 0.0, 0.0 );
+ glScaled( 0.5 * scale, 0.5 * scale, 0.5 * scale );
+ glTranslated( 0.0, 0.0, -1.5 );
+
+ for (i = 0; i < 10; i++) {
+ for (j = 0; j < 4; j++) {
+ for (k = 0; k < 4; k++) {
+ for (l = 0; l < 3; l++) {
+ p[j][k][l] = cpdata[patchdata[i][j * 4 + k]][l];
+ q[j][k][l] = cpdata[patchdata[i][j * 4 + (3 - k)]][l];
+ if (l == 1)
+ q[j][k][l] *= -1.0;
+ if (i < 6) {
+ r[j][k][l] =
+ cpdata[patchdata[i][j * 4 + (3 - k)]][l];
+ if (l == 0)
+ r[j][k][l] *= -1.0;
+ s[j][k][l] = cpdata[patchdata[i][j * 4 + k]][l];
+ if (l == 0)
+ s[j][k][l] *= -1.0;
+ if (l == 1)
+ s[j][k][l] *= -1.0;
+ }
+ }
+ }
+ }
+
+ glMap2d(GL_MAP2_TEXTURE_COORD_2, 0.0, 1.0, 2, 2, 0.0, 1.0, 4, 2,
+ &tex[0][0][0]);
+ glMap2d(GL_MAP2_VERTEX_3, 0.0, 1.0, 3, 4, 0.0, 1.0, 12, 4,
+ &p[0][0][0]);
+ glMapGrid2d(grid, 0.0, 1.0, grid, 0.0, 1.0);
+ glEvalMesh2(type, 0, grid, 0, grid);
+ glMap2d(GL_MAP2_VERTEX_3, 0.0, 1.0, 3, 4, 0.0, 1.0, 12, 4,
+ &q[0][0][0]);
+ glEvalMesh2(type, 0, grid, 0, grid);
+ if (i < 6) {
+ glMap2d(GL_MAP2_VERTEX_3, 0.0, 1.0, 3, 4, 0.0, 1.0, 12, 4,
+ &r[0][0][0]);
+ glEvalMesh2(type, 0, grid, 0, grid);
+ glMap2d(GL_MAP2_VERTEX_3, 0.0, 1.0, 3, 4, 0.0, 1.0, 12, 4,
+ &s[0][0][0]);
+ glEvalMesh2(type, 0, grid, 0, grid);
+ }
+ }
+
+ glPopMatrix();
+ glPopAttrib();
+}
+
+
+/* -- INTERFACE FUNCTIONS -------------------------------------------------- */
+
+/*
+ * Renders a beautiful wired teapot...
+ */
+void glutWireTeapot( GLdouble size )
+{
+ /* We will use the general teapot rendering code */
+ fghTeapot( 10, size, GL_LINE );
+}
+
+/*
+ * Renders a beautiful filled teapot...
+ */
+void glutSolidTeapot( GLdouble size )
+{
+ /* We will use the general teapot rendering code */
+ fghTeapot( 7, size, GL_FILL );
+}
+
+/*** END OF FILE ***/
[ Direct Link to Message ]
